利用atl中注册com组件的方法来访问注册表

工作中需要一个快速编辑修改注册表的功能。记得atl中有那么一个通过脚本来访问编辑注册表的东东。于是，抠出其代码如下。其中删除了部分代码。删除的部分，原先atl是用来进行预处理替换操作的。

代码如下：

1. 
   
2. class CRegParser
3. {
4. public:
5.     CRegParser();
6. 
   
7.     HRESULT  PreProcessBuffer(_In_z_ LPTSTR lpszReg, _Deref_out_opt_z_ LPTSTR* ppszReg);
8.     HRESULT  RegisterBuffer(_In_z_ LPTSTR szReg, _In_ BOOL bRegister);
9. 
   
10. protected:
11. 
    
12.     static const int MAX_VALUE = 4096;
13.     void    SkipWhiteSpace();
14.     HRESULT NextToken(LPTSTR szToken);
15.     HRESULT AddValue(CRegKey& rkParent, LPCTSTR szValueName, LPTSTR szToken);
16.     BOOL    CanForceRemoveKey(LPCTSTR szKey);
17.     BOOL    HasSubKeys(HKEY hkey);
18.     BOOL    HasValues(HKEY hkey);
19.     HRESULT RegisterSubkeys(LPTSTR szToken, HKEY hkParent, BOOL bRegister, BOOL bInRecovery = FALSE);
20.     BOOL    IsSpace(TCHAR ch);
21.     LPTSTR  m_pchCur;
22. 
    
23.     HRESULT GenerateError(UINT) {return DISP_E_EXCEPTION;}
24.     //HRESULT HandleReplacements(LPTSTR& szToken);
25.     HRESULT SkipAssignment(LPTSTR szToken);
26. 
    
27.     BOOL    EndOfVar() { return chQuote == *m_pchCur && chQuote != *CharNext(m_pchCur); }
28.     static LPTSTR StrChr(LPTSTR lpsz, TCHAR ch);
29.     static HKEY HKeyFromString(LPTSTR szToken);
30.     static BYTE ChToByte(const TCHAR ch);
31.     static BOOL VTFromRegType(LPCTSTR szValueType, VARTYPE& vt);
32.     static const TCHAR* const rgszNeverDelete[];
33.     static const int cbNeverDelete;
34.     static const int MAX_TYPE = 4096;
35. 
    
36.     // Implementation Helper
37.     class CParseBuffer
38.     {
39.     public:
40.         int nPos;
41.         int nSize;
42.         LPTSTR p;
43.         CParseBuffer(int nInitial)
44.         {
45.             if (nInitial < 100)
46.                 nInitial = 1000;
47.             nPos = 0;
48.             nSize = nInitial;
49.             p = (LPTSTR) ::ATL::AtlCoTaskMemCAlloc(nSize,static_cast<ULONG>(sizeof(TCHAR)));
50.             if (p != NULL)
51.                 *p = NULL;
52.         }
53.         ~CParseBuffer()
54.         {
55.             CoTaskMemFree(p);
56.         }
57.         BOOL Append(const TCHAR* pch, int nChars)
58.         {
59.             ATLASSERT(p != NULL);
60.             int newSize = nPos + nChars + 1;
61.             if ((newSize <= nPos) || (newSize <= nChars))
62.                 return FALSE;
63. 
    
64.             if (newSize >= nSize)
65.             {
66.                 while (newSize >= nSize) {
67.                     if (nSize > INT_MAX / 2)
68.                     return FALSE;
69.                     nSize *= 2;
70.                 }
71.                 LPTSTR pTemp = (LPTSTR)::ATL::AtlCoTaskMemRecalloc(p, nSize, sizeof(TCHAR));
72.                 if (pTemp == NULL)
73.                     return FALSE;
74.                 p = pTemp;
75.             }
76.             if ((nPos < 0) || (nPos >= nSize) || nSize - nPos > nSize)
77.                 return FALSE;
78. 
    
79. #pragma warning(push)
80. #pragma warning(disable: 22008)
81.             /* Prefast false warning is fired here despite the all above checks */
82.             Checked::memcpy_s(p + nPos, (nSize-nPos) * sizeof(TCHAR), pch, int(nChars * sizeof(TCHAR)));
83.             nPos += nChars;
84.             *(p + nPos) = NULL;
85. #pragma warning(pop)
86.             return TRUE;            
87.         }
88. 
    
89.         BOOL AddChar(const TCHAR* pch)
90.         {
91. #ifndef _UNICODE        
92.             int nChars = int(CharNext(pch) - pch);
93. #else
94.             int nChars = 1;
95. #endif
96.             return Append(pch, nChars);
97. 
    
98.         }
99.         BOOL AddString(LPCOLESTR lpsz)
100.         {
101.             if (lpsz == NULL)
102.             {
103.                 return FALSE;
104.             }
105.             USES_CONVERSION_EX;
106.             LPCTSTR lpszT = OLE2CT_EX(lpsz, _ATL_SAFE_ALLOCA_DEF_THRESHOLD);
107.             if (lpszT == NULL)
108.             {
109.                 return FALSE;
110.             }
111.             return Append(lpszT, (int)lstrlen(lpszT));
112.         }
113.         LPTSTR Detach()
114.         {
115.             LPTSTR lp = p;
116.             p = NULL;
117.             nSize = nPos = 0;
118.             return lp;
119.         }
120. 
     
121.     };
122. };
123. 
     
