开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
KIniFile.cpp
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：32k
源码类别：

模拟服务器

开发平台：

C/C++

KIniFile.cpp：源码内容
  1. //---------------------------------------------------------------------------
  2. // Sword3 Engine (c) 1999-2000 by Kingsoft
  3. //
  4. // File: KIniFile.cpp
  5. // Date: 2000.08.08
  6. // Code: WangWei(Daphnis)
  7. // Desc: Ini File Operation Class
  8. //---------------------------------------------------------------------------
  9. #include "KWin32.h"
  10. #include "KDebug.h"
  11. #include "KMemBase.h"
  12. #include "KStrBase.h"
  13. #include "KFile.h"
  14. #include "KFilePath.h"
  15. #include "KPakFile.h"
  16. #ifndef _SERVER
  17. #include "KCodec.h"
  18. #endif
  19. #include "KIniFile.h"
  20. #include <string.h>
  21. #include "KSG_StringProcess.h"
  23. //---------------------------------------------------------------------------
  24. typedef struct {
  25. DWORD Id; // 文件标识 = 0x4b434150 ("PACK")
  26. DWORD DataLen; // 文件原始的长度
  27. DWORD PackLen; // 文件压缩后长度
  28. DWORD Method; // 使用的压缩算法
  29. } TPackHead;
  30. //---------------------------------------------------------------------------
  31. static int  g_nCodec = 0;// codec method = 0,1,2,3,
  32. //---------------------------------------------------------------------------
  33. // 函数: SetCodec
  34. // 功能: set codec method
  35. // 参数: void
  36. // 返回: void
  37. //---------------------------------------------------------------------------
  38. void g_SetIniCodec(int nCodec)
  39. {
  40. g_nCodec = nCodec;
  41. }
  42. //---------------------------------------------------------------------------
  43. // 函数: KIniFile
  44. // 功能: 购造函数
  45. // 参数: void
  46. // 返回: void
  47. //---------------------------------------------------------------------------
  48. KIniFile::KIniFile()
  49. {
  50. g_MemZero(&m_Header, sizeof(SECNODE));
  51. }
  52. //---------------------------------------------------------------------------
  53. // 函数: ~KIniFile
  54. // 功能: 析造函数
  55. // 参数: void
  56. // 返回: void
  57. //---------------------------------------------------------------------------
  58. KIniFile::~KIniFile()
  59. {
  60. Clear();
  61. }
  62. //---------------------------------------------------------------------------
  63. // 函数: Load
  64. // 功能: 加载一个INI文件
  65. // 参数: FileName 文件名
  66. // 返回: TRUE 成功
  67. // FALSE 失败
  68. //---------------------------------------------------------------------------
  69. BOOL KIniFile::Load(LPCSTR FileName)
  70. {
  71. KPakFile File;
  72. DWORD dwSize;
  73. PVOID Buffer;
  74. TPackHead* pHeader;
  76. // check file name
  77. if (FileName[0] == 0)
  78. return FALSE;
  80. if (m_Header.pNextNode)
  81. Clear();
  83. if (!File.Open((char*)FileName))
  84. {
  85. g_DebugLog("Can't open ini file : %s", FileName);
  86. return FALSE;
  87. }
  88. #pragma message("KIniFile 当前不支持 KeyName 为中文! by Romandou")
  90. dwSize = File.Size();
  92. Buffer = m_MemStack.Push(dwSize + 4);
  94. File.Read(Buffer, dwSize);
  96. pHeader = (TPackHead*)Buffer;
  97. if (pHeader->Id == 0x4b434150) // "PACK"
  98. {
  99. File.Close();
  100. return LoadPack(FileName);
  101. }
  103. CreateIniLink(Buffer, dwSize);
  105. return TRUE;
  106. }
  107. //---------------------------------------------------------------------------
  108. // 函数: LoadPack
  109. // 功能: 打开一个压缩的INI文件
  110. // 参数: FileName 文件名
  111. // 返回: TRUE 成功
  112. // FALSE 失败
  113. //---------------------------------------------------------------------------
  114. BOOL KIniFile::LoadPack(LPCSTR FileName)
  115. {
  116. KPakFile File;
  117. PVOID PackBuf;
  118. PVOID DataBuf;
  119. #ifndef _SERVER
  120. KCodec* pCodec;
  121. TCodeInfo CodeInfo;
  122. #endif
  123. TPackHead Header;
  125. // check file name
  126. if (FileName[0] == 0)
  127. return FALSE;
  129. // close open file
  130. if (m_Header.pNextNode)
  131. Clear();
  133. // open the pack ini file
  134. if (!File.Open((char*)FileName))
  135. return FALSE;
  137. // read pack file header
  138. File.Read(&Header, sizeof(Header));
  140. // if not a pack file read directly
  141. if (Header.Id != 0x4b434150) // "PACK"
  142. return FALSE;
  144. // init codec
  145. #ifndef _SERVER
  146. pCodec = NULL;
  147. g_InitCodec(&pCodec, Header.Method);
  148. if (pCodec == NULL)
  149. return FALSE;
  150. #endif
  151. // allocate buffer for pack data
  152. PackBuf = m_MemStack.Push(Header.PackLen);
  154. // allocate bufer for real data
  155. DataBuf = m_MemStack.Push(Header.DataLen + 2);
  157. // read pack data for file
  158. File.Read(PackBuf, Header.PackLen);
  160. // decompress data
  161. #ifndef _SERVER
  162. CodeInfo.lpPack = (PBYTE)PackBuf;
  163. CodeInfo.dwPackLen = Header.PackLen;
  164. CodeInfo.lpData = (PBYTE)DataBuf;
  165. CodeInfo.dwDataLen = Header.DataLen;
  166. pCodec->Decode(&CodeInfo);
  167. g_FreeCodec(&pCodec, Header.Method);
  168. if (CodeInfo.dwDataLen != Header.DataLen)
  169. {
  170. g_DebugLog("Ini file unpack fail : %s", FileName);
  171. return FALSE;
  172. }
  173. #endif
  174. // check data length
  176. // create ini link in memory
  177. CreateIniLink(DataBuf, Header.DataLen);
  179. return TRUE;
  180. }
  181. //---------------------------------------------------------------------------
  182. // 函数: Save
  183. // 功能: 保存当前的INI文件
  184. // 参数: void
  185. // 返回: TRUE 成功
  186. // FALSE 失败
  187. //---------------------------------------------------------------------------
  188. BOOL KIniFile::Save(LPCSTR FileName)
  189. {
  190. KFile File;
  191. LPSTR DataBuf;
  192. LPSTR pBuffer;
  193. DWORD dwLen;
  195. if (FileName[0] == 0)
  196. return FALSE;
  198. if (g_nCodec)
  199. return SavePack(FileName);
  201. dwLen = m_MemStack.GetStackSize();
  203. DataBuf = (LPSTR)m_MemStack.Push(dwLen);
  204. pBuffer = DataBuf;
  206. SECNODE* SecNode = m_Header.pNextNode;
  207. KEYNODE* KeyNode = NULL;
  209. // write ini file to memory buffer
  210. while (SecNode != NULL)
  211. {
  212. dwLen = sprintf(pBuffer, "%srn", SecNode->pSection);
  213. pBuffer += dwLen;
  214. KeyNode = SecNode->pKeyNode.pNextNode;
  215. while (KeyNode != NULL)
  216. {
  217. dwLen = sprintf(pBuffer, "%s%c%srn", KeyNode->pKey, '=',
  218. KeyNode->pValue);
  219. pBuffer += dwLen;
  220. KeyNode = KeyNode->pNextNode;
  221. }
  222. SecNode = SecNode->pNextNode;
  223. dwLen = sprintf(pBuffer, "rn");
  224. pBuffer += dwLen;
  225. }
  227. // get buffer len
  228. dwLen = pBuffer - DataBuf;
  230. // create ini file
  231. if (!File.Create((char*)FileName))
  232. return FALSE;
  234. // write ini file
  235. File.Write(DataBuf, dwLen);
  237. return TRUE;
  238. }
  239. //---------------------------------------------------------------------------
  240. // 函数: SavePack
  241. // 功能: 保存一个压缩的INI文件
  242. // 参数: FileName 文件名
  243. // 返回: TRUE 成功
  244. // FALSE 失败
  245. //---------------------------------------------------------------------------
  246. BOOL KIniFile::SavePack(LPCSTR FileName)
  247. {
  248. KFile File;
  249. PVOID DataBuf;
  250. PVOID PackBuf;
  251. #ifndef _SERVER
  252. KCodec* pCodec;
  253. TCodeInfo CodeInfo;
  254. #endif
  255. TPackHead Header;
  256. LPSTR pBuffer;
  257. DWORD dwLen;
  259. // check file name
  260. if (FileName[0] == 0)
  261. return FALSE;
  263. dwLen = m_MemStack.GetStackSize();
  265. // allocate realdata buffer
  266. DataBuf = m_MemStack.Push(dwLen);
  268. // allocate compress buffer
  269. PackBuf = m_MemStack.Push(dwLen + 256);
  271. // print ini file to realdata buffer
  272. pBuffer = (LPSTR)DataBuf;
  273. SECNODE* SecNode = m_Header.pNextNode;
  274. KEYNODE* KeyNode = NULL;
  276. // write ini file to memory buffer
  277. while (SecNode != NULL)
  278. {
  279. dwLen = sprintf(pBuffer, "%srn", SecNode->pSection);
  280. pBuffer += dwLen;
  281. KeyNode = SecNode->pKeyNode.pNextNode;
  282. while (KeyNode != NULL)
  283. {
  284. dwLen = sprintf(pBuffer, "%s%c%srn", KeyNode->pKey, '=',
  285. KeyNode->pValue);
  286. pBuffer += dwLen;
  287. KeyNode = KeyNode->pNextNode;
  288. }
  289. SecNode = SecNode->pNextNode;
  290. dwLen = sprintf(pBuffer, "rn");
  291. pBuffer += dwLen;
  292. }
  294. // set header
  295. Header.Id = 0x4b434150; // "PACK"
  296. Header.Method = g_nCodec; // CODEC_LZO = 2;
  298. // init codec
  299. #ifndef _SERVER
  300. pCodec = NULL;
  301. g_InitCodec(&pCodec, Header.Method);
  302. if (pCodec == NULL)
  303. return FALSE;
  304. #endif
  306. // compress the data buffer
  307. #ifndef _SERVER
  308. CodeInfo.lpData = (PBYTE)DataBuf;
  309. CodeInfo.lpPack = (PBYTE)PackBuf;
  310. CodeInfo.dwDataLen = pBuffer - (LPCSTR)DataBuf;
  311. CodeInfo.dwPackLen = 0;
  312. pCodec->Encode(&CodeInfo);
  313. g_FreeCodec(&pCodec, Header.Method);
  314. Header.DataLen = CodeInfo.dwDataLen;
  315. Header.PackLen = CodeInfo.dwPackLen;
  316. #endif
  318. // create ini file
  319. if (!File.Create((char*)FileName))
  320. return FALSE;
  322. // write file header
  323. File.Write(&Header, sizeof(Header));
  325. // write file data
  326. File.Write(PackBuf, Header.PackLen);
  328. return TRUE;
  329. }
  330. //---------------------------------------------------------------------------
  331. // 函数: Clear
  332. // 功能: 清除INI文件的内容
  333. // 参数: void
  334. // 返回: void
  335. //---------------------------------------------------------------------------
  336. void KIniFile::Clear()
  337. {
  338. ReleaseIniLink();
  339. }
  340. //---------------------------------------------------------------------------
  341. // 函数: ReadLine
  342. // 功能: 读取INI文件的一行
  343. // 参数: Buffer 缓存
  344. // Szie 长度
  345. // 返回: TRUE 成功
  346. // FALSE 失败
  347. //---------------------------------------------------------------------------
  348. BOOL KIniFile::ReadLine(LPSTR Buffer,LONG Size)
  349. {
  350. if (m_Offset >= Size)
  351. {
  352. return FALSE;
  353. }
  354. while (Buffer[m_Offset] != 0x0D && Buffer[m_Offset] != 0x0A)
  355. {
  356. m_Offset++;
  357. if (m_Offset >= Size)
  358. break;
  359. }
  360. Buffer[m_Offset] = 0;
  361. if (Buffer[m_Offset] == 0x0D && Buffer[m_Offset + 1] == 0x0A)
  362. m_Offset += 2;
  363. else
  364. m_Offset += 1; //linux [wxb 2003-7-29]
  365. return TRUE;
  366. }
  367. //---------------------------------------------------------------------------
  368. // 函数: IsKeyChar
  369. // 功能: 判断一个字符是否为字母
  370. // 参数: ch 要判断的字符
  371. // 返回: TRUE 是字母
  372. // FALSE 不是字母
  373. //---------------------------------------------------------------------------
  374. BOOL KIniFile::IsKeyChar(char ch)
  375. {
  376. if ((ch >= '0') && (ch <= '9'))
  377. return TRUE;
  378. if ((ch >= 'A') && (ch <= 'Z'))
  379. return TRUE;
  380. if ((ch >= 'a') && (ch <= 'z'))
  381. return TRUE;
  382. return FALSE;
  383. }
  384. //---------------------------------------------------------------------------
  385. // 函数: CreateIniLink
  386. // 功能: 创建Ini链表
  387. // 参数: pBuffer 缓存
  388. // nBufLen 长度
  389. // 返回: void
  390. //---------------------------------------------------------------------------
  391. void KIniFile::CreateIniLink(LPVOID pBuffer, LONG nBufLen)
  392. {
  393. LPSTR lpBuffer = (LPSTR)pBuffer;
  394. LPSTR lpString = NULL;
  395. LPSTR lpValue  = NULL;
  396. char  szSection[32] = "[MAIN]";
  398. m_Offset = 0;
  399. while (m_Offset < nBufLen)
  400. {
  401. lpString = &lpBuffer[m_Offset];
  402. if (!ReadLine(lpBuffer, nBufLen))
  403. break;
  404. if (IsKeyChar(*lpString))
  405. {
  406. lpValue = SplitKeyValue(lpString);
  407. SetKeyValue(szSection, lpString, lpValue);
  408. }
  409. if (*lpString == '[')
  410. {
  411. g_StrCpyLen(szSection, lpString, sizeof(szSection));
  412. }
  413. }
  414. }
  415. //---------------------------------------------------------------------------
  416. // 函数: ReleaseIniLink()
  417. // 功能: 释放Ini链表
  418. // 参数: void
  419. // 返回: void
  420. //---------------------------------------------------------------------------
  421. void KIniFile::ReleaseIniLink()
  422. {
  423. SECNODE* pThisSec = &m_Header;
  424. SECNODE* pNextSec = pThisSec->pNextNode;
  425. KEYNODE* pThisKey = NULL;
  426. KEYNODE* pNextKey = NULL;
  428. while (pNextSec != NULL)
  429. {
  430. pThisSec = pNextSec->pNextNode;
  431. pThisKey = &pNextSec->pKeyNode;
  432. pNextKey = pThisKey->pNextNode;
  433. while (pNextKey != NULL)
  434. {
  435. pThisKey = pNextKey->pNextNode;
  436. m_MemStack.Free(pNextKey->pKey);
  437. m_MemStack.Free(pNextKey->pValue);
  438. m_MemStack.Free(pNextKey);
  439. pNextKey = pThisKey;
  440. }
  441. m_MemStack.Free(pNextSec->pSection);
  442. m_MemStack.Free(pNextSec);
  443. pNextSec = pThisSec;
  444. }
  445. m_Header.pNextNode = NULL;
  447. m_MemStack.FreeAllChunks();
  448. }
  449. //---------------------------------------------------------------------------
  450. // 函数: SplitKeyValue
  451. // 功能: 分割Key和Value
  452. // 参数: pString Key=Value
  453. // 返回: 指向Value
  454. //---------------------------------------------------------------------------
  455. LPSTR KIniFile::SplitKeyValue(LPSTR pString)
  456. {
  457. LPSTR pValue = pString;
  458. while (*pValue)
  459. {
  460. if (*pValue == '=')
  461. break;
  462. pValue++;
  463. }
  464. *pValue = 0;
  465. return pValue + 1;
  466. }
  467. //---------------------------------------------------------------------------
  468. // 函数: String2Id
  469. // 功能: 字符串转成32 bits ID
  470. // 参数: pString 字符串
  471. // 返回: 32 bits ID
  472. //---------------------------------------------------------------------------
  473. DWORD KIniFile::String2Id(LPCSTR pString)
  474. {
  475. DWORD Id = 0;
  476. for (int i=0; pString[i]; i++)
  477. {
  478. Id = (Id + (i+1) * pString[i]) % 0x8000000b * 0xffffffef;
  479. }
  480. return Id ^ 0x12345678;
  481. }
  482. //---------------------------------------------------------------------------
  483. // 函数: IsSectionExist
  484. // 功能: Section是否存在
  485. // 参数: pSection 节的名字
  486. // 返回: BOOL
  487. //---------------------------------------------------------------------------
  488. BOOL KIniFile::IsSectionExist(LPCSTR pSection)
  489. {
  490. // setup section name
  491. char szSection[32] = "[";
  492. if (pSection[0] != '[')
  493. {
  494. g_StrCat(szSection, pSection);
  495. g_StrCat(szSection, "]");
  496. }
  497. else
  498. {
  499. g_StrCpy(szSection, pSection);
  500. }
  502. // search for the matched section
  503. SECNODE* pSecNode = m_Header.pNextNode;
  504. DWORD dwID = String2Id(szSection);
  505. while (pSecNode != NULL)
  506. {
  507. if (dwID == pSecNode->dwID)
  508. return TRUE;
  509. pSecNode = pSecNode->pNextNode;
  510. }
  512. return FALSE;
  513. }
  514. //---------------------------------------------------------------------------
  515. // 函数: EraseSection
  516. // 功能: 清除一个Section的内容
  517. // 参数: pSection 节的名字
  518. // 返回: void
  519. //---------------------------------------------------------------------------
  520. void KIniFile::EraseSection(LPCSTR pSection)
  521. {
  522. // setup section name
  523. char szSection[32] = "[";
  524. if (pSection[0] != '[')
  525. {
  526. g_StrCat(szSection, pSection);
  527. g_StrCat(szSection, "]");
  528. }
  529. else
  530. {
  531. g_StrCpy(szSection, pSection);
  532. }
  534. // search for the matched section
  535. SECNODE* pSecNode = m_Header.pNextNode;
  536. DWORD dwID = String2Id(szSection);
  537. while (pSecNode != NULL)
  538. {
  539. if (dwID == pSecNode->dwID)
  540. {
  541. break;
  542. }
  543. pSecNode = pSecNode->pNextNode;
  544. }
  546. // if no such section found
  547. if (pSecNode == NULL)
  548. {
  549. return;
  550. }
  552. // erase all key in the section
  553. KEYNODE* pThisKey = &pSecNode->pKeyNode;
  554. KEYNODE* pNextKey = pThisKey->pNextNode;
  555. while (pNextKey != NULL)
  556. {
  557. pThisKey = pNextKey->pNextNode;
  558. m_MemStack.Free(pNextKey->pKey);
  559. m_MemStack.Free(pNextKey->pValue);
  560. m_MemStack.Free(pNextKey);
  561. pNextKey = pThisKey;
  562. }
  563. pSecNode->pKeyNode.pNextNode = NULL;
  564. }
  566. //---------------------------------------------------------------------------
  567. // 函数: EraseKey
  568. // 功能: 清除Section的下一个Key的内容
  569. // 参数: pSection 节的名字
  570. // 返回: void
  571. //---------------------------------------------------------------------------
  572. void KIniFile::EraseKey(LPCSTR lpSection, LPCSTR lpKey)
  573. {
  574. // setup section name
  575. char szSection[32] = "[";
  576. if (lpSection[0] != '[')
  577. {
  578. g_StrCat(szSection, lpSection);
  579. g_StrCat(szSection, "]");
  580. }
  581. else
  582. {
  583. g_StrCpy(szSection, lpSection);
  584. }
  586. // search for the matched section
  587. SECNODE* pSecNode = m_Header.pNextNode;
  588. DWORD dwID = String2Id(szSection);
  589. while (pSecNode != NULL)
  590. {
  591. if (dwID == pSecNode->dwID)
  592. {
  593. break;
  594. }
  595. pSecNode = pSecNode->pNextNode;
  596. }
  598. // if no such section found
  599. if (pSecNode == NULL)
  600. {
  601. return;
  602. }
  604. // erase all key in the section
  605. KEYNODE* pThisKey = &pSecNode->pKeyNode;
  606. KEYNODE* pNextKey = pThisKey->pNextNode;
  607. dwID = String2Id(lpKey);
  608. while (pNextKey != NULL)
  609. {
  611. if (pNextKey->dwID == dwID)
  612. {
  613. pThisKey->pNextNode = pNextKey->pNextNode;
  614. m_MemStack.Free(pNextKey->pKey);
  615. m_MemStack.Free(pNextKey->pValue);
  616. m_MemStack.Free(pNextKey);
  617. return;
  618. }
  619. pThisKey = pNextKey;
  620. pNextKey = pNextKey->pNextNode;
  621. }
  623. }
  627. //---------------------------------------------------------------------------
  628. // 函数: SetKeyValue
  629. // 功能: 设置Key的Value
  630. // 参数: pSection 节名
  631. // pKey 建名
  632. // pValue 建值
  633. // 返回: TRUE－成功 FALSE－失败
  634. //---------------------------------------------------------------------------
  635. BOOL KIniFile::SetKeyValue(
  636. LPCSTR pSection,
  637. LPCSTR pKey,
  638. LPCSTR pValue)
  639. {
  640. int nLen;
  641. DWORD dwID;
  643. // setup section name
  644. char szSection[32] = "[";
  645. if (pSection[0] != '[')
  646. {
  647. g_StrCat(szSection, pSection);
  648. g_StrCat(szSection, "]");
  649. }
  650. else
  651. {
  652. g_StrCpy(szSection, pSection);
  653. }
  655. // search for the matched section
  656. SECNODE* pThisSecNode = &m_Header;
  657. SECNODE* pNextSecNode = pThisSecNode->pNextNode;
  658. dwID = String2Id(szSection);
  659. while (pNextSecNode != NULL)
  660. {
  661. if (dwID == pNextSecNode->dwID)
  662. {
  663. break;
  664. }
  665. pThisSecNode = pNextSecNode;
  666. pNextSecNode = pThisSecNode->pNextNode;
  667. }
  669. // if no such section found create a new section
  670. if (pNextSecNode == NULL)
  671. {
  672. nLen = g_StrLen(szSection) + 1;
  673. pNextSecNode = (SECNODE *)m_MemStack.Push(sizeof(SECNODE));
  674. pNextSecNode->pSection = (char *)m_MemStack.Push(nLen);
  675. g_MemCopy(pNextSecNode->pSection, szSection, nLen);
  676. pNextSecNode->dwID = dwID;
  677. pNextSecNode->pKeyNode.pNextNode = NULL;
  678. pNextSecNode->pNextNode = NULL;
  679. pThisSecNode->pNextNode = pNextSecNode;
  680. }
  682. // search for the same key
  683. KEYNODE* pThisKeyNode = &pNextSecNode->pKeyNode;
  684. KEYNODE* pNextKeyNode = pThisKeyNode->pNextNode;
  685. dwID = String2Id(pKey);
  686. while (pNextKeyNode != NULL)
  687. {
  688. if (dwID == pNextKeyNode->dwID)
  689. {
  690. break;
  691. }
  692. pThisKeyNode = pNextKeyNode;
  693. pNextKeyNode = pThisKeyNode->pNextNode;
  694. }
  696. // if no such key found create a new key
  697. if (pNextKeyNode == NULL)
  698. {
  699. pNextKeyNode = (KEYNODE *)m_MemStack.Push(sizeof(KEYNODE));
  701. nLen = g_StrLen(pKey) + 1;
  702. pNextKeyNode->pKey = (char *)m_MemStack.Push(nLen);
  703. g_MemCopy(pNextKeyNode->pKey, (void*)pKey, nLen);
  705. nLen = g_StrLen(pValue) + 1;
  706. pNextKeyNode->pValue = (char *)m_MemStack.Push(nLen);
  707. g_MemCopy(pNextKeyNode->pValue, (void*)pValue, nLen);
  709. pNextKeyNode->dwID = dwID;
  710. pNextKeyNode->pNextNode = NULL;
  711. pThisKeyNode->pNextNode = pNextKeyNode;
  712. }
  713. // replace the old value with new
  714. else
  715. {
  716. m_MemStack.Free(pNextKeyNode->pValue);
  717. nLen = g_StrLen(pValue) + 1;
  718. pNextKeyNode->pValue = (char *)m_MemStack.Push(nLen);
  719. g_MemCopy(pNextKeyNode->pValue, (void*)pValue, nLen);
  720. }
  721. return TRUE;
  722. }
  723. //---------------------------------------------------------------------------
  724. // 函数: GetKeyValue
  725. // 功能: 取得Key的Value
  726. // 参数: pSection 节名
  727. // pKey 建名
  728. // pValue 建值
  729. // 返回: TRUE－成功 FALSE－失败
  730. //---------------------------------------------------------------------------
  731. BOOL KIniFile::GetKeyValue(
  732. LPCSTR pSection,
  733. LPCSTR pKey,
  734. LPSTR pValue,
  735. DWORD dwSize)
  736. {
  737. DWORD dwID;
  739. // setup section name
  740. char szSection[32] = "[";
  741. if (pSection[0] != '[')
  742. {
  743. g_StrCat(szSection, pSection);
  744. g_StrCat(szSection, "]");
  745. }
  746. else
  747. {
  748. g_StrCpy(szSection, pSection);
  749. }
  751. // search for the matched section
  752. SECNODE* pSecNode = m_Header.pNextNode;
  753. dwID = String2Id(szSection);
  754. while (pSecNode != NULL)
  755. {
  756. if (dwID == pSecNode->dwID)
  757. {
  758. break;
  759. }
  760. pSecNode = pSecNode->pNextNode;
  761. }
  763. // if no such section founded
  764. if (pSecNode == NULL)
  765. {
  766. return FALSE;
  767. }
  769. // search for the same key
  770. KEYNODE* pKeyNode = pSecNode->pKeyNode.pNextNode;
  771. dwID = String2Id(pKey);
  772. while (pKeyNode != NULL)
  773. {
  774. if (dwID == pKeyNode->dwID)
  775. {
  776. break;
  777. }
  778. pKeyNode = pKeyNode->pNextNode;
  779. }
  781. // if no such key found
  782. if (pKeyNode == NULL)
  783. {
  784. return FALSE;
  785. }
  787. // copy the value of the key
  788. g_StrCpyLen(pValue, pKeyNode->pValue, dwSize);
  789. return TRUE;
  790. }
  791. //---------------------------------------------------------------------------
  792. // 函数: GetString
  793. // 功能: 读取一个字符串
  794. // 参数: lpSection 节名
  795. // lpKeyName 建名
  796. // lpDefault 缺省值
  797. // lpRString 返回值
  798. // dwSize 返回字符串的最大长度
  799. // 返回: void
  800. //---------------------------------------------------------------------------
  801. BOOL KIniFile::GetString(
  802. LPCSTR lpSection, // points to section name
  803. LPCSTR lpKeyName, // points to key name
  804. LPCSTR lpDefault, // points to default string
  805. LPSTR lpRString, // points to destination buffer
  806. DWORD dwSize // size of string buffer
  807. )
  808. {
  809. if (GetKeyValue(lpSection, lpKeyName, lpRString, dwSize))
  810. return TRUE;
  811. g_StrCpyLen(lpRString, lpDefault, dwSize);
  812. return FALSE;
  813. }
  814. //---------------------------------------------------------------------------
  815. // 函数: GetInteger
  816. // 功能: 读取一个整数
  817. // 参数: lpSection 节名
  818. // lpKeyName 建名
  819. // nDefault 缺省值
  820. // pnValue 返回值
  821. // 返回: void
  822. //---------------------------------------------------------------------------
  823. BOOL KIniFile::GetInteger(
  824. LPCSTR lpSection, // points to section name
  825. LPCSTR lpKeyName, // points to key name
  826. int   nDefault, // default value
  827. int   *pnValue          // points to value
  828. )
  829. {
  830. char Buffer[32];
  831. if (GetKeyValue(lpSection, lpKeyName, Buffer, sizeof(Buffer)))
  832. {
  833. *pnValue = atoi(Buffer);
  834. return TRUE;
  835. }
  836. else
  837. {
  838. *pnValue = nDefault;
  839. return FALSE;
  840. }
  841. }
  842. //---------------------------------------------------------------------------
  843. // 函数: GetInteger2
  844. // 功能: 读取2个整数，整数之间用逗号分割。
  845. // 参数: lpSection 节名
  846. // lpKeyName 建名
  847. // pnValue1 返回值1
  848. // pnValue2 返回值2
  849. // 返回: void
  850. //---------------------------------------------------------------------------
  851. void KIniFile::GetInteger2(
  852. LPCSTR lpSection, // points to section name
  853. LPCSTR lpKeyName, // points to key name
  854. int   *pnValue1, // value 1
  855. int   *pnValue2 // value 2
  856. )
  857. {
  858. char  Buffer[32];
  859. char* pChar = Buffer;
  860. if (GetKeyValue(lpSection, lpKeyName, Buffer, sizeof(Buffer)))
  861. {
  862. while (*pChar)
  863. {
  864. if (',' == *pChar)
  865. {
  866. *pChar++ = 0;
  867. break;
  868. }
  869. pChar++;
  870. }
  871. *pnValue1 = atoi(Buffer);
  872. *pnValue2 = atoi(pChar);
  873. }
  874. }
  875. //---------------------------------------------------------------------------
  876. // 函数: GetFloat
  877. // 功能: 读取1个浮点数
  878. // 参数: lpSection 节名
  879. // lpKeyName 建名
  880. // fDefault 缺省值
  881. // pfValue 返回值
  882. // 返回: void
  883. //---------------------------------------------------------------------------
  884. BOOL KIniFile::GetFloat(
  885. LPCSTR lpSection, // points to section name
  886. LPCSTR lpKeyName, // points to key name
  887. float fDefault, // default value
  888. float *pfValue        // return value
  889. )
  890. {
  891. char Buffer[32];
  892. if (GetKeyValue(lpSection, lpKeyName, Buffer, sizeof(Buffer)))
  893. {
  894. *pfValue = (float)atof(Buffer);
  895. return TRUE;
  896. }
  897. else
  898. {
  899. *pfValue = fDefault;
  900. return FALSE;
  901. }
  902. }
  903. //---------------------------------------------------------------------------
  904. // 函数: GetFloat2
  905. // 功能: 读取2个浮点数，之间用逗号分割。
  906. // 参数: lpSection 节名
  907. // lpKeyName 建名
  908. // pfValue1 返回值1
  909. // pfValue2 返回值2
  910. // 返回: void
  911. //---------------------------------------------------------------------------
  912. void KIniFile::GetFloat2(
  913. LPCSTR lpSection, // points to section name
  914. LPCSTR lpKeyName, // points to key name
  915. float *pfValue1, // value 1
  916. float *pfValue2 // value 2
  917. )
  918. {
  919. char  Buffer[32];
  920. char* pChar = Buffer;
  922. if (GetKeyValue(lpSection, lpKeyName, Buffer, sizeof(Buffer)))
  923. {
  924. while (*pChar)
  925. {
  926. if (',' == *pChar)
  927. {
  928. *pChar++ = 0;
  929. break;
  930. }
  931. pChar++;
  932. }
  933. *pfValue1 = (float)atof(Buffer);
  934. *pfValue2 = (float)atof(pChar);
  935. }
  936. }
  937. //---------------------------------------------------------------------------
  938. // 函数: GetStruct
  939. // 功能: 读取一个结构
  940. // 参数: lpSection 节名
  941. // lpKeyName 建名
  942. // lpStruct 缓存
  943. // dwSize 缓存大小
  944. // 返回: void
  945. //---------------------------------------------------------------------------
  946. void KIniFile::GetStruct(
  947. LPCSTR lpSection, // pointer to section name
  948. LPCSTR lpKeyName, // pointer to key name
  949. LPVOID lpStruct, // pointer to buffer that contains data to add
  950. DWORD dwSize // size, in bytes, of the buffer
  951. )
  952. {
  953. char    Buffer[512];
  954. LPBYTE lpByte;
  955. BYTE ah,al;
  957. if (!GetKeyValue(lpSection, lpKeyName, Buffer, sizeof(Buffer)))
  958. return;
  959. lpByte = (LPBYTE)lpStruct;
  960. int len = g_StrLen(Buffer);
  961. if (len / 2 != (int)dwSize)
  962. return;
  963. for (int i = 0; i < len; i += 2)
  964. {
  965. // get byte high
  966. ah = Buffer[i];
  967. if ((ah >= 48) && (ah <= 57))
  968. ah = (BYTE)(ah - 48);
  969. else
  970. ah = (BYTE)(ah - 65 + 10);
  971. // get byte low
  972. al = Buffer[i+1];
  973. if ((al >= 48) && (al <= 57))
  974. al = (BYTE)(al - 48);
  975. else
  976. al = (BYTE)(al - 65 + 10);
  977. // set struct bye
  978. *lpByte++ = (BYTE)(ah * 16 + al);
  979. }
  980. }
  981. //---------------------------------------------------------------------------
  982. // 函数: WriteString
  983. // 功能: 写入一个字符串
  984. // 参数: lpSection 节名
  985. // lpKeyName 建名
  986. // lpString 字符串
  987. // 返回: void
  988. //---------------------------------------------------------------------------
  989. void KIniFile::WriteString(
  990. LPCSTR lpSection, // pointer to section name
  991. LPCSTR lpKeyName, // pointer to key name
  992. LPCSTR lpString // pointer to string to add
  993. )
  994. {
  995. SetKeyValue(lpSection, lpKeyName, lpString);
  996. }
  997. //---------------------------------------------------------------------------
  998. // 函数: WriteInteger
  999. // 功能: 写入一个整数
  1000. // 参数: lpSection 节名
  1001. // lpKeyName 建名
  1002. // nValue 整数
  1003. // 返回: void
  1004. //---------------------------------------------------------------------------
  1005. void KIniFile::WriteInteger(
  1006. LPCSTR lpSection, // pointer to section name
  1007. LPCSTR lpKeyName, // pointer to key name
  1008. int  nValue // Integer to write
  1009. )
  1010. {
  1011. char Buffer[32];
  1013. sprintf(Buffer, "%d", nValue);
  1014. SetKeyValue(lpSection, lpKeyName, Buffer);
  1015. }
  1016. //---------------------------------------------------------------------------
  1017. // 函数: WriteInteger2
  1018. // 功能: 写入2个整数
  1019. // 参数: lpSection 节名
  1020. // lpKeyName 建名
  1021. // nValue1 整数1
  1022. // nValue2 整数2
  1023. // 返回: void
  1024. //---------------------------------------------------------------------------
  1025. void KIniFile::WriteInteger2(
  1026. LPCSTR lpSection, // pointer to section name
  1027. LPCSTR lpKeyName, // pointer to key name
  1028. int  Value1, // value 1 to write
  1029. int Value2 // value 2 to write
  1030. )
  1031. {
  1032. char Buffer[32];
  1034. sprintf(Buffer, "%d,%d", Value1, Value2);
  1035. SetKeyValue(lpSection, lpKeyName, Buffer);
  1036. }
  1037. //---------------------------------------------------------------------------
  1038. // 函数: WriteFloat
  1039. // 功能: 写入1个浮点数
  1040. // 参数: lpSection 节名
  1041. // lpKeyName 建名
  1042. // fValue 浮点数
  1043. // 返回: void
  1044. //---------------------------------------------------------------------------
  1045. void KIniFile::WriteFloat(
  1046. LPCSTR lpSection, // pointer to section name
  1047. LPCSTR lpKeyName, // pointer to key name
  1048. float fValue // Integer to write
  1049. )
  1050. {
  1051. char Buffer[32];
  1053. sprintf(Buffer,"%f",fValue);
  1054. SetKeyValue(lpSection, lpKeyName, Buffer);
  1055. }
  1056. //---------------------------------------------------------------------------
  1057. // 函数: WriteFloat2
  1058. // 功能: 写入2个浮点数
  1059. // 参数: lpSection 节名
  1060. // lpKeyName 建名
  1061. // fValue1 浮点数1
  1062. // fValue2 浮点数2
  1063. // 返回: void
  1064. //---------------------------------------------------------------------------
  1065. void KIniFile::WriteFloat2(
  1066. LPCSTR lpSection, // pointer to section name
  1067. LPCSTR lpKeyName, // pointer to key name
  1068. float  fValue1, // value 1 to write
  1069. float fValue2 // value 2 to write
  1070. )
  1071. {
  1072. char Buffer[32];
  1074. sprintf(Buffer, "%f,%f", fValue1, fValue2);
  1075. SetKeyValue(lpSection, lpKeyName, Buffer);
  1076. }
  1077. //---------------------------------------------------------------------------
  1078. // 函数: WriteFloat2
  1079. // 功能: 写入一个结构
  1080. // 参数: lpSection 节名
  1081. // lpKeyName 建名
  1082. // lpStruct 结构
  1083. // dwSize 结构大小
  1084. // 返回: void
  1085. //---------------------------------------------------------------------------
  1086. void KIniFile::WriteStruct(
  1087. LPCSTR lpSection, // pointer to section name
  1088. LPCSTR lpKeyName, // pointer to key name
  1089. LPVOID lpStruct, // pointer to buffer that contains data to add
  1090. DWORD  dwSize // size, in bytes, of the buffer
  1091. )
  1092. {
  1093. char    Buffer[512];
  1094. LPSTR lpBuff = Buffer;
  1095. LPBYTE lpByte;
  1097. if (dwSize * 2 >= 512)
  1098. {
  1099. return;
  1100. }
  1101. lpByte = (LPBYTE) lpStruct;
  1102. for (DWORD i=0; i<dwSize; i++)
  1103. {
  1104. sprintf(lpBuff,"%02x",*lpByte);
  1105. lpBuff++;
  1106. lpBuff++;
  1107. lpByte++;
  1108. }
  1109. g_StrUpper(Buffer);
  1110. SetKeyValue(lpSection, lpKeyName, Buffer);
  1111. }
  1112. //---------------------------------------------------------------------------
  1113. //---------------------------------------------------------------------------
  1114. BOOL KIniFile::GetNextSection(LPCSTR pSection, LPSTR pNextSection)
  1115. {
  1117. if (!pSection[0]) // 传入参数为""时就是取第一个Section
  1118. {
  1119. if (!m_Header.pNextNode)
  1120. return FALSE;
  1121. else
  1122. {
  1123. g_StrCpy(pNextSection, m_Header.pNextNode->pSection);
  1124. return TRUE;
  1125. }
  1126. }
  1127. else
  1128. {
  1129. char szSection[32] = "[";
  1130. if (pSection[0] != '[')
  1131. {
  1132. g_StrCat(szSection, pSection);
  1133. g_StrCat(szSection, "]");
  1134. }
  1135. else
  1136. {
  1137. g_StrCpy(szSection, pSection);
  1138. }
  1139. // 查找参数给定的Section
  1140. SECNODE* pThisSecNode = &m_Header;
  1141. SECNODE* pNextSecNode = pThisSecNode->pNextNode;
  1142. DWORD dwID = String2Id(szSection);
  1143. while (pNextSecNode != NULL)
  1144. {
  1145. if (dwID == pNextSecNode->dwID)
  1146. {
  1147. break;
  1148. }
  1149. pThisSecNode = pNextSecNode;
  1150. pNextSecNode = pThisSecNode->pNextNode;
  1151. }
  1152. // 没有这个Section，无所谓下一个
  1153. if (!pNextSecNode)
  1154. {
  1155. return FALSE;
  1156. }
  1157. else
  1158. {
  1159. // 参数给定的Section已经是最后一个了
  1160. if (!pNextSecNode->pNextNode)
  1161. {
  1162. return FALSE;
  1163. }
  1164. else
  1165. {
  1166. g_StrCpy(pNextSection, pNextSecNode->pNextNode->pSection);
  1167. return TRUE;
  1168. }
  1169. }
  1170. }
  1171. }
  1172. //---------------------------------------------------------------------------
  1173. //---------------------------------------------------------------------------
  1174. BOOL KIniFile::GetNextKey(LPCSTR pSection, LPCSTR pKey, LPSTR pNextKey)
  1175. {
  1176. char szSection[32] = "[";
  1177. if (pSection[0] != '[')
  1178. {
  1179. g_StrCat(szSection, pSection);
  1180. g_StrCat(szSection, "]");
  1181. }
  1182. else
  1183. {
  1184. g_StrCpy(szSection, pSection);
  1185. }
  1186. // 查找参数给定的Section
  1187. SECNODE* pThisSecNode = &m_Header;
  1188. SECNODE* pNextSecNode = pThisSecNode->pNextNode;
  1189. DWORD dwID = String2Id(szSection);
  1190. while (pNextSecNode != NULL)
  1191. {
  1192. if (dwID == pNextSecNode->dwID)
  1193. {
  1194. break;
  1195. }
  1196. pThisSecNode = pNextSecNode;
  1197. pNextSecNode = pThisSecNode->pNextNode;
  1198. }
  1199. // 没有这个Section，无所谓取Key
  1200. if (!pNextSecNode)
  1201. {
  1202. return FALSE;
  1203. }
  1205. KEYNODE* pThisKeyNode = &pNextSecNode->pKeyNode;
  1206. KEYNODE* pNextKeyNode = pThisKeyNode->pNextNode;
  1208. // Key给的参数为""的话，取第一个Key
  1209. if (!pKey[0])
  1210. {
  1211. // 没有Key，返回失败
  1212. if (!pNextKeyNode->pKey)
  1213. {
  1214. return FALSE;
  1215. }
  1216. else
  1217. {
  1218. g_StrCpy(pNextKey, pNextKeyNode->pKey);
  1219. return TRUE;
  1220. }
  1221. }
  1223. dwID = String2Id(pKey);
  1224. while(pNextKeyNode != NULL)
  1225. {
  1226. if (dwID == pNextKeyNode->dwID)
  1227. {
  1228. break;
  1229. }
  1230. pThisKeyNode = pNextKeyNode;
  1231. pNextKeyNode = pThisKeyNode->pNextNode;
  1232. }
  1233. // 找不到所给的Key，无所谓下一个
  1234. if (!pNextKeyNode)
  1235. {
  1236. return FALSE;
  1237. }
  1238. // 参数给定的Key已经是最后一个了
  1239. if (!pNextKeyNode->pNextNode)
  1240. {
  1241. return FALSE;
  1242. }
  1243. else
  1244. {
  1245. g_StrCpy(pNextKey, pNextKeyNode->pNextNode->pKey);
  1246. return TRUE;
  1247. }
  1248. }
  1250. int KIniFile::GetSectionCount()
  1251. {
  1252. char Section[200];
  1253. char Section1[200];
  1254. if (!GetNextSection("",Section)) return 0;
  1255. int i  = 1;
  1256. while (1)
  1257. {
  1258. strcpy(Section1, Section);
  1259. if (!GetNextSection(Section1, Section)) return i;
  1260. i++;
  1261. }
  1262. return i;
  1263. }
  1265. // 如果从文件中没有取到对应的Section 和 Key则 pRect里面的值不变
  1266. void KIniFile::GetRect(LPCSTR lpSection, LPCSTR lpKeyName, RECT *pRect)
  1267. {
  1268. char  Buffer[256];
  1270. if (GetKeyValue(lpSection, lpKeyName, Buffer, sizeof(Buffer)))
  1271. {
  1272.         const char *pcszTemp = Buffer;
  1273.         
  1274.         pRect->left   = KSG_StringGetInt(&pcszTemp, 0);
  1275.         KSG_StringSkipSymbol(&pcszTemp, ',');
  1276.         pRect->top    = KSG_StringGetInt(&pcszTemp, 0);
  1277.         KSG_StringSkipSymbol(&pcszTemp, ',');
  1278.         pRect->right  = KSG_StringGetInt(&pcszTemp, 0);
  1279.         KSG_StringSkipSymbol(&pcszTemp, ',');
  1280.         pRect->bottom = KSG_StringGetInt(&pcszTemp, 0);
  1281. //sscanf(Buffer, "%d,%d,%d,%d", &(pRect->left), &(pRect->top), &(pRect->right), &(pRect->bottom));
  1282. }
  1283. }
  1285. void KIniFile::GetFloat3(LPCSTR lpSection, LPCSTR lpKeyName, float* pRect)
  1286. {
  1287. char Buffer[256];
  1289. if (GetKeyValue(lpSection, lpKeyName, Buffer, sizeof(Buffer)))
  1290. {
  1291. sscanf(Buffer, "%f,%f,%f", &pRect[0], &pRect[1], &pRect[2]);
  1292. }
  1293. }
  1295. void KIniFile::GetFloat4(LPCSTR lpSection, LPCSTR lpKeyName, float* pRect)
  1296. {
  1297. char  Buffer[256];
  1299. if (GetKeyValue(lpSection, lpKeyName, Buffer, sizeof(Buffer)))
  1300. {
  1301. sscanf(Buffer, "%f,%f,%f,%f", &pRect[0], &pRect[1], &pRect[2], &pRect[3]);
  1302. }
  1303. }
  1305. void KIniFile::GetBool(LPCSTR lpSection, LPCSTR lpKeyName, BOOL* pBool)
  1306. {
  1307. char  Buffer;
  1309. if (GetKeyValue(lpSection, lpKeyName, &Buffer, 1))
  1310. {
  1311. if ('T' == Buffer)
  1312. *pBool = TRUE;
  1313. else
  1314. *pBool = FALSE;
  1315. }
  1316. }