现在的位置: 首页 > 综合 > 正文

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

2013年12月02日 ⁄ 综合 ⁄ 共 20093字 ⁄ 字号 小 中 大 ⁄ 评论关闭

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

代码如下：

  2. class CRegParser
  3. {
  4. public:
  5.     CRegParser();
  7.     HRESULT  PreProcessBuffer(_In_z_ LPTSTR lpszReg, _Deref_out_opt_z_ LPTSTR* ppszReg);
  8.     HRESULT  RegisterBuffer(_In_z_ LPTSTR szReg, _In_ BOOL bRegister);
  10. protected:
  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;
  23.     HRESULT GenerateError(UINT) {return DISP_E_EXCEPTION;}
  24.     //HRESULT HandleReplacements(LPTSTR& szToken);
  25.     HRESULT SkipAssignment(LPTSTR szToken);
  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;
  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;
  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;
  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.         }
  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);
  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.         }
  121.     };
  122. };
  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. };
  141. __declspec(selectany) const int CRegParser::cbNeverDelete = sizeof(rgszNeverDelete) / sizeof(LPCTSTR*);
  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
  154.     static const typemap map[] = {
  155.         {szStringVal, VT_BSTR},
  156.         {multiszStringVal, VT_BSTR | VT_BYREF},
  157.         {szDwordVal,  VT_UI4},
  158.         {szBinaryVal, VT_UI1}
  159.     };
  161. #pragma warning (pop)
  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.     }
  172.     return FALSE;
  174. }
  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. }
  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.     };
  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. }
  244. inline LPTSTR CRegParser::StrChr(_In_z_ LPTSTR lpsz, _In_ TCHAR ch)
  245. {
  246.     LPTSTR p = NULL;
  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. }
  263. inline CRegParser::CRegParser()
  264. {
  265.     m_pchCur = NULL;
  266. }
  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.     }
  279.     return FALSE;
  280. }
  282. inline void CRegParser::SkipWhiteSpace()
  283. {
  284.     while(IsSpace(*m_pchCur))
  285.         m_pchCur = CharNext(m_pchCur);
  286. }
  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();
  294.     // NextToken cannot be called at EOS
  295.     if (NULL == *m_pchCur)
  296.         return GenerateError(E_ATL_UNEXPECTED_EOS);
  297. #pragma warning(pop)
  299.     LPCTSTR szOrig = szToken;
  300.     // handle quoted value / key
  301.     if (chQuote == *m_pchCur)
  302.     {
  303.         m_pchCur = CharNext(m_pchCur);
  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);
  310.             LPTSTR pchPrev = m_pchCur;
  311.             m_pchCur = CharNext(m_pchCur);
  313.             INT_PTR nChars = m_pchCur - pchPrev;
  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);
  319.             for (int i = 0; i < (int)nChars; i++, szToken++, pchPrev++)
  320.                 *szToken = *pchPrev;
  321.         }
  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.         }
  329.         *szToken = NULL;
  330.         m_pchCur = CharNext(m_pchCur);
  331.     }
  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);
  341.             INT_PTR nChars = m_pchCur - pchPrev;
  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);
  347.             for (int i = 0; i < (int)nChars; i++, szToken++, pchPrev++)
  348.                 *szToken = *pchPrev;
  349.         }
  351.         *szToken = NULL;
  352.     }
  353.     return S_OK;
  354. }
  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;
  362.     TCHAR       szValue[MAX_VALUE];
  363.     VARTYPE     vt = VT_EMPTY;
  364.     LONG        lRes = ERROR_SUCCESS;
  365.     UINT        nIDRes = 0;
  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)
  376.     SkipWhiteSpace();
  377.     if (FAILED(hr = NextToken(szValue)))
  378.         return hr;
  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;
  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.     }
  475.     if (ERROR_SUCCESS != lRes)
  476.     {
  477.         nIDRes = E_ATL_VALUE_SET_FAILED;
  478.         return AtlHresultFromWin32(lRes);
  479.     }
  481.     if (FAILED(hr = NextToken(szToken)))
  482.         return hr;
  484.     return S_OK;
  485. }
  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
  493.     return TRUE;
  494. }
  496. inline BOOL CRegParser::HasSubKeys(HKEY hkey)
  497. {
  498.     DWORD       cbSubKeys = 0;
  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.     }
  509.     return cbSubKeys > 0;
  510. }
  512. inline BOOL CRegParser::HasValues(HKEY hkey)
  513. {
  514.     DWORD       cbValues = 0;
  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.     }
  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.     }
  537.     return cbValues > 0; // More than 1 means we have a non-default value
  538. }
  540. inline HRESULT CRegParser::SkipAssignment(_Inout_z_cap_c_(MAX_VALUE) LPTSTR szToken)
  541. {
  542.     HRESULT hr;
  543.     TCHAR szValue[MAX_VALUE];
  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.     }
  557.     return S_OK;
  558. }
  560. inline HRESULT CRegParser::PreProcessBuffer(_In_z_ LPTSTR lpszReg, _Deref_out_opt_z_ LPTSTR* ppszReg)
  561. {
  562.     ATLASSERT(lpszReg != NULL);
  563.     ATLASSERT(ppszReg != NULL);
  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;
  576.     bool bRedirectionEnabled = false;
  577.     hr = AtlGetPerUserRegistration(&bRedirectionEnabled);
  578.     if( FAILED(hr) )
  579.     {
  580.         return hr;
  581.     }
  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;
  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";
  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);
  609.                     // Add HKCU
  610.                     if (!pb.AddString(szStartHKCU))
  611.                     {
  612.                         hr = E_OUTOFMEMORY;
  613.                         break;
  614.                     }
  616.                     bRedirectionPresent = true;
  617.                 }
  618.             }
  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.             }
  646.             if ( (false == bInsideQuotes) && (*m_pchCur == _T('{')) )
  647.             {
  648.                 ++nNestingLevel;
  649.             }
  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.                     }
  662.                     bRedirectionPresent = false;
  663.                 }
  664.             }
  665.         }
  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.                 //}
  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
返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