mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
878 lines
20 KiB
878 lines
20 KiB
/*++
|
|
|
|
Copyright (c) 1994 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
StrUtils.C
|
|
|
|
Abstract:
|
|
|
|
String utility functions
|
|
|
|
Author:
|
|
|
|
Bob Watson (a-robw)
|
|
|
|
Revision History:
|
|
|
|
24 Jun 94 Written
|
|
|
|
--*/
|
|
//
|
|
// Windows Include Files
|
|
//
|
|
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
#include <malloc.h>
|
|
#include <tchar.h> // unicode macros
|
|
#include <stdlib.h> // string to number conversions
|
|
//
|
|
// app include files
|
|
//
|
|
#include "otnboot.h"
|
|
#include "otnbtdlg.h"
|
|
//
|
|
// Local constants
|
|
//
|
|
#define NUM_BUFS 8
|
|
|
|
BOOL
|
|
MatchFirst (
|
|
IN LPCTSTR szStringA,
|
|
IN LPCTSTR szStringB
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
performs a case in-sensitive comparison of the two strings to
|
|
the extent of the shortest string. If, up to the length
|
|
of the shortest string, the strings match then TRUE is
|
|
returned otherwise FALSE is returned.
|
|
|
|
|
|
Arguments:
|
|
|
|
IN LPCTSTR szStringA,
|
|
pointer to first string
|
|
|
|
IN LPCTSTR szStringB
|
|
pointer to second string
|
|
|
|
Return Value:
|
|
|
|
TRUE if match found
|
|
FALSE if not
|
|
|
|
--*/
|
|
{
|
|
LPTSTR szAptr; // pointer to char in szStringA to compare
|
|
LPTSTR szBptr; // pointer to char in szStringB to compare
|
|
|
|
if ((szStringA != NULL) && (szStringB != NULL)) {
|
|
szAptr = (LPTSTR)szStringA;
|
|
szBptr = (LPTSTR)szStringB;
|
|
while ((*szBptr != 0) && (*szAptr != 0)) {
|
|
if (_totlower(*szBptr) != _totlower(*szAptr)) break;
|
|
szBptr++;
|
|
szAptr++;
|
|
}
|
|
if (((*szAptr == 0) && ((*szBptr == 0) || (*szBptr == cBackslash))) ||
|
|
((*szBptr == 0) && ((*szAptr == 0) || (*szAptr == cBackslash)))) {
|
|
// then a matched directoryto the end of the shortest string
|
|
return TRUE;
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
DWORD
|
|
GetSizeFromInfString (
|
|
IN LPCTSTR szString
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Reads the estimated size of the directory tree as stored in the
|
|
inf file. The format of the INF string is:
|
|
|
|
key=entry
|
|
where:
|
|
key = subdir name
|
|
entry = NumberOfFiles,TotalBytes
|
|
|
|
value must be less than 2**32
|
|
|
|
Arguments:
|
|
|
|
"entry" string read from INF file
|
|
|
|
|
|
Return Value:
|
|
|
|
DWORD value of TotalBytes in entry
|
|
|
|
--*/
|
|
{
|
|
LPTSTR szSize; // size string parsed from input string
|
|
LPTSTR szLastChar; // beginning of size value in string
|
|
|
|
// size is second param in comma separated list
|
|
// go to first comma
|
|
szSize = (LPTSTR)szString;
|
|
while ((*szSize != cComma) && (*szSize != 0)) szSize++;
|
|
szSize++; // go to first char after comma
|
|
return _tcstoul (szSize, &szLastChar, 10);
|
|
}
|
|
|
|
BOOL
|
|
SavePathToRegistry (
|
|
LPCTSTR szPath,
|
|
LPCTSTR szServerKey,
|
|
LPCTSTR szShareKey
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
splits the path (which must be a UNC path) into server & sharepoint
|
|
for loading into the system registry. The key used is the
|
|
\HKEY_CURRENT_USER\Software\Microsoft\Windows NT\CurrentVersion\Network
|
|
and the NCAdmin key is created (if it doesn't exist) under which the
|
|
Server is stored in the szServerKey value and the share point is
|
|
stored under the szShareKey value
|
|
|
|
Arguments:
|
|
|
|
LPCTSTR szPath
|
|
UNC path to store
|
|
|
|
LPCTSTR szServerKey
|
|
name of registry value to store server under
|
|
|
|
LPCTSTR szShareKey
|
|
name of registry value to store share under
|
|
|
|
Return Value:
|
|
|
|
TRUE values stored OK
|
|
FALSE values not stored
|
|
|
|
--*/
|
|
{
|
|
TCHAR szMachine[MAX_COMPUTERNAME_LENGTH+1]; // computer name buffer
|
|
LPTSTR szShare; // share name buffer
|
|
HKEY hkeyUserInfo; // registry key
|
|
HKEY hkeyAppInfo; // registry key
|
|
|
|
LONG lStatus; // local function status
|
|
BOOL bReturn; // return value of this fn
|
|
DWORD dwAppKeyDisp; // create/existing value
|
|
|
|
szShare = GlobalAlloc (GPTR, MAX_PATH_BYTES);
|
|
if (szShare == NULL) {
|
|
// unable to alloc memory.
|
|
return FALSE;
|
|
}
|
|
|
|
if (IsUncPath (szPath)) {
|
|
// open registry key containing net apps
|
|
|
|
lStatus = RegOpenKeyEx (
|
|
HKEY_CURRENT_USER,
|
|
cszUserInfoKey,
|
|
0L,
|
|
KEY_READ,
|
|
&hkeyUserInfo);
|
|
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
// unable to open key so return error
|
|
bReturn = FALSE;
|
|
} else {
|
|
// open registry key containing this app's info
|
|
lStatus = RegCreateKeyEx (
|
|
hkeyUserInfo,
|
|
szAppName,
|
|
0L,
|
|
(LPTSTR)cszEmptyString,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_WRITE,
|
|
NULL,
|
|
&hkeyAppInfo,
|
|
&dwAppKeyDisp);
|
|
|
|
if (lStatus != ERROR_SUCCESS) {
|
|
// unable to open key so return false
|
|
bReturn = FALSE;
|
|
} else {
|
|
if (!GetServerFromUnc (szPath, szMachine)) {
|
|
// unable to read share so clear value
|
|
szMachine[0] = 0;
|
|
}
|
|
// get server name from registry
|
|
lStatus = RegSetValueEx (
|
|
hkeyAppInfo,
|
|
(LPTSTR)szServerKey,
|
|
0L,
|
|
REG_SZ,
|
|
(LPBYTE)&szMachine[0],
|
|
(DWORD)(lstrlen(szMachine)*sizeof(TCHAR)));
|
|
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
if (!GetShareFromUnc (szPath, szShare)) {
|
|
szShare[0] = 0;
|
|
}
|
|
|
|
lStatus = RegSetValueEx (
|
|
hkeyAppInfo,
|
|
(LPTSTR)szShareKey,
|
|
0L,
|
|
REG_SZ,
|
|
(LPBYTE)&szShare[0],
|
|
(DWORD)(lstrlen(szShare)*sizeof(TCHAR)));
|
|
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
bReturn = TRUE;
|
|
} else {
|
|
bReturn = FALSE;
|
|
}
|
|
} else {
|
|
bReturn = FALSE;
|
|
}
|
|
|
|
RegCloseKey (hkeyAppInfo);
|
|
}
|
|
RegCloseKey (hkeyUserInfo);
|
|
}
|
|
|
|
bReturn = TRUE;
|
|
} else {
|
|
// not a UNC path so return error
|
|
bReturn = FALSE;
|
|
}
|
|
|
|
FREE_IF_ALLOC (szShare);
|
|
return bReturn;
|
|
|
|
}
|
|
|
|
DWORD
|
|
QuietGetPrivateProfileString (
|
|
IN LPCTSTR lpszSection, /* address of section name */
|
|
IN LPCTSTR lpszKey, /* address of key name */
|
|
IN LPCTSTR lpszDefault, /* address of default string */
|
|
OUT LPTSTR lpszReturnBuffer, /* address of destination buffer */
|
|
IN DWORD cchReturnBuffer, /* size of destination buffer */
|
|
IN LPCTSTR lpszFile /* address of initialization filename */
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Reads data from profile file without triggering OS error message if
|
|
unable to access file.
|
|
|
|
Arguments:
|
|
|
|
IN LPCTSTR lpszSection
|
|
address of section name
|
|
IN LPCTSTR lpszKey
|
|
address of key name
|
|
IN LPCTSTR lpszDefault
|
|
address of default string
|
|
OUT LPTSTR lpszReturnBuffer
|
|
address of destination buffer
|
|
IN DWORD cchReturnBuffer
|
|
size of destination buffer (in characters)
|
|
IN LPCTSTR lpszFile
|
|
address of initialization filename
|
|
|
|
See HELP on GetPrivateProfileString for details on using these arguments.
|
|
|
|
Return Value:
|
|
|
|
number of characters copied into lpszReturnBuffer.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwReturn;
|
|
UINT nErrorMode;
|
|
|
|
// disable windows error message popup
|
|
nErrorMode = SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
|
|
|
|
// call function
|
|
dwReturn = GetPrivateProfileString (
|
|
lpszSection, lpszKey, lpszDefault, lpszReturnBuffer,
|
|
cchReturnBuffer, lpszFile);
|
|
|
|
SetErrorMode (nErrorMode); // restore old error mode
|
|
|
|
return dwReturn;
|
|
}
|
|
|
|
LPCTSTR
|
|
GetKeyFromEntry (
|
|
IN LPCTSTR szEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
copys the "key" from an INF string of the format:
|
|
Key=Value. All text up to, but not including the "="
|
|
is returned.
|
|
|
|
Arguments:
|
|
|
|
IN LPCTSTR szEntry
|
|
line from INF file to process. must be in the format referenced
|
|
above.
|
|
|
|
Return Value:
|
|
|
|
pointer to a read only string that contains the resulting key string.
|
|
|
|
NOTE: this is stored in a static variable and should be copied to a
|
|
local variable for further processing OR before calling this routine
|
|
again.
|
|
|
|
--*/
|
|
{
|
|
static TCHAR szReturnBuffer[MAX_PATH];
|
|
LPTSTR szSource, szDest;
|
|
|
|
szSource = (LPTSTR)szEntry;
|
|
szDest = &szReturnBuffer[0];
|
|
|
|
*szDest = 0;
|
|
|
|
if (*szSource != 0) {
|
|
// copy all chars from start to the equal sign
|
|
// (or the end of the string)
|
|
while ((*szSource != cEqual) && (*szSource != 0)) {
|
|
*szDest++ = *szSource++;
|
|
}
|
|
*szDest = 0; //terminate destination string (key)
|
|
}
|
|
return szReturnBuffer;
|
|
}
|
|
|
|
LPCTSTR
|
|
GetItemFromEntry (
|
|
IN LPCTSTR szEntry,
|
|
IN DWORD dwItem
|
|
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
returns nth item from comma separated list returned from
|
|
inf file. leaves (double)quoted strings intact.
|
|
|
|
Arguments:
|
|
|
|
IN LPCTSTR szEntry
|
|
entry string returned from INF file
|
|
|
|
IN DWORD dwItem
|
|
1-based index indicating which item to return. (i.e. 1= first item
|
|
in list, 2= second, etc.)
|
|
|
|
|
|
Return Value:
|
|
|
|
pointer to buffer containing desired entry in string. Note, this
|
|
routine may only be called 4 times before the string
|
|
buffer is re-used. (i.e. don't use this function more than
|
|
4 times in another function call!!)
|
|
|
|
--*/
|
|
{
|
|
static TCHAR szReturnBuffer[4][MAX_PATH];
|
|
LPTSTR szSource, szDest;
|
|
DWORD dwThisItem;
|
|
static DWORD dwBuff;
|
|
|
|
dwBuff = ++dwBuff % 4; // wrap buffer index
|
|
|
|
szSource = (LPTSTR)szEntry;
|
|
szDest = &szReturnBuffer[dwBuff][0];
|
|
|
|
*szDest = 0;
|
|
|
|
// go past ini key
|
|
while ((*szSource != cEqual) && (*szSource != 0)) szSource++;
|
|
if (*szSource == 0){
|
|
// no equals found so start at beginning
|
|
// presumably this is just the "value"
|
|
szSource = (LPTSTR)szEntry;
|
|
} else {
|
|
szSource++;
|
|
}
|
|
dwThisItem = 1;
|
|
while (dwThisItem < dwItem) {
|
|
if (*szSource != 0) {
|
|
while ((*szSource != cComma) && (*szSource != 0)) {
|
|
if (*szSource == cDoubleQuote) {
|
|
// if this is a quote, then go to the close quote
|
|
szSource++;
|
|
while ((*szSource != cDoubleQuote) && (*szSource != 0)) szSource++;
|
|
}
|
|
if (*szSource != 0) szSource++;
|
|
}
|
|
}
|
|
dwThisItem++;
|
|
if (*szSource != 0) szSource++;
|
|
}
|
|
// copy this entry to the return buffer
|
|
if (*szSource != 0) {
|
|
while ((*szSource != cComma) && (*szSource != 0)) {
|
|
if (*szSource == cDoubleQuote) {
|
|
// if this is a quote, then go to the close quote
|
|
// don't copy quotes!
|
|
szSource++;
|
|
while ((*szSource != cDoubleQuote) && (*szSource != 0)) {
|
|
*szDest++ = *szSource++;
|
|
}
|
|
if (*szSource != 0) szSource++;
|
|
} else {
|
|
*szDest++ = *szSource++;
|
|
}
|
|
}
|
|
*szDest = 0;
|
|
}
|
|
|
|
return &szReturnBuffer[dwBuff][0];
|
|
}
|
|
|
|
LPCTSTR
|
|
GetFileNameFromEntry (
|
|
IN LPCTSTR szEntry
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
returns pointer into szEntry where file name is found.
|
|
first character after the ":"
|
|
|
|
Arguments:
|
|
|
|
string containing filename in format of:
|
|
nn:filename.ext
|
|
|
|
Return Value:
|
|
|
|
returns pointer into szEntry where file name is found.
|
|
first character after the ":"
|
|
returns an empty string if no ":" char was found.
|
|
|
|
--*/
|
|
{
|
|
LPTSTR szReturn;
|
|
szReturn = (LPTSTR)szEntry;
|
|
// go to COLON character
|
|
while ((*szReturn != cColon) && (*szReturn != 0)) szReturn++;
|
|
// scoot to next char
|
|
if (*szReturn != 0) szReturn++;
|
|
return szReturn;
|
|
}
|
|
|
|
BOOL
|
|
TrimSpaces (
|
|
IN OUT LPTSTR szString
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Trims leading and trailing spaces from szString argument, modifying
|
|
the buffer passed in
|
|
|
|
Arguments:
|
|
|
|
IN OUT LPTSTR szString
|
|
buffer to process
|
|
|
|
Return Value:
|
|
|
|
TRUE if string was modified
|
|
FALSE if not
|
|
|
|
--*/
|
|
{
|
|
LPTSTR szSource;
|
|
LPTSTR szDest;
|
|
LPTSTR szLast;
|
|
BOOL bChars;
|
|
|
|
szLast = szSource = szDest = szString;
|
|
bChars = FALSE;
|
|
|
|
while (*szSource != 0) {
|
|
// skip leading non-space chars
|
|
if (*szSource > cSpace) {
|
|
szLast = szDest;
|
|
bChars = TRUE;
|
|
}
|
|
if (bChars) {
|
|
// remember last non-space character
|
|
// copy source to destination & increment both
|
|
*szDest++ = *szSource++;
|
|
} else {
|
|
szSource++;
|
|
}
|
|
}
|
|
|
|
if (bChars) {
|
|
*++szLast = 0; // terminate after last non-space char
|
|
} else {
|
|
// string was all spaces so return an empty (0-len) string
|
|
*szString = 0;
|
|
}
|
|
|
|
return (szLast != szSource);
|
|
}
|
|
|
|
BOOL
|
|
IsUncPath (
|
|
IN LPCTSTR szPath
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
examines path as a string looking for "tell-tale" double
|
|
backslash indicating the machine name syntax of a UNC path
|
|
|
|
Arguments:
|
|
|
|
IN LPCTSTR szPath
|
|
path to examine
|
|
|
|
Return Value:
|
|
|
|
TRUE if \\ found at start of string
|
|
FALSE if not
|
|
|
|
--*/
|
|
{
|
|
LPTSTR szPtChar;
|
|
|
|
szPtChar = (LPTSTR)szPath;
|
|
if (*szPtChar == cBackslash) {
|
|
if (*++szPtChar == cBackslash) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
LPCTSTR
|
|
GetEntryInMultiSz (
|
|
IN LPCTSTR mszList,
|
|
IN DWORD dwEntry
|
|
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Searches for the specified element in the mszList and returns the pointer
|
|
to that element in the list.
|
|
|
|
Arguments:
|
|
|
|
IN LPCTSTR mszList Multi-SZ list to search
|
|
IN DWORD dwEntry 1-based index of entry to return
|
|
|
|
ReturnValue:
|
|
|
|
!=cszEmptyString pointer to matching element in list
|
|
cszEmptyString (pointer to 0-length string) entry is not in list
|
|
--*/
|
|
{
|
|
LPCTSTR szThisString;
|
|
DWORD dwIndex=0;
|
|
|
|
if (mszList == NULL) return (LPCTSTR)cszEmptyString; // no list to process
|
|
if (dwEntry == 0) return (LPCTSTR)cszEmptyString; // no string to find
|
|
|
|
for (szThisString = mszList;
|
|
*szThisString;
|
|
szThisString += (lstrlen(szThisString)+ 1)) {
|
|
dwIndex++;
|
|
if (dwIndex == dwEntry) {
|
|
return szThisString;
|
|
}
|
|
}
|
|
|
|
return (LPCTSTR)cszEmptyString;
|
|
}
|
|
|
|
DWORD
|
|
AddStringToMultiSz (
|
|
LPTSTR OUT mszDest,
|
|
LPCTSTR IN szSource
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
appends the source string to the end of the destination MULTI_SZ
|
|
string. Assumes that the destination is large enough!
|
|
|
|
Arguments:
|
|
|
|
LPTSTR OUT mszDest multi-sz string to be appended
|
|
LPTSTR IN szSource ASCIZ string to be added to the end of the dest
|
|
string
|
|
|
|
ReturnValue:
|
|
|
|
1
|
|
|
|
--*/
|
|
{
|
|
LPTSTR szDestElem;
|
|
|
|
// check function arguments
|
|
|
|
if ((mszDest == NULL) || (szSource == NULL)) return 0; // invalid buffers
|
|
if (*szSource == '\0') return 0; // no string to add
|
|
|
|
// go to end of dest string
|
|
//
|
|
|
|
for (szDestElem = mszDest;
|
|
*szDestElem;
|
|
szDestElem += (lstrlen(szDestElem)+1));
|
|
|
|
// if here, then add string
|
|
// szDestElem is at end of list
|
|
|
|
lstrcpy (szDestElem, szSource);
|
|
szDestElem += (lstrlen(szDestElem) + 1);
|
|
*szDestElem = '\0'; // add second NULL
|
|
|
|
return 1;
|
|
}
|
|
|
|
DWORD
|
|
StringInMultiSz (
|
|
IN LPCTSTR szString,
|
|
IN LPCTSTR mszList
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Searches each element in the mszList and does a case-insensitive
|
|
comparison with the szString argument.
|
|
|
|
Arguments:
|
|
|
|
IN LPCTSTR szString string to find in list
|
|
IN LPCTSTR mszList list to search
|
|
|
|
ReturnValue:
|
|
|
|
>0 szString was found in the list, # returned is the
|
|
index of the matching entry (1= first)
|
|
0 szString was NOT found
|
|
--*/
|
|
{
|
|
LPTSTR szThisString;
|
|
DWORD dwIndex=0;
|
|
|
|
// check input arguments
|
|
|
|
if ((szString == NULL) || (mszList == NULL)) return 0; // invalid buffer
|
|
if (*szString == 0) return 0; // no string to find
|
|
|
|
for (szThisString = (LPTSTR)mszList;
|
|
*szThisString;
|
|
szThisString += (lstrlen(szThisString)+ 1)) {
|
|
dwIndex++;
|
|
if (lstrcmpi(szThisString, szString) == 0) {
|
|
return dwIndex;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
LPCTSTR
|
|
GetStringResource (
|
|
IN UINT nId
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
look up string resource and return string
|
|
|
|
Arguments:
|
|
|
|
IN UINT nId
|
|
Resource ID of string to look up
|
|
|
|
Return Value:
|
|
|
|
pointer to string referenced by ID in arg list
|
|
|
|
--*/
|
|
{
|
|
static TCHAR szBufArray[NUM_BUFS][SMALL_BUFFER_SIZE];
|
|
static DWORD dwIndex;
|
|
LPTSTR szBuffer;
|
|
DWORD dwLength;
|
|
|
|
dwIndex++;
|
|
dwIndex %= NUM_BUFS;
|
|
szBuffer = &szBufArray[dwIndex][0];
|
|
|
|
dwLength = LoadString (
|
|
GetModuleHandle (NULL),
|
|
nId,
|
|
szBuffer,
|
|
SMALL_BUFFER_SIZE);
|
|
|
|
return (LPCTSTR)szBuffer;
|
|
}
|
|
|
|
DWORD
|
|
GetMultiSzLen (
|
|
IN LPCTSTR mszInString
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Counts the number of characters in the multi-sz string (including
|
|
NULL's between strings and terminating NULL char)
|
|
|
|
Arguments:
|
|
|
|
IN LPCTSTR mszInString
|
|
multi-sz string to count
|
|
|
|
Return Value:
|
|
|
|
number of characters in string
|
|
|
|
--*/
|
|
{
|
|
LPCTSTR szEndChar = mszInString;
|
|
BOOL bEnd = FALSE;
|
|
DWORD dwCharsInString = 0;
|
|
|
|
while (!bEnd) {
|
|
if (*szEndChar == 0) {
|
|
// this is the end of a line so adjust the count to
|
|
// account for the crlf being 2 chars
|
|
szEndChar++;
|
|
dwCharsInString += 2;
|
|
|
|
if (*szEndChar == 0) {
|
|
// this is the end of the MSZ
|
|
dwCharsInString++; // for the CTRL-Z
|
|
bEnd = TRUE;
|
|
}
|
|
} else {
|
|
szEndChar++;
|
|
dwCharsInString++;
|
|
}
|
|
}
|
|
|
|
return dwCharsInString;
|
|
}
|
|
|
|
DWORD
|
|
TranslateEscapeChars (
|
|
IN LPTSTR szNewString,
|
|
IN LPTSTR szString
|
|
)
|
|
/*++
|
|
|
|
Translates the following escape sequences if found in the string.
|
|
The translation is performed on szString and written to szNewString.
|
|
|
|
The return value is the length of the resulting string in characters;
|
|
|
|
--*/
|
|
{
|
|
LPTSTR szSource;
|
|
LPTSTR szDest;
|
|
|
|
szSource = szString;
|
|
szDest = szNewString;
|
|
|
|
while (*szSource != 0) {
|
|
if (*szSource == '\\') {
|
|
// this is an escape sequence so go to the next char
|
|
// and see which one.
|
|
szSource++;
|
|
switch (*szSource) {
|
|
case _T('b'):
|
|
*szDest = _T('\b');
|
|
break;
|
|
|
|
case _T('f'):
|
|
*szDest = _T('\f');
|
|
break;
|
|
|
|
case _T('n'):
|
|
*szDest = _T('\n');
|
|
break;
|
|
|
|
case _T('r'):
|
|
*szDest = _T('\r');
|
|
break;
|
|
|
|
case _T('t'):
|
|
*szDest = _T('\t');
|
|
break;
|
|
|
|
case _T('v'):
|
|
*szDest = _T('\v');
|
|
break;
|
|
|
|
case _T('?'):
|
|
*szDest = _T('\?');
|
|
break;
|
|
|
|
case _T('\''):
|
|
*szDest = _T('\'');
|
|
break;
|
|
|
|
case _T('\"'):
|
|
*szDest = _T('\"');
|
|
break;
|
|
|
|
case _T('\\'):
|
|
*szDest = _T('\\');
|
|
break;
|
|
|
|
default:
|
|
*szDest = *szSource;
|
|
break;
|
|
}
|
|
szDest++;
|
|
szSource++;
|
|
} else {
|
|
// just a plain old character so copy it
|
|
*szDest++ = *szSource++;
|
|
}
|
|
}
|
|
return (DWORD)(szDest - szNewString);
|
|
|
|
}
|