Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
dynastr.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 4k
Category:

Windows Kernel

Development Platform:

Visual C++

dynastr.cpp：Code Content
  1. #include "priv.h"
  2. #include "dynastr.h"
  4. #define DM_DYNASTR  DM_TRACE
  6. LPWSTR DynaStrW::_Realloc(UINT cch)
  7. {
  8.     ASSERT(cch >= CCH_DYNASTR_MIN);
  9.     UINT cb = cch*SIZEOF(_ach[0]);
  11.     if (_psz != _ach) {
  12.         if ( LocalSize(_psz) < cb ) {
  13.             LPWSTR pszNew = (LPWSTR)LocalReAlloc(_psz, cb, LMEM_MOVEABLE);
  14.             TraceMsg(DM_DYNASTR, "DynaStrW::_Realloc reallocated memory %x->%x", _psz, pszNew);
  15.             if (!pszNew) {
  16.                 return NULL;
  17.             }
  18.             _psz = pszNew;
  19.         }
  20.     } else {
  21.         LPWSTR pszNew = (LPWSTR)LocalAlloc(LPTR, cb);
  22.         TraceMsg(DM_DYNASTR, "DynaStrW::_Realloc allocated memory %x", pszNew);
  23.         if (!pszNew) {
  24.             return NULL;
  25.         }
  26.         _psz = pszNew;
  27.     }
  29.     return _psz;
  30. }
  32. BOOL DynaStrW::lstrcpy(LPCWSTR pwszSrc)
  33. {
  34.     UINT cch = lstrlenW(pwszSrc);
  35.     if (cch < CCH_DYNASTR_MIN || _Realloc(cch+1)) {
  36.         ASSERT(_psz==_ach || LocalSize(_psz) >= cch+1*SIZEOF(_psz[0]));
  37.         memcpy(_psz, pwszSrc, (cch+1)*SIZEOF(_psz[0]));
  38.         return TRUE;
  39.     }
  40.     return FALSE;
  41. }
  43. BOOL DynaStrW::lstrcpy(LPCSTR pszSrc)
  44. {
  45.     UINT cch = MultiByteToWideChar(CP_ACP, 0, pszSrc, -1, NULL, 0);
  46.     if (cch < CCH_DYNASTR_MIN || _Realloc(cch+1)) {
  47.         ASSERT(_psz==_ach || LocalSize(_psz) >= cch+1*SIZEOF(_psz[0]));
  48.         MultiByteToWideChar(CP_ACP, 0, pszSrc, -1, _psz, cch+1);
  49.         return TRUE;
  50.     }
  51.     return FALSE;
  52. }
  54. DynaStrW::~DynaStrW()
  55. {
  56.     if (_psz != _ach) {
  57.         TraceMsg(DM_DYNASTR, "dtr ~DynaStrW freeing allocated memory %x", _psz);
  58.         LocalFree(_psz);
  59.     }
  60. }
  63. LPSTR DynaStrA::_Realloc(UINT cch)
  64. {
  65.     ASSERT(cch >= CCH_DYNASTR_MIN);
  66.     UINT cb = cch*SIZEOF(_ach[0]);
  68.     if (_psz != _ach) {
  69.         if ( LocalSize(_psz) < cb ) {
  70.             LPSTR pszNew = (LPSTR)LocalReAlloc(_psz, cb, LMEM_MOVEABLE);
  71.             TraceMsg(DM_DYNASTR, "DynaStrA::_Realloc reallocated memory %x->%x", _psz, pszNew);
  72.             if (!pszNew) {
  73.                 return NULL;
  74.             }
  75.             _psz = pszNew;
  76.         }
  77.     } else {
  78.         LPSTR pszNew = (LPSTR)LocalAlloc(LPTR, cb);
  79.         TraceMsg(DM_DYNASTR, "DynaStrA::_Realloc allocated memory %x", pszNew);
  80.         if (!pszNew) {
  81.             return NULL;
  82.         }
  83.         _psz = pszNew;
  84.     }
  86.     return _psz;
  87. }
  89. BOOL DynaStrA::lstrcpy(LPCSTR pszSrc)
  90. {
  91.     UINT cch = lstrlen(pszSrc);
  92.     if (cch < CCH_DYNASTR_MIN || _Realloc(cch+1)) {
  93.         ASSERT(_psz==_ach || LocalSize(_psz) >= cch+1*SIZEOF(_psz[0]));
  94.         memcpy(_psz, pszSrc, (cch+1)*SIZEOF(_psz[0]));
  95.         return TRUE;
  96.     }
  97.     return FALSE;
  98. }
  100. BOOL DynaStrA::lstrcpy(LPCWSTR pwszSrc)
  101. {
  102.     UINT cch = WideCharToMultiByte(CP_ACP, 0, pwszSrc, -1, NULL, 0, NULL, NULL);
  103.     if (cch < CCH_DYNASTR_MIN || _Realloc(cch+1)) {
  104.         ASSERT(_psz==_ach || LocalSize(_psz) >= cch+1*SIZEOF(_psz[0]));
  105.         WideCharToMultiByte(CP_ACP, 0, pwszSrc, -1, _psz, cch+1, NULL, NULL);
  106.         return TRUE;
  107.     }
  108.     return FALSE;
  109. }
  111. DynaStrA::~DynaStrA()
  112. {
  113.     if (_psz != _ach) {
  114.         TraceMsg(DM_DYNASTR, "dtr ~DynaStrA freeing allocated memory %x", _psz);
  115.         LocalFree(_psz);
  116.     }
  117. }
  119. // Some test cases
  120. #if 0
  121. extern HRESULT test0(LPCWSTR pwsz);
  123. //
  124. // Code size:   58 bytes
  125. // Stack frame: 4096+
  126. //
  127. HRESULT test1(LPSTR pszIn)
  128. {
  129.     WCHAR wsz[MAX_URL_STRING*2];
  130.     MultiByteToWideChar(CP_ACP, 0, pszIn, -1, wsz, ARRAYSIZE(wsz));
  131.     return test0(wsz);
  132. }
  134. //
  135. // Code size:   70 bytes
  136. // Stack frame: 0+
  137. //
  138. HRESULT test2(LPSTR pszIn)
  139. {
  140.     LPWSTR pwsz = (LPWSTR)LocalAlloc(LPTR, 2*MAX_URL_STRING*SIZEOF(WCHAR));
  141.     HRESULT hres;
  142.     if (pwsz) {
  143.         MultiByteToWideChar(CP_ACP, 0, pszIn, -1, pwsz, MAX_URL_STRING);
  144.         hres = test0(pwsz);
  145.         LocalFree(pwsz);
  146.     } else {
  147.         hres = E_OUTOFMEMORY;
  148.     }
  149.     return hres;
  150. }
  152. //
  153. // Code size:   68 bytes
  154. // Stack frame: 0+
  155. //
  156. HRESULT test3(LPSTR pszIn)
  157. {
  158.     DynaStrW wsz;
  159.     HRESULT hres;
  160.     if (wsz.lstrcpy(pszIn)) {
  161.         hres = test0(wsz);
  162.     } else {
  163.         hres = E_OUTOFMEMORY;
  164.     }
  165.     return hres;
  166. }
  167. #endif