![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stringex.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / mfc / src|
Return to stringex.cpp CVS log | Up to [WindowsNT SDKs] / mstools / mfc / src |
1.1 ! root 1: // This is a part of the Microsoft Foundation Classes C++ library. ! 2: // Copyright (C) 1992 Microsoft Corporation ! 3: // All rights reserved. ! 4: // ! 5: // This source code is only intended as a supplement to the ! 6: // Microsoft Foundation Classes Reference and Microsoft ! 7: // QuickHelp documentation provided with the library. ! 8: // See these sources for detailed information regarding the ! 9: // Microsoft Foundation Classes product. ! 10: ! 11: ! 12: #include "afx.h" ! 13: #pragma hdrstop ! 14: #include <limits.h> ! 15: ! 16: #ifdef AFX_AUX_SEG ! 17: #pragma code_seg(AFX_AUX_SEG) ! 18: #endif ! 19: ! 20: #ifdef _DEBUG ! 21: #undef THIS_FILE ! 22: static char BASED_CODE THIS_FILE[] = __FILE__; ! 23: #endif ! 24: ! 25: #define new DEBUG_NEW ! 26: ! 27: extern char _afxChNil; ! 28: ! 29: ////////////////////////////////////////////////////////////////////////////// ! 30: // More sophisticated construction ! 31: ! 32: CString::CString(char ch, int nRepeat) ! 33: { ! 34: if (nRepeat < 1) ! 35: // return empty string if invalid repeat count ! 36: Init(); ! 37: else ! 38: { ! 39: AllocBuffer(nRepeat); ! 40: memset(m_pchData, ch, nRepeat); ! 41: } ! 42: } ! 43: ! 44: ! 45: CString::CString(const char* pch, int nLen) ! 46: { ! 47: if (nLen == 0) ! 48: Init(); ! 49: else ! 50: { ! 51: AllocBuffer(nLen); ! 52: memcpy(m_pchData, pch, nLen); ! 53: } ! 54: } ! 55: ! 56: ////////////////////////////////////////////////////////////////////////////// ! 57: // Additional constructors for far string data ! 58: ! 59: #ifdef _NEARDATA ! 60: ! 61: CString::CString(const char FAR* lpsz) ! 62: { ! 63: int nLen; ! 64: if (lpsz == NULL || (nLen = _fstrlen(lpsz)) == 0) ! 65: Init(); ! 66: else ! 67: { ! 68: AllocBuffer(nLen); ! 69: _fmemcpy(m_pchData, lpsz, nLen); ! 70: } ! 71: } ! 72: ! 73: CString::CString(const char FAR* lpch, int nLen) ! 74: { ! 75: if (nLen == 0) ! 76: Init(); ! 77: else ! 78: { ! 79: AllocBuffer(nLen); ! 80: _fmemcpy(m_pchData, lpch, nLen); ! 81: } ! 82: } ! 83: ! 84: #endif // need far overloads ! 85: ! 86: ////////////////////////////////////////////////////////////////////////////// ! 87: // Assignment operators ! 88: const CString& ! 89: CString::operator =(char ch) ! 90: { ! 91: AssignCopy(1, &ch); ! 92: return *this; ! 93: } ! 94: ! 95: ! 96: ! 97: ////////////////////////////////////////////////////////////////////////////// ! 98: // concatenation ! 99: const CString& ! 100: CString::operator +=(char ch) ! 101: { ! 102: ConcatInPlace(1, &ch); ! 103: return *this; ! 104: } ! 105: ! 106: ! 107: CString ! 108: operator +(const CString& string1, char ch) ! 109: { ! 110: CString s; ! 111: s.ConcatCopy(string1.m_nDataLength, string1.m_pchData, 1, &ch); ! 112: return s; ! 113: } ! 114: ! 115: ! 116: CString ! 117: operator +(char ch, const CString& string) ! 118: { ! 119: CString s; ! 120: s.ConcatCopy(1, &ch, string.m_nDataLength, string.m_pchData); ! 121: return s; ! 122: } ! 123: ! 124: ! 125: ////////////////////////////////////////////////////////////////////////////// ! 126: // Very simple sub-string extraction ! 127: ! 128: CString ! 129: CString::Mid(int nFirst) const ! 130: { ! 131: return Mid(nFirst, m_nDataLength - nFirst); ! 132: } ! 133: ! 134: CString ! 135: CString::Mid(int nFirst, int nCount) const ! 136: { ! 137: ASSERT(nFirst >= 0); ! 138: ASSERT(nCount >= 0); ! 139: ! 140: // out-of-bounds requests return sensible things ! 141: if (nFirst + nCount > m_nDataLength) ! 142: nCount = m_nDataLength - nFirst; ! 143: if (nFirst > m_nDataLength) ! 144: nCount = 0; ! 145: ! 146: CString dest; ! 147: AllocCopy(dest, nCount, nFirst, 0); ! 148: return dest; ! 149: } ! 150: ! 151: CString ! 152: CString::Right(int nCount) const ! 153: { ! 154: ASSERT(nCount >= 0); ! 155: ! 156: if (nCount > m_nDataLength) ! 157: nCount = m_nDataLength; ! 158: ! 159: CString dest; ! 160: AllocCopy(dest, nCount, m_nDataLength-nCount, 0); ! 161: return dest; ! 162: } ! 163: ! 164: CString ! 165: CString::Left(int nCount) const ! 166: { ! 167: ASSERT(nCount >= 0); ! 168: ! 169: if (nCount > m_nDataLength) ! 170: nCount = m_nDataLength; ! 171: ! 172: CString dest; ! 173: AllocCopy(dest, nCount, 0, 0); ! 174: return dest; ! 175: } ! 176: ! 177: CString ! 178: CString::SpanIncluding(const char* pszCharSet) const ! 179: { ! 180: // strspn equivalent ! 181: return Left(strspn(m_pchData, pszCharSet)); ! 182: } ! 183: ! 184: ! 185: CString ! 186: CString::SpanExcluding(const char* pszCharSet) const ! 187: { ! 188: // strcspn equivalent ! 189: return Left(strcspn(m_pchData, pszCharSet)); ! 190: } ! 191: ! 192: ////////////////////////////////////////////////////////////////////////////// ! 193: // Finding ! 194: ! 195: int CString::Find(char ch) const ! 196: { ! 197: // find a single character (strchr) ! 198: ! 199: register char* psz; ! 200: psz = (char*) strchr(m_pchData, ch); ! 201: return (psz == NULL) ? -1 : psz - m_pchData; ! 202: } ! 203: ! 204: ! 205: int CString::ReverseFind(char ch) const ! 206: { ! 207: // find a single character (start backwards, strrchr) ! 208: ! 209: register char* psz; ! 210: psz = (char*) strrchr(m_pchData, ch); ! 211: return (psz == NULL) ? -1 : psz - m_pchData; ! 212: } ! 213: ! 214: ! 215: int CString::FindOneOf(const char* pszCharSet) const ! 216: { ! 217: // like single character find, but look for any of the characters ! 218: // in the string "pszCharSet", like strpbrk ! 219: ! 220: char* psz = (char*) strpbrk(m_pchData, pszCharSet); ! 221: return (psz == NULL) ? -1 : (psz-m_pchData); ! 222: } ! 223: ! 224: ! 225: int CString::Find(const char* pszSub) const ! 226: { ! 227: // find a sub-string (like strstr) ! 228: ! 229: char* psz = (char*) strstr(m_pchData, pszSub); ! 230: return (psz == NULL) ? -1 : (psz-m_pchData); ! 231: } ! 232: ! 233: /////////////////////////////////////////////////////////////////////////////// ! 234: // Advanced access ! 235: ! 236: char* CString::GetBuffer(int nMinBufLength) ! 237: { ! 238: if (nMinBufLength > m_nAllocLength) ! 239: { ! 240: // we have to grow the buffer ! 241: char* pszOldData = m_pchData; ! 242: int nOldLen = m_nDataLength; // AllocBuffer will tromp it ! 243: ! 244: AllocBuffer(nMinBufLength); ! 245: memcpy(m_pchData, pszOldData, nOldLen); ! 246: m_nDataLength = nOldLen; ! 247: m_pchData[m_nDataLength] = '\0'; ! 248: ! 249: ASSERT(pszOldData != NULL); ! 250: if (pszOldData != &_afxChNil) ! 251: delete [] pszOldData; ! 252: } ! 253: ! 254: // return a pointer to the character storage for this string ! 255: return m_pchData; ! 256: } ! 257: ! 258: void CString::ReleaseBuffer(int nNewLength) ! 259: { ! 260: if (nNewLength == -1) ! 261: nNewLength = strlen(m_pchData); // zero terminated ! 262: ! 263: ASSERT(nNewLength <= m_nAllocLength); ! 264: m_nDataLength = nNewLength; ! 265: m_pchData[m_nDataLength] = '\0'; ! 266: } ! 267: ! 268: char* CString::GetBufferSetLength(int nNewLength) ! 269: { ! 270: GetBuffer(nNewLength); ! 271: m_nDataLength = nNewLength; ! 272: m_pchData[m_nDataLength] = '\0'; ! 273: return m_pchData; ! 274: } ! 275: ! 276: /////////////////////////////////////////////////////////////////////////////// ! 277:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.