124. 
     
125. __declspec(selectany) const TCHAR* const CRegParser::rgszNeverDelete[] =
126. {
127.     _T("AppID"),
128.     _T("CLSID"),
129.     _T("Component Categories"),
130.     _T("FileType"),
131.     _T("Interface"),
132.     _T("Hardware"),
133.     _T("Mime"),
134.     _T("SAM"),
135.     _T("SECURITY"),
136.     _T("SYSTEM"),
137.     _T("Software"),
138.     _T("TypeLib")
139. };
140. 
     
141. __declspec(selectany) const int CRegParser::cbNeverDelete = sizeof(rgszNeverDelete) / sizeof(LPCTSTR*);
142. 
     
143. 
     
144. inline BOOL CRegParser::VTFromRegType(LPCTSTR szValueType, VARTYPE& vt)
145. {
146.     struct typemap
147.     {
148.         LPCTSTR lpsz;
149.         VARTYPE vt;
150.     };
151. #pragma warning (push)
152. #pragma warning (disable : 4640)    // construction of local static object is not thread-safe
153. 
     
154.     static const typemap map[] = {
155.         {szStringVal, VT_BSTR},
156.         {multiszStringVal, VT_BSTR | VT_BYREF},
157.         {szDwordVal,  VT_UI4},
158.         {szBinaryVal, VT_UI1}
159.     };
160. 
     
161. #pragma warning (pop)
162. 
     
163.     for (int i=0;i<sizeof(map)/sizeof(typemap);i++)
164.     {
165.         if (!lstrcmpi(szValueType, map[i].lpsz))
166.         {
167.             vt = map[i].vt;
168.             return TRUE;
169.         }
170.     }
171. 
     
172.     return FALSE;
173. 
     
174. }
175. 
     
176. inline BYTE CRegParser::ChToByte(const TCHAR ch)
177. {
178.     switch (ch)
179.     {
180.         case '0':
181.         case '1':
182.         case '2':
183.         case '3':
184.         case '4':
185.         case '5':
186.         case '6':
187.         case '7':
188.         case '8':
189.         case '9':
190.                 return (BYTE) (ch - '0');
191.         case 'A':
192.         case 'B':
193.         case 'C':
194.         case 'D':
195.         case 'E':
196.         case 'F':
197.                 return (BYTE) (10 + (ch - 'A'));
198.         case 'a':
199.         case 'b':
200.         case 'c':
201.         case 'd':
202.         case 'e':
203.         case 'f':
204.                 return (BYTE) (10 + (ch - 'a'));
205.         default:
206.                 ATLASSERT(FALSE);
207.                 ATLTRACE(atlTraceRegistrar, 0, _T("Bogus value %c passed as binary Hex value/n"), ch);
208.                 return 0;
209.     }
210. }
211. 
     
212. inline HKEY CRegParser::HKeyFromString(_In_z_ LPTSTR szToken)
213. {
214.     struct keymap
215.     {
216.         LPCTSTR lpsz;
217.         HKEY hkey;
218.     };
219.     static const keymap map[] = {
220.         {_T("HKCR"), HKEY_CLASSES_ROOT},
221.         {_T("HKCU"), HKEY_CURRENT_USER},
222.         {_T("HKLM"), HKEY_LOCAL_MACHINE},
223.         {_T("HKU"),  HKEY_USERS},
224.         {_T("HKPD"), HKEY_PERFORMANCE_DATA},
225.         {_T("HKDD"), HKEY_DYN_DATA},
226.         {_T("HKCC"), HKEY_CURRENT_CONFIG},
227.         {_T("HKEY_CLASSES_ROOT"), HKEY_CLASSES_ROOT},
228.         {_T("HKEY_CURRENT_USER"), HKEY_CURRENT_USER},
229.         {_T("HKEY_LOCAL_MACHINE"), HKEY_LOCAL_MACHINE},
230.         {_T("HKEY_USERS"), HKEY_USERS},
231.         {_T("HKEY_PERFORMANCE_DATA"), HKEY_PERFORMANCE_DATA},
232.         {_T("HKEY_DYN_DATA"), HKEY_DYN_DATA},
233.         {_T("HKEY_CURRENT_CONFIG"), HKEY_CURRENT_CONFIG}
234.     };
235. 
     
236.     for (int i=0;i<sizeof(map)/sizeof(keymap);i++)
237.     {
238.         if (!lstrcmpi(szToken, map[i].lpsz))
239.             return map[i].hkey;
240.     }
241.     return NULL;
242. }
243. 
     
244. inline LPTSTR CRegParser::StrChr(_In_z_ LPTSTR lpsz, _In_ TCHAR ch)
245. {
246.     LPTSTR p = NULL;
247. 
     
248.     if (lpsz == NULL)
249.         return NULL;
250.     
251.     while (*lpsz)
252.     {
253.         if (*lpsz == ch)
254.         {
255.             p = lpsz;
256.             break;
257.         }
258.         lpsz = CharNext(lpsz);
259.     }
260.     return p;
261. }
262. 
     
263. inline CRegParser::CRegParser()
264. {
265.     m_pchCur = NULL;
266. }
267. 
     
268. inline BOOL CRegParser::IsSpace(TCHAR ch)
269. {
270.     switch (ch)
271.     {
272.         case _T(' '):
273.         case _T('/t'):
274.         case _T('/r'):
275.         case _T('/n'):
276.                 return TRUE;
277.     }
278. 
     
279.     return FALSE;
280. }
281. 
     
282. inline void CRegParser::SkipWhiteSpace()
283. {
284.     while(IsSpace(*m_pchCur))
285.         m_pchCur = CharNext(m_pchCur);
286. }
287. 
     
288. #pragma warning(push)
289. #pragma warning(disable:6385) // suppressing code analysis warning on the GenerateError code path
290. inline HRESULT CRegParser::NextToken(_Out_z_cap_c_(MAX_VALUE) LPTSTR szToken)
291. {
292.     SkipWhiteSpace();
293. 
     
294.     // NextToken cannot be called at EOS
295.     if (NULL == *m_pchCur)
296.         return GenerateError(E_ATL_UNEXPECTED_EOS);
297. #pragma warning(pop)
298. 
     
299.     LPCTSTR szOrig = szToken;
300.     // handle quoted value / key
301.     if (chQuote == *m_pchCur)
302.     {
303.         m_pchCur = CharNext(m_pchCur);
304. 
     
305.         while (NULL != *m_pchCur && !EndOfVar())
306.         {
307.             if (chQuote == *m_pchCur) // If it is a quote that means we must skip it
308.                 m_pchCur = CharNext(m_pchCur);
309. 
     
310.             LPTSTR pchPrev = m_pchCur;
311.             m_pchCur = CharNext(m_pchCur);
312. 
     
313.             INT_PTR nChars = m_pchCur - pchPrev;
314. 
     
315.             // Make sure we have room for nChars plus terminating NULL
316.             if ((szToken + nChars + 1) >= szOrig + MAX_VALUE)
317.                 return GenerateError(E_ATL_VALUE_TOO_LARGE);
318. 
     
319.             for (int i = 0; i < (int)nChars; i++, szToken++, pchPrev++)
320.                 *szToken = *pchPrev;
321.         }
322. 
     
323.         if (NULL == *m_pchCur)
324.         {
325.             ATLTRACE(atlTraceRegistrar, 0, _T("NextToken : Unexpected End of File/n"));
326.             return GenerateError(E_ATL_UNEXPECTED_EOS);
327.         }
328. 
     
329.         *szToken = NULL;
330.         m_pchCur = CharNext(m_pchCur);
331.     }
332. 
     
333.     else
334.     {   
335.         // Handle non-quoted ie parse up till first "White Space"
336.         while (NULL != *m_pchCur && !IsSpace(*m_pchCur))
337.         {
338.             LPTSTR pchPrev = m_pchCur;
339.             m_pchCur = CharNext(m_pchCur);
340. 
     
341.             INT_PTR nChars = m_pchCur - pchPrev;
342. 
     
343.             // Make sure we have room for nChars plus terminating NULL
344.             if ((szToken + nChars + 1) >= szOrig + MAX_VALUE)
345.                 return GenerateError(E_ATL_VALUE_TOO_LARGE);
346. 
     
347.             for (int i = 0; i < (int)nChars; i++, szToken++, pchPrev++)
348.                 *szToken = *pchPrev;
349.         }
350. 
     
351.         *szToken = NULL;
352.     }
353.     return S_OK;
354. }
355. 
     
356. #pragma warning(push)
357. #pragma warning(disable:6385) // suppressing code analysis warning on the GenerateError code path
358. inline HRESULT CRegParser::AddValue(_In_ CRegKey& rkParent, _In_opt_z_ LPCTSTR szValueName, _Out_z_cap_c_(MAX_VALUE) LPTSTR szToken)
359. {
360.     HRESULT hr;
361. 
     
362.     TCHAR       szValue[MAX_VALUE];
363.     VARTYPE     vt = VT_EMPTY;
364.     LONG        lRes = ERROR_SUCCESS;
365.     UINT        nIDRes = 0;
366. 
     
367.     if (FAILED(hr = NextToken(szValue)))
368.         return hr;
369.     if (!VTFromRegType(szValue, vt))
370.     {
371.         ATLTRACE(atlTraceRegistrar, 0, _T("%s Type not supported/n"), szValue);
372.         return GenerateError(E_ATL_TYPE_NOT_SUPPORTED);
373.     }
374. #pragma warning(pop)
375. 
     
376.     SkipWhiteSpace();
377.     if (FAILED(hr = NextToken(szValue)))
378.         return hr;
379. 
     
380.     switch (vt)
381.     {
382.     case VT_BSTR:
383.         {
384.             lRes = rkParent.SetStringValue(szValueName, szValue);
385.             ATLTRACE(atlTraceRegistrar, 2, _T("Setting Value %s at %s/n"), szValue, !szValueName ? _T("default") : szValueName);
386.             break;
387.         }
388.     case VT_BSTR | VT_BYREF:
389.         {
390.             ATLTRACE(atlTraceRegistrar, 2, _T("Setting Value %s at %s/n"), szValue, !szValueName ? _T("default") : szValueName);
391.             int nLen = lstrlen(szValue) + 2; //Allocate space for double null termination.
392.             CTempBuffer<TCHAR, 256> pszDestValue;
393.             //nLen should be >= the max size of the target buffer.
394.             ATLTRY(pszDestValue.Allocate(nLen));
395.             if (pszDestValue != NULL)
396.             {
397.                 TCHAR* p = pszDestValue;
398.                 TCHAR* q = szValue;
399.                 nLen = 0;
400.                 while (*q != _T('/0'))
401.                 {
402.                     TCHAR* r = CharNext(q);
403.                     if (*q == _T('//') && *r == _T('0'))
404.                     {
405.                         *p++ = NULL;
406.                         q = CharNext(r);
407.                     }
408.                     else
409.                     {
410.                         *p = *q;
411. #ifndef _UNICODE
412.                         if (IsDBCSLeadByte(*q))
413.                         {
414.                             p++;
415.                             q++;
416.                             //Protect from Lead byte followed by the zero terminator.May skip beyond the end of the string.
417.                             if (*q == _T('/0')) { break; }
418.                             *p = *q;
419.                         }
420. #endif
421.                         p++;
422.                         q++;
423.                     }
424.                     nLen ++;
425.                 }
426.                //Always terminate with 2 NULLs.
427.                 *p = NULL;
428.                 p++;
429.                 *p = NULL;
430.                 lRes = rkParent.SetMultiStringValue(szValueName, pszDestValue);
431.             }
432.             else
433.             {
434.                 lRes = ERROR_OUTOFMEMORY;
435.             }
436.         }
437.         break;
438.     case VT_UI4:
439.         {
440.             ULONG ulVal;
441.             USES_CONVERSION_EX;
442. 
     
443.             LPOLESTR lpszV = T2OLE_EX(szValue, _ATL_SAFE_ALLOCA_DEF_THRESHOLD);
444.     #ifndef _UNICODE
445.             if(lpszV == NULL) 
446.                 return E_OUTOFMEMORY;
447.     #endif  
448.             VarUI4FromStr(lpszV, 0, 0, &ulVal);
449.             
450.             lRes = rkParent.SetDWORDValue(szValueName, ulVal);
451.             ATLTRACE(atlTraceRegistrar, 2, _T("Setting Value %d at %s/n"), ulVal, !szValueName ? _T("default") : szValueName);
452.             break;
453.         }
454.     case VT_UI1:
455.         {
456.             int cbValue = lstrlen(szValue);
457.             if (cbValue & 0x00000001)
458.             {
459.                 ATLTRACE(atlTraceRegistrar, 0, _T("Binary Data does not fall on BYTE boundries/n"));
460.                 return E_FAIL;
461.             }
462.             int cbValDiv2 = cbValue/2;
463.             CTempBuffer<BYTE, 256> rgBinary;
464.             ATLTRY(rgBinary.Allocate(cbValDiv2));           
465.             if (rgBinary == NULL)
466.                 return E_FAIL;
467.             memset(rgBinary, 0, cbValDiv2);             
468.             for (int irg = 0; irg < cbValue; irg++)
469.                 rgBinary[(irg/2)] |= (ChToByte(szValue[irg])) << (4*(1 - (irg & 0x00000001)));
470.             lRes = RegSetValueEx(rkParent, szValueName, 0, REG_BINARY, rgBinary, cbValDiv2);
471.             break;
472.         }
473.     }
474. 
     
475.     if (ERROR_SUCCESS != lRes)
476.     {
477.         nIDRes = E_ATL_VALUE_SET_FAILED;
478.         return AtlHresultFromWin32(lRes);
479.     }
480. 
     
481.     if (FAILED(hr = NextToken(szToken)))
482.         return hr;
483. 
     
484.     return S_OK;
485. }
486. 
     
487. inline BOOL CRegParser::CanForceRemoveKey(LPCTSTR szKey)
488. {
489.     for (int iNoDel = 0; iNoDel < cbNeverDelete; iNoDel++)
490.         if (!lstrcmpi(szKey, rgszNeverDelete[iNoDel]))
491.              return FALSE;                       // We cannot delete it
492. 
     
493.     return TRUE;
494. }
495. 
     
496. inline BOOL CRegParser::HasSubKeys(HKEY hkey)
497. {
498.     DWORD       cbSubKeys = 0;
499. 
     
500.     if (RegQueryInfoKey(hkey, NULL, NULL, NULL,
501.                                &cbSubKeys, NULL, NULL,
502.                                NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
503.     {
504.         ATLTRACE(atlTraceRegistrar, 0, _T("Should not be here!!/n"));
505.         ATLASSERT(FALSE);
506.         return FALSE;
507.     }
508. 
     
509.     return cbSubKeys > 0;
510. }
511. 
     
512. inline BOOL CRegParser::HasValues(HKEY hkey)
513. {
514.     DWORD       cbValues = 0;
515. 
     
516.     LONG lResult = RegQueryInfoKey(hkey, NULL, NULL, NULL,
517.                                   NULL, NULL, NULL,
518.                                   &cbValues, NULL, NULL, NULL, NULL);
519.     if (ERROR_SUCCESS != lResult)
520.     {
521.         ATLTRACE(atlTraceRegistrar, 0, _T("RegQueryInfoKey Failed "));
522.         ATLASSERT(FALSE);
523.         return FALSE;
524.     }
525. 
     
526.     if (1 == cbValues)
527.     {
528.         DWORD cbMaxName= MAX_VALUE;
529.         TCHAR szValueName[MAX_VALUE];
530.         // Check to see if the Value is default or named
531.         lResult = RegEnumValue(hkey, 0, szValueName, &cbMaxName, NULL, NULL, NULL, NULL);
532.         if (ERROR_SUCCESS == lResult && (szValueName[0] != NULL))
533.             return TRUE; // Named Value means we have a value
534.         return FALSE;
535.     }
536. 
     
537.     return cbValues > 0; // More than 1 means we have a non-default value
538. }
539. 
     
540. inline HRESULT CRegParser::SkipAssignment(_Inout_z_cap_c_(MAX_VALUE) LPTSTR szToken)
541. {
542.     HRESULT hr;
543.     TCHAR szValue[MAX_VALUE];
544. 
     
545.     if (*szToken == chEquals)
546.     {
547.         if (FAILED(hr = NextToken(szToken)))
548.             return hr;
549.         // Skip assignment
550.         SkipWhiteSpace();
551.         if (FAILED(hr = NextToken(szValue)))
552.             return hr;
553.         if (FAILED(hr = NextToken(szToken)))
554.             return hr;
555.     }
556. 
     
557.     return S_OK;
558. }
559. 
     
560. inline HRESULT CRegParser::PreProcessBuffer(_In_z_ LPTSTR lpszReg, _Deref_out_opt_z_ LPTSTR* ppszReg)
561. {
562.     ATLASSERT(lpszReg != NULL);
563.     ATLASSERT(ppszReg != NULL);
564. 
     
565.     if (lpszReg == NULL || ppszReg == NULL)
566.         return E_POINTER;
567.     
568.     *ppszReg = NULL;
569.     int nSize = lstrlen(lpszReg)*2;
570.     CParseBuffer pb(nSize);
571.     if (pb.p == NULL)
572.         return E_OUTOFMEMORY;
573.     m_pchCur = lpszReg;
574.     HRESULT hr = S_OK;
575. 
     
576.     bool bRedirectionEnabled = false;
577.     hr = AtlGetPerUserRegistration(&bRedirectionEnabled);
578.     if( FAILED(hr) )
579.     {
580.         return hr;
581.     }
582. 
     
583.     // nNestingLevel is used to avoid checking for unnecessary root key replacements
584.     // since all of them are expected to be at the top level.
585.     int nNestingLevel = 0;
586.     bool bRedirectionPresent = false;
587.     bool bInsideQuotes = false;
588. 
     
589.     while (*m_pchCur != NULL) // look for end
590.     {
591.         if ( true == bRedirectionEnabled )
592.         {
593.             LPCOLESTR szStartHKCU = L"HKCU/r/n{/tSoftware/r/n/t{/r/n/t/tClasses";
594.             LPCOLESTR szEndHKCU = L"/r/n/t}/r/n}/r/n";
595. 
     
596.             if ( 0 == nNestingLevel )
597.             {
598.                 // Then we should be reading a root key. HKCR, HKCU, etc
599.                 TCHAR* szRootKey = NULL;
600.                 if( NULL != ( szRootKey = _tcsstr(m_pchCur, _T("HKCR")) ) &&    // if HKCR is found.
601.                     (szRootKey == m_pchCur) )   // if HKCR is the first token.
602.                 {
603.                     // Skip HKCR
604.                     m_pchCur = CharNext(m_pchCur);
605.                     m_pchCur = CharNext(m_pchCur);
606.                     m_pchCur = CharNext(m_pchCur);
607.                     m_pchCur = CharNext(m_pchCur);
608. 
     
609.                     // Add HKCU
610.                     if (!pb.AddString(szStartHKCU))
611.                     {
612.                         hr = E_OUTOFMEMORY;
613.                         break;
614.                     }
615. 
     
616.                     bRedirectionPresent = true;
617.                 }
618.             }
619. 
     
620.             if ( chQuote == *m_pchCur )
621.             {
622.                 if( false == bInsideQuotes )
623.                 {
624.                     bInsideQuotes = true;
625.                 }
626.                 else
627.                 {
628.                     // Make sure it is not an escaped sequence.
629.                     if( EndOfVar() )
630.                     {
631.                         bInsideQuotes = false;
632.                     }
633.                     else
634.                     {
635.                         // An escaped single quote...
636.                         m_pchCur = CharNext(m_pchCur);
637.                         if (!pb.AddChar(m_pchCur))
638.                         {
639.                             hr = E_OUTOFMEMORY;
640.                             break;
641.                         }
642.                     }
643.                 }
644.             }
645. 
     
646.             if ( (false == bInsideQuotes) && (*m_pchCur == _T('{')) )
647.             {
648.                 ++nNestingLevel;
649.             }
650. 
     
651.             if ( (false == bInsideQuotes) && (*m_pchCur == _T('}')) )
652.             {
653.                 --nNestingLevel;
654.                 if ( (0 == nNestingLevel) && (true == bRedirectionPresent) )
655.                 {
656.                     if (!pb.AddString(szEndHKCU))
657.                     {
658.                         hr = E_OUTOFMEMORY;
659.                         break;
660.                     }
661. 
     
662.                     bRedirectionPresent = false;
663.                 }
664.             }
665.         }
666. 
     
667.         if (*m_pchCur == _T('%'))
668.         {
669.             m_pchCur = CharNext(m_pchCur);
670.             if (*m_pchCur == _T('%'))
671.             {
672.                 if (!pb.AddChar(m_pchCur))
673.                 {
674.                     hr = E_OUTOFMEMORY;
675.                     break;
676.                 }
677.             }
678.             else
679.             {
680.                 LPTSTR lpszNext = StrChr(m_pchCur, _T('%'));
681.                 if (lpszNext == NULL)
682.                 {
683.                     ATLTRACE(atlTraceRegistrar, 0, _T("Error no closing %% found/n"));
684.                     hr = GenerateError(E_ATL_UNEXPECTED_EOS);
685.                     break;
686.                 }
687.                 if ((lpszNext-m_pchCur) > 31)
688.                 {
689.                     hr = E_FAIL;
690.                     break;
691.                 }
692.                 int nLength = int(lpszNext - m_pchCur);
693.                 TCHAR buf[32];
694.                 Checked::tcsncpy_s(buf, _countof(buf), m_pchCur, nLength);
695.                 //LPCOLESTR lpszVar = m_pRegObj->StrFromMap(buf);
696.                 //if (lpszVar == NULL)
697.                 //{
698.                 //  hr = GenerateError(E_ATL_NOT_IN_MAP);
699.                 //  break;
700.                 //}
701.                 //if (!pb.AddString(lpszVar))
702.                 //{
703.                 //  hr = E_OUTOFMEMORY;
704.                 //  break;
705.                 //}
706. 
     
707.                 while (m_pchCur != lpszNext)
708.                     m_pchCur = CharNext(m_pchCur);
709.             }
710.         }
711.         else
712.         {
713.             if (!pb.AddChar(m_pchCur))
714.             {
715.                 hr = E_OUTOFMEMORY;
716.                 break;
717.             }
718.         }
719. 
     
720.         m_pchCur = CharNext(m_pchCur);
721.     }
722.     if (SUCCEEDED(hr))
723.         *ppszReg = pb.Detach();
724.     return hr;
725. }
726. 
     
727. inline HRESULT CRegParser::RegisterBuffer(LPTSTR szBuffer, BOOL bRegister)
728. {
729.     TCHAR   szToken[MAX_VALUE];
730.     HRESULT hr = S_OK;
731. 
     
732.     LPTSTR szReg = NULL;
733.     hr = PreProcessBuffer(szBuffer, &szReg);
734.     if (FAILED(hr))
735.         return hr;
736. 
     
737.     m_pchCur = szReg;
738. 
     
739.     // Preprocess szReg
740. 
     
741.     while (NULL != *m_pchCur)
742.     {
743.         if (FAILED(hr = NextToken(szToken)))
744.             break;
745.         HKEY hkBase;
746.         if ((hkBase = HKeyFromString(szToken)) == NULL)
747.         {
748.             hr = GenerateError(E_ATL_BAD_HKEY);
749.             break;
750.         }
751. 
     
752.         if (FAILED(hr = NextToken(szToken)))
753.             break;
754. 
     
755.         if (chLeftBracket != *szToken)
756.         {
757.             hr = GenerateError(E_ATL_MISSING_OPENKEY_TOKEN);
758.             break;
759.         }
760.         if (bRegister)
761.         {
762.             LPTSTR szRegAtRegister = m_pchCur;
763.             hr = RegisterSubkeys(szToken, hkBase, bRegister);
764.             if (FAILED(hr))
765.             {
766.                 m_pchCur = szRegAtRegister;
767.                 RegisterSubkeys(szToken, hkBase, FALSE);
768.                 break;
769.             }
770.         }
771.         else
772.         {
773.             if (FAILED(hr = RegisterSubkeys(szToken, hkBase, bRegister)))
774.                 break;
775.         }
776. 
     
777.         SkipWhiteSpace();
778.     }
779.     CoTaskMemFree(szReg);
780.     return hr;
781. }
782. 
     
783. inline HRESULT CRegParser::RegisterSubkeys(LPTSTR szToken, _In_ HKEY hkParent, _In_ BOOL bRegister, _In_ BOOL bRecover)
784. {
785.     CRegKey keyCur;
786.     LONG    lRes;
787.     TCHAR  szKey[_MAX_PATH];
788.     BOOL    bDelete = TRUE;
789.     BOOL    bInRecovery = bRecover;
790.     HRESULT hr = S_OK;
791. 
     
792.     if (FAILED(hr = NextToken(szToken)))
793.         return hr;
794. 
     
795.     while (*szToken != chRightBracket) // Continue till we see a }
796.     {
797.         bDelete = TRUE;
798.         BOOL bTokenDelete = !lstrcmpi(szToken, szDelete);
799. 
     
800.         if (!lstrcmpi(szToken, szForceRemove) || bTokenDelete)
801.         {
802.             if (FAILED(hr = NextToken(szToken)))
803.                 break;
804. 
     
805.             if (bRegister)
806.             {
807.                 CRegKey rkForceRemove;
808. 
     
809.                 if (StrChr(szToken, chDirSep) != NULL)
810.                     return GenerateError(E_ATL_COMPOUND_KEY);
811. 
     
812.                 if (CanForceRemoveKey(szToken))
813.                 {
814.                     rkForceRemove.Attach(hkParent);
815.                     // Error not returned. We will overwrite the values any way.
816.                     rkForceRemove.RecurseDeleteKey(szToken);
817.                     rkForceRemove.Detach();
818.                 }
819.                 if (bTokenDelete)
820.                 {
821.                     if (FAILED(hr = NextToken(szToken)))
822.                         break;
823.                     if (FAILED(hr = SkipAssignment(szToken)))
824.                         break;
825.                     goto EndCheck;
826.                 }
827.             }
828. 
     
829.         }
830. 
     
831.         if (!lstrcmpi(szToken, szNoRemove))
832.         {
833.             bDelete = FALSE;    // set even for register
834.             if (FAILED(hr = NextToken(szToken)))
835.                 break;
836.         }
837. 
     
838.         if (!lstrcmpi(szToken, szValToken)) // need to add a value to hkParent
839.         {
840.             TCHAR  szValueName[MAX_VALUE];
841. 
     
842. 
     
843.          
844.             if (FAILED(hr = NextToken(szValueName)))
845.                 break;
846.             if (FAILED(hr = NextToken(szToken)))
847.                 break;
848.  
849.             if (*szToken != chEquals)
850.                 return GenerateError(E_ATL_EXPECTING_EQUAL);
851. 
     
852.             if (bRegister)
853.             {
854.                 CRegKey rk;
855. 
     
856.                 rk.Attach(hkParent);
857.                 hr = AddValue(rk, szValueName, szToken);
858.                 rk.Detach();
859. 
     
860.                 if (FAILED(hr))
861.                     return hr;
862. 
     
863.                 goto EndCheck;
864.             }
865.             else
866.             {
867.                 if (!bRecover && bDelete)
868.                 {
869.                     ATLTRACE(atlTraceRegistrar, 1, _T("Deleting %s/n"), szValueName);
870.                     // We have to open the key for write to be able to delete.
871.                     CRegKey rkParent;
872.                     lRes = rkParent.Open(hkParent, NULL, KEY_WRITE);
873.                     if (lRes == ERROR_SUCCESS)
874.                     {
875.                         lRes = rkParent.DeleteValue(szValueName);
876.                         if (lRes != ERROR_SUCCESS && lRes != ERROR_FILE_NOT_FOUND)
877.                         {
878.                             // Key not present is not an error
879.                             hr = AtlHresultFromWin32(lRes);
880.                             break;
881.                         }
882.                     }
883.                     else
884.                     {
885.                         hr = AtlHresultFromWin32(lRes);
886.                         break;
887.                     }
888.                 }
889.                 if (FAILED(hr = SkipAssignment(szToken)))
890.                     break;
891.                 continue;  // can never have a subkey
892.             }
893.         }
894. 
     
895.         if (StrChr(szToken, chDirSep) != NULL)
896.             return GenerateError(E_ATL_COMPOUND_KEY);
897. 
     
898.         if (bRegister)
899.         {
900.             lRes = keyCur.Open(hkParent, szToken, KEY_READ | KEY_WRITE);
901.             if (ERROR_SUCCESS != lRes)
902.             {
903.                 // Failed all access try read only
904.                 lRes = keyCur.Open(hkParent, szToken, KEY_READ);
905.                 if (ERROR_SUCCESS != lRes)
906.                 {
907.                     // Finally try creating it
908.                     ATLTRACE(atlTraceRegistrar, 2, _T("Creating key %s/n"), szToken);
909.                     lRes = keyCur.Create(hkParent, szToken, REG_NONE, REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE);
910.                     if (lRes != ERROR_SUCCESS)
911.                         return AtlHresultFromWin32(lRes);
912.                 }
913.             }
914. 
     
915.             if (FAILED(hr = NextToken(szToken)))
916.                 break;
917. 
     
918. 
     
919.             if (*szToken == chEquals)
920.             {
921.                 if (FAILED(hr = AddValue(keyCur, NULL, szToken))) // NULL == default
922.                     break;
923.             }
924.         }
925.         else //Unregister
926.         {
927.             if (!bRecover)
928.             {
929.                 lRes = keyCur.Open(hkParent, szToken, KEY_READ);
930. 
     
931.             }
932.             else
933.                 lRes = ERROR_FILE_NOT_FOUND;
934. 
     
935. 
     
936.             // Open failed set recovery mode
937.             if (lRes != ERROR_SUCCESS)
938.                 bRecover = true;
939. 
     
940.             // TRACE out Key open status and if in recovery mode
941. #ifdef _DEBUG
942.             if (!bRecover)
943.                 ATLTRACE(atlTraceRegistrar, 1, _T("Opened Key %s/n"), szToken);
944.             else
945.                 ATLTRACE(atlTraceRegistrar, 0, _T("Ignoring Open key on %s : In Recovery mode/n"), szToken);
946. #endif //_DEBUG
947. 
     
948.             // Remember Subkey
949.             Checked::tcsncpy_s(szKey, _countof(szKey), szToken, _TRUNCATE);
950. 
     
951.             if (FAILED(hr = NextToken(szToken)))
952.                 break;
953.             if (FAILED(hr = SkipAssignment(szToken)))
954.                 break;
955. 
     
956.             if (*szToken == chLeftBracket && lstrlen(szToken) == 1)
957.             {
958.                 hr = RegisterSubkeys(szToken, keyCur.m_hKey, bRegister, bRecover);
959.                 // In recover mode ignore error
960.                 if (FAILED(hr) && !bRecover)
961.                     break;
962.                 // Skip the }
963.                 if (FAILED(hr = NextToken(szToken)))
964.                     break;
965.             }
966. 
     
967. #ifdef _DEBUG
968.             if (bRecover != bInRecovery)
969.                 ATLTRACE(atlTraceRegistrar, 0, _T("Ending Recovery Mode/n"));
970. #endif
971.             bRecover = bInRecovery;
972. 
     
973.             if (lRes == ERROR_FILE_NOT_FOUND)
974.                 // Key already not present so not an error.
975.                 continue;
976. 
     
977.             if (lRes != ERROR_SUCCESS)
978.             {
979.                 // We are recovery mode continue on errors else break
980.                 if (bRecover)
981.                     continue;
982.                 else
983.                 {
984.                     hr = AtlHresultFromWin32(lRes);
985.                     break;
986.                 }
987.             }
988. 
     
989.             // If in recovery mode
990.             if (bRecover && HasSubKeys(keyCur))
991.             {
992.                 // See if the KEY is in the NeverDelete list and if so, don't
993.                 if (CanForceRemoveKey(szKey) && bDelete)
994.                 {
995.                     ATLTRACE(atlTraceRegistrar, 0, _T("Deleting non-empty subkey %s by force/n"), szKey);
996.                     // Error not returned since we are in recovery mode. The error that caused recovery mode is returned
997.                     keyCur.RecurseDeleteKey(szKey);
998.                 }
999.                 continue;
1000.             }
1001.             
1002.             BOOL bHasSubKeys=HasSubKeys(keyCur);
1003.             lRes = keyCur.Close();
1004.             if (lRes != ERROR_SUCCESS)
1005.             return AtlHresultFromWin32(lRes);
1006. 
      
1007.             if (bDelete&& !bHasSubKeys)
1008.             {
1009.                 ATLTRACE(atlTraceRegistrar, 0, _T("Deleting Key %s/n"), szKey);
1010.                 CRegKey rkParent;
1011.                 rkParent.Attach(hkParent);
1012.                 lRes = rkParent.DeleteSubKey(szKey);
1013.                 rkParent.Detach();
1014.                 if (lRes != ERROR_SUCCESS)
1015.                 {
1016.                      
1017.                     hr = AtlHresultFromWin32(lRes);
1018.                     break;
1019.                 }
1020.             }
1021.         }
1022. 
      
1023. EndCheck:
1024. 
      
1025.         if (bRegister)
1026.         {
1027.             if (*szToken == chLeftBracket && lstrlen(szToken) == 1)
1028.             {
1029.                 if (FAILED(hr = RegisterSubkeys(szToken, keyCur.m_hKey, bRegister, FALSE)))
1030.                     break;
1031.                 if (FAILED(hr = NextToken(szToken)))
1032.                     break;
1033.             }
1034.         }
1035.     }
1036. 
      
1037.     return hr;
1038. }

注意，该段代码需要包含atl的某些头文件。请自行查阅msdn
使用这段代码的方法如下：

1. USES_CONVERSION;
2. int r;
3. char buffer[CRegParser::MAX_VALUE];
4. CRegParser reg;
5. CString str;
6. CFile file;
7. 
   
8. file.Open ();
9. r = file.Read (buffer, sizeof (buffer));
10. if (r >= sizeof (buffer))
11. {
12. // error;
13. }
14. 
    
15. buffer[r] = '/0';
16. reg.RegisterBuffer (CA2CT(buffer), TRUE);

这是一段伪代码，该段代码从文件中读出注册表脚本，传入RegisterBuffer函数，该函数执行更新注册表的操作。需要MFC库、需要ATL的头文件。

下面的代码可以用来更新注册表，使得鼠标右击后可以选择使用notepad来打开选中的文件的菜单项。将这段代码保存到文件中。修改上面那段示例代码，将打开的文件名更改为保存的文件名即可。

1. HKEY_LOCAL_MACHINE
2. {
3.  NoRemove SOFTWARE
4.  {
5.   NoRemove Classes
6.   {
7.     NoRemove *
8.     {
9.      NoRemove Shell
10.      {
11.       ForceRemove 使用记事本打开
12.       {
13.        Command = s 'Notepad "%%1"'
14.       }
15.      }
16.     }
17.   }
18.  }
19. }
20. 
    

注册表脚本的格式可以参见msdn的文章http://msdn.microsoft.com/zh-cn/library/cc451363(VS.71).aspx