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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
JXINIFile.cpp
资源名称：MiniCA2.rar　[点击查看]
上传用户：dengkfang
上传日期：2008-12-30
资源大小：5233k
文件大小：98k
源码类别：

CA认证

开发平台：

Visual C++

JXINIFile.cpp：源码内容
  1. /************************************
  2.   REVISION LOG ENTRY
  3.   Written and Revision By: Zhang, Zhefu
  4.   Contact: codetiger@hotmail
  5.   URL: http://www.chi.c.dendai.ac.jp/~zhang/index.htm
  6.   Revised on 2001/09/27 in FujiSoftABC Ltd. Japan
  7.   Comment: JXINIFile Implementation File
  8.  ************************************/
  9. //
  10. //
  11. //Last Modified 2001/9/4
  12. //Reason: NotePad add 0xFF FE to the text file header, make the first
  13. //        section unrecognizable. 
  14. //Fixment: Add member m_pTrueData to pass the 2 byte head
  16. #include "stdAfx.h"
  17. #include "JXIniFile.h"
  20. //dwSize = -1 if szMultiByte null terminated
  21. //dwSize not include the ending null
  22. //return WCHARs
  23. LPWSTR _A2W(LPSTR szMultiByte, DWORD dwSize, DWORD& dwRetSize)
  24. {
  25. static WCHAR szInternalBuffer[8096];
  26. if(szMultiByte == NULL || (dwSize == -1 && ::strlen(szMultiByte) == 0)) 
  27. { dwRetSize = 0; return NULL; }
  28. int nLen = MultiByteToWideChar(CP_ACP, 0,szMultiByte, dwSize, NULL, NULL);
  29. if(nLen > 8096) { dwRetSize = 0; return NULL; } 
  30. //dwRetSize in WCHARs, include null if szMultiByte nulled ended
  31.     dwRetSize = MultiByteToWideChar(CP_ACP, 0, szMultiByte, dwSize, szInternalBuffer, 8096);
  32. if(dwSize == -1)
  33. dwRetSize--;
  34. else
  35.     szInternalBuffer[dwRetSize] = WCHAR('');
  36.     return szInternalBuffer;
  37. }
  39. //return BYTEs
  40. LPSTR _W2A(LPWSTR szUnicode, DWORD dwSize, DWORD& dwRetSize)
  41. {
  42. static char szInternalBuffer[8096];
  43. if(szUnicode == NULL || (dwSize == -1 && ::wcslen(szUnicode) == 0)) 
  44. { dwRetSize = 0; return NULL; }
  45. int nLen = WideCharToMultiByte(CP_ACP, 0,szUnicode, dwSize, NULL, 0, NULL, FALSE);
  46. if(nLen > 8096) { dwRetSize = 0; return NULL; } 
  47. //Ret: in BYTEs, The number includes the byte for the null terminator. if szUnicode null ended
  48. dwRetSize = WideCharToMultiByte(CP_ACP, 0, szUnicode, dwSize, szInternalBuffer, nLen, NULL, FALSE);
  49.     if(dwSize == -1) //dwRetSize include null, szInternalBuffer null ended
  50. dwRetSize--;
  51. else
  52. szInternalBuffer[dwRetSize] = char('');
  53. return szInternalBuffer;
  54. }
  56. CJXINIFile::CJXINIFile() 
  57. {
  58. m_strFilename = _T("");
  59. m_hFile = INVALID_HANDLE_VALUE;
  60. m_hMMF = NULL;
  61. m_dwSize = 0;
  62. m_pData = 0;
  63. m_bSectionMapDirty = TRUE; //No Section Map
  64. m_bSectionMapLock = FALSE;
  65. m_mapSection.InitHashTable(700, TRUE);
  66. }
  68. CJXINIFile::~CJXINIFile()
  69. {
  70. UnloadIniFile();
  71. if(m_pData)
  72. {
  73. ::UnmapViewOfFile(m_pData);
  74. m_pData = NULL;
  75. }
  76. if(m_hMMF != NULL)
  77. {
  78. ::CloseHandle(m_hMMF);
  79. m_hMMF = NULL;
  80. }
  81. if(m_hFile != INVALID_HANDLE_VALUE)
  82. {
  83. ::CloseHandle(m_hFile);
  84. m_hFile = INVALID_HANDLE_VALUE;
  85. }
  86. }
  88. //CMap m_mapSection; 
  89. void CJXINIFile::UpdateMapA()
  90. {
  91. if(m_bSectionMapLock) return;
  92. LPSTR pHead = (LPSTR)m_pTrueData;
  93. LPSTR p1 = pHead;
  94. LPSTR p2 = pHead;
  96. p1 = pHead;
  97.     while(p1- pHead < (int)(m_dwUseSize/sizeof(char)) - 1)
  98. {
  99. while(p1- pHead < (int)(m_dwUseSize/sizeof(char)) - 1 &&
  100. *p1 != char('['))
  101. p1++;
  102. p2 = p1;
  103. while(p2- pHead < (int)(m_dwUseSize/sizeof(char)) - 1 &&
  104. *p2 != char(']'))
  105. p2++;
  106. if(p1- pHead < (int)(m_dwUseSize/sizeof(char)) &&
  107. p2- pHead < (int)(m_dwUseSize/sizeof(char)))
  108. {
  109. //Found, Ready To Map
  110. int lenSection = p2 - p1 - 1;
  111. //Section Name Length must >= 1
  112. if(lenSection >= 1)
  113. {
  114. p1++;
  115. CString strSection;
  116. #ifdef _UNICODE
  117.                 DWORD dwRetSize;
  118. PWSTR pTemp = _A2W(p1, lenSection, dwRetSize);
  119. ::wcsncpy(strSection.GetBuffer(dwRetSize), pTemp, dwRetSize);
  120.                 strSection.ReleaseBuffer(dwRetSize);
  121. #else
  122. ::strncpy(strSection.GetBuffer(lenSection), p1, lenSection);
  123.                 strSection.ReleaseBuffer(lenSection);
  124. #endif
  125. p1--; //point to [
  126. m_mapSection.SetAt(strSection, (LPVOID)p1);
  127. } 
  128. }
  129. p1 = p2 + 1;
  130. }
  131. //Debug Part
  132. m_bSectionMapDirty = FALSE;
  133.     return ;
  134. }
  136. void CJXINIFile::UpdateMapW()
  137. {
  138. if(m_bSectionMapLock) return;
  139. LPWSTR pHead = (LPWSTR)m_pTrueData;
  140. LPWSTR p1 = pHead;
  141. LPWSTR p2 = pHead;
  142.     //Calculate the section number
  143. // int nSection = 0;
  144. //    while(p1- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) - 1)
  145. // {
  146. // if(*p1 == WCHAR('[')) nSection++;
  147. // p1++;
  148. // }
  149. // if(nSection < 13) nSection = 13;
  150. // //allow 20% margine
  151. // m_mapSection.InitHashTable((UINT)(1.2*nSection), TRUE);
  152.     
  153. p1 = pHead;
  154.     while(p1- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) - 1)
  155. {
  156. while(p1- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) - 1 &&
  157. *p1 != WCHAR('['))
  158. p1++;
  159. p2 = p1;
  160. while(p2- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) - 1 &&
  161. *p2 != WCHAR(']'))
  162. p2++;
  163. if(p1- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) &&
  164. p2- pHead < (int)(m_dwUseSize/sizeof(WCHAR)))
  165. {
  166. //Found, Ready To Map
  167. int lenSection = p2 - p1 - 1;
  168. //Section Name Length must >= 1
  169. if(lenSection >= 1)
  170. {
  171. p1++;
  172. CString strSection;
  173. #ifdef _UNICODE
  174. ::wcsncpy(strSection.GetBuffer(lenSection), p1, lenSection);
  175.                 strSection.ReleaseBuffer(lenSection);
  176. #else
  177. DWORD dwRetSize;
  178. PSTR pTemp = _W2A(p1, lenSection, dwRetSize);
  179.                 ::strncpy(strSection.GetBuffer(dwRetSize), pTemp, dwRetSize);
  180.                 strSection.ReleaseBuffer(dwRetSize);
  181. #endif
  182. p1--; //point to [
  183. m_mapSection.SetAt(strSection, (LPVOID)p1);
  184. } 
  185. }
  186. p1 = p2 + 1;
  187. }
  188. //Debug Part
  189. m_bSectionMapDirty = FALSE;
  191. //  int count = m_mapSection.GetCount();
  192. // CString str; str.Format(_T("UpdateW %d"), count); 
  193. // AfxMessageBox(str);
  194. /*
  195. POSITION pos = m_mapSection.GetStartPosition();
  196. while(pos)
  197. {
  198. CString strKey;
  199. LPVOID lpPos;
  200. m_mapSection.GetNextAssoc(pos, strKey, lpPos);
  201. if(AfxMessageBox(strKey, MB_YESNO | MB_ICONINFORMATION) == IDNO)
  202. return;
  203. }
  204. */
  205. return ;
  206. }
  208. void CJXINIFile::ResizeMap(int nNewSize)
  209. {
  210. ASSERT(nNewSize > 0);
  211. m_mapSection.RemoveAll();
  212. m_mapSection.InitHashTable(nNewSize);
  213. }
  215. // return 0 -- no key, size too small to put value
  216. //return -1  -- error
  217. //return string length (of course > 1)
  218. //Ex Version use Map
  219. DWORD CJXINIFile::GetPrivateProfileStringExA(
  220.          LPCSTR lpAppName,        // section name
  221.          LPCSTR lpKeyName,        // key name
  222.          LPCSTR lpDefault,        // default string
  223.          LPSTR lpReturnedString,  // destination buffer
  224.          DWORD nSize,              
  225.  // size of destination buffer,Specifies the size, in TCHARs, 
  226.          LPCSTR lpFileName        // initialization file name
  227.     )
  228. {
  229. BOOL bRet = LoadIniFile(lpFileName, 1);
  230. if(!bRet) return (UINT)-1;
  231. if(lpDefault == NULL) return -1;
  232. if(m_dwUseSize == 0) return -1;
  234. //Section Map Not Available
  235. if(m_bSectionMapDirty && m_bSectionMapLock) //
  236. return GetPrivateProfileStringA(lpAppName,lpKeyName,
  237.    lpDefault,lpReturnedString,nSize,lpFileName);
  238. else if(!m_bSectionMapLock && m_bSectionMapDirty)
  239. {
  240. UpdateMapA();        
  241. }
  242.  
  243. //AfxMessageBox(_T("Using Section Map"));
  244. //Now Map Info Available
  245. if(lpAppName == NULL) //get all section
  246. {
  247. return GetSectionsExA(lpReturnedString, nSize, lpFileName);
  248. }
  249. if(lpKeyName == NULL) //get all key in one section
  250. {
  251. return GetKeysExA(lpAppName, lpReturnedString, nSize, lpFileName);
  252. }
  254. LPSTR pHead = (LPSTR)m_pTrueData;
  255. UINT uSec, uKey;
  256. uSec = (UINT) -1;
  257. uKey = (UINT)-1;
  258. uKey = GetKeyExA(pHead, (UINT)m_dwUseSize, 
  259. lpAppName, lpKeyName, uSec);
  260.     if(uKey == (UINT)-1) //not key
  261. {
  262. if(::strlen(lpDefault) > (int)nSize) return -1;
  263. ::strncpy(lpReturnedString, lpDefault, ::strlen(lpDefault));
  264. //append a null
  265.         lpReturnedString[::strlen(lpDefault)+1] = char('');
  266. return 0;
  267. }
  268. char buffer[MAX_PATH];
  270.     LPSTR pValue = pHead + uKey;
  271. while(pValue - pHead < (int)((m_dwUseSize)/sizeof(char)) && 
  272.  *pValue != char('r') && *pValue != char('n'))
  273. {
  274. pValue++;  //in unicode, +2 byte
  275. }
  277. int len = pValue - pHead - uKey;
  278. pValue = pHead + uKey;
  279. ::strncpy(buffer, pValue, len); 
  280. if(nSize <= (UINT)len)
  281. {
  282. ::strncpy(lpReturnedString, pValue, nSize);
  283.         lpReturnedString[nSize - 1] = char('');
  284. return 0;
  285. }
  286. else
  287. {
  288. ::strncpy(lpReturnedString, pValue, len);
  289. //append null
  290.         lpReturnedString[len] = char('');
  291. return len;
  292. }
  293. return (UINT) -1;
  294. }
  296. // return 0 -- no key, size too small to put value
  297. //return -1  -- error
  298. //return string length (of course > 1)
  299. //Ex Version use Map
  300. DWORD CJXINIFile::GetPrivateProfileStringExW(
  301.          LPCWSTR lpAppName,        // section name
  302.          LPCWSTR lpKeyName,        // key name
  303.          LPCWSTR lpDefault,        // default string
  304.          LPWSTR lpReturnedString,  // destination buffer
  305.          DWORD nSize,              
  306.  // size of destination buffer,Specifies the size, in TCHARs, 
  307.          LPCWSTR lpFileName        // initialization file name
  308.     )
  309. {
  310. BOOL bRet = LoadIniFile(lpFileName, 2);
  311. if(!bRet) return (UINT)-1;
  312. if(lpDefault == NULL) return -1;
  313. if(m_dwUseSize == 0) return -1;
  315. //Section Map Not Available
  316. if(m_bSectionMapDirty && m_bSectionMapLock) //
  317. return GetPrivateProfileStringW(lpAppName,lpKeyName,
  318.    lpDefault,lpReturnedString,nSize,lpFileName);
  319. else if(!m_bSectionMapLock && m_bSectionMapDirty)
  320. {
  321. UpdateMapW();        
  322. }
  323.  
  324. //AfxMessageBox(_T("Using Section Map"));
  325. //Now Map Info Available
  326. if(lpAppName == NULL) //get all section
  327. {
  328. return GetSectionsExW(lpReturnedString, nSize, lpFileName);
  329. }
  330. if(lpKeyName == NULL) //get all key in one section
  331. {
  332. return GetKeysExW(lpAppName, lpReturnedString, nSize, lpFileName);
  333. }
  335. LPWSTR pHead = (LPWSTR)m_pTrueData;
  336. UINT uSec, uKey;
  337. uSec = (UINT) -1;
  338. uKey = (UINT)-1;
  339. uKey = GetKeyExW(pHead, (UINT)m_dwUseSize, 
  340. lpAppName, lpKeyName, uSec);
  341.     if(uKey == (UINT)-1) //not key
  342. {
  343. if(::wcslen(lpDefault) > (int)nSize) return -1;
  344. ::wcsncpy(lpReturnedString, lpDefault, ::wcslen(lpDefault));
  345. //append a null
  346.         lpReturnedString[::wcslen(lpDefault)+1] = WCHAR('');
  347. return 0;
  348. }
  349. WCHAR buffer[MAX_PATH];
  351.     LPWSTR pValue = pHead + uKey;
  352. while(pValue - pHead < (int)((m_dwUseSize)/sizeof(WCHAR)) && 
  353.  *pValue != WCHAR('r') && *pValue != WCHAR('n'))
  354. {
  355. pValue++;  //in unicode, +2 byte
  356. }
  358. int len = pValue - pHead - uKey;
  359. pValue = pHead + uKey;
  360. ::wcsncpy(buffer, pValue, len); 
  361. if(nSize <= (UINT)len)
  362. {
  363. ::wcsncpy(lpReturnedString, pValue, nSize);
  364.         lpReturnedString[nSize - 1] = WCHAR('');
  365. return 0;
  366. }
  367. else
  368. {
  369. ::wcsncpy(lpReturnedString, pValue, len);
  370. //append null
  371.         lpReturnedString[len] = WCHAR('');
  372. return len;
  373. }
  374. return (UINT) -1;
  375. }
  377. //User Query All Section Name in INI File
  378. DWORD CJXINIFile::GetSectionsExA(
  379.          LPSTR lpReturnedString,  // destination buffer
  380.          DWORD nSize, // size of destination buffer, In WCHAR
  381.          LPCSTR lpFileName        // initialization file name
  382.     )
  383. {
  384. ASSERT(!m_bSectionMapDirty);
  385.     BYTE wNULL = 0x00; 
  386. int posRet = 0;
  387. POSITION pos = m_mapSection.GetStartPosition();
  388. while(pos)
  389. {
  390. CString strKey;
  391. LPVOID lpPos;
  392. m_mapSection.GetNextAssoc(pos, strKey, lpPos);
  393. #ifdef _UNICODE
  394. int lenSection = strKey.GetLength();
  395. DWORD dwRetSize;
  396. LPSTR pTemp = _W2A(strKey.GetBuffer(lenSection), lenSection, dwRetSize);
  397. if(dwRetSize + 1 + posRet > (int)nSize) return 0; //nSize - 1;
  398.         ::strncpy(lpReturnedString + posRet, pTemp, dwRetSize);
  399.         posRet += dwRetSize;
  400. #else
  401. int lenSection = strKey.GetLength();
  402. if(lenSection + 1 + posRet > (int)nSize) return 0; //nSize - 1;
  403. ::strncpy(lpReturnedString + posRet, (LPCSTR)strKey, lenSection);
  404.         posRet += lenSection;
  405. #endif
  406. //NULL = 0x00 , 2 Byte
  407. ::memcpy(lpReturnedString + posRet, &wNULL, 1);
  408.         posRet += 1;
  409. }
  410. //last NULL 
  411.     if(1 + posRet > (int)nSize) return 0; //nSize - 1; 
  412.     ::memcpy(lpReturnedString + posRet, &wNULL, 1);
  413. posRet += 1;
  414. return posRet;
  415. }
  417. //User Query All Section Name in INI File
  418. DWORD CJXINIFile::GetSectionsExW(
  419.          LPWSTR lpReturnedString,  // destination buffer
  420.          DWORD nSize, // size of destination buffer, In WCHAR
  421.          LPCWSTR lpFileName        // initialization file name
  422.     )
  423. {
  424. ASSERT(!m_bSectionMapDirty);
  425.     WORD wNULL = 0x0000; 
  426. int posRet = 0;
  427. POSITION pos = m_mapSection.GetStartPosition();
  428. while(pos)
  429. {
  430. CString strKey;
  431. LPVOID lpPos;
  432. m_mapSection.GetNextAssoc(pos, strKey, lpPos);
  433. #ifdef _UNICODE
  434. int lenSection = strKey.GetLength();
  435. if(lenSection + 1 + posRet > (int)nSize) return 0; //nSize - 1;
  436. ::wcsncpy(lpReturnedString + posRet, (LPCWSTR)strKey, lenSection);
  437.         posRet += lenSection;
  438. #else
  439. int lenSection = strKey.GetLength();
  440. DWORD dwRetSize;
  441. PWSTR pTemp = _A2W(strKey.GetBuffer(lenSection), lenSection, dwRetSize);
  442. if(dwRetSize + 1 + posRet > (int)nSize) return 0; //nSize - 1;
  443.         ::wcsncpy(lpReturnedString + posRet, pTemp, dwRetSize);
  444.         posRet += dwRetSize;
  445. #endif
  446. //NULL = 0x00 00, 2 Byte
  447. ::memcpy(lpReturnedString + posRet, &wNULL, 2);
  448.         posRet += 1;
  450. }
  451. //last NULL 
  452.     if(1 + posRet > (int)nSize) return 0; //nSize - 1; 
  453.     ::memcpy(lpReturnedString + posRet, &wNULL, 2);
  454. posRet += 1;
  455. return posRet;
  456. }
  458. //User Query All Keys in a Given Section
  459. DWORD CJXINIFile::GetKeysExA(
  460.  LPCSTR lpAppName,        // section name
  461.          LPSTR lpReturnedString,  // destination buffer
  462.          DWORD nSize,              // size of destination buffer
  463.          LPCSTR lpFileName        // initialization file name
  464.     )
  465. {
  466. int posRet = 0;
  467. int secLen = ::strlen(lpAppName);
  468. LPSTR pHead = (LPSTR)m_pTrueData;
  470. LPSTR pSecHead = NULL; //pointing to [
  471. //Section Map Must be Available
  472. ASSERT(!m_bSectionMapDirty);
  474. #ifdef _UNICODE
  475. DWORD dwRetSize;
  476. LPWSTR pTemp = _A2W((LPSTR)lpAppName, -1, dwRetSize);
  477.     if(0 == m_mapSection.Lookup((LPCWSTR)pTemp, (LPVOID&)pSecHead))
  478. return 0;
  479. #else
  480. if(0 == m_mapSection.Lookup(lpAppName, (LPVOID&)pSecHead))
  481. return 0;
  482. #endif
  484. LPSTR pSecTail = NULL; //point to next [
  485. LPSTR p1 = pSecHead;
  486. LPSTR p2;
  487.         
  488. BYTE wNULL = 0x00; 
  489. while(p1- pHead < (int)(m_dwUseSize/sizeof(char)) - 1)
  490. {
  491. p1++;
  492. if(*p1 == char('['))
  493. {
  494. pSecTail = p1;
  495. break;
  496. }
  497. }
  498. if(pSecHead == NULL) return -1;
  499. if(pSecTail == NULL)
  500. pSecTail = pHead + m_dwUseSize/sizeof(char);
  501. pSecTail--;
  502.     
  503. //Enum Keys in Section
  504.     p1 = pSecHead;
  505. int keyLen;
  506. while(p1 < pSecTail - 1)
  507. {
  508. while(p1 < pSecTail - 1 &&
  509. *p1 != char('r') && *p1 != char('n'))
  510. p1++;
  511. while(p1 < pSecTail - 1 &&
  512. (*p1 == char('r') || *p1 == char('n')))
  513. p1++;
  514. p2 = p1;
  515. while(p2 < pSecTail - 1 &&
  516. *p2 != char('='))
  517. p2++;
  518. if(p1 < pSecTail - 1 && p2 < pSecTail - 1)
  519. {
  520. //Found A Key
  521. keyLen = p2 - p1;
  523. // CString str;
  524. // ::lstrcpyn(str.GetBuffer(keyLen), p1, keyLen);
  525. // str.ReleaseBuffer(keyLen);
  526. // PopMsg(_T("Used %d KeyLen %d, %s"), posRet, keyLen, str);
  527.             
  528. if(keyLen >= 1)
  529. {
  530. if(keyLen + 1 + posRet > (int)nSize) 
  531. {
  532. //PopMsg(_T("You Want Fetch Sections, Buffer %d, Keylen %d, Used %d, in %s"),
  533. // nSize, keyLen, posRet, m_strFilename);
  534. return 0; //nSize - 1;
  535. }
  536. ::strncpy(lpReturnedString + posRet, p1, keyLen);
  537.                 posRet += keyLen;
  538. //NULL = 0x00 , 1 Byte
  539. ::memcpy(lpReturnedString + posRet, &wNULL, 1);
  540.                 posRet += 1;
  541. }
  542. }
  543. p1 = p2 + 1;
  544. }
  545. //last NULL 
  546. //PopMsg(_T("%d"), posRet);
  547.     if(1 + posRet > (int)nSize) return 0; //nSize - 1; 
  548.     ::memcpy(lpReturnedString + posRet, &wNULL, 1);
  549. posRet += 1;
  550. return posRet;
  551. }
  553. //User Query All Keys in a Given Section
  554. DWORD CJXINIFile::GetKeysExW(
  555.  LPCWSTR lpAppName,        // section name
  556.          LPWSTR lpReturnedString,  // destination buffer
  557.          DWORD nSize,              // size of destination buffer
  558.          LPCWSTR lpFileName        // initialization file name
  559.     )
  560. {
  561. int posRet = 0;
  562. int secLen = ::wcslen(lpAppName);
  563. LPWSTR pHead = (LPWSTR)m_pTrueData;
  565. LPWSTR pSecHead = NULL; //pointing to [
  566. //Section Map Must be Available
  567. ASSERT(!m_bSectionMapDirty);
  568. #ifdef _UNICODE
  569. if(0 == m_mapSection.Lookup(lpAppName, (LPVOID&)pSecHead))
  570. return 0;
  571. #else
  572. DWORD dwRetSize;
  573. PSTR pTemp = _W2A((LPWSTR)lpAppName, -1, dwRetSize);
  574.     if(0 == m_mapSection.Lookup((LPCSTR)pTemp, (LPVOID&)pSecHead))
  575. return 0;
  576. #endif
  577. LPWSTR pSecTail = NULL; //point to next [
  578. LPWSTR p1 = pSecHead;
  579. LPWSTR p2;
  580.         
  581. WORD wNULL = 0x0000; 
  582. while(p1- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) - 1)
  583. {
  584. p1++;
  585. if(*p1 == WCHAR('['))
  586. {
  587. pSecTail = p1;
  588. break;
  589. }
  590. }
  591. if(pSecHead == NULL) return -1;
  592. if(pSecTail == NULL)
  593. pSecTail = pHead + m_dwUseSize/sizeof(WCHAR);
  594. pSecTail--;
  595.     
  596. //Enum Keys in Section
  597.     p1 = pSecHead;
  598. int keyLen;
  599. while(p1 < pSecTail - 1)
  600. {
  601. while(p1 < pSecTail - 1 &&
  602. *p1 != WCHAR('r') && *p1 != WCHAR('n'))
  603. p1++;
  604. while(p1 < pSecTail - 1 &&
  605. (*p1 == WCHAR('r') || *p1 == WCHAR('n')))
  606. p1++;
  607. p2 = p1;
  608. while(p2 < pSecTail - 1 &&
  609. *p2 != WCHAR('='))
  610. p2++;
  611. if(p1 < pSecTail - 1 && p2 < pSecTail - 1)
  612. {
  614. //Found A Key
  615. keyLen = p2 - p1;
  617. // CString str;
  618. // ::lstrcpyn(str.GetBuffer(keyLen), p1, keyLen);
  619. // str.ReleaseBuffer(keyLen);
  620. // PopMsg(_T("Used %d KeyLen %d, %s"), posRet, keyLen, str);
  621.             
  622. if(keyLen >= 1)
  623. {
  624. if(keyLen + 1 + posRet > (int)nSize) 
  625. {
  626. //PopMsg(_T("You Want Fetch Sections, Buffer %d, Keylen %d, Used %d, in %s"),
  627. // nSize, keyLen, posRet, m_strFilename);
  628. return 0; //nSize - 1;
  629. }
  630. ::wcsncpy(lpReturnedString + posRet, p1, keyLen);
  631.                 posRet += keyLen;
  632. //NULL = 0x00 00, 2 Byte
  633. ::memcpy(lpReturnedString + posRet, &wNULL, 2);
  634.                 posRet += 1;
  635. }
  636. }
  637. p1 = p2 + 1;
  638. }
  639. //last NULL 
  640. //PopMsg(_T("%d"), posRet);
  641.     if(1 + posRet > (int)nSize) return 0; //nSize - 1; 
  642.     ::memcpy(lpReturnedString + posRet, &wNULL, 2);
  643. posRet += 1;
  644. return posRet;
  645. }
  647. // return 0 -- no key, size too small to put value
  648. //return -1  -- error
  649. //return string length (of course > 1)
  650. DWORD CJXINIFile::GetPrivateProfileStringW(
  651.          LPCWSTR lpAppName,        // section name
  652.          LPCWSTR lpKeyName,        // key name
  653.          LPCWSTR lpDefault,        // default string
  654.          LPWSTR lpReturnedString,  // destination buffer
  655.          DWORD nSize,              
  656.  // size of destination buffer,Specifies the size, in TCHARs, 
  657.          LPCWSTR lpFileName        // initialization file name
  658.     )
  659. {
  660. BOOL bRet = LoadIniFile(lpFileName, 2);
  661. if(!bRet) return (UINT)-1;
  662. if(lpDefault == NULL) return -1;
  663. if(m_dwUseSize == 0) return -1;
  664. if(lpAppName == NULL)
  665. return GetSectionsW(lpReturnedString, nSize, lpFileName);
  666. if(lpKeyName == NULL)
  667. return GetKeysW(lpAppName, lpReturnedString, nSize, lpFileName);
  669. LPWSTR pHead = (LPWSTR)m_pTrueData;
  670. UINT uSec, uKey;
  671. uSec = (UINT) -1;
  672. uKey = (UINT)-1;
  673. uKey = GetKeyW(pHead, (UINT)m_dwUseSize, 
  674. lpAppName, lpKeyName, uSec);
  675.     if(uKey == (UINT)-1) //not key
  676. {
  677. if(::wcslen(lpDefault) > (int)nSize) return -1;
  678. ::wcsncpy(lpReturnedString, lpDefault, ::wcslen(lpDefault));
  679. //append a null
  680.         lpReturnedString[::wcslen(lpDefault)+1] = WCHAR('');
  681. return 0;
  682. }
  683. WCHAR buffer[MAX_PATH];
  685.     LPWSTR pValue = pHead + uKey;
  686. while(pValue - pHead < (int)((m_dwUseSize)/sizeof(WCHAR)) && 
  687.  *pValue != WCHAR('r') && *pValue != WCHAR('n'))
  688. {
  689. pValue++;  //in unicode, +2 byte
  690. }
  692. int len = pValue - pHead - uKey;
  693. pValue = pHead + uKey;
  694. ::wcsncpy(buffer, pValue, len); 
  695. if(nSize <= (UINT)len)
  696. {
  697. ::wcsncpy(lpReturnedString, pValue, nSize);
  698.         lpReturnedString[nSize - 1] = WCHAR('');
  699. return 0;
  700. }
  701. else
  702. {
  703. ::wcsncpy(lpReturnedString, pValue, len);
  704. //append null
  705.         lpReturnedString[len] = WCHAR('');
  706. return len;
  707. }
  708. return (UINT) -1;
  709. }
  711. BOOL CJXINIFile::WritePrivateProfileStringExA(
  712.          LPCSTR lpAppName,  // section name
  713.          LPCSTR lpKeyName,  // key name
  714.          LPCSTR lpString,   // string to add
  715.          LPCSTR lpFileName  // initialization file
  716.     )
  717. {
  718. BOOL bRet = this->LoadIniFile(lpFileName, 1);
  719. if(!bRet) return FALSE;
  720. m_bDirty = TRUE;
  722. if(lpKeyName == NULL)
  723. return DeleteSectionExA(lpAppName);
  724. else if(lpString == NULL)
  725. return this->DeleteKeyExA(lpAppName, lpKeyName);
  727. LPSTR pHead = (LPSTR)m_pTrueData;
  728. //2001/10/19 if lpString.len > MAX_PATH error 
  729. //WCHAR buffer[MAX_PATH];
  730. LPSTR buffer = NULL;
  732. UINT uSec, uKey;  
  733. //Warning: uKey, uSec is measured in WCHARs!!!!!
  734. //in UNICODE now
  735. if(!m_bSectionMapDirty)
  736. uKey = GetKeyExA(pHead, (UINT)m_dwUseSize, 
  737.    lpAppName, lpKeyName, uSec);
  738. else if(!m_bSectionMapLock)
  739. {
  740. UpdateMapA();
  741. uKey = GetKeyExA(pHead, (UINT)m_dwUseSize, 
  742.    lpAppName, lpKeyName, uSec);
  743. }
  744. else
  745.         uKey = GetKeyA(pHead, (UINT)m_dwUseSize, 
  746.    lpAppName, lpKeyName, uSec);
  748.     if(uKey == (UINT)-1 && uSec == (UINT)-1) //no section
  749. {
  750. int len = strlen(lpAppName) + strlen(lpKeyName) + strlen(lpString);
  751. len += 7;
  752. buffer = new char[len+1];
  753. ::sprintf(buffer, "[%s]rn%s=%srn", lpAppName, lpKeyName, lpString);
  754. buffer[len] = 0;
  755. LPSTR pStr = pHead;
  756. pStr += m_dwUseSize/sizeof(char);
  757. ::memcpy(pStr, buffer, len*sizeof(char));
  758. m_dwUseSize += len*sizeof(char);
  760. delete []buffer;
  761. buffer = NULL;
  762.         
  763. CString strSection;
  764. #ifdef _UNICODE
  765. DWORD dwRetSize;
  766. LPWSTR pTemp = _A2W((LPSTR)lpAppName, -1, dwRetSize);
  767.         ::wcsncpy(strSection.GetBuffer(dwRetSize), pTemp, dwRetSize);
  768. strSection.ReleaseBuffer(dwRetSize);
  769. #else
  770. strSection = lpAppName;
  771. #endif
  773. if(!m_bSectionMapLock)
  774. {
  775. m_mapSection.SetAt(strSection, (LPVOID)pStr);
  776. }
  777. else
  778. m_bSectionMapDirty = TRUE;
  779. //No Change //m_bSectionMapDirty = ;
  780. bRet = TRUE;
  781. }
  782. else if(uKey == (UINT)-1 && uSec != (UINT)-1) 
  783. //section exist but value do not exist
  784. {
  785. // Following Write Just After [section],
  786. //that new item become the first of the section
  787.         //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  788. //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  789. /*
  790. LPWSTR pSection = pHead + uSec;
  791. while(pSection - pHead < (int)(m_dwUseSize/sizeof(WCHAR)) && 
  792.       *pSection != WCHAR('r') && *pSection != WCHAR('n'))
  793. {
  794. pSection++;
  795. }
  796.      while(*pSection == WCHAR('r') || *pSection == WCHAR('n'))
  797. pSection++;
  798. UINT uMoveHead = (UINT)(pSection - pHead); 
  799.         //move memory
  800. ::swprintf(buffer, L"%s=%srn", lpKeyName, lpString);
  801. int len = ::wcslen(buffer);
  802. //also ok
  803. //::memmove(pHead + uMoveHead + len, pHead + uMoveHead, m_dwUseSize-uMoveHead*sizeof(WCHAR));
  804. for(int i = (int)(m_dwUseSize - sizeof(WCHAR)); 
  805.     i >= (int)(uMoveHead*sizeof(WCHAR)); i -= sizeof(WCHAR))
  806. {
  807. ::memcpy(pHead + i/sizeof(WCHAR) + len, 
  808. pHead + i/sizeof(WCHAR), sizeof(WCHAR));
  809. }
  810. */
  811. //Following Write new item the last item in the section
  812.         //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  813. //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  814.         LPSTR pSection = pHead + uSec + 1;
  815. while(pSection - pHead < (int)(m_dwUseSize/sizeof(char)) && 
  816.       *pSection != char('['))
  817. {
  818. pSection++;
  819. }
  820. // ::swprintf(buffer, L"%s=%srn", lpKeyName, lpString);
  821. // int len = ::wcslen(buffer);
  823. int len = strlen(lpKeyName) + strlen(lpString);
  824. len += 3;
  825. buffer = new char[len+1];
  826. ::sprintf(buffer, "%s=%srn", lpKeyName, lpString);
  827. buffer[len] = 0;
  828.      if(pSection - pHead == (int)(m_dwUseSize/sizeof(char)))
  829. {
  830. //no move needed, file end
  831. //no need to Update Section map
  832. }
  833. else
  834. {
  835. UINT uMoveHead = (UINT)(pSection - pHead); 
  836.             //move memory
  837.     //also ok
  838.     //::memmove(pHead + uMoveHead + len, pHead + uMoveHead, m_dwUseSize-uMoveHead*sizeof(WCHAR));
  839.     for(int i = (int)(m_dwUseSize - sizeof(char)); 
  840.        i >= (int)(uMoveHead*sizeof(char)); i -= sizeof(char))
  841. {
  842.    ::memcpy(pHead + i/sizeof(char) + len, 
  843.      pHead + i/sizeof(char), sizeof(char));
  844. }
  845. if(m_bSectionMapLock)
  846. { 
  847. m_bSectionMapDirty = TRUE;
  848. }
  849. else //update section map
  850. {
  851. POSITION pos = m_mapSection.GetStartPosition();
  852.             while(pos)
  853. {
  854. CString strKey;
  855.             LPVOID lpPos;
  856.             m_mapSection.GetNextAssoc(pos, strKey, lpPos);
  857. //adjust Section Map
  858.     if((LPSTR)lpPos - pSection > 0)
  859. {
  860. LPWSTR pTemp = (LPWSTR)lpPos;
  861. pTemp += len;
  862. lpPos = (LPVOID)pTemp;
  863. m_mapSection.SetAt(strKey, lpPos);
  864. }
  865. }
  866. }
  867. }
  868. ::memcpy(pSection, buffer, sizeof(char)*len);
  869. m_dwUseSize += len*sizeof(char);
  870. delete buffer;
  871. buffer = NULL;
  872. bRet = TRUE;
  873. }
  874. else //key exist
  875. {
  876. ASSERT(uKey != (UINT)-1);
  877.         LPSTR pValue = pHead + uKey;
  878.     while(pValue - pHead < (int)(m_dwUseSize/sizeof(char)) && 
  879.     *pValue != char('r') && *pValue != char('n'))
  880. {
  881. pValue++;
  882. }
  884.     while(*pValue == char('r') || *pValue == char('n'))
  885. pValue++;
  886. UINT uMoveHead = (UINT)(pValue - pHead);
  888. UINT uPrevLen = uMoveHead - uKey;
  890. int len = strlen(lpString);
  891. len += 2;
  892. buffer = new char[len+1];
  893. ::sprintf(buffer, "%srn", lpString);
  894.         buffer[len] = 0;
  895. UINT uCurLen = len;
  896.         //move have 2 direction
  897. if(uCurLen > uPrevLen)
  898. {
  899. int charDiff = uCurLen - uPrevLen;
  900. int begin = (int)(m_dwUseSize - sizeof(char));
  901. int end = (int)uMoveHead*sizeof(char);
  902. for(int i = begin; i >= end; i -= sizeof(char))
  903. {
  904. ::memcpy(pHead + i/sizeof(char) + charDiff,
  905. pHead + i/sizeof(char), sizeof(char));
  906. }
  907. if(m_bSectionMapLock)
  908. m_bSectionMapDirty = TRUE;
  909. else //update section map
  910. {
  911. POSITION pos = m_mapSection.GetStartPosition();
  912.             while(pos)
  913. {
  914. CString strKey;
  915.             LPVOID lpPos;
  916.             m_mapSection.GetNextAssoc(pos, strKey, lpPos);
  917. //adjust Section Map
  918.     if((LPSTR)lpPos - pHead > (int)uMoveHead)
  919. {
  920. LPSTR pTemp = (LPSTR)lpPos;
  921. pTemp += charDiff;
  922. lpPos = (LPVOID)pTemp;
  923. m_mapSection.SetAt(strKey, lpPos);
  924. }
  925. }
  926. }
  927. }
  928. else if(uCurLen < uPrevLen)
  929. {
  930. int charDiff = uPrevLen - uCurLen;
  931. int begin = (int)uMoveHead*sizeof(char);
  932. int end = (int)(m_dwUseSize - sizeof(char));
  933. for(int i = begin; i <= end;  i+=sizeof(char))
  934. {
  935. ::memcpy(pHead + i/sizeof(char) - charDiff,
  936. pHead + i/sizeof(char), sizeof(char));
  937. }
  938. if(m_bSectionMapLock)
  939. m_bSectionMapDirty = TRUE;
  940. else //update section map
  941. {
  942. POSITION pos = m_mapSection.GetStartPosition();
  943.             while(pos)
  944. {
  945. CString strKey;
  946.             LPVOID lpPos;
  947.             m_mapSection.GetNextAssoc(pos, strKey, lpPos);
  948. //adjust Section Map
  949.     if((LPSTR)lpPos - pHead > (int)uMoveHead)
  950. {
  951. LPSTR pTemp = (LPSTR)lpPos;
  952. pTemp -= charDiff;
  953. lpPos = (LPVOID)pTemp;
  954. m_mapSection.SetAt(strKey, lpPos);
  955. }
  956. }
  957. }
  958. }
  959. pValue = pHead + uKey;
  960. ::memcpy(pValue, buffer, sizeof(char)*uCurLen);
  961.         m_dwUseSize += (uCurLen-uPrevLen)*sizeof(char);
  963. delete buffer;
  964. buffer = NULL;
  965.         bRet = TRUE;
  966. }
  969. if(!bRet) 
  970. {
  971. UnloadIniFile();
  972. return FALSE;
  973. }
  974. //If the File is large enough, flush the file
  975. if((int)(m_dwUseSize - m_dwSize) > JXFlushIncrement - 5*JXPage)
  976. {
  977. //Flush Back to HardDisk
  978. UnloadIniFile();
  979. }
  980. return TRUE;
  981. }
  983. BOOL CJXINIFile::WritePrivateProfileStringExW(
  984.          LPCWSTR lpAppName,  // section name
  985.          LPCWSTR lpKeyName,  // key name
  986.          LPCWSTR lpString,   // string to add
  987.          LPCWSTR lpFileName  // initialization file
  988.     )
  989. {
  990. BOOL bRet = this->LoadIniFile(lpFileName, 2);
  991. if(!bRet) return FALSE;
  992. m_bDirty = TRUE;
  994. if(lpKeyName == NULL)
  995. return DeleteSectionExW(lpAppName);
  996. else if(lpString == NULL)
  997. return this->DeleteKeyExW(lpAppName, lpKeyName);
  999. LPWSTR pHead = (LPWSTR)m_pTrueData;
  1000. //2001/10/19 if lpString.len > MAX_PATH error 
  1001. //WCHAR buffer[MAX_PATH];
  1002. LPWSTR buffer = NULL;
  1004. UINT uSec, uKey;  
  1005. //Warning: uKey, uSec is measured in WCHARs!!!!!
  1006. //in UNICODE now
  1007. if(!m_bSectionMapDirty)
  1008. uKey = GetKeyExW(pHead, (UINT)m_dwUseSize, 
  1009.    lpAppName, lpKeyName, uSec);
  1010. else if(!m_bSectionMapLock)
  1011. {
  1012. UpdateMapW();
  1013. uKey = GetKeyExW(pHead, (UINT)m_dwUseSize, 
  1014.    lpAppName, lpKeyName, uSec);
  1015. }
  1016. else
  1017.         uKey = GetKeyW(pHead, (UINT)m_dwUseSize, 
  1018.    lpAppName, lpKeyName, uSec);
  1020.     if(uKey == (UINT)-1 && uSec == (UINT)-1) //no section
  1021. {
  1022. int len = wcslen(lpAppName) + wcslen(lpKeyName) +wcslen(lpString);
  1023. len += 7;
  1024. buffer = new WCHAR[len+1];
  1025. ::swprintf(buffer, L"[%s]rn%s=%srn", lpAppName, lpKeyName, lpString);
  1026. buffer[len] = 0;
  1027. LPWSTR pStr = pHead;
  1028. pStr += m_dwUseSize/sizeof(WCHAR);
  1029. ::memcpy(pStr, buffer, len*sizeof(WCHAR));
  1030. m_dwUseSize += len*sizeof(WCHAR);
  1032. delete []buffer;
  1033. buffer = NULL;
  1034.         
  1035. CString strSection;
  1036. #ifdef _UNICODE
  1037. strSection = lpAppName;
  1038. #else
  1039. DWORD dwRetSize;
  1040. LPSTR pTemp = _W2A((LPWSTR)lpAppName, -1, dwRetSize);
  1041.         ::strncpy(strSection.GetBuffer(dwRetSize), pTemp, dwRetSize);
  1042. strSection.ReleaseBuffer(dwRetSize);
  1043. #endif
  1045. if(!m_bSectionMapLock)
  1046. {
  1047. m_mapSection.SetAt(strSection, (LPVOID)pStr);
  1048. }
  1049. else
  1050. m_bSectionMapDirty = TRUE;
  1051. //No Change //m_bSectionMapDirty = ;
  1052. bRet = TRUE;
  1053. }
  1054. else if(uKey == (UINT)-1 && uSec != (UINT)-1) 
  1055. //section exist but value do not exist
  1056. {
  1057. // Following Write Just After [section],
  1058. //that new item become the first of the section
  1059.         //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  1060. //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  1061. /*
  1062. LPWSTR pSection = pHead + uSec;
  1063. while(pSection - pHead < (int)(m_dwUseSize/sizeof(WCHAR)) && 
  1064.       *pSection != WCHAR('r') && *pSection != WCHAR('n'))
  1065. {
  1066. pSection++;
  1067. }
  1068.      while(*pSection == WCHAR('r') || *pSection == WCHAR('n'))
  1069. pSection++;
  1070. UINT uMoveHead = (UINT)(pSection - pHead); 
  1071.         //move memory
  1072. ::swprintf(buffer, L"%s=%srn", lpKeyName, lpString);
  1073. int len = ::wcslen(buffer);
  1074. //also ok
  1075. //::memmove(pHead + uMoveHead + len, pHead + uMoveHead, m_dwUseSize-uMoveHead*sizeof(WCHAR));
  1076. for(int i = (int)(m_dwUseSize - sizeof(WCHAR)); 
  1077.     i >= (int)(uMoveHead*sizeof(WCHAR)); i -= sizeof(WCHAR))
  1078. {
  1079. ::memcpy(pHead + i/sizeof(WCHAR) + len, 
  1080. pHead + i/sizeof(WCHAR), sizeof(WCHAR));
  1081. }
  1082. */
  1083. //Following Write new item the last item in the section
  1084.         //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  1085. //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  1086.         LPWSTR pSection = pHead + uSec + 1;
  1087. while(pSection - pHead < (int)(m_dwUseSize/sizeof(WCHAR)) && 
  1088.       *pSection != WCHAR('['))
  1089. {
  1090. pSection++;
  1091. }
  1092. // ::swprintf(buffer, L"%s=%srn", lpKeyName, lpString);
  1093. // int len = ::wcslen(buffer);
  1095. int len = wcslen(lpKeyName) + wcslen(lpString);
  1096. len += 3;
  1097. buffer = new WCHAR[len+1];
  1098. ::swprintf(buffer, L"%s=%srn", lpKeyName, lpString);
  1099. buffer[len] = 0;
  1100.      if(pSection - pHead == (int)(m_dwUseSize/sizeof(WCHAR)))
  1101. {
  1102. //no move needed, file end
  1103. //no need to Update Section map
  1104. }
  1105. else
  1106. {
  1107. UINT uMoveHead = (UINT)(pSection - pHead); 
  1108.             //move memory
  1109.     //also ok
  1110.     //::memmove(pHead + uMoveHead + len, pHead + uMoveHead, m_dwUseSize-uMoveHead*sizeof(WCHAR));
  1111.     for(int i = (int)(m_dwUseSize - sizeof(WCHAR)); 
  1112.        i >= (int)(uMoveHead*sizeof(WCHAR)); i -= sizeof(WCHAR))
  1113. {
  1114.    ::memcpy(pHead + i/sizeof(WCHAR) + len, 
  1115.      pHead + i/sizeof(WCHAR), sizeof(WCHAR));
  1116. }
  1117. if(m_bSectionMapLock)
  1118. { 
  1119. m_bSectionMapDirty = TRUE;
  1120. }
  1121. else //update section map
  1122. {
  1123. POSITION pos = m_mapSection.GetStartPosition();
  1124.             while(pos)
  1125. {
  1126. CString strKey;
  1127.             LPVOID lpPos;
  1128.             m_mapSection.GetNextAssoc(pos, strKey, lpPos);
  1129. //adjust Section Map
  1130.     if((LPWSTR)lpPos - pSection > 0)
  1131. {
  1132. LPWSTR pTemp = (LPWSTR)lpPos;
  1133. pTemp += len;
  1134. lpPos = (LPVOID)pTemp;
  1135. m_mapSection.SetAt(strKey, lpPos);
  1136. }
  1137. }
  1138. }
  1139. }
  1140. ::memcpy(pSection, buffer, sizeof(WCHAR)*len);
  1141. m_dwUseSize += len*sizeof(WCHAR);
  1142. delete buffer;
  1143. buffer = NULL;
  1144. bRet = TRUE;
  1145. }
  1146. else //key exist
  1147. {
  1148. ASSERT(uKey != (UINT)-1);
  1149.         LPWSTR pValue = pHead + uKey;
  1150.     while(pValue - pHead < (int)(m_dwUseSize/sizeof(WCHAR)) && 
  1151.     *pValue != WCHAR('r') && *pValue != WCHAR('n'))
  1152. {
  1153. pValue++;
  1154. }
  1156.     while(*pValue == WCHAR('r') || *pValue == WCHAR('n'))
  1157. pValue++;
  1158. UINT uMoveHead = (UINT)(pValue - pHead);
  1160. UINT uPrevLen = uMoveHead - uKey;
  1162. int len = wcslen(lpString);
  1163. len += 2;
  1164. buffer = new WCHAR[len+1];
  1165. ::swprintf(buffer, L"%srn", lpString);
  1166.         buffer[len] = 0;
  1167. UINT uCurLen = len;
  1168.         //move have 2 direction
  1169. if(uCurLen > uPrevLen)
  1170. {
  1171. int charDiff = uCurLen - uPrevLen;
  1172. int begin = (int)(m_dwUseSize - sizeof(WCHAR));
  1173. int end = (int)uMoveHead*sizeof(WCHAR);
  1174. for(int i = begin; i >= end; i -= sizeof(WCHAR))
  1175. {
  1176. ::memcpy(pHead + i/sizeof(WCHAR) + charDiff,
  1177. pHead + i/sizeof(WCHAR), sizeof(WCHAR));
  1178. }
  1179. if(m_bSectionMapLock)
  1180. m_bSectionMapDirty = TRUE;
  1181. else //update section map
  1182. {
  1183. POSITION pos = m_mapSection.GetStartPosition();
  1184.             while(pos)
  1185. {
  1186. CString strKey;
  1187.             LPVOID lpPos;
  1188.             m_mapSection.GetNextAssoc(pos, strKey, lpPos);
  1189. //adjust Section Map
  1190.     if((LPWSTR)lpPos - pHead > (int)uMoveHead)
  1191. {
  1192. LPWSTR pTemp = (LPWSTR)lpPos;
  1193. pTemp += charDiff;
  1194. lpPos = (LPVOID)pTemp;
  1195. m_mapSection.SetAt(strKey, lpPos);
  1196. }
  1197. }
  1198. }
  1199. }
  1200. else if(uCurLen < uPrevLen)
  1201. {
  1202. int charDiff = uPrevLen - uCurLen;
  1203. int begin = (int)uMoveHead*sizeof(WCHAR);
  1204. int end = (int)(m_dwUseSize - sizeof(WCHAR));
  1205. for(int i = begin; i <= end;  i+=sizeof(WCHAR))
  1206. {
  1207. ::memcpy(pHead + i/sizeof(WCHAR) - charDiff,
  1208. pHead + i/sizeof(WCHAR), sizeof(WCHAR));
  1209. }
  1210. if(m_bSectionMapLock)
  1211. m_bSectionMapDirty = TRUE;
  1212. else //update section map
  1213. {
  1214. POSITION pos = m_mapSection.GetStartPosition();
  1215.             while(pos)
  1216. {
  1217. CString strKey;
  1218.             LPVOID lpPos;
  1219.             m_mapSection.GetNextAssoc(pos, strKey, lpPos);
  1220. //adjust Section Map
  1221.     if((LPWSTR)lpPos - pHead > (int)uMoveHead)
  1222. {
  1223. LPWSTR pTemp = (LPWSTR)lpPos;
  1224. pTemp -= charDiff;
  1225. lpPos = (LPVOID)pTemp;
  1226. m_mapSection.SetAt(strKey, lpPos);
  1227. }
  1228. }
  1229. }
  1230. }
  1231. pValue = pHead + uKey;
  1232. ::memcpy(pValue, buffer, sizeof(WCHAR)*uCurLen);
  1233.         m_dwUseSize += (uCurLen-uPrevLen)*sizeof(WCHAR);
  1235. delete buffer;
  1236. buffer = NULL;
  1237.         bRet = TRUE;
  1238. }
  1241. if(!bRet) 
  1242. {
  1243. UnloadIniFile();
  1244. return FALSE;
  1245. }
  1246. //If the File is large enough, flush the file
  1247. if((int)(m_dwUseSize - m_dwSize) > JXFlushIncrement - 5*JXPage)
  1248. {
  1249. //Flush Back to HardDisk
  1250. UnloadIniFile();
  1251. }
  1252. return TRUE;
  1253. }
  1255. BOOL CJXINIFile::WritePrivateProfileStringW(
  1256.          LPCWSTR lpAppName,  // section name
  1257.          LPCWSTR lpKeyName,  // key name
  1258.          LPCWSTR lpString,   // string to add
  1259.          LPCWSTR lpFileName  // initialization file
  1260.     )
  1261. {
  1262. BOOL bRet = this->LoadIniFile(lpFileName, 2);
  1263. if(!bRet) return FALSE;
  1264. m_bDirty = TRUE;
  1266. if(lpKeyName == NULL)
  1267. return DeleteSectionW(lpAppName);
  1268. else if(lpString == NULL)
  1269. return this->DeleteKeyW(lpAppName, lpKeyName);
  1271. LPWSTR pHead = (LPWSTR)m_pTrueData;
  1272. //2001/10/19 if lpString.len > MAX_PATH error 
  1273. //WCHAR buffer[MAX_PATH];
  1274. LPWSTR buffer = NULL;
  1276. UINT uSec, uKey;  
  1277. //Warning: uKey, uSec is measured in WCHARs!!!!!
  1278. //in UNICODE now
  1279. uKey = GetKeyW(pHead, (UINT)m_dwUseSize, 
  1280. lpAppName, lpKeyName, uSec);
  1281.     if(uKey == (UINT)-1 && uSec == (UINT)-1) //no section
  1282. {
  1283. // ::swprintf(buffer, L"[%s]rn%s=%srn", lpAppName, lpKeyName, lpString);
  1284. // int len = ::wcslen(buffer);
  1285. // LPWSTR pStr = pHead;
  1286. // pStr += m_dwUseSize/sizeof(WCHAR);
  1287. // ::memcpy(pStr, buffer, len*sizeof(WCHAR));
  1288. // m_dwUseSize += len*sizeof(WCHAR);
  1290. int len = wcslen(lpAppName) + wcslen(lpKeyName) +wcslen(lpString);
  1291. len += 7;
  1292. buffer = new WCHAR[len+1];
  1293. ::swprintf(buffer, L"[%s]rn%s=%srn", lpAppName, lpKeyName, lpString);
  1294. buffer[len] = 0;
  1295. LPWSTR pStr = pHead;
  1296. pStr += m_dwUseSize/sizeof(WCHAR);
  1297. ::memcpy(pStr, buffer, len*sizeof(WCHAR));
  1298. m_dwUseSize += len*sizeof(WCHAR);
  1300. delete []buffer;
  1301. buffer = NULL;
  1302. bRet = TRUE;
  1303. }
  1304. else if(uKey == (UINT)-1 && uSec != (UINT)-1) 
  1305. //section exist but value do not exist
  1306. {
  1307. // Following Write Just After [section],
  1308. //that new item become the first of the section
  1309.         //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  1310. //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  1311. /*
  1312. LPWSTR pSection = pHead + uSec;
  1313. while(pSection - pHead < (int)(m_dwUseSize/sizeof(WCHAR)) && 
  1314.       *pSection != WCHAR('r') && *pSection != WCHAR('n'))
  1315. {
  1316. pSection++;
  1317. }
  1318.      while(*pSection == WCHAR('r') || *pSection == WCHAR('n'))
  1319. pSection++;
  1320. UINT uMoveHead = (UINT)(pSection - pHead); 
  1321.         //move memory
  1322. ::swprintf(buffer, L"%s=%srn", lpKeyName, lpString);
  1323. int len = ::wcslen(buffer);
  1324. //also ok
  1325. //::memmove(pHead + uMoveHead + len, pHead + uMoveHead, m_dwUseSize-uMoveHead*sizeof(WCHAR));
  1326. for(int i = (int)(m_dwUseSize - sizeof(WCHAR)); 
  1327.     i >= (int)(uMoveHead*sizeof(WCHAR)); i -= sizeof(WCHAR))
  1328. {
  1329. ::memcpy(pHead + i/sizeof(WCHAR) + len, 
  1330. pHead + i/sizeof(WCHAR), sizeof(WCHAR));
  1331. }
  1332. */
  1333. //Following Write new item the last item in the section
  1334.         //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  1335. //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  1336.         LPWSTR pSection = pHead + uSec + 1;
  1337. while(pSection - pHead < (int)(m_dwUseSize/sizeof(WCHAR)) && 
  1338.       *pSection != WCHAR('['))
  1339. {
  1340. pSection++;
  1341. }
  1342. // ::swprintf(buffer, L"%s=%srn", lpKeyName, lpString);
  1343. // int len = ::wcslen(buffer);
  1345. int len = wcslen(lpKeyName) + wcslen(lpString);
  1346. len += 3;
  1347. buffer = new WCHAR[len+1];
  1348. ::swprintf(buffer, L"%s=%srn", lpKeyName, lpString);
  1349. buffer[len] = 0;
  1350.      if(pSection - pHead == (int)(m_dwUseSize/sizeof(WCHAR)))
  1351. {
  1352. //no move needed, file end
  1353. }
  1354. else
  1355. {
  1356. UINT uMoveHead = (UINT)(pSection - pHead); 
  1357.             //move memory
  1358.     //also ok
  1359.     //::memmove(pHead + uMoveHead + len, pHead + uMoveHead, m_dwUseSize-uMoveHead*sizeof(WCHAR));
  1360.     for(int i = (int)(m_dwUseSize - sizeof(WCHAR)); 
  1361.        i >= (int)(uMoveHead*sizeof(WCHAR)); i -= sizeof(WCHAR))
  1362. {
  1363.    ::memcpy(pHead + i/sizeof(WCHAR) + len, 
  1364.      pHead + i/sizeof(WCHAR), sizeof(WCHAR));
  1365. }
  1366. }
  1368. ::memcpy(pSection, buffer, sizeof(WCHAR)*len);
  1370. m_dwUseSize += len*sizeof(WCHAR);
  1371. delete buffer;
  1372. buffer = NULL;
  1373. bRet = TRUE;
  1374. }
  1375. else //key exist
  1376. {
  1377. ASSERT(uKey != (UINT)-1);
  1378.         LPWSTR pValue = pHead + uKey;
  1379.     while(pValue - pHead < (int)(m_dwUseSize/sizeof(WCHAR)) && 
  1380.     *pValue != WCHAR('r') && *pValue != WCHAR('n'))
  1381. {
  1382. pValue++;
  1383. }
  1385.     while(*pValue == WCHAR('r') || *pValue == WCHAR('n'))
  1386. pValue++;
  1387. UINT uMoveHead = (UINT)(pValue - pHead);
  1389. UINT uPrevLen = uMoveHead - uKey;
  1391. int len = wcslen(lpString);
  1392. len += 2;
  1393. buffer = new WCHAR[len+1];
  1394. ::swprintf(buffer, L"%srn", lpString);
  1395.         buffer[len] = 0;
  1396. UINT uCurLen = len;
  1397.         //move have 2 direction
  1398. if(uCurLen > uPrevLen)
  1399. {
  1400. int charDiff = uCurLen - uPrevLen;
  1401. int begin = (int)(m_dwUseSize - sizeof(WCHAR));
  1402. int end = (int)uMoveHead*sizeof(WCHAR);
  1403. for(int i = begin; i >= end; i -= sizeof(WCHAR))
  1404. {
  1405. ::memcpy(pHead + i/sizeof(WCHAR) + charDiff,
  1406. pHead + i/sizeof(WCHAR), sizeof(WCHAR));
  1407. }
  1408. }
  1409. else if(uCurLen < uPrevLen)
  1410. {
  1411. int charDiff = uPrevLen - uCurLen;
  1412. int begin = (int)uMoveHead*sizeof(WCHAR);
  1413. int end = (int)(m_dwUseSize - sizeof(WCHAR));
  1414. for(int i = begin; i <= end;  i+=sizeof(WCHAR))
  1415. {
  1416. ::memcpy(pHead + i/sizeof(WCHAR) - charDiff,
  1417. pHead + i/sizeof(WCHAR), sizeof(WCHAR));
  1418. }
  1419. }
  1420. pValue = pHead + uKey;
  1421. ::memcpy(pValue, buffer, sizeof(WCHAR)*uCurLen);
  1422.         m_dwUseSize += (uCurLen-uPrevLen)*sizeof(WCHAR);
  1424. delete buffer;
  1425. buffer = NULL;
  1426.         bRet = TRUE;
  1427. }
  1429. m_bSectionMapDirty = TRUE;
  1430. if(!bRet) 
  1431. {
  1432. UnloadIniFile();
  1433. return FALSE;
  1434. }
  1435. //If the File is large enough, flush the file
  1436. if((int)(m_dwUseSize - m_dwSize) > JXFlushIncrement - 5*JXPage)
  1437. {
  1438. //Flush Back to HardDisk
  1439. UnloadIniFile();
  1440. }
  1441. return TRUE;
  1442. }
  1444. //User Query All Section Name in INI File
  1445. DWORD CJXINIFile::GetSectionsW(
  1446.          LPWSTR lpReturnedString,  // destination buffer
  1447.          DWORD nSize,              // size of destination buffer
  1448.          LPCWSTR lpFileName        // initialization file name
  1449.     )
  1450. {
  1451.     int posRet = 0;
  1452. LPWSTR pHead = (LPWSTR)m_pTrueData;
  1453. LPWSTR p1 = pHead;
  1454. LPWSTR p2 = pHead;
  1455.         
  1456. WORD wNULL = 0x0000; 
  1457. while(p1- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) - 1)
  1458. {
  1459. while(p1- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) - 1 &&
  1460. *p1 != WCHAR('['))
  1461. p1++;
  1462. p2 = p1;
  1463. while(p2- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) - 1 &&
  1464. *p2 != WCHAR(']'))
  1465. p2++;
  1466. if(p1- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) &&
  1467. p2- pHead < (int)(m_dwUseSize/sizeof(WCHAR)))
  1468. {
  1469. //Found, Ready To Copy To lpReturnedString
  1470. int lenSection = p2 - p1 - 1;
  1472. if(lenSection >= 1)
  1473. {
  1474. p1++;
  1475. if(lenSection + 1 + posRet > (int)nSize) return 0; //nSize - 1;
  1476. ::wcsncpy(lpReturnedString + posRet, p1, lenSection);
  1477.                 posRet += lenSection;
  1478. //NULL = 0x00 00, 2 Byte
  1479. ::memcpy(lpReturnedString + posRet, &wNULL, 2);
  1480.                 posRet += 1;
  1481. } 
  1482. }
  1483. p1 = p2 + 1;
  1484. }
  1485. //last NULL 
  1486.     if(1 + posRet > (int)nSize) return 0; //nSize - 1; 
  1487.     ::memcpy(lpReturnedString + posRet, &wNULL, 2);
  1488. posRet += 1;
  1489. return posRet;
  1490. }
  1492. //User Query All Keys in a Given Section
  1493. DWORD CJXINIFile::GetKeysW(
  1494.  LPCWSTR lpAppName,        // section name
  1495.          LPWSTR lpReturnedString,  // destination buffer
  1496.          DWORD nSize,              // size of destination buffer
  1497.          LPCWSTR lpFileName        // initialization file name
  1498.     )
  1499. {
  1500. int posRet = 0;
  1501. int secLen = ::wcslen(lpAppName);
  1502. LPWSTR pHead = (LPWSTR)m_pTrueData;
  1503. LPWSTR p1 = pHead;
  1504. LPWSTR p2 = pHead;
  1505. LPWSTR pSecHead = NULL; //pointing to [
  1506. LPWSTR pSecTail = NULL; //point to next [
  1507.         
  1508. WORD wNULL = 0x0000; 
  1509. while(p1- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) - 1)
  1510. {
  1511. while(p1- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) - 1 &&
  1512. *p1 != WCHAR('['))
  1513. p1++;
  1514. p2 = p1;
  1515. while(p2- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) - 1 &&
  1516. *p2 != WCHAR(']'))
  1517. p2++;
  1518. //p2 points to ]
  1519. if(p1- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) &&
  1520. p2- pHead < (int)(m_dwUseSize/sizeof(WCHAR)))
  1521. {
  1522. //Found A Section
  1523. if(pSecHead != NULL)
  1524. {
  1525. pSecTail = p1;
  1526. break;
  1527. }
  1528. else //pSecHead == NULL
  1529. {
  1530. if(secLen == p2 - p1 - 1) //same length
  1531. {
  1532. p1++;
  1533. LPWSTR p3 = p1; //p3 points to ["X"
  1534.     for(int i = 0; i < secLen; i++)
  1535. {
  1536. if(*p1 != (WCHAR)(lpAppName[i])) break;
  1537. p1++;
  1538. }
  1539.     if(i == secLen) //Found;
  1540. pSecHead = p3 - 1;
  1541. }
  1542. }
  1543. }
  1544. p1 = p2 + 1;
  1545. }
  1546. if(pSecHead == NULL) return -1;
  1547. if(pSecTail == NULL)
  1548. pSecTail = pHead + m_dwUseSize/sizeof(WCHAR);
  1549. pSecTail--;
  1550.     
  1551. //Enum Keys in Section
  1552.     p1 = pSecHead;
  1553. int keyLen;
  1554. while(p1 < pSecTail - 1)
  1555. {
  1556. while(p1 < pSecTail - 1 &&
  1557. *p1 != WCHAR('r') && *p1 != WCHAR('n'))
  1558. p1++;
  1559. while(p1 < pSecTail - 1 &&
  1560. (*p1 == WCHAR('r') || *p1 == WCHAR('n')))
  1561. p1++;
  1562. p2 = p1;
  1563. while(p2 < pSecTail - 1 &&
  1564. *p2 != WCHAR('='))
  1565. p2++;
  1566. if(p1 < pSecTail - 1 && p2 < pSecTail - 1)
  1567. {
  1568. //Found A Key
  1569. keyLen = p2 - p1;
  1570. if(keyLen >= 1)
  1571. {
  1572. if(keyLen + 1 + posRet > (int)nSize) return 0; //nSize - 1;
  1573. ::wcsncpy(lpReturnedString + posRet, p1, keyLen);
  1574.                 posRet += keyLen;
  1575. //NULL = 0x00 00, 2 Byte
  1576. ::memcpy(lpReturnedString + posRet, &wNULL, 2);
  1577.                 posRet += 1;
  1578. }
  1579. }
  1580. p1 = p2 + 1;
  1581. }
  1582. //last NULL 
  1583.     if(1 + posRet > (int)nSize) return 0; //nSize - 1; 
  1584.     ::memcpy(lpReturnedString + posRet, &wNULL, 2);
  1585. posRet += 1;
  1586. return posRet;
  1587. }
  1588. //MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
  1589. //MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
  1590. //ANSI Version ----------------------------------------------
  1591. // return 0 -- no key, size too small to put value
  1592. //return -1  -- error
  1593. //return string length (of course > 1)
  1594. DWORD CJXINIFile::GetPrivateProfileStringA(
  1595.          LPCSTR lpAppName,        // section name
  1596.          LPCSTR lpKeyName,        // key name
  1597.          LPCSTR lpDefault,        // default string
  1598.          LPSTR lpReturnedString,  // destination buffer
  1599.          DWORD nSize,              
  1600.  // size of destination buffer,Specifies the size, in TCHARs, 
  1601.          LPCSTR lpFileName        // initialization file name
  1602.     )
  1603. {
  1604. BOOL bRet = LoadIniFile(lpFileName, 1);
  1605. if(!bRet) return (UINT)-1;
  1606. if(lpDefault == NULL) return -1;
  1607. if(m_dwUseSize == 0) return -1;
  1608. if(lpAppName == NULL)
  1609. return GetSectionsA(lpReturnedString, nSize, lpFileName);
  1610. if(lpKeyName == NULL)
  1611. return GetKeysA(lpAppName, lpReturnedString, nSize, lpFileName);
  1613. LPSTR pHead = (LPSTR)m_pTrueData;
  1614. UINT uSec, uKey;
  1615. uSec = (UINT) -1;
  1616. uKey = (UINT)-1;
  1617. uKey = GetKeyA(pHead, (UINT)m_dwUseSize, 
  1618. lpAppName, lpKeyName, uSec);
  1619.     if(uKey == (UINT)-1) //not key
  1620. {
  1621. if(::strlen(lpDefault) > (int)nSize) return -1;
  1622. ::strncpy(lpReturnedString, lpDefault, ::strlen(lpDefault));
  1623. //append a null
  1624.         lpReturnedString[::strlen(lpDefault)+1] = char('');
  1625. return 0;
  1626. }
  1627. char buffer[MAX_PATH];
  1629.     LPSTR pValue = pHead + uKey;
  1630. while(pValue - pHead < (int)((m_dwUseSize)/sizeof(char)) && 
  1631.  *pValue != char('r') && *pValue != char('n'))
  1632. {
  1633. pValue++;  //in unicode, +2 byte
  1634. }
  1636. int len = pValue - pHead - uKey;
  1637. pValue = pHead + uKey;
  1638. ::strncpy(buffer, pValue, len); 
  1639. if(nSize <= (UINT)len)
  1640. {
  1641. ::strncpy(lpReturnedString, pValue, nSize);
  1642.         lpReturnedString[nSize - 1] = char('');
  1643. return 0;
  1644. }
  1645. else
  1646. {
  1647. ::strncpy(lpReturnedString, pValue, len);
  1648. //append null
  1649.         lpReturnedString[len] = char('');
  1650. return len;
  1651. }
  1652. return (UINT) -1;
  1653. }
  1655. BOOL CJXINIFile::WritePrivateProfileStringA(
  1656.          LPCSTR lpAppName,  // section name
  1657.          LPCSTR lpKeyName,  // key name
  1658.          LPCSTR lpString,   // string to add
  1659.          LPCSTR lpFileName  // initialization file
  1660.     )
  1661. {
  1662. BOOL bRet = this->LoadIniFile(lpFileName, 1);
  1663. if(!bRet) return FALSE;
  1664. m_bDirty = TRUE;
  1666. LPSTR pHead = (LPSTR)m_pTrueData;
  1667. //2001/10/19 if lpString.len > MAX_PATH error 
  1668. //char buffer[MAX_PATH];
  1669. LPSTR buffer = NULL;
  1671. UINT uSec, uKey;  
  1672. //Warning: uKey, uSec is measured in WCHARs!!!!!
  1673. //in UNICODE now
  1674. uKey = GetKeyA(pHead, (UINT)m_dwUseSize, 
  1675. lpAppName, lpKeyName, uSec);
  1676.     if(uKey == (UINT)-1 && uSec == (UINT)-1) //no section
  1677. {
  1678. int len = strlen(lpAppName) + strlen(lpKeyName) +strlen(lpString);
  1679. len += 7;
  1680. buffer = new char[len+1];
  1681. ::sprintf(buffer, "[%s]rn%s=%srn", lpAppName, lpKeyName, lpString);
  1682. buffer[len] = 0;
  1683. LPSTR pStr = pHead;
  1684. pStr += m_dwUseSize/sizeof(char);
  1685. ::memcpy(pStr, buffer, len*sizeof(char));
  1686. m_dwUseSize += len*sizeof(char);
  1688. delete []buffer;
  1689. buffer = NULL;
  1690. bRet = TRUE;
  1691. }
  1692. else if(uKey == (UINT)-1 && uSec != (UINT)-1) 
  1693. //section exist but value do not exist
  1694. {
  1695. // Following Write Just After [section],
  1696. //that new item become the first of the section
  1697.         //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  1698. //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  1699. /*
  1700. LPSTR pSection = pHead + uSec;
  1701. while(pSection - pHead < (int)(m_dwUseSize/sizeof(char)) && 
  1702.       *pSection != char('r') && *pSection != char('n'))
  1703. {
  1704. pSection++;
  1705. }
  1706.      while(*pSection == char('r') || *pSection == char('n'))
  1707. pSection++;
  1708. UINT uMoveHead = (UINT)(pSection - pHead); 
  1709.         //move memory
  1710. ::sprintf(buffer, L"%s=%srn", lpKeyName, lpString);
  1711. int len = ::strlen(buffer);
  1712. //also ok
  1713. //::memmove(pHead + uMoveHead + len, pHead + uMoveHead, m_dwUseSize-uMoveHead*sizeof(char));
  1714. for(int i = (int)(m_dwUseSize - sizeof(char)); 
  1715.     i >= (int)(uMoveHead*sizeof(char)); i -= sizeof(char))
  1716. {
  1717. ::memcpy(pHead + i/sizeof(char) + len, 
  1718. pHead + i/sizeof(char), sizeof(char));
  1719. }
  1720. */
  1721. //Following Write new item the last item in the section
  1722.         //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  1723. //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
  1724.         LPSTR pSection = pHead + uSec + 1;
  1725. while(pSection - pHead < (int)(m_dwUseSize/sizeof(char)) && 
  1726.       *pSection != char('['))
  1727. {
  1728. pSection++;
  1729. }
  1730. // ::sprintf(buffer, L"%s=%srn", lpKeyName, lpString);
  1731. // int len = ::strlen(buffer);
  1733. int len = strlen(lpKeyName) + strlen(lpString);
  1734. len += 3;
  1735. buffer = new char[len+1];
  1736. ::sprintf(buffer, "%s=%srn", lpKeyName, lpString);
  1737. buffer[len] = 0;
  1738.      if(pSection - pHead == (int)(m_dwUseSize/sizeof(char)))
  1739. {
  1740. //no move needed, file end
  1741. }
  1742. else
  1743. {
  1744. UINT uMoveHead = (UINT)(pSection - pHead); 
  1745.             //move memory
  1746.     //also ok
  1747.     //::memmove(pHead + uMoveHead + len, pHead + uMoveHead, m_dwUseSize-uMoveHead*sizeof(char));
  1748.     for(int i = (int)(m_dwUseSize - sizeof(char)); 
  1749.        i >= (int)(uMoveHead*sizeof(char)); i -= sizeof(char))
  1750. {
  1751.    ::memcpy(pHead + i/sizeof(char) + len, 
  1752.      pHead + i/sizeof(char), sizeof(char));
  1753. }
  1754. }
  1756. ::memcpy(pSection, buffer, sizeof(char)*len);
  1758. m_dwUseSize += len*sizeof(char);
  1759. delete buffer;
  1760. buffer = NULL;
  1761. bRet = TRUE;
  1762. }
  1763. else //key exist
  1764. {
  1765. ASSERT(uKey != (UINT)-1);
  1766.         LPSTR pValue = pHead + uKey;
  1767.     while(pValue - pHead < (int)(m_dwUseSize/sizeof(char)) && 
  1768.     *pValue != char('r') && *pValue != char('n'))
  1769. {
  1770. pValue++;
  1771. }
  1773.     while(*pValue == char('r') || *pValue == char('n'))
  1774. pValue++;
  1775. UINT uMoveHead = (UINT)(pValue - pHead);
  1777. UINT uPrevLen = uMoveHead - uKey;
  1779. int len = strlen(lpString);
  1780. len += 2;
  1781. buffer = new char[len+1];
  1782. ::sprintf(buffer, "%srn", lpString);
  1783.         buffer[len] = 0;
  1784. UINT uCurLen = len;
  1785.         //move have 2 direction
  1786. if(uCurLen > uPrevLen)
  1787. {
  1788. int charDiff = uCurLen - uPrevLen;
  1789. int begin = (int)(m_dwUseSize - sizeof(char));
  1790. int end = (int)uMoveHead*sizeof(char);
  1791. for(int i = begin; i >= end; i -= sizeof(char))
  1792. {
  1793. ::memcpy(pHead + i/sizeof(char) + charDiff,
  1794. pHead + i/sizeof(char), sizeof(char));
  1795. }
  1796. }
  1797. else if(uCurLen < uPrevLen)
  1798. {
  1799. int charDiff = uPrevLen - uCurLen;
  1800. int begin = (int)uMoveHead*sizeof(char);
  1801. int end = (int)(m_dwUseSize - sizeof(char));
  1802. for(int i = begin; i <= end;  i+=sizeof(char))
  1803. {
  1804. ::memcpy(pHead + i/sizeof(char) - charDiff,
  1805. pHead + i/sizeof(char), sizeof(char));
  1806. }
  1807. }
  1808. pValue = pHead + uKey;
  1809. ::memcpy(pValue, buffer, sizeof(char)*uCurLen);
  1810.         m_dwUseSize += (uCurLen-uPrevLen)*sizeof(char);
  1812. delete buffer;
  1813. buffer = NULL;
  1814.         bRet = TRUE;
  1815. }
  1817. m_bSectionMapDirty = TRUE;
  1818. if(!bRet) 
  1819. {
  1820. UnloadIniFile();
  1821. return FALSE;
  1822. }
  1823. //If the File is large enough, flush the file
  1824. if((int)(m_dwUseSize - m_dwSize) > JXFlushIncrement - 5*JXPage)
  1825. {
  1826. //Flush Back to HardDisk
  1827. UnloadIniFile();
  1828. }
  1829. return TRUE;
  1830. }
  1832. //User Query All Section Name in INI File
  1833. DWORD CJXINIFile::GetSectionsA(
  1834.          LPSTR lpReturnedString,  // destination buffer
  1835.          DWORD nSize,              // size of destination buffer
  1836.          LPCSTR lpFileName        // initialization file name
  1837.     )
  1838. {
  1839.     int posRet = 0;
  1840. LPSTR pHead = (LPSTR)m_pData;
  1841. LPSTR p1 = pHead;
  1842. LPSTR p2 = pHead;
  1843.         
  1844. BYTE wNULL = 0x0000; 
  1845. while(p1- pHead < (int)(m_dwUseSize/sizeof(char)) - 1)
  1846. {
  1847. while(p1- pHead < (int)(m_dwUseSize/sizeof(char)) - 1 &&
  1848. *p1 != char('['))
  1849. p1++;
  1850. p2 = p1;
  1851. while(p2- pHead < (int)(m_dwUseSize/sizeof(char)) - 1 &&
  1852. *p2 != char(']'))
  1853. p2++;
  1854. if(p1- pHead < (int)(m_dwUseSize/sizeof(char)) &&
  1855. p2- pHead < (int)(m_dwUseSize/sizeof(char)))
  1856. {
  1857. //Found, Ready To Copy To lpReturnedString
  1858. int lenSection = p2 - p1 - 1;
  1860. if(lenSection >= 1)
  1861. {
  1862. p1++;
  1863. if(lenSection + 1 + posRet > (int)nSize) return 0; //nSize - 1;
  1864. ::strncpy(lpReturnedString + posRet, p1, lenSection);
  1865.                 posRet += lenSection;
  1866. //NULL = 0x00,  1Byte
  1867. ::memcpy(lpReturnedString + posRet, &wNULL, 1);
  1868.                 posRet += 1;
  1869. } 
  1870. }
  1871. p1 = p2 + 1;
  1872. }
  1873. //last NULL 
  1874.     if(1 + posRet > (int)nSize) return 0; //nSize - 1; 
  1875.     ::memcpy(lpReturnedString + posRet, &wNULL, 1);
  1876. posRet += 1;
  1877. return posRet;
  1878. }
  1881. //User Query All Keys in a Given Section
  1882. DWORD CJXINIFile::GetKeysA(
  1883.          LPCSTR lpAppName,        // section name
  1884.          LPSTR lpReturnedString,  // destination buffer
  1885.          DWORD nSize,              // size of destination buffer
  1886.          LPCSTR lpFileName        // initialization file name
  1887.     )
  1888. {
  1889. int posRet = 0;
  1890. int secLen = ::strlen(lpAppName);
  1891. LPSTR pHead = (LPSTR)m_pTrueData;
  1892. LPSTR p1 = pHead;
  1893. LPSTR p2 = pHead;
  1894. LPSTR pSecHead = NULL; //pointing to [
  1895. LPSTR pSecTail = NULL; //point to next [
  1896.         
  1897. BYTE byteNULL = 0x00; 
  1898. while(p1- pHead < (int)(m_dwUseSize/sizeof(char)) - 1)
  1899. {
  1900. while(p1- pHead < (int)(m_dwUseSize/sizeof(char)) - 1 &&
  1901. *p1 != char('['))
  1902. p1++;
  1903. p2 = p1;
  1904. while(p2- pHead < (int)(m_dwUseSize/sizeof(char)) - 1 &&
  1905. *p2 != char(']'))
  1906. p2++;
  1907. //p2 points to ]
  1908. if(p1- pHead < (int)(m_dwUseSize/sizeof(char)) &&
  1909. p2- pHead < (int)(m_dwUseSize/sizeof(char)))
  1910. {
  1911. //Found A Section
  1912. if(pSecHead != NULL)
  1913. {
  1914. pSecTail = p1;
  1915. break;
  1916. }
  1917. else //pSecHead == NULL
  1918. {
  1919. if(secLen == p2 - p1 - 1) //same length
  1920. {
  1921. p1++;
  1922. LPSTR p3 = p1; //p3 points to ["X"
  1923.     for(int i = 0; i < secLen; i++)
  1924. {
  1925. if(*p1 != (char)(lpAppName[i])) break;
  1926. p1++;
  1927. }
  1928.     if(i == secLen) //Found;
  1929. pSecHead = p3 - 1;
  1930. }
  1931. }
  1932. }
  1933. p1 = p2 + 1;
  1934. }
  1935. if(pSecHead == NULL) return -1;
  1936. if(pSecTail == NULL)
  1937. pSecTail = pHead + m_dwUseSize/sizeof(char);
  1938. pSecTail--;
  1939.     
  1940. //Enum Keys in Section
  1941.     p1 = pSecHead;
  1942. int keyLen;
  1943. while(p1 < pSecTail - 1)
  1944. {
  1945. while(p1 < pSecTail - 1 &&
  1946. *p1 != char('r') && *p1 != char('n'))
  1947. p1++;
  1948. while(p1 < pSecTail - 1 &&
  1949. (*p1 == char('r') || *p1 == char('n')))
  1950. p1++;
  1951. p2 = p1;
  1952. while(p2 < pSecTail - 1 &&
  1953. *p2 != char('='))
  1954. p2++;
  1955. if(p1 < pSecTail - 1 && p2 < pSecTail - 1)
  1956. {
  1957. //Found A Key
  1958. keyLen = p2 - p1;
  1959. if(keyLen >= 1)
  1960. {
  1961. if(keyLen + 1 + posRet > (int)nSize) return 0; //nSize - 1;
  1962. ::strncpy(lpReturnedString + posRet, p1, keyLen);
  1963.                 posRet += keyLen;
  1964. //NULL = 0x00 , 1 Byte
  1965. ::memcpy(lpReturnedString + posRet, &byteNULL, 1);
  1966.                 posRet += 1;
  1967. }
  1968. }
  1969. p1 = p2 + 1;
  1970. }
  1971. //last NULL 
  1972.     if(1 + posRet > (int)nSize) return 0; //nSize - 1; 
  1973.     ::memcpy(lpReturnedString + posRet, &byteNULL, 1);
  1974. posRet += 1;
  1975. return posRet;
  1976. }
  1978. BOOL CJXINIFile::LoadIniFile(CString strFilename, DWORD dwMode)
  1979. {
  1980. if(dwMode == 0 && sizeof(TCHAR) == 1) m_bUnicode = FALSE;
  1981. if(dwMode == 0 && sizeof(TCHAR) == 2) m_bUnicode = TRUE;
  1982.     if(dwMode == 1) m_bUnicode = FALSE;
  1983. if(dwMode == 2) m_bUnicode = TRUE;
  1985. if(strFilename == _T("")) return FALSE;
  1986. //Already Loaded
  1987. if(m_strFilename == strFilename) return TRUE; 
  1989. if(m_strFilename != _T("")) //Unload First
  1990. {
  1991. UnloadIniFile();
  1992. }
  1993.     
  1994. m_strFilename = strFilename;
  1995. m_bDirty = FALSE;
  1996. m_bSectionMapDirty = TRUE;
  1997.     m_bSectionMapLock = FALSE;
  1999. DWORD dwHigh, dwLow;
  2001. DWORD dwTotal, dwError;
  2002. //Open File Handle
  2003. m_hFile = ::CreateFile(m_strFilename, GENERIC_READ | GENERIC_WRITE,
  2004.  FILE_SHARE_READ, NULL, OPEN_EXISTING, 
  2005.  FILE_ATTRIBUTE_NORMAL, NULL);
  2006. if(m_hFile != INVALID_HANDLE_VALUE)
  2007. {
  2008. //Measure File Size
  2009.     dwLow = GetFileSize(m_hFile, &dwHigh);
  2010.     dwTotal = 0;
  2011.        if(dwLow == -1 && (dwError = GetLastError()) != NO_ERROR)
  2012. {
  2013. ::MessageBox(NULL, _T("File Size Failure"),
  2014. _T("CJXINIFile::Load"), MB_OK | MB_ICONSTOP);
  2015.     if(m_hFile != INVALID_HANDLE_VALUE)
  2016. ::CloseHandle(m_hFile);
  2017.     m_dwSize = 0;
  2018.     m_strFilename = _T("");
  2019.         return FALSE;
  2020. }
  2021. m_dwSize = dwLow;  //32bit -> 4Gb
  2022. }
  2023. else
  2024. {
  2025. m_hFile = ::CreateFile(m_strFilename, GENERIC_READ | GENERIC_WRITE,
  2026.    FILE_SHARE_READ, NULL, OPEN_ALWAYS, 
  2027.    FILE_ATTRIBUTE_NORMAL, NULL);
  2028.     if(m_hFile == INVALID_HANDLE_VALUE)
  2029. {
  2030. ::MessageBox(NULL, _T("CreateFile Failure"),
  2031.               _T("CJXINIFile::Load"), MB_OK | MB_ICONSTOP);
  2032.     if(m_hFile != INVALID_HANDLE_VALUE)
  2033. ::CloseHandle(m_hFile);
  2034.     m_dwSize = 0;
  2035.     m_strFilename = _T("");
  2036.         return FALSE;
  2037. }
  2038. m_dwSize = 0;
  2039. }
  2040.         
  2041. //Open Memory-Mapping File, maximum size = File Size + JXFlushIncrement
  2042. dwLow = m_dwSize + JXFlushIncrement;
  2043. m_hMMF = ::CreateFileMapping(m_hFile, NULL,
  2044. PAGE_READWRITE,  0 , dwLow, NULL);
  2045. if(NULL == m_hMMF)
  2046. {
  2047. ::MessageBox(NULL, _T("CreateFileMapping Failure"),
  2048.                 _T("CJXINIFile::Load"), MB_OK | MB_ICONSTOP);
  2049. if(m_hMMF != NULL)
  2050. ::CloseHandle(m_hMMF);
  2051.     if(m_hFile != INVALID_HANDLE_VALUE)
  2052. ::CloseHandle(m_hFile);
  2053. m_dwSize = 0;
  2054. m_strFilename = _T("");
  2055. return FALSE;
  2056. }
  2058. //Map pointer
  2059. m_pData = ::MapViewOfFile(m_hMMF, FILE_MAP_READ | FILE_MAP_WRITE,
  2060. 0, 0, dwLow);
  2061.     if(m_pData == NULL)
  2062. {
  2063. //ReportErr(_T(""));
  2064. if(m_hMMF != NULL)
  2065. ::CloseHandle(m_hMMF);
  2066.     if(m_hFile != INVALID_HANDLE_VALUE)
  2067. ::CloseHandle(m_hFile);
  2068. m_dwSize = 0;
  2069. m_strFilename = _T("");
  2070. ::MessageBox(NULL, _T("MapViewOfFile Failure"),
  2071.                _T("CJXINIFile::Load"), MB_OK | MB_ICONSTOP);
  2072. return FALSE;
  2073. }
  2074. m_dwUseSize = m_dwSize;
  2075.     
  2076. CutZeroTail();
  2078. //if(sizeof(TCHAR) == 2) //UNICODE only
  2079. if(this->m_bUnicode)
  2080. //Pass Potentail 0xFF FE header if edited by MS NotePad
  2081. {
  2082. LPBYTE pByte = (LPBYTE)m_pData;
  2083.     if(m_dwUseSize >= 2 && *pByte == 0xFF && *(pByte +1) == 0xFE)
  2084. {
  2085. m_pTrueData = (LPVOID)(pByte + 2);
  2086. m_dwUseSize -= 2;
  2087. }
  2088.     else
  2089. {
  2090. if(m_dwUseSize == 0) //a new file, add 0xFF FE header
  2091.                  //for Win2k SP1 need 0xFF FE
  2092. {
  2093. *pByte = 0xFF;
  2094. *(pByte +1) = 0xFE;
  2095. //m_dwUseSize = 2;
  2096. m_pTrueData = (LPVOID)(pByte+2);
  2097. }
  2098. else //old format without 0xFF FE
  2099. {
  2100. ::memmove((LPVOID)(pByte+2), (LPVOID)pByte, m_dwUseSize);
  2101. *pByte = 0xFF;
  2102. *(pByte +1) = 0xFE;
  2103. //m_dwUseSize += 2;
  2104.                 m_pTrueData = (LPVOID)(pByte+2);
  2105. }
  2106. }
  2107. }
  2108. else
  2109. m_pTrueData = m_pData;
  2110.     return TRUE;
  2111. }
  2113. BOOL CJXINIFile::UnloadIniFile()
  2114. {
  2115. DWORD dwFileSize;
  2116. //if(sizeof(TCHAR) == 2) //UNICODE leading 0xFF FE
  2117. if(this->m_bUnicode)
  2118. dwFileSize = m_dwUseSize + 2;
  2119. else
  2120. dwFileSize = m_dwUseSize;
  2121. if(m_strFilename == _T("")) return TRUE; 
  2122.     if(!m_bDirty)
  2123. {
  2124. if(m_pData)
  2125. {
  2126. ::UnmapViewOfFile(m_pData);
  2127. m_pData = NULL;
  2128. }
  2129.     if(m_hMMF != NULL)
  2130. {
  2131. ::CloseHandle(m_hMMF);
  2132. m_hMMF = NULL;
  2133. }
  2134. LONG highDist = 0;
  2135.     ::SetFilePointer(
  2136. m_hFile,                // handle to file
  2137.             dwFileSize,        // bytes to move pointer
  2138.             &highDist,  // bytes to move pointer
  2139.             FILE_BEGIN           // starting point
  2140.         );
  2141.     ::SetEndOfFile(m_hFile);
  2142.     if(m_hFile != INVALID_HANDLE_VALUE)
  2143. {
  2144.     ::CloseHandle(m_hFile);
  2145.     m_hFile = INVALID_HANDLE_VALUE;
  2146. }
  2147. m_strFilename = _T("");
  2148. return TRUE;
  2149. }
  2150. //Modified
  2151. ASSERT(m_pData);
  2152. if(!::FlushViewOfFile(m_pData, m_dwUseSize))
  2153. {
  2154. ::MessageBox(NULL, _T("FlushViewMMF"), _T(""), MB_OK);
  2155. ::UnmapViewOfFile(m_pData);
  2156.     ::CloseHandle(m_hMMF);
  2157. LONG highDist = 0;
  2158.     ::SetFilePointer(
  2159.   m_hFile,                // handle to file
  2160.           dwFileSize,        // bytes to move pointer
  2161.           &highDist,  // bytes to move pointer
  2162.           FILE_BEGIN           // starting point
  2163.         );
  2164. ::SetEndOfFile(m_hFile);
  2165.     ::CloseHandle(m_hFile);
  2166. m_strFilename = _T("");
  2167. m_pData = NULL;
  2168. m_hMMF = NULL;
  2169. m_hFile = INVALID_HANDLE_VALUE;
  2170. m_dwSize = 0;
  2171. return FALSE;
  2172. }
  2173. ::UnmapViewOfFile(m_pData);
  2174. ::CloseHandle(m_hMMF);
  2175. //Adjust File Size
  2176. LONG highDist = 0;
  2177. ::SetFilePointer(
  2178. m_hFile,                // handle to file
  2179.         dwFileSize,        // bytes to move pointer
  2180.         &highDist,  // bytes to move pointer
  2181.         FILE_BEGIN           // starting point
  2182.     );
  2183. ::SetEndOfFile(m_hFile);
  2184. ::CloseHandle(m_hFile);
  2185. m_strFilename = _T("");
  2186. m_pData = NULL;
  2187. m_hMMF = NULL;
  2188. m_hFile = INVALID_HANDLE_VALUE;
  2189. m_dwSize = 0;
  2190. //
  2191. m_mapSection.RemoveAll();
  2192. m_bSectionMapDirty = TRUE;
  2194. m_bSectionMapLock = FALSE;
  2195. return TRUE;
  2196. }
  2198. //return -1 if not find key
  2199. //return first character of the key line 
  2200. //[section name]rn
  2201. //keyname = valuenamern
  2202. //Ex Version use Map
  2203. //posSection & ret all in WCHARs
  2204. UINT CJXINIFile::GetKeyExA(LPSTR pHead, UINT uSize, 
  2205. LPCSTR szSection, LPCSTR szKey, UINT& posSection)
  2206. {
  2207. //Map Must Be Ready Here
  2208. ASSERT(!m_bSectionMapDirty);
  2209. LPSTR pSecHead = NULL; //pointing to [
  2211. #ifdef _UNICODE
  2212. DWORD dwRetSize;
  2213. LPWSTR pTemp = _A2W((LPSTR)szSection, -1, dwRetSize);
  2214.     if(0 == m_mapSection.Lookup(pTemp, (LPVOID&)pSecHead))
  2215. {
  2216.         posSection = (UINT)-1;
  2217. return (UINT)-1; 
  2218. }
  2219. #else
  2220. if(0 == m_mapSection.Lookup(szSection, (LPVOID&)pSecHead))
  2221. {
  2222.         posSection = (UINT)-1;
  2223. return (UINT)-1; 
  2224. }
  2225. #endif
  2227. posSection = -1;
  2228. LPSTR p1 = pSecHead;
  2229. LPSTR p2 = pSecHead;
  2230. int lenSection = ::strlen(szSection);
  2231. char szSection2[MAX_PATH];
  2232. //section --> [section]
  2233.     ::strncpy(szSection2+1, szSection, lenSection);
  2234. szSection2[0] = char('[');
  2235. szSection2[lenSection+1] = char(']');
  2236. szSection2[lenSection+2] = char('');
  2237.         
  2238. BOOL bSection = FALSE; //found the section
  2239. BOOL bKey = FALSE;     //found the key
  2240. char buffer[MAX_PATH]; 
  2241. int line;
  2243. while(p1- pHead < (int)(uSize/sizeof(char)) - 1)
  2244. {
  2245. //WCHAR s1 = (WCHAR)'r'; //13
  2246. //WCHAR s2 = (WCHAR)'n'; //10
  2247. //WCHAR s3 = (WCHAR)0x0A; //10
  2248. //01/7/5 //avoid leak blank line
  2249. int rInc, nInc;
  2250. rInc = nInc = 0;
  2251. while(p1- pHead < (int)(uSize/sizeof(char)-1) && 
  2252. (*p1 == (char)'r' || *p1 == (char)'n'))
  2253. {
  2254. if(*p1 == (char)'r') rInc++;
  2255.             if(*p1 == (char)'n') nInc++;
  2256. p1++;
  2257. }
  2259. if(rInc == 1 && nInc == 1)
  2260. {
  2261. }
  2262. else if(rInc == nInc && rInc > 1)
  2263. line += rInc - 1;
  2264. else if(rInc != nInc)
  2265. {
  2266. line += rInc > nInc ? rInc - 1 : nInc - 1;
  2267. }
  2269. p2 = p1;
  2270. while(p2- pHead < (int)(uSize/sizeof(char))-1)
  2271. {
  2272. //$$$ some file end  with n only
  2273. if(*p2 == (char)'r' && *(p2+1) == (char)'n') 
  2274. {
  2275. break; //touch it
  2276. }
  2277.             if(*p2 == (char)'n') break;
  2278. if(*p2 == (char)'r') break;
  2279.     p2++;
  2280. }
  2281. if(p2 - pHead == (int)(uSize/sizeof(char))-1)
  2282. {
  2283. //the last sentence 
  2284.             while(*p2 == (char)'r' || *p2 == (char)'n') p2--;
  2285. int len = p2 - p1 + 1; 
  2286. line++;
  2287. if(len > 1)
  2288. {
  2289. if(len > MAX_PATH) 
  2290. {
  2291. p1 = p2 + 1;
  2292. continue;
  2293. }
  2294. ::strncpy(buffer, p1, len);
  2295. buffer[len] = char('');
  2297. //a section ?
  2298.     if(buffer[0] == char('[') && 
  2299.     buffer[len-1] == char(']'))
  2300. {
  2301. //AfxMessageBox(buffer);
  2302. if(::strcmp(buffer,szSection2) == 0) //match
  2303. {
  2304. if(!bSection) 
  2305. {
  2306. bSection = TRUE;
  2307.     posSection = (UINT)(p1 - pHead);
  2308. }
  2309. }
  2310.     else
  2311. {
  2312. if(bSection) return (UINT)-1;
  2313. }
  2314. }
  2315.     else //a key line
  2316. {
  2317. if(!bSection)
  2318. {
  2319. }
  2320.     else
  2321. {
  2322. //key name = value name
  2323. int lenKey = ::strlen(szKey);
  2324.     //find =
  2325.     int sam;
  2326.     for(sam = 0; sam < len; sam++)
  2327. if(buffer[sam] == char('=')) break;
  2328.     if(sam >= lenKey && sam < len)
  2329. {
  2330. for(int q = 0; q < sam; q++)
  2331. {
  2332. if(q < lenKey && buffer[q] != szKey[q]) break;
  2333.     if(q > lenKey && buffer[q] != char(' ')) break;
  2334. }
  2335.     if(q == sam) //found
  2336. {
  2337. bKey = TRUE;
  2338.     return (UINT)(p1 - pHead + sam + 1);
  2339.     //return (UINT)(p1 - pHead);
  2340. }
  2341. }
  2342. }
  2343. }
  2345. line++;
  2346. }
  2347.             break;
  2348. }
  2349. p2--;
  2350. //now p2 points to the ending of the sentence
  2351.         int len = p2 - p1 + 1; //in chars
  2352. line++;
  2353. if(len > 1)
  2354. {
  2355. if(len > MAX_PATH) 
  2356. {
  2357. p1 = p2 + 1;
  2358. continue;
  2359. }
  2360. //this sentence must shorter than MAX_PATH
  2361. ::strncpy(buffer, p1, len);
  2362. buffer[len] = char('');
  2364. //???, lstrcpy seems not add null-trminator
  2365. //buffer[len] = WCHAR('');
  2367. //a section ?
  2368. if(buffer[0] == char('[') && 
  2369. buffer[len-1] == char(']'))
  2370. {
  2371. //AfxMessageBox(buffer);
  2372. if(::strcmp(buffer,szSection2) == 0) //match
  2373. {
  2374. if(!bSection) 
  2375. {
  2376. bSection = TRUE;
  2377. posSection = (UINT)(p1 - pHead);
  2378. }
  2379. }
  2380. else
  2381. {
  2382. if(bSection) return (UINT)-1;
  2383. }
  2384. }
  2385. else //a key line
  2386. {
  2387. if(!bSection)
  2388. {
  2389. }
  2390. else
  2391. {
  2392. //key name = value name
  2393. int lenKey = ::strlen(szKey);
  2394. //find =
  2395. int sam;
  2396. for(sam = 0; sam < len; sam++)
  2397. if(buffer[sam] == char('=')) break;
  2398. if(sam >= lenKey && sam < len)
  2399. {
  2400. for(int q = 0; q < sam; q++)
  2401. {
  2402. if(q < lenKey && buffer[q] != szKey[q]) break;
  2403. if(q > lenKey && buffer[q] != char(' ')) break;
  2404. }
  2405. if(q == sam) //found
  2406. {
  2407. bKey = TRUE;
  2408. return (UINT)(p1 - pHead + sam + 1);
  2409. //return (UINT)(p1 - pHead);
  2410. }
  2411. }
  2412. }
  2413. }
  2414. }
  2415. p1 = p2 + 1;
  2416. }
  2417. return (UINT)-1;
  2418. }
  2420. //return -1 if not find key
  2421. //return first character of the key line 
  2422. //[section name]rn
  2423. //keyname = valuenamern
  2424. //Ex Version use Map
  2425. //posSection & ret all in WCHARs
  2426. UINT CJXINIFile::GetKeyExW(LPWSTR pHead, UINT uSize, 
  2427. LPCWSTR szSection, LPCWSTR szKey, UINT& posSection)
  2428. {
  2429. //Map Must Be Ready Here
  2430. ASSERT(!m_bSectionMapDirty);
  2431. LPWSTR pSecHead = NULL; //pointing to [
  2432. #ifdef _UNICODE
  2433. if(0 == m_mapSection.Lookup(szSection, (LPVOID&)pSecHead))
  2434. {
  2435.         posSection = (UINT)-1;
  2436. return (UINT)-1; 
  2437. }
  2438. #else
  2439. DWORD dwRetSize;
  2440. LPSTR pTemp = _W2A((LPWSTR)szSection, -1, dwRetSize);
  2441.     if(0 == m_mapSection.Lookup(pTemp, (LPVOID&)pSecHead))
  2442. {
  2443.         posSection = (UINT)-1;
  2444. return (UINT)-1; 
  2445. }
  2446. #endif
  2447. posSection = -1;
  2448. LPWSTR p1 = pSecHead;
  2449. LPWSTR p2 = pSecHead;
  2450. int lenSection = ::wcslen(szSection);
  2451. WCHAR szSection2[MAX_PATH];
  2452. //section --> [section]
  2453.     ::wcsncpy(szSection2+1, szSection, lenSection);
  2454. szSection2[0] = WCHAR('[');
  2455. szSection2[lenSection+1] = WCHAR(']');
  2456. szSection2[lenSection+2] = WCHAR('');
  2457.         
  2458. BOOL bSection = FALSE; //found the section
  2459. BOOL bKey = FALSE;     //found the key
  2460. WCHAR buffer[MAX_PATH]; 
  2461. int line;
  2463. while(p1- pHead < (int)(uSize/sizeof(WCHAR)) - 1)
  2464. {
  2465. //WCHAR s1 = (WCHAR)'r'; //13
  2466. //WCHAR s2 = (WCHAR)'n'; //10
  2467. //WCHAR s3 = (WCHAR)0x0A; //10
  2468. //01/7/5 //avoid leak blank line
  2469. int rInc, nInc;
  2470. rInc = nInc = 0;
  2471. while(p1- pHead < (int)(uSize/sizeof(WCHAR)-1) && 
  2472. (*p1 == (WCHAR)'r' || *p1 == (WCHAR)'n'))
  2473. {
  2474. if(*p1 == (WCHAR)'r') rInc++;
  2475.             if(*p1 == (WCHAR)'n') nInc++;
  2476. p1++;
  2477. }
  2479. if(rInc == 1 && nInc == 1)
  2480. {
  2481. }
  2482. else if(rInc == nInc && rInc > 1)
  2483. line += rInc - 1;
  2484. else if(rInc != nInc)
  2485. {
  2486. line += rInc > nInc ? rInc - 1 : nInc - 1;
  2487. }
  2489. p2 = p1;
  2490. while(p2- pHead < (int)(uSize/sizeof(WCHAR))-1)
  2491. {
  2492. //$$$ some file end  with n only
  2493. if(*p2 == (WCHAR)'r' && *(p2+1) == (WCHAR)'n') 
  2494. {
  2495. break; //touch it
  2496. }
  2497.             if(*p2 == (WCHAR)'n') break;
  2498. if(*p2 == (WCHAR)'r') break;
  2499.     p2++;
  2500. }
  2501. if(p2 - pHead == (int)(uSize/sizeof(WCHAR))-1)
  2502. {
  2503. //the last sentence 
  2504.             while(*p2 == (WCHAR)'r' || *p2 == (WCHAR)'n') p2--;
  2505. int len = p2 - p1 + 1; 
  2506. line++;
  2507. if(len > 1)
  2508. {
  2509. if(len > MAX_PATH) 
  2510. {
  2511. p1 = p2 + 1;
  2512. continue;
  2513. }
  2514. ::wcsncpy(buffer, p1, len);
  2515. buffer[len] = WCHAR('');
  2517. //a section ?
  2518.     if(buffer[0] == WCHAR('[') && 
  2519.     buffer[len-1] == WCHAR(']'))
  2520. {
  2521. //AfxMessageBox(buffer);
  2522. if(::wcscmp(buffer,szSection2) == 0) //match
  2523. {
  2524. if(!bSection) 
  2525. {
  2526. bSection = TRUE;
  2527.     posSection = (UINT)(p1 - pHead);
  2528. }
  2529. }
  2530.     else
  2531. {
  2532. if(bSection) return (UINT)-1;
  2533. }
  2534. }
  2535.     else //a key line
  2536. {
  2537. if(!bSection)
  2538. {
  2539. }
  2540.     else
  2541. {
  2542. //key name = value name
  2543. int lenKey = ::wcslen(szKey);
  2544.     //find =
  2545.     int sam;
  2546.     for(sam = 0; sam < len; sam++)
  2547. if(buffer[sam] == WCHAR('=')) break;
  2548.     if(sam >= lenKey && sam < len)
  2549. {
  2550. for(int q = 0; q < sam; q++)
  2551. {
  2552. if(q < lenKey && buffer[q] != szKey[q]) break;
  2553.     if(q > lenKey && buffer[q] != WCHAR(' ')) break;
  2554. }
  2555.     if(q == sam) //found
  2556. {
  2557. bKey = TRUE;
  2558.     return (UINT)(p1 - pHead + sam + 1);
  2559.     //return (UINT)(p1 - pHead);
  2560. }
  2561. }
  2562. }
  2563. }
  2565. line++;
  2566. }
  2567.             break;
  2568. }
  2569. p2--;
  2570. //now p2 points to the ending of the sentence
  2571.         int len = p2 - p1 + 1; //in WCHARs
  2572. line++;
  2573. if(len > 1)
  2574. {
  2575. if(len > MAX_PATH) 
  2576. {
  2577. p1 = p2 + 1;
  2578. continue;
  2579. }
  2580. //this sentence must shorter than MAX_PATH
  2581. ::wcsncpy(buffer, p1, len);
  2582. buffer[len] = WCHAR('');
  2584. //???, lstrcpy seems not add null-trminator
  2585. //buffer[len] = WCHAR('');
  2587. //a section ?
  2588. if(buffer[0] == WCHAR('[') && 
  2589. buffer[len-1] == WCHAR(']'))
  2590. {
  2591. //AfxMessageBox(buffer);
  2592. if(::wcscmp(buffer,szSection2) == 0) //match
  2593. {
  2594. if(!bSection) 
  2595. {
  2596. bSection = TRUE;
  2597. posSection = (UINT)(p1 - pHead);
  2598. }
  2599. }
  2600. else
  2601. {
  2602. if(bSection) return (UINT)-1;
  2603. }
  2604. }
  2605. else //a key line
  2606. {
  2607. if(!bSection)
  2608. {
  2609. }
  2610. else
  2611. {
  2612. //key name = value name
  2613. int lenKey = ::wcslen(szKey);
  2614. //find =
  2615. int sam;
  2616. for(sam = 0; sam < len; sam++)
  2617. if(buffer[sam] == WCHAR('=')) break;
  2618. if(sam >= lenKey && sam < len)
  2619. {
  2620. for(int q = 0; q < sam; q++)
  2621. {
  2622. if(q < lenKey && buffer[q] != szKey[q]) break;
  2623. if(q > lenKey && buffer[q] != WCHAR(' ')) break;
  2624. }
  2625. if(q == sam) //found
  2626. {
  2627. bKey = TRUE;
  2628. return (UINT)(p1 - pHead + sam + 1);
  2629. //return (UINT)(p1 - pHead);
  2630. }
  2631. }
  2632. }
  2633. }
  2634. }
  2635. p1 = p2 + 1;
  2636. }
  2637. return (UINT)-1;
  2638. }
  2640. //return -1 if not find key
  2641. //return first character of the key line 
  2642. //[section name]rn
  2643. //keyname = valuenamern
  2644. //posSection & ret all in WCHARs
  2645. UINT CJXINIFile::GetKeyW(LPWSTR pHead, UINT uSize, 
  2646. LPCWSTR szSection, LPCWSTR szKey, UINT& posSection)
  2647. {
  2648. posSection = -1;
  2649. LPWSTR p1 = pHead;
  2650. LPWSTR p2 = pHead;
  2651. int lenSection = ::wcslen(szSection);
  2652. WCHAR szSection2[MAX_PATH];
  2653. //section --> [section]
  2654.     ::wcsncpy(szSection2+1, szSection, lenSection);
  2655. szSection2[0] = WCHAR('[');
  2656. szSection2[lenSection+1] = WCHAR(']');
  2657. szSection2[lenSection+2] = WCHAR('');
  2658.         
  2659. BOOL bSection = FALSE; //found the section
  2660. BOOL bKey = FALSE;     //found the key
  2661. WCHAR buffer[MAX_PATH]; 
  2662. int line;
  2664. while(p1- pHead < (int)(uSize/sizeof(WCHAR)) - 1)
  2665. {
  2666. //WCHAR s1 = (WCHAR)'r'; //13
  2667. //WCHAR s2 = (WCHAR)'n'; //10
  2668. //WCHAR s3 = (WCHAR)0x0A; //10
  2669. //01/7/5 //avoid leak blank line
  2670. int rInc, nInc;
  2671. rInc = nInc = 0;
  2672. while(p1- pHead < (int)(uSize/sizeof(WCHAR)-1) && 
  2673. (*p1 == (WCHAR)'r' || *p1 == (WCHAR)'n'))
  2674. {
  2675. if(*p1 == (WCHAR)'r') rInc++;
  2676.             if(*p1 == (WCHAR)'n') nInc++;
  2677. p1++;
  2678. }
  2680. if(rInc == 1 && nInc == 1)
  2681. {
  2682. }
  2683. else if(rInc == nInc && rInc > 1)
  2684. line += rInc - 1;
  2685. else if(rInc != nInc)
  2686. {
  2687. line += rInc > nInc ? rInc - 1 : nInc - 1;
  2688. }
  2690. p2 = p1;
  2691. while(p2- pHead < (int)(uSize/sizeof(WCHAR))-1)
  2692. {
  2693. //$$$ some file end  with n only
  2694. if(*p2 == (WCHAR)'r' && *(p2+1) == (WCHAR)'n') 
  2695. {
  2696. break; //touch it
  2697. }
  2698.             if(*p2 == (WCHAR)'n') break;
  2699. if(*p2 == (WCHAR)'r') break;
  2700.     p2++;
  2701. }
  2702. if(p2 - pHead == (int)(uSize/sizeof(WCHAR))-1)
  2703. {
  2704. //the last sentence 
  2705.             while(*p2 == (WCHAR)'r' || *p2 == (WCHAR)'n') p2--;
  2706. int len = p2 - p1 + 1; 
  2707. line++;
  2708. if(len > 1)
  2709. {
  2710. if(len > MAX_PATH) 
  2711. {
  2712. p1 = p2 + 1;
  2713. continue;
  2714. }
  2715. ::wcsncpy(buffer, p1, len);
  2716. buffer[len] = WCHAR('');
  2718. //a section ?
  2719.     if(buffer[0] == WCHAR('[') && 
  2720.     buffer[len-1] == WCHAR(']'))
  2721. {
  2722. //AfxMessageBox(buffer);
  2723. if(::wcscmp(buffer,szSection2) == 0) //match
  2724. {
  2725. if(!bSection) 
  2726. {
  2727. bSection = TRUE;
  2728.     posSection = (UINT)(p1 - pHead);
  2729. }
  2730. }
  2731.     else
  2732. {
  2733. if(bSection) return (UINT)-1;
  2734. }
  2735. }
  2736.     else //a key line
  2737. {
  2738. if(!bSection)
  2739. {
  2740. }
  2741.     else
  2742. {
  2743. //key name = value name
  2744. int lenKey = ::wcslen(szKey);
  2745.     //find =
  2746.     int sam;
  2747.     for(sam = 0; sam < len; sam++)
  2748. if(buffer[sam] == WCHAR('=')) break;
  2749.     if(sam >= lenKey && sam < len)
  2750. {
  2751. for(int q = 0; q < sam; q++)
  2752. {
  2753. if(q < lenKey && buffer[q] != szKey[q]) break;
  2754.     if(q > lenKey && buffer[q] != WCHAR(' ')) break;
  2755. }
  2756.     if(q == sam) //found
  2757. {
  2758. bKey = TRUE;
  2759.     return (UINT)(p1 - pHead + sam + 1);
  2760.     //return (UINT)(p1 - pHead);
  2761. }
  2762. }
  2763. }
  2764. }
  2766. line++;
  2767. }
  2768.             break;
  2769. }
  2770. p2--;
  2771. //now p2 points to the ending of the sentence
  2772.         int len = p2 - p1 + 1; //in WCHARs
  2773. line++;
  2774. if(len > 1)
  2775. {
  2776. if(len > MAX_PATH) 
  2777. {
  2778. p1 = p2 + 1;
  2779. continue;
  2780. }
  2781. //this sentence must shorter than MAX_PATH
  2782. ::wcsncpy(buffer, p1, len);
  2783. buffer[len] = WCHAR('');
  2785. //???, lstrcpy seems not add null-trminator
  2786. //buffer[len] = WCHAR('');
  2788. //a section ?
  2789. if(buffer[0] == WCHAR('[') && 
  2790. buffer[len-1] == WCHAR(']'))
  2791. {
  2792. //AfxMessageBox(buffer);
  2793. if(::wcscmp(buffer,szSection2) == 0) //match
  2794. {
  2795. if(!bSection) 
  2796. {
  2797. bSection = TRUE;
  2798. posSection = (UINT)(p1 - pHead);
  2799. }
  2800. }
  2801. else
  2802. {
  2803. if(bSection) return (UINT)-1;
  2804. }
  2805. }
  2806. else //a key line
  2807. {
  2808. if(!bSection)
  2809. {
  2810. }
  2811. else
  2812. {
  2813. //key name = value name
  2814. int lenKey = ::wcslen(szKey);
  2815. //find =
  2816. int sam;
  2817. for(sam = 0; sam < len; sam++)
  2818. if(buffer[sam] == WCHAR('=')) break;
  2819. if(sam >= lenKey && sam < len)
  2820. {
  2821. for(int q = 0; q < sam; q++)
  2822. {
  2823. if(q < lenKey && buffer[q] != szKey[q]) break;
  2824. if(q > lenKey && buffer[q] != WCHAR(' ')) break;
  2825. }
  2826. if(q == sam) //found
  2827. {
  2828. bKey = TRUE;
  2829. return (UINT)(p1 - pHead + sam + 1);
  2830. //return (UINT)(p1 - pHead);
  2831. }
  2832. }
  2833. }
  2834. }
  2835. }
  2836. p1 = p2 + 1;
  2837. }
  2838. return (UINT)-1;
  2839. }
  2841. UINT CJXINIFile::GetKeyA(LPSTR pHead, UINT uSize, 
  2842. LPCSTR szSection, LPCSTR szKey, UINT& posSection)
  2843. {
  2844. posSection = -1;
  2845. LPSTR p1 = pHead;
  2846. LPSTR p2 = pHead;
  2847. int lenSection = ::strlen(szSection);
  2848. char szSection2[MAX_PATH];
  2849. //section --> [section]
  2850.     ::strncpy(szSection2+1, szSection, lenSection);
  2851. szSection2[0] = char('[');
  2852. szSection2[lenSection+1] = char(']');
  2853. szSection2[lenSection+2] = char('');
  2854.         
  2855. BOOL bSection = FALSE; //found the section
  2856. BOOL bKey = FALSE;     //found the key
  2857. char buffer[MAX_PATH]; 
  2858. int line;
  2860. while(p1- pHead < (int)(uSize/sizeof(char)) - 1)
  2861. {
  2862. //char s1 = (char)'r'; //13
  2863. //char s2 = (char)'n'; //10
  2864. //char s3 = (char)0x0A; //10
  2865. //01/7/5 //avoid leak blank line
  2866. int rInc, nInc;
  2867. rInc = nInc = 0;
  2868. while(p1- pHead < (int)(uSize/sizeof(char)-1) && 
  2869. (*p1 == (char)'r' || *p1 == (char)'n'))
  2870. {
  2871. if(*p1 == (char)'r') rInc++;
  2872.             if(*p1 == (char)'n') nInc++;
  2873. p1++;
  2874. }
  2876. if(rInc == 1 && nInc == 1)
  2877. {
  2878. }
  2879. else if(rInc == nInc && rInc > 1)
  2880. line += rInc - 1;
  2881. else if(rInc != nInc)
  2882. {
  2883. line += rInc > nInc ? rInc - 1 : nInc - 1;
  2884. }
  2886. p2 = p1;
  2887. while(p2- pHead < (int)(uSize/sizeof(char))-1)
  2888. {
  2889. //$$$ some file end  with n only
  2890. if(*p2 == (char)'r' && *(p2+1) == (char)'n') 
  2891. {
  2892. break; //touch it
  2893. }
  2894.             if(*p2 == (char)'n') break;
  2895. if(*p2 == (char)'r') break;
  2896.     p2++;
  2897. }
  2898. if(p2 - pHead == (int)(uSize/sizeof(char))-1)
  2899. {
  2900. //the last sentence 
  2901.             while(*p2 == (char)'r' || *p2 == (char)'n') p2--;
  2902. int len = p2 - p1 + 1; 
  2903. line++;
  2904. if(len > 1)
  2905. {
  2906. if(len > MAX_PATH) 
  2907. {
  2908. p1 = p2 + 1;
  2909. continue;
  2910. }
  2911. ::strncpy(buffer, p1, len);
  2912. buffer[len] = char('');
  2914. //a section ?
  2915.     if(buffer[0] == char('[') && 
  2916.     buffer[len-1] == char(']'))
  2917. {
  2918. //AfxMessageBox(buffer);
  2919. if(::strcmp(buffer,szSection2) == 0) //match
  2920. {
  2921. if(!bSection) 
  2922. {
  2923. bSection = TRUE;
  2924.     posSection = (UINT)(p1 - pHead);
  2925. }
  2926. }
  2927.     else
  2928. {
  2929. if(bSection) return (UINT)-1;
  2930. }
  2931. }
  2932.     else //a key line
  2933. {
  2934. if(!bSection)
  2935. {
  2936. }
  2937.     else
  2938. {
  2939. //key name = value name
  2940. int lenKey = ::strlen(szKey);
  2941.     //find =
  2942.     int sam;
  2943.     for(sam = 0; sam < len; sam++)
  2944. if(buffer[sam] == char('=')) break;
  2945.     if(sam >= lenKey && sam < len)
  2946. {
  2947. for(int q = 0; q < sam; q++)
  2948. {
  2949. if(q < lenKey && buffer[q] != szKey[q]) break;
  2950.     if(q > lenKey && buffer[q] != char(' ')) break;
  2951. }
  2952.     if(q == sam) //found
  2953. {
  2954. bKey = TRUE;
  2955.     return (UINT)(p1 - pHead + sam + 1);
  2956.     //return (UINT)(p1 - pHead);
  2957. }
  2958. }
  2959. }
  2960. }
  2962. line++;
  2963. }
  2964.             break;
  2965. }
  2966. p2--;
  2967. //now p2 points to the ending of the sentence
  2968.         int len = p2 - p1 + 1; //in WCHARs
  2969. line++;
  2970. if(len > 1)
  2971. {
  2972. if(len > MAX_PATH) 
  2973. {
  2974. p1 = p2 + 1;
  2975. continue;
  2976. }
  2977. //this sentence must shorter than MAX_PATH
  2978. ::strncpy(buffer, p1, len);
  2979. buffer[len] = char('');
  2981. //???, lstrcpy seems not add null-trminator
  2982. //buffer[len] = char('');
  2984. //a section ?
  2985. if(buffer[0] == char('[') && 
  2986. buffer[len-1] == char(']'))
  2987. {
  2988. //AfxMessageBox(buffer);
  2989. if(::strcmp(buffer,szSection2) == 0) //match
  2990. {
  2991. if(!bSection) 
  2992. {
  2993. bSection = TRUE;
  2994. posSection = (UINT)(p1 - pHead);
  2995. }
  2996. }
  2997. else
  2998. {
  2999. if(bSection) return (UINT)-1;
  3000. }
  3001. }
  3002. else //a key line
  3003. {
  3004. if(!bSection)
  3005. {
  3006. }
  3007. else
  3008. {
  3009. //key name = value name
  3010. int lenKey = ::strlen(szKey);
  3011. //find =
  3012. int sam;
  3013. for(sam = 0; sam < len; sam++)
  3014. if(buffer[sam] == char('=')) break;
  3015. if(sam >= lenKey && sam < len)
  3016. {
  3017. for(int q = 0; q < sam; q++)
  3018. {
  3019. if(q < lenKey && buffer[q] != szKey[q]) break;
  3020. if(q > lenKey && buffer[q] != char(' ')) break;
  3021. }
  3022. if(q == sam) //found
  3023. {
  3024. bKey = TRUE;
  3025. return (UINT)(p1 - pHead + sam + 1);
  3026. //return (UINT)(p1 - pHead);
  3027. }
  3028. }
  3029. }
  3030. }
  3031. }
  3032. p1 = p2 + 1;
  3033. }
  3034. return (UINT)-1;
  3035. }
  3037. void CJXINIFile::CutZeroTail()
  3038. {
  3039. //AfxMessageBox(m_strFilename);
  3040. //::PopMsg(_T("%s - %d"), m_strFilename, m_dwUseSize);
  3041. if(m_dwUseSize == 0) return; //empty file
  3042. int i = m_dwUseSize - 1;
  3043. LPBYTE pByte = (LPBYTE)m_pData; 
  3044. pByte += m_dwUseSize - sizeof(TCHAR);
  3045.     //if(sizeof(TCHAR) == 1) //MBCS
  3046. if(!this->m_bUnicode)
  3047. {
  3048. while(*pByte == 0x00 && pByte - (LPBYTE)m_pData > 0)
  3049. {
  3050. pByte--;
  3051. m_dwUseSize--;
  3052. }
  3053. }
  3054. else //UNICODE
  3055. {
  3056. while(*pByte == 0x00 && *(pByte+1) == 0x00 &&
  3057. pByte - (LPBYTE)m_pTrueData > 0)
  3058. {
  3059. pByte -= 2;
  3060. m_dwUseSize -= 2;
  3061. }
  3062. }
  3063. //DWORD   m_dwSize; //Current Open File Size in BYTEs
  3064. //DWORD   m_dwUseSize; //Curent Using Size in BYTEs
  3065. //AfxMessageBox(_T("")); //妋擣俷俲
  3066. return;
  3067. }
  3069. DWORD CJXINIFile::DeleteSectionW(
  3070.  LPCWSTR lpAppName        // section name
  3071.     )
  3072. {
  3073.     int lenTargetSec = wcslen(lpAppName);
  3074. LPWSTR pSecHead = NULL;
  3075. LPWSTR pHead = (LPWSTR)m_pTrueData;
  3076. LPWSTR p1 = pHead;
  3077. LPWSTR p2 = pHead;
  3078.         
  3079. while(p1- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) - 1)
  3080. {
  3081. while(p1- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) - 1 &&
  3082. *p1 != WCHAR('['))
  3083. p1++;
  3084. p2 = p1;
  3085. while(p2- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) - 1 &&
  3086. *p2 != WCHAR(']'))
  3087. p2++;
  3088. if(p1- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) &&
  3089. p2- pHead < (int)(m_dwUseSize/sizeof(WCHAR)))
  3090. {
  3091. //Found A Section, Check
  3092. int lenSection = p2 - p1 - 1;
  3093. if(lenSection == lenTargetSec)
  3094. {
  3095. pSecHead = p1;
  3096. for(int i = 0; i < lenTargetSec; i++)
  3097. {
  3098. if(lpAppName[i] != (WCHAR)*(p1+1+i))
  3099. {
  3100.                         pSecHead = NULL;
  3101. break;
  3102. }
  3103. }
  3104. } 
  3105. }
  3106. if(pSecHead != NULL) break;
  3107. p1 = p2 + 1;
  3108. }
  3110. if(pSecHead == NULL) return -1;
  3111.     p1 = pSecHead + lenTargetSec;
  3113. while(p1- pHead < (int)(m_dwUseSize/sizeof(WCHAR)) - 1 &&
  3114. *p1 != WCHAR('['))
  3115. p1++;
  3116.    
  3117. if(p1- pHead == (int)(m_dwUseSize/sizeof(WCHAR)) - 1)
  3118. {
  3119. //This is the Last Section
  3120.         m_dwUseSize = sizeof(WCHAR)*(pSecHead-pHead);
  3121. return 0;
  3122. }
  3123. else
  3124. {
  3125. int memLen = m_dwUseSize - (p1 - pHead)*sizeof(WCHAR);
  3126. //C++ Run-time Lib handle overlapped mem
  3127.         memmove(pSecHead, p1, memLen);
  3128. m_dwUseSize -= sizeof(WCHAR)*(p1 - pSecHead);
  3129. }
  3130. return 0;
  3131. }
  3133. DWORD CJXINIFile::DeleteKeyW(
  3134.          LPCWSTR lpAppName,  // section name
  3135.          LPCWSTR lpKeyName  // key name
  3136.     )
  3137. {
  3138. LPWSTR pHead = (LPWSTR)m_pTrueData;
  3139. UINT uSec, uKey;  
  3140. //Warning: uKey, uSec is measured in WCHARs!!!!!
  3141. //in UNICODE now
  3142. uKey = GetKeyW(pHead, (UINT)m_dwUseSize, 
  3143. lpAppName, lpKeyName, uSec);
  3144.     if(uKey == (UINT)-1 && uSec == (UINT)-1) //no section
  3145. {
  3146. return -1;
  3147. }
  3148. else if(uKey == (UINT)-1 && uSec != (UINT)-1) 
  3149. //section exist but value do not exist
  3150. {
  3151. return -1;
  3152. }
  3153. else //key exist
  3154. {
  3155. ASSERT(uKey != (UINT)-1);
  3156.         LPWSTR pValue = pHead + uKey;
  3157.     while(pValue - pHead < (int)(m_dwUseSize/sizeof(WCHAR)) && 
  3158.     *pValue != WCHAR('r') && *pValue != WCHAR('n'))
  3159. {
  3160. pValue++;
  3161. }
  3163.     while(*pValue == WCHAR('r') || *pValue == WCHAR('n'))
  3164. pValue++;
  3165. int lenKey = pValue - pHead - uKey;
  3166.         LPWSTR pKeyHead = pHead + uKey;
  3167. int lenMove = m_dwUseSize - (pValue - pHead)*sizeof(WCHAR);
  3168. memmove(pKeyHead, pValue, lenMove);
  3169.         m_dwUseSize -= lenKey*sizeof(WCHAR);
  3170. }
  3171. this->m_bSectionMapDirty = TRUE;
  3172. return 0;
  3173. }
  3175. DWORD CJXINIFile::DeleteSectionExW(
  3176.  LPCWSTR lpAppName        // section name
  3177.     )
  3178. {
  3179. ASSERT(!this->m_bSectionMapLock);
  3180. if(this->m_bSectionMapDirty)
  3181. this->UpdateMapW();
  3183.     LPWSTR lpHead = (LPWSTR)m_pTrueData;    
  3184. CString strKey;
  3185. LPWSTR lpPos;
  3186. #ifdef _UNICODE
  3187. strKey = lpAppName;
  3188. #else
  3189. DWORD dwRetSize;
  3190. LPSTR pTemp = _W2A((LPWSTR)lpAppName, -1, dwRetSize);
  3191. ::strncpy(strKey.GetBuffer(dwRetSize), pTemp, dwRetSize);
  3192. strKey.ReleaseBuffer(dwRetSize);
  3193. #endif
  3194. //No Such Section Exists
  3195. LPVOID lpVoid;
  3196. if(!m_mapSection.Lookup(strKey, lpVoid)) return -1;
  3197.     ASSERT(m_mapSection.RemoveKey(strKey));
  3198. lpPos = (LPWSTR)lpVoid;
  3199. LPWSTR lpSection = (LPWSTR)lpPos;
  3200.     
  3201. LPWSTR lpNextSec = NULL;
  3202. int distance = -1;
  3204. POSITION pos = m_mapSection.GetStartPosition();
  3205. while(pos)
  3206. {
  3207. CString strKey2;
  3208. LPWSTR lpPos2;
  3209. m_mapSection.GetNextAssoc(pos, strKey2, lpVoid);
  3210. lpPos2 = (LPWSTR)lpVoid;
  3211. if(lpPos2 - lpPos > 0)
  3212. {
  3213. if(distance == -1) 
  3214. {
  3215. distance = lpPos2 - lpPos;
  3216. lpNextSec = lpPos2;
  3217. }
  3218. else
  3219. {
  3220. if(lpPos2 - lpPos < distance)
  3221. {
  3222. distance = lpPos2 - lpPos;
  3223.     lpNextSec = lpPos2;
  3224. }
  3225. }
  3227. }
  3228. }
  3229.     
  3231. if(lpNextSec == NULL)
  3232. {
  3233. ASSERT(distance == -1);
  3234. //This is the Last Section
  3235.         m_dwUseSize = sizeof(WCHAR)*(lpPos-lpHead);
  3236. return 0;
  3237. }
  3238. else
  3239. {
  3240. int memLen = m_dwUseSize - (lpNextSec - lpHead)*sizeof(WCHAR);
  3241. //C++ Run-time Lib handle overlapped mem
  3242.         memmove((LPVOID)lpPos, (LPVOID)lpNextSec, memLen);
  3243. m_dwUseSize -= sizeof(WCHAR)*(lpNextSec - lpPos);
  3244. }
  3245.     
  3246. //m_bSectionMapDirty = TRUE;
  3247. //return TRUE;
  3249. int lenSec = lpNextSec - lpPos;
  3250. if(m_bSectionMapLock)
  3251. { 
  3252. m_bSectionMapDirty = TRUE;
  3253. }
  3254. else //update section map
  3255. {
  3256. POSITION pos = m_mapSection.GetStartPosition();
  3257.     while(pos)
  3258. {
  3259. CString strTemp;
  3260.         LPVOID lpTemp;
  3261.         m_mapSection.GetNextAssoc(pos, strTemp, lpTemp);
  3262.      //adjust Section Map
  3263. if((LPWSTR)lpTemp - lpSection > 0)
  3264. {
  3265. LPWSTR lp = (LPWSTR)lpTemp;
  3266. lp -= lenSec;
  3267. lpTemp = (LPVOID)lp;
  3268. m_mapSection.SetAt(strTemp, lpTemp);
  3269. }
  3270. }
  3271. }
  3272. return TRUE;
  3273. }
  3275. DWORD CJXINIFile::DeleteKeyExW(
  3276.          LPCWSTR lpAppName,  // section name
  3277.          LPCWSTR lpKeyName  // key name
  3278.     )
  3279. {
  3280. LPWSTR pHead = (LPWSTR)m_pTrueData;
  3281. UINT uSec, uKey;  
  3282. //Warning: uKey, uSec is measured in WCHARs!!!!!
  3283. //in UNICODE now
  3284. uKey = GetKeyExW(pHead, (UINT)m_dwUseSize, 
  3285. lpAppName, lpKeyName, uSec);
  3286.     if(uKey == (UINT)-1 && uSec == (UINT)-1) //no section
  3287. {
  3288. return -1;
  3289. }
  3290. else if(uKey == (UINT)-1 && uSec != (UINT)-1) 
  3291. //section exist but value do not exist
  3292. {
  3293. return -1;
  3294. }
  3295. else //key exist
  3296. {
  3297. ASSERT(uKey != (UINT)-1);
  3298. LPWSTR pSection = pHead + uSec;
  3299.         LPWSTR pValue = pHead + uKey;
  3300.     while(pValue - pHead < (int)(m_dwUseSize/sizeof(WCHAR)) && 
  3301.     *pValue != WCHAR('r') && *pValue != WCHAR('n'))
  3302. {
  3303. pValue++;
  3304. }
  3306.     while(*pValue == WCHAR('r') || *pValue == WCHAR('n'))
  3307. pValue++;
  3308. int lenKey = pValue - pHead - uKey;
  3309.         LPWSTR pKeyHead = pHead + uKey;
  3310. int lenMove = m_dwUseSize - (pValue - pHead)*sizeof(WCHAR);
  3311. memmove(pKeyHead, pValue, lenMove);
  3312.         m_dwUseSize -= lenKey*sizeof(WCHAR);
  3314. if(m_bSectionMapLock)
  3315. { 
  3316. m_bSectionMapDirty = TRUE;
  3317. }
  3318. else //update section map
  3319. {
  3320. POSITION pos = m_mapSection.GetStartPosition();
  3321.         while(pos)
  3322. {
  3323. CString strKey;
  3324.         LPVOID lpPos;
  3325.         m_mapSection.GetNextAssoc(pos, strKey, lpPos);
  3326.      //adjust Section Map
  3327. if((LPWSTR)lpPos - pSection > 0)
  3328. {
  3329. LPWSTR pTemp = (LPWSTR)lpPos;
  3330. pTemp -= lenKey;
  3331. lpPos = (LPVOID)pTemp;
  3332. m_mapSection.SetAt(strKey, lpPos);
  3333. }
  3334. }
  3335. }
  3336. }
  3337. return 0;
  3338. }
  3340. DWORD CJXINIFile::DeleteSectionExA(
  3341.  LPCSTR lpAppName        // section name
  3342.     )
  3343. {
  3344. return 0;
  3345. }
  3347. DWORD CJXINIFile::DeleteKeyExA(
  3348.          LPCSTR lpAppName,  // section name
  3349.          LPCSTR lpKeyName  // key name
  3350.     )
  3351. {
  3352. return 0;
  3353. }
  3355. DWORD CJXINIFile::DeleteSectionA(
  3356.  LPCSTR lpAppName        // section name
  3357.     )
  3358. {
  3359. return 0;
  3360. }
  3362. DWORD CJXINIFile::DeleteKeyA(
  3363.          LPCSTR lpAppName,  // section name
  3364.          LPCSTR lpKeyName  // key name
  3365.     )
  3366. {
  3367. return 0;
  3368. }
  3370. //-------------------------------------------------------------------
  3371. //-------------Export Part ------------------------------------------
  3372. //UNICODE & ANSI Version
  3373. CJXINIFile& GetINIFileClass()
  3374. {
  3375. static CJXINIFile g_clsINIFile;
  3376. return g_clsINIFile;
  3377. }
  3379. DWORD JXGetPrivateProfileStringW(
  3380.   LPCWSTR lpAppName,        // section name
  3381.   LPCWSTR lpKeyName,        // key name
  3382.   LPCWSTR lpDefault,        // default string
  3383.   LPWSTR lpReturnedString,  // destination buffer
  3384.   DWORD nSize,              // size of destination buffer
  3385.   LPCWSTR lpFileName        // initialization file name
  3386.  )
  3387. {
  3388. return GetINIFileClass().GetPrivateProfileStringExW(
  3389. lpAppName,        // section name
  3390.         lpKeyName,        // key name
  3391.         lpDefault,        // default string
  3392.         lpReturnedString,  // destination buffer
  3393.         nSize,              // size of destination buffer
  3394.         lpFileName        // initialization file name
  3395. );
  3396. }
  3398. BOOL JXWritePrivateProfileStringW(
  3399.   LPCWSTR lpAppName,  // section namen
  3400.   LPCWSTR lpKeyName,  // key name
  3401.   LPCWSTR lpString,   // string to add
  3402.   LPCWSTR lpFileName  // initialization file
  3403.  )
  3404. {
  3405. return GetINIFileClass().WritePrivateProfileStringExW(
  3406.         lpAppName,  // section namen
  3407.         lpKeyName,  // key name
  3408.         lpString,   // string to add
  3409.         lpFileName  // initialization file
  3410. );
  3411. }
  3414. //ANSI VERSION
  3415. DWORD JXGetPrivateProfileStringA(
  3416.   LPCSTR lpAppName,        // section name
  3417.   LPCSTR lpKeyName,        // key name
  3418.   LPCSTR lpDefault,        // default string
  3419.   LPSTR lpReturnedString,  // destination buffer
  3420.   DWORD nSize,              // size of destination buffer
  3421.   LPCSTR lpFileName        // initialization file name
  3422.  )
  3423. {
  3424. return GetINIFileClass().GetPrivateProfileStringExA(
  3425. lpAppName,        // section name
  3426.         lpKeyName,        // key name
  3427.         lpDefault,        // default string
  3428.         lpReturnedString,  // destination buffer
  3429.         nSize,              // size of destination buffer
  3430.         lpFileName        // initialization file name
  3431. );
  3432. }
  3434. //Warning: Using namespace for WinAPI have the same name
  3435. BOOL JXWritePrivateProfileStringA(
  3436.   LPCSTR lpAppName,  // section namen
  3437.   LPCSTR lpKeyName,  // key name
  3438.   LPCSTR lpString,   // string to add
  3439.   LPCSTR lpFileName  // initialization file
  3440.  )
  3441. {
  3442. return GetINIFileClass().WritePrivateProfileStringExA(
  3443.         lpAppName,  // section namen
  3444.         lpKeyName,  // key name
  3445.         lpString,   // string to add
  3446.         lpFileName  // initialization file
  3447. );
  3448. }
  3450. DWORD ControlINI(DWORD dwControl)
  3451. {
  3452. #define INI_SET_DIRTY_MAP  0
  3453. #define INI_SET_LOCK_MAP   1
  3454. #define INI_SET_UNLOCK_MAP 2
  3455. #define INI_UPDATE_MAP     3
  3456. switch(dwControl)
  3457. {
  3458. case INI_SET_DIRTY_MAP:
  3459.         GetINIFileClass().m_bSectionMapDirty = TRUE;
  3460. break;
  3461. case INI_SET_LOCK_MAP:
  3462.         GetINIFileClass().m_bSectionMapLock = TRUE;
  3463. break;
  3464.     case INI_SET_UNLOCK_MAP:
  3465.         GetINIFileClass().m_bSectionMapLock = FALSE;
  3466. break;
  3467. case INI_UPDATE_MAP:
  3468. #ifdef _UNICODE
  3469. GetINIFileClass().UpdateMapW();
  3470. #else
  3471. GetINIFileClass().UpdateMapA();
  3472. #endif
  3473. break;
  3474. default:
  3475. break;
  3476. }
  3477. return 0;
  3478. }
  3480. //Flush Memory Data To Disk File and Close File Handle
  3481. BOOL JXUnloadPrivateProfile()
  3482. {
  3483. return GetINIFileClass().UnloadIniFile();
  3484. }
  3486. BOOL JXRenameSectionExW(
  3487.   LPCWSTR lpAppName,        // section name
  3488.   LPCWSTR lpNewName,        // new section name
  3489.   LPCWSTR lpFileName        // initialization file name
  3490.  )
  3491. {
  3492. return GetINIFileClass().RenameSectionExW(
  3493. lpAppName,        // section name
  3494.         lpNewName,        // new section name
  3495.         lpFileName        // initialization file name
  3496. );
  3497. }
  3499. BOOL JXCopySectionExW(
  3500.   LPCWSTR lpAppName,        // section name
  3501.   LPCWSTR lpNewName,        // new section name
  3502.   LPCWSTR lpFileName        // initialization file name
  3503.  )
  3504. {
  3505. return GetINIFileClass().CopySectionExW(
  3506. lpAppName,        // section name
  3507.         lpNewName,        // new section name
  3508.         lpFileName        // initialization file name
  3509. );
  3510. }
  3512. BOOL CJXINIFile::RenameSectionExW(
  3513.   LPCWSTR lpAppName,        // section name
  3514.   LPCWSTR lpNewName,        // new section name
  3515.   LPCWSTR lpFileName        // initialization file name
  3516.  )
  3517. {
  3518. BOOL bRet = LoadIniFile(lpFileName, 2);  //Unicode Text
  3519. if(!bRet) 
  3520. {
  3521. AfxMessageBox(_T("CJXINIFile::RenameSectionExW - LoadIniFile Err"));
  3522. return FALSE;
  3523. }
  3525. //If Section Locked And Section Dirty ASSERT(FALSE);
  3526.     ASSERT(!(m_bSectionMapLock && m_bSectionMapDirty));
  3527. if(m_bSectionMapDirty) this->UpdateMapW();
  3529.     LPWSTR pHead = (LPWSTR)m_pTrueData;    
  3530. CString strKey, strNewKey;
  3531. LPWSTR lpPos;
  3532. #ifdef _UNICODE
  3533. strKey = lpAppName;
  3534. strNewKey = lpNewName;
  3535. #else
  3536. DWORD dwRetSize;
  3537. LPSTR pTemp = _W2A((LPWSTR)lpAppName, -1, dwRetSize);
  3538. ::strncpy(strKey.GetBuffer(dwRetSize), pTemp, dwRetSize);
  3539. strKey.ReleaseBuffer(dwRetSize);
  3541. pTemp = _W2A((LPWSTR)lpNewName, -1, dwRetSize);
  3542. ::strncpy(strNewKey.GetBuffer(dwRetSize), pTemp, dwRetSize);
  3543. strNewKey.ReleaseBuffer(dwRetSize);
  3544. #endif
  3545. //No Such Section Exists
  3546. LPVOID lpVoid;
  3547. if(!m_mapSection.Lookup(strKey, lpVoid)) 
  3548. {
  3549. #ifdef _DEBUG
  3550. AfxMessageBox(_T("CJXINIFile::RenameSectionExW - lpAppName Not Found") + strKey);
  3551. #endif
  3552. return FALSE;
  3553. }
  3554.     m_mapSection.RemoveKey(strKey);
  3555. lpPos = (LPWSTR)lpVoid;
  3556. LPWSTR lpSection = (LPWSTR)lpPos;
  3557.     
  3558. int oldLen = ::wcslen(lpAppName);
  3559. int newLen = ::wcslen(lpNewName);
  3560. m_mapSection.SetAt(strNewKey, (LPVOID)lpSection);
  3561. if(newLen == oldLen)
  3562. {
  3563. ::wcscspn((LPWSTR)(lpSection+1), (LPCWSTR)lpNewName); //[
  3564. return TRUE;
  3565. }
  3566. //Hard Time Now
  3567. if(newLen < oldLen)
  3568. {
  3569. int memLen = m_dwUseSize - (lpSection - pHead + oldLen + 2)*sizeof(WCHAR);
  3570. //C++ Run-time Lib handle overlapped mem
  3571. LPWSTR buffer = new WCHAR[newLen+2];
  3572. ::swprintf(buffer, L"[%s]", lpNewName);
  3573. memmove(lpSection+2+newLen, lpSection+2+oldLen, memLen);
  3574. ::wcsncpy(lpSection, buffer, newLen+2);
  3575. m_dwUseSize -= sizeof(WCHAR)*(oldLen-newLen);
  3576. }
  3577. else
  3578. {
  3579. int memLen = m_dwUseSize - (lpSection - pHead + oldLen + 2)*sizeof(WCHAR);
  3580. //C++ Run-time Lib handle overlapped mem
  3581. LPWSTR buffer = new WCHAR[newLen+2];
  3582. ::swprintf(buffer, L"[%s]", lpNewName);
  3583. memmove(lpSection+2+newLen, lpSection+2+oldLen, memLen);
  3584. ::wcsncpy(lpSection, buffer, newLen+2);
  3585. m_dwUseSize += sizeof(WCHAR)*(newLen-oldLen);
  3586. }
  3587.  
  3588. //Adjust Section Map if Applicable
  3589. if(m_bSectionMapLock)
  3590. { 
  3591. m_bSectionMapDirty = TRUE;
  3592. }
  3593. else //update section map
  3594. {
  3595. POSITION pos = m_mapSection.GetStartPosition();
  3596.     while(pos)
  3597. {
  3598. CString strKey;
  3599.         LPVOID lpPos;
  3600.         m_mapSection.GetNextAssoc(pos, strKey, lpPos);
  3601.      //adjust Section Map
  3602. if((LPWSTR)lpPos - lpSection > 0)
  3603. {
  3604. LPWSTR pTemp = (LPWSTR)lpPos;
  3605. pTemp += newLen-oldLen;
  3606. lpPos = (LPVOID)pTemp;
  3607. m_mapSection.SetAt(strKey, lpPos);
  3608. }
  3609. }
  3610. }
  3611. return TRUE;
  3612. }
  3614. BOOL CJXINIFile::CopySectionExW(
  3615.   LPCWSTR lpAppName,        // section name
  3616.   LPCWSTR lpNewName,        // new section name
  3617.   LPCWSTR lpFileName        // initialization file name
  3618.  )
  3619. {
  3620.     BOOL bRet = LoadIniFile(lpFileName, 2);  //Unicode Text
  3621. if(!bRet) 
  3622. {
  3623. AfxMessageBox(_T("CJXINIFile::CopySectionExW - LoadIniFile Err"));
  3624. return FALSE;
  3625. }
  3627. if(m_bSectionMapLock) 
  3628. {
  3629. AfxMessageBox(_T("CJXINIFile::CopySectionExW - Map Locked Err"));
  3630. return FALSE;
  3631. }
  3632. if(m_bSectionMapDirty) this->UpdateMapW();
  3634. m_bSectionMapLock = FALSE;
  3635. LPWSTR lpHead = (LPWSTR)m_pTrueData;    
  3636. CString strKey, strNewKey;
  3637. LPWSTR lpPos;
  3638. #ifdef _UNICODE
  3639. strKey = lpAppName;
  3640. strNewKey = lpNewName;
  3641. #else
  3642. DWORD dwRetSize;
  3643. LPSTR pTemp = _W2A((LPWSTR)lpAppName, -1, dwRetSize);
  3644. ::strncpy(strKey.GetBuffer(dwRetSize), pTemp, dwRetSize);
  3645. strKey.ReleaseBuffer(dwRetSize);
  3647. pTemp = _W2A((LPWSTR)lpNewName, -1, dwRetSize);
  3648. ::strncpy(strNewKey.GetBuffer(dwRetSize), pTemp, dwRetSize);
  3649. strNewKey.ReleaseBuffer(dwRetSize);
  3650. #endif
  3652. //No Such Section Exists
  3653. LPVOID lpVoid;
  3654. if(!m_mapSection.Lookup(strKey, lpVoid)) 
  3655. {
  3656. #ifdef _DEBUG
  3657. AfxMessageBox(_T("CJXINIFile::CopySectionExW - lpAppName Not Found") + strKey);
  3658. #endif
  3659. return FALSE;
  3660. }
  3661.     lpPos = (LPWSTR)lpVoid;
  3662. LPWSTR lpSection = (LPWSTR)lpPos;
  3663.    
  3664. //The lpNewName -- New Section Name Should not Exist
  3665.     if(m_mapSection.Lookup(strNewKey, lpVoid)) 
  3666. {
  3667. AfxMessageBox(_T("CJXINIFile::CopySectionExW - lpNewName Exist"));
  3668.     return FALSE;
  3669. }
  3671. UINT secBodySize = GetSectionSizeExW(lpAppName, lpFileName);
  3672.     secBodySize -= 2 + ::wcslen(lpAppName);
  3673. if((int)(m_dwUseSize - m_dwSize + 
  3674. (secBodySize+::wcslen(lpNewName))*sizeof(WCHAR)) > JXFlushIncrement - 5*JXPage)
  3675. {
  3676. //::MessageBoxW(NULL, lpAppName, lpNewName, MB_OK);
  3677. //if the Section Reproduction Need Too Much Space
  3678. //Flush Back to HardDisk First. Then Append It
  3679. LPVOID lpMem = ::VirtualAlloc(NULL, (secBodySize+::wcslen(lpNewName))*sizeof(WCHAR),
  3680. MEM_COMMIT, PAGE_READWRITE);
  3681. if(!lpMem) 
  3682. {
  3683. ::MessageBox(NULL, _T("CopySection"), _T("VirtualAlloc Err"), MB_OK);
  3684. return FALSE;
  3685. }
  3686. ::memcpy(lpMem, lpSection + 2 + ::wcslen(lpAppName), secBodySize*sizeof(WCHAR));
  3687. UnloadIniFile();
  3688. m_bSectionMapDirty = TRUE;
  3690. //Write To Disk
  3691.         HANDLE hFile = ::CreateFileW(lpFileName, GENERIC_WRITE,
  3692.  FILE_SHARE_READ, NULL, OPEN_EXISTING, 
  3693.  FILE_ATTRIBUTE_NORMAL, NULL);
  3694.     if(hFile == INVALID_HANDLE_VALUE) 
  3695. {
  3696. ::MessageBox(NULL, _T("CopySectionExW"), _T("CreateFileW Err"), MB_OK);
  3697. return FALSE;
  3698. }
  3699. LONG l = 0;
  3700. ::SetFilePointer(hFile, 0, &l, FILE_END);
  3701. LPWSTR buffer = new WCHAR[2 + ::wcslen(lpNewName)];
  3702.         ::swprintf(buffer, L"[%s]", lpNewName);
  3703. DWORD dwRet;
  3704. ::WriteFile(hFile, buffer, sizeof(WCHAR)*(2 + ::wcslen(lpNewName)), &dwRet, NULL);
  3705. ::WriteFile(hFile, lpMem, sizeof(WCHAR)*secBodySize, &dwRet, NULL);
  3706. ::CloseHandle(hFile);
  3707. return TRUE;
  3708. }
  3709. else
  3710. {
  3711. LPWSTR lpNewSec = lpHead + m_dwUseSize/sizeof(WCHAR);
  3712. if(!m_bSectionMapLock)
  3713. {
  3714. m_mapSection.SetAt(strNewKey, (LPVOID)lpNewSec);
  3715. }
  3716. else
  3717. m_bSectionMapDirty = TRUE;
  3718.         ::swprintf(lpNewSec, L"[%s]", lpNewName);
  3719. lpNewSec += 2 + ::wcslen(lpNewName);
  3720. ::memcpy(lpNewSec, lpSection + 2 + ::wcslen(lpAppName), sizeof(WCHAR)*secBodySize);
  3721.         m_dwUseSize += (secBodySize + ::wcslen(lpNewName) + 2)*sizeof(WCHAR); 
  3722. }
  3723. return TRUE;
  3724. }
  3727. //in WCHARs, return 0 when err, Section Map Version
  3728. UINT CJXINIFile::GetSectionSizeExW(
  3729.    LPCWSTR lpAppName,        // section name
  3730.        LPCWSTR lpFileName)        // initialization file name
  3731. {
  3732. BOOL bRet = LoadIniFile(lpFileName, 2);  //Unicode Text
  3733. if(!bRet) return FALSE;
  3735. CString strKey;
  3736. #ifdef _UNICODE
  3737. strKey = lpAppName;
  3738. #else
  3739. DWORD dwRetSize;
  3740. LPSTR pTemp = _W2A((LPWSTR)lpAppName, -1, dwRetSize);
  3741. ::strncpy(strKey.GetBuffer(dwRetSize), pTemp, dwRetSize);
  3742. strKey.ReleaseBuffer(dwRetSize);
  3743. #endif
  3744. LPWSTR pHead = (LPWSTR)m_pTrueData; 
  3745. //if No Such Section Exists
  3746. LPVOID lpVoid;
  3747. if(!m_mapSection.Lookup(strKey, lpVoid)) return 0;
  3748.     LPWSTR lpPos = (LPWSTR)lpVoid;
  3749. LPWSTR lpSection = (LPWSTR)lpPos;
  3751. LPWSTR lpNextSec = NULL;
  3752. int distance = -1;
  3754. POSITION pos = m_mapSection.GetStartPosition();
  3755. while(pos)
  3756. {
  3757. CString strKey2;
  3758. LPWSTR lpPos2;
  3759. m_mapSection.GetNextAssoc(pos, strKey2, lpVoid);
  3760. lpPos2 = (LPWSTR)lpVoid;
  3761. if(lpPos2 - lpPos > 0)
  3762. {
  3763. if(distance == -1) 
  3764. {
  3765. distance = lpPos2 - lpPos;
  3766. lpNextSec = lpPos2;
  3767. }
  3768. else
  3769. {
  3770. if(lpPos2 - lpPos < distance)
  3771. {
  3772. distance = lpPos2 - lpPos;
  3773.     lpNextSec = lpPos2;
  3774. }
  3775. }
  3776. }
  3777. }
  3778.  
  3779. if(lpNextSec == NULL)
  3780. {
  3781. ASSERT(distance == -1);
  3782. //This is the Last Section
  3783.         return m_dwUseSize/sizeof(WCHAR) - (lpPos-pHead);
  3784. }
  3785. else
  3786. {
  3787.         return lpNextSec - lpPos;
  3788. }
  3789.     return 0;
  3790. }
  3792. ////in WCHARs, return 0 when err,
  3793. UINT CJXINIFile::GetSectionSizeW(
  3794.    LPCWSTR lpAppName,        // section name
  3795.        LPCWSTR lpFileName)        // initialization file name
  3796. {
  3797. return 0;
  3798. }