Method InterpretEscapedString

src/twparser/parserhelper.cpp:418–521

converts escaped character sequences in strEscapedString into their escape characters in strInterpretedString ( e.g. turns "Hello World!\n" (literal backslash) into "Hello World! " all C++ escape sequences are recognized: (1) octal numbers \012 (1, 2, or 3 octal digits), (2) hex numbers \x2A ( 'x' followed by one or two hex digits ), (3) unicode characters \uABCD ( 'u' followed by exac

//          (4) chars: \t, \v, \b, \r, \f, \a, \\, \?, \', and \"
//          (5) all other escaped chars are treated as if not escaped
void cParserUtil::InterpretEscapedString(const std::string& strEscapedString, TSTRING& strInterpretedString)
{
    cDebug d("cParserHelper::InterpretEscapedString");

    ASSERT((void*)&strEscapedString != (void*)&strInterpretedString); // don't let us read and write to same string

    // The source string may contain literal multibyte characters, escaped MB characters, and escaped Unicode characters.
    // On Unix TCHAR == char always, therefore literal and esacped mb chars can be stored in strInterpretedString
    // directly, and everythign will be hunky dory (escased Unicode will cause an error).
    // But on Windows we need to build an intermediate narrow string because it needs to be passed through
    // cStringUtil::StrToTstr() to convert literal and escaped mb chars to TCHARs (which are wchar_t in this case).
    // Escaped Unicode chars are included in this intermediate string specially encoded so that StrToTstr()
    // leaves it alone.  After we have the wide string, we convert these encoded Unicode chars into true 16 bit
    // Unicode chars.


    // for unix we cheat a bit and do the initial interpretation
    // directly to the final string.
    typedef TCHAR INTERCHAR;
    TSTRING&      strIntermediateString = strInterpretedString;

    const char* pchCur = strEscapedString.c_str();

    for (strIntermediateString.erase(); *pchCur != 0; pchCur++) // only single byte in this part of the policy file
    {
        if (*pchCur != '\\') // just regular char
        {
            strIntermediateString += *pchCur;
        }
        else // deal with escaped character sequence
        {
            // make sure the '\' isn't the end of the string
            // ( if it is, the "for" will ++ pchCur, see it's 0, then break )
            if (*(pchCur + 1))
            {
                int nCharsRead;

                pchCur++; // go to char past '\'

                if (*pchCur == 'x' &&
                    std::isxdigit<TCHAR>(
                        *(pchCur + 1),
                        std::locale())) // deal with \xXXXX where 'x' is the character 'x', and 'X' is a hex number
                {
                    pchCur++; // go to char past 'x'
                    char cEscapedChar = static_cast<char>(util_ConvertHex(pchCur, &nCharsRead));
                    pchCur += (nCharsRead == 0) ? 0 : nCharsRead - 1; //increment pointer to last char we read

                    if (cEscapedChar == 0) // null characters are not allowed
                    {
                        throw eParserBadHex(cStringUtil::StrToTstr(pchCur - ((nCharsRead == 0) ? 0 : nCharsRead - 1)));
                    }
                    else
                    {
                        strIntermediateString += static_cast<INTERCHAR>(cEscapedChar);
                    }
                }
                else if (*pchCur == 'u') // unicode escape