Remove typedefs for MIchar, MIschar, MIuchar.

[brucem]

Summary

This is a start on bringing lldb-mi more in line with the typical
LLDB coding style. This just removes the usage of the typedefs and
doesn't yet clean up any logic or other issues. (This is to keep
the review simple.)

[brucem]

The MI tests pass on Mac OS X with this:

RESULT: PASSED (85 passes, 0 failures, 0 errors, 1 skipped, 3 expected failures, 0 unexpected successes)

No new compilation warnings.

[abidh]

LGTM. Thanks for doing it.

lldb/trunk/tools/lldb-mi/MICmdArgContext.h

public:
     // Overridden:
   public:
     // From CMIUtilString
     /* dtor */ virtual ~CMICmdArgContext(void);
 
     // Attributes:
   private:
     CMIUtilString m_strCmdArgsAndOptions;
-    const MIchar m_constCharSpace;
+    const char m_constCharSpace;
     const CMIUtilString m_constStrSpace;
 };

lldb/trunk/tools/lldb-mi/MICmdArgValFile.cpp

 // Throws:  None.
 //--
 CMIUtilString
 CMICmdArgValFile::GetFileNamePath(const CMIUtilString &vrTxt) const
 {
     CMIUtilString fileNamePath(vrTxt);
 
     // Look for a space in the path
-    const MIchar cSpace = ' ';
+    const char cSpace = ' ';
     const MIint nPos = fileNamePath.find(cSpace);
     if (nPos != (MIint)std::string::npos)
         fileNamePath = CMIUtilString::Format("\"%s\"", fileNamePath.c_str());
 
     return fileNamePath;
 }
 
 //++ ------------------------------------------------------------------------------------

 // Args:    vrText  - (R) The text data to examine.
 // Return:  bool - True = yes valid, false = one or more chars is valid.
 // Throws:  None.
 //--
 bool
 CMICmdArgValFile::IsValidChars(const CMIUtilString &vrText) const
 {
     static CMIUtilString s_strSpecialCharacters(".'\"`@#$%^&*()_+-={}[]| ");
-    const MIchar *pPtr = const_cast<MIchar *>(vrText.c_str());
+    const char *pPtr = const_cast<char *>(vrText.c_str());
     for (MIuint i = 0; i < vrText.length(); i++, pPtr++)
     {
-        const MIchar c = *pPtr;
+        const char c = *pPtr;
         if (::isalnum((int)c) == 0)
         {
             if (s_strSpecialCharacters.find(c) == CMIUtilString::npos)
                 return false;
         }
     }
 
     return true;
 }

lldb/trunk/tools/lldb-mi/MICmdArgValString.cpp

CMICmdArgValString::ValidateQuotedText(CMICmdArgContext &vrwArgContext)
     if (!IsStringArg(rArg))
         return MIstatus::failure;
 
     m_bFound = true;
 
     if (vrwArgContext.RemoveArg(rArg))
     {
         m_bValid = true;
-        const MIchar cQuote = '"';
+        const char cQuote = '"';
         m_argValue = rArg.Trim(cQuote).StripSlashes();
         return MIstatus::success;
     }
 
     return MIstatus::failure;
 }
 
 //++ ------------------------------------------------------------------------------------

 bool
 CMICmdArgValString::IsStringArgQuotedText(const CMIUtilString &vrTxt) const
 {
     // Accept anything as string word
     if (m_bHandleAnything)
         return true;
 
     // CODETAG_QUOTEDTEXT_SIMILAR_CODE
-    const MIchar cQuote = '"';
+    const char cQuote = '"';
     const MIint nPos = vrTxt.find(cQuote);
     if (nPos == (MIint)std::string::npos)
         return false;
 
     // Is one and only quote at end of the string
     if (nPos == (MIint)(vrTxt.length() - 1))
         return false;
 
     // Quote must be the first character in the string or be preceded by a space
     // Also check for embedded string formating quote
-    const MIchar cBckSlash = '\\';
-    const MIchar cSpace = ' ';
+    const char cBckSlash = '\\';
+    const char cSpace = ' ';
     if ((nPos > 1) && (vrTxt[nPos - 1] == cBckSlash) && (vrTxt[nPos - 2] != cSpace))
     {
         return false;
     }
     if ((nPos > 0) && (vrTxt[nPos - 1] != cSpace))
         return false;
 
     // Need to find the other quote

 // Args:    vrTxt   - (R) Some text.
 // Return:  bool    - True = yes valid arg, false = no.
 // Throws:  None.
 //--
 bool
 CMICmdArgValString::IsStringArgQuotedTextEmbedded(const CMIUtilString &vrTxt) const
 {
     // CODETAG_QUOTEDTEXT_SIMILAR_CODE
-    const MIchar cBckSlash = '\\';
+    const char cBckSlash = '\\';
     const MIint nPos = vrTxt.find(cBckSlash);
     if (nPos == (MIint)std::string::npos)
         return false;
 
     // Slash must be the first character in the string or be preceded by a space
-    const MIchar cSpace = ' ';
+    const char cSpace = ' ';
     if ((nPos > 0) && (vrTxt[nPos - 1] != cSpace))
         return false;
 
     // Need to find the other matching slash
     const MIint nPos2 = vrTxt.rfind(cBckSlash);
     if (nPos2 == (MIint)std::string::npos)
         return false;
 

lldb/trunk/tools/lldb-mi/MICmdCmdData.h

public:
     virtual bool Execute(void);
     virtual bool Acknowledge(void);
     virtual bool ParseArgs(void);
     // From CMICmnBase
     /* dtor */ virtual ~CMICmdCmdDataEvaluateExpression(void);
 
     // Methods:
   private:
-    bool HaveInvalidCharacterInExpression(const CMIUtilString &vrExpr, MIchar &vrwInvalidChar);
+    bool HaveInvalidCharacterInExpression(const CMIUtilString &vrExpr, char &vrwInvalidChar);
 
     // Attributes:
   private:
     bool m_bExpressionValid;     // True = yes is valid, false = not valid
     bool m_bEvaluatedExpression; // True = yes is expression evaluated, false = failed
     CMIUtilString m_strValue;
     CMICmnMIValueTuple m_miValueTuple;
     bool m_bCompositeVarType; // True = yes composite type, false = internal type
     bool m_bFoundInvalidChar; // True = yes found unexpected character in the expression, false = all ok
-    MIchar m_cExpressionInvalidChar;
+    char m_cExpressionInvalidChar;
     const CMIUtilString m_constStrArgThread; // Not specified in MI spec but Eclipse gives this option. Not handled by command.
     const CMIUtilString m_constStrArgFrame;  // Not specified in MI spec but Eclipse gives this option. Not handled by command.
     const CMIUtilString m_constStrArgExpr;
 };
 
 //++ ============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "data-disassemble".
public:
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgThread; // Not in the MI spec but implemented by GDB.
     const CMIUtilString m_constStrArgFrame; // Not in the MI spec but implemented by GDB.
     const CMIUtilString m_constStrArgByteOffset;
     const CMIUtilString m_constStrArgAddrExpr;
     const CMIUtilString m_constStrArgNumBytes;
-    MIuchar *m_pBufferMemory;
+    unsigned char *m_pBufferMemory;
     MIuint64 m_nAddrStart;
     MIuint64 m_nAddrNumBytesToRead;
 };
 
 //++ ============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "data-read-memory".
 // Gotchas: None.
private:
     const CMIUtilString m_constStrArgOffset;   // Not specified in MI spec but Eclipse gives this option.
     const CMIUtilString m_constStrArgAddr;     // Not specified in MI spec but Eclipse gives this option.
     const CMIUtilString m_constStrArgD;        // Not specified in MI spec but Eclipse gives this option.
     const CMIUtilString m_constStrArgNumber;   // Not specified in MI spec but Eclipse gives this option.
     const CMIUtilString m_constStrArgContents; // Not specified in MI spec but Eclipse gives this option.
     MIuint64 m_nAddr;
     CMIUtilString m_strContents;
     MIuint64 m_nCount;
-    MIuchar *m_pBufferMemory;
+    unsigned char *m_pBufferMemory;
 };
 
 //++ ============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "data-info-line".
 //          See MIExtensions.txt for details.
 //--
 class CMICmdCmdDataInfoLine : public CMICmdBase

lldb/trunk/tools/lldb-mi/MICmdCmdData.cpp

 // Details: Examine the expression string to see if it contains invalid characters.
 // Type:    Method.
 // Args:    vrExpr          - (R) Expression string given to *this command.
 //          vrwInvalidChar  - (W) True = Invalid character found, false = nothing found.
 // Return:  bool - True = Invalid character found, false = nothing found.
 // Throws:  None.
 //--
 bool
-CMICmdCmdDataEvaluateExpression::HaveInvalidCharacterInExpression(const CMIUtilString &vrExpr, MIchar &vrwInvalidChar)
+CMICmdCmdDataEvaluateExpression::HaveInvalidCharacterInExpression(const CMIUtilString &vrExpr, char &vrwInvalidChar)
 {
     static const std::string strInvalidCharacters(";#\\");
     const size_t nInvalidCharacterOffset = vrExpr.find_first_of(strInvalidCharacters);
     const bool bFoundInvalidCharInExpression = (nInvalidCharacterOffset != CMIUtilString::npos);
     vrwInvalidChar = bFoundInvalidCharInExpression ? vrExpr[nInvalidCharacterOffset] : 0x00;
     return bFoundInvalidCharInExpression;
 }
 
CMICmdCmdDataDisassemble::Execute(void)
     const MIuint nInstructions = instructions.GetSize();
     // Calculate the offset of first instruction so that we can generate offset starting at 0
     lldb::addr_t start_offset = 0;
     if(nInstructions > 0)
         start_offset = instructions.GetInstructionAtIndex(0).GetAddress().GetOffset();
 
     for (size_t i = 0; i < nInstructions; i++)
     {
-        const MIchar *pUnknown = "??";
+        const char *pUnknown = "??";
         lldb::SBInstruction instrt = instructions.GetInstructionAtIndex(i);
-        const MIchar *pStrMnemonic = instrt.GetMnemonic(sbTarget);
+        const char *pStrMnemonic = instrt.GetMnemonic(sbTarget);
         pStrMnemonic = (pStrMnemonic != nullptr) ? pStrMnemonic : pUnknown;
-        const MIchar *pStrComment = instrt.GetComment(sbTarget);
+        const char *pStrComment = instrt.GetComment(sbTarget);
         CMIUtilString strComment;
         if (pStrComment != nullptr && *pStrComment != '\0')
             strComment = CMIUtilString::Format("; %s", pStrComment);
         lldb::SBAddress address = instrt.GetAddress();
         lldb::addr_t addr = address.GetLoadAddress(sbTarget);
-        const MIchar *pFnName = address.GetFunction().GetName();
+        const char *pFnName = address.GetFunction().GetName();
         pFnName = (pFnName != nullptr) ? pFnName : pUnknown;
         lldb::addr_t addrOffSet = address.GetOffset() - start_offset;
-        const MIchar *pStrOperands = instrt.GetOperands(sbTarget);
+        const char *pStrOperands = instrt.GetOperands(sbTarget);
         pStrOperands = (pStrOperands != nullptr) ? pStrOperands : pUnknown;
         const size_t instrtSize = instrt.GetByteSize();
 
         // MI "{address=\"0x%016" PRIx64 "\",func-name=\"%s\",offset=\"%lld\",inst=\"%s %s\"}"
         const CMICmnMIValueConst miValueConst(CMIUtilString::Format("0x%016" PRIx64, addr));
         const CMICmnMIValueResult miValueResult("address", miValueConst);
         CMICmnMIValueTuple miValueTuple(miValueResult);
         const CMICmnMIValueConst miValueConst2(pFnName);
         const CMICmnMIValueResult miValueResult2("func-name", miValueConst2);
         miValueTuple.Add(miValueResult2);
         const CMICmnMIValueConst miValueConst3(CMIUtilString::Format("%lld", addrOffSet));
         const CMICmnMIValueResult miValueResult3("offset", miValueConst3);
         miValueTuple.Add(miValueResult3);
         const CMICmnMIValueConst miValueConst4(CMIUtilString::Format("%d", instrtSize));
         const CMICmnMIValueResult miValueResult4("size", miValueConst4);
         miValueTuple.Add(miValueResult4);
         const CMICmnMIValueConst miValueConst5(CMIUtilString::Format("%s %s%s", pStrMnemonic, pStrOperands, strComment.Escape(true).c_str()));
         const CMICmnMIValueResult miValueResult5("inst", miValueConst5);
         miValueTuple.Add(miValueResult5);
 
         if (nDisasmMode == 1)
         {
             lldb::SBLineEntry lineEntry = address.GetLineEntry();
             const MIuint nLine = lineEntry.GetLine();
-            const MIchar *pFileName = lineEntry.GetFileSpec().GetFilename();
+            const char *pFileName = lineEntry.GetFileSpec().GetFilename();
             pFileName = (pFileName != nullptr) ? pFileName : pUnknown;
 
             // MI "src_and_asm_line={line=\"%u\",file=\"%s\",line_asm_insn=[ ]}"
             const CMICmnMIValueConst miValueConst(CMIUtilString::Format("0x%u", nLine));
             const CMICmnMIValueResult miValueResult("line", miValueConst);
             CMICmnMIValueTuple miValueTuple2(miValueResult);
             const CMICmnMIValueConst miValueConst2(pFileName);
             const CMICmnMIValueResult miValueResult2("file", miValueConst2);
CMICmdCmdDataReadMemoryBytes::Execute(void)
     {
         SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_EXPR_INVALID), rAddrExpr.c_str()));
         return MIstatus::failure;
     }
 
     nAddrStart += nAddrOffset;
     const MIuint64 nAddrNumBytes = pArgNumBytes->GetValue();
 
-    m_pBufferMemory = new MIuchar[nAddrNumBytes];
+    m_pBufferMemory = new unsigned char[nAddrNumBytes];
     if (m_pBufferMemory == nullptr)
     {
         SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_MEMORY_ALLOC_FAILURE), m_cmdData.strMiCmd.c_str(), nAddrNumBytes));
         return MIstatus::failure;
     }
 
     const MIuint64 nReadBytes = sbProcess.ReadMemory(static_cast<lldb::addr_t>(nAddrStart), (void *)m_pBufferMemory, nAddrNumBytes, error);
     if (nReadBytes != nAddrNumBytes)
CMICmdCmdDataWriteMemory::Execute(void)
     {
         SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ARGS_ERR_VALIDATION_INVALID), m_cmdData.strMiCmd.c_str(), m_constStrArgAddr.c_str()));
         return MIstatus::failure;
     }
     m_nAddr = pArgAddr->GetValue();
     m_nCount = pArgNumber->GetValue();
     const MIuint64 nValue = pArgContents->GetValue();
 
-    m_pBufferMemory = new MIuchar[m_nCount];
+    m_pBufferMemory = new unsigned char[m_nCount];
     if (m_pBufferMemory == nullptr)
     {
         SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_MEMORY_ALLOC_FAILURE), m_cmdData.strMiCmd.c_str(), m_nCount));
         return MIstatus::failure;
     }
-    *m_pBufferMemory = static_cast<MIchar>(nValue);
+    *m_pBufferMemory = static_cast<char>(nValue);
 
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
     lldb::SBProcess sbProcess = rSessionInfo.GetProcess();
     lldb::SBError error;
     lldb::addr_t addr = static_cast<lldb::addr_t>(m_nAddr + nAddrOffset);
     const size_t nBytesWritten = sbProcess.WriteMemory(addr, (const void *)m_pBufferMemory, (size_t)m_nCount, error);
     if (nBytesWritten != static_cast<size_t>(m_nCount))
     {

lldb/trunk/tools/lldb-mi/MICmdCmdExec.cpp

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdExecContinue::Execute(void)
 {
-    const MIchar *pCmd = "continue";
+    const char *pCmd = "continue";
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
     const lldb::ReturnStatus rtn = rSessionInfo.GetDebugger().GetCommandInterpreter().HandleCommand(pCmd, m_lldbResult);
     MIunused(rtn);
 
     if (m_lldbResult.GetErrorSize() == 0)
     {
         // CODETAG_DEBUG_SESSION_RUNNING_PROG_RECEIVED_SIGINT_PAUSE_PROGRAM
         if (!CMIDriver::Instance().SetDriverStateRunningDebugging())
         {
             const CMIUtilString &rErrMsg(CMIDriver::Instance().GetErrorDescription());
             SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_SET_NEW_DRIVER_STATE), m_cmdData.strMiCmd.c_str(), rErrMsg.c_str()));
             return MIstatus::failure;
         }
     }
     else
     {
         // ToDo: Re-evaluate if this is required when application near finished as this is parsing LLDB error message
         // which seems a hack and is code brittle
-        const MIchar *pLldbErr = m_lldbResult.GetError();
+        const char *pLldbErr = m_lldbResult.GetError();
         const CMIUtilString strLldbMsg(CMIUtilString(pLldbErr).StripCREndOfLine());
         if (strLldbMsg == "error: Process must be launched.")
         {
             CMIDriver::Instance().SetExitApplicationFlag(true);
         }
     }
 
     return MIstatus::success;

 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdExecNext::Acknowledge(void)
 {
     if (m_lldbResult.GetErrorSize() > 0)
     {
-        const MIchar *pLldbErr = m_lldbResult.GetError();
+        const char *pLldbErr = m_lldbResult.GetError();
         MIunused(pLldbErr);
         const CMICmnMIValueConst miValueConst(m_lldbResult.GetError());
         const CMICmnMIValueResult miValueResult("message", miValueConst);
         const CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error, miValueResult);
         m_miResultRecord = miRecordResult;
     }
     else
     {

 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdExecStep::Acknowledge(void)
 {
     if (m_lldbResult.GetErrorSize() > 0)
     {
-        const MIchar *pLldbErr = m_lldbResult.GetError();
+        const char *pLldbErr = m_lldbResult.GetError();
         MIunused(pLldbErr);
         const CMICmnMIValueConst miValueConst(m_lldbResult.GetError());
         const CMICmnMIValueResult miValueResult("message", miValueConst);
         const CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error, miValueResult);
         m_miResultRecord = miRecordResult;
     }
     else
     {

 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdExecNextInstruction::Acknowledge(void)
 {
     if (m_lldbResult.GetErrorSize() > 0)
     {
-        const MIchar *pLldbErr = m_lldbResult.GetError();
+        const char *pLldbErr = m_lldbResult.GetError();
         MIunused(pLldbErr);
         const CMICmnMIValueConst miValueConst(m_lldbResult.GetError());
         const CMICmnMIValueResult miValueResult("message", miValueConst);
         const CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error, miValueResult);
         m_miResultRecord = miRecordResult;
     }
     else
     {

 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdExecStepInstruction::Acknowledge(void)
 {
     if (m_lldbResult.GetErrorSize() > 0)
     {
-        const MIchar *pLldbErr = m_lldbResult.GetError();
+        const char *pLldbErr = m_lldbResult.GetError();
         MIunused(pLldbErr);
         const CMICmnMIValueConst miValueConst(m_lldbResult.GetError());
         const CMICmnMIValueResult miValueResult("message", miValueConst);
         const CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error, miValueResult);
         m_miResultRecord = miRecordResult;
     }
     else
     {

 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdExecFinish::Acknowledge(void)
 {
     if (m_lldbResult.GetErrorSize() > 0)
     {
-        const MIchar *pLldbErr = m_lldbResult.GetError();
+        const char *pLldbErr = m_lldbResult.GetError();
         MIunused(pLldbErr);
         const CMICmnMIValueConst miValueConst(m_lldbResult.GetError());
         const CMICmnMIValueResult miValueResult("message", miValueConst);
         const CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error, miValueResult);
         m_miResultRecord = miRecordResult;
     }
     else
     {

lldb/trunk/tools/lldb-mi/MICmdCmdFile.cpp

CMICmdCmdFileExecAndSymbols::Execute(void)
     CMIUtilString platformName;
     if (bPlatformName)
     {
         pArgPlatformName->GetExpectedOption<CMICmdArgValString, CMIUtilString>(platformName);
     }
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
     lldb::SBDebugger &rDbgr = rSessionInfo.GetDebugger();
     lldb::SBError error;
-    const MIchar *pTargetTriple = nullptr; // Let LLDB discover the triple required
-    const MIchar *pTargetPlatformName = platformName.c_str();
+    const char *pTargetTriple = nullptr; // Let LLDB discover the triple required
+    const char *pTargetPlatformName = platformName.c_str();
     const bool bAddDepModules = false;
     lldb::SBTarget target = rDbgr.CreateTarget(strExeFilePath.c_str(), pTargetTriple, pTargetPlatformName, bAddDepModules, error);
     CMIUtilString strWkDir;
     const CMIUtilString &rStrKeyWkDir(rSessionInfo.m_constStrSharedDataKeyWkDir);
     if (!rSessionInfo.SharedDataRetrieve<CMIUtilString>(rStrKeyWkDir, strWkDir))
     {
         strWkDir = CMIUtilFileStd::StripOffFileName(strExeFilePath);
         if (!rSessionInfo.SharedDataAdd<CMIUtilString>(rStrKeyWkDir, strWkDir))

lldb/trunk/tools/lldb-mi/MICmdCmdMiscellanous.cpp

if (!m_bIsI1)
             const CMICmnMIValueConst miValueConst3(strPid);
             const CMICmnMIValueResult miValueResult3("pid", miValueConst3);
             miTuple.Add(miValueResult3);
         }
 
         if (rSessionInfo.GetTarget().IsValid())
         {
             lldb::SBTarget sbTrgt = rSessionInfo.GetTarget();
-            const MIchar *pDir = sbTrgt.GetExecutable().GetDirectory();
-            const MIchar *pFileName = sbTrgt.GetExecutable().GetFilename();
+            const char *pDir = sbTrgt.GetExecutable().GetDirectory();
+            const char *pFileName = sbTrgt.GetExecutable().GetFilename();
             const CMIUtilString strFile(CMIUtilString::Format("%s/%s", pDir, pFileName));
             const CMICmnMIValueConst miValueConst4(strFile);
             const CMICmnMIValueResult miValueResult4("executable", miValueConst4);
             miTuple.Add(miValueResult4);
         }
 
         const CMICmnMIValueList miValueList(miTuple);
         const CMICmnMIValueResult miValueResult5("groups", miValueList);

lldb/trunk/tools/lldb-mi/MICmdCmdSymbol.cpp

 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdSymbolListLines::Acknowledge(void)
 {
     if (m_lldbResult.GetErrorSize() > 0)
     {
-        const MIchar *pLldbErr = m_lldbResult.GetError();
+        const char *pLldbErr = m_lldbResult.GetError();
         const CMIUtilString strMsg(CMIUtilString(pLldbErr).StripCRAll());
         const CMICmnMIValueConst miValueConst(strMsg);
         const CMICmnMIValueResult miValueResult("message", miValueConst);
         const CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error, miValueResult);
         m_miResultRecord = miRecordResult;
     }
     else
     {

lldb/trunk/tools/lldb-mi/MICmdCmdTarget.cpp

if (rRemoteType != "remote")
         SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_INVALID_TARGET_TYPE), m_cmdData.strMiCmd.c_str(), rRemoteType.c_str()));
         return MIstatus::failure;
     }
 
     // Create a URL pointing to the remote gdb stub
     const CMIUtilString strUrl = CMIUtilString::Format("connect://%s", pArgParameters->GetValue().c_str());
 
     // Ask LLDB to collect to the target port
-    const MIchar *pPlugin("gdb-remote");
+    const char *pPlugin("gdb-remote");
     lldb::SBError error;
     lldb::SBProcess process = rSessionInfo.GetTarget().ConnectRemote(rSessionInfo.GetListener(), strUrl.c_str(), pPlugin, error);
 
     // Verify that we have managed to connect successfully
     lldb::SBStream errMsg;
     if (!process.IsValid())
     {
         SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_INVALID_TARGET_PLUGIN), m_cmdData.strMiCmd.c_str(), errMsg.GetData()));

lldb/trunk/tools/lldb-mi/MICmdCmdVar.h

public:
     // Overridden:
   public:
     // From CMICmnBase
     /* dtor */ virtual ~CMICmdCmdVarUpdate(void);
 
     // Methods:
   private:
     bool ExamineSBValueForChange(lldb::SBValue &vrwValue, bool &vrwbChanged);
-    bool MIFormResponse(const CMIUtilString &vrStrVarName, const MIchar *const vpValue, const CMIUtilString &vrStrScope);
+    bool MIFormResponse(const CMIUtilString &vrStrVarName, const char *const vpValue, const CMIUtilString &vrStrScope);
 
     // Attribute:
   private:
     const CMIUtilString m_constStrArgPrintValues;
     const CMIUtilString m_constStrArgName;
     bool m_bValueChanged; // True = yes value changed, false = no change
     CMICmnMIValueList m_miValueList;
 };

lldb/trunk/tools/lldb-mi/MICmdCmdVar.cpp

 // Args:    vrStrVarName    - (R)   Session var object's name.
 //          vpValue         - (R)   Text version of the value held in the variable.
 //          vrStrScope      - (R)   In scope "yes" or "no".
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
-CMICmdCmdVarUpdate::MIFormResponse(const CMIUtilString &vrStrVarName, const MIchar *const vpValue, const CMIUtilString &vrStrScope)
+CMICmdCmdVarUpdate::MIFormResponse(const CMIUtilString &vrStrVarName, const char *const vpValue, const CMIUtilString &vrStrScope)
 {
     // MI print "[{name=\"%s\",value=\"%s\",in_scope=\"%s\",type_changed=\"false\",has_more=\"0\"}]"
     const CMICmnMIValueConst miValueConst(vrStrVarName);
     const CMICmnMIValueResult miValueResult("name", miValueConst);
     CMICmnMIValueTuple miValueTuple(miValueResult);
     bool bOk = true;
     if (vpValue != nullptr)
     {
CMICmdCmdVarInfoPathExpression::Execute(void)
 
     lldb::SBStream stream;
     if (!rValue.GetExpressionPath(stream, true))
     {
         SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_VARIABLE_EXPRESSIONPATH), m_cmdData.strMiCmd.c_str(), rVarObjName.c_str()));
         return MIstatus::failure;
     }
 
-    const MIchar *pPathExpression = stream.GetData();
+    const char *pPathExpression = stream.GetData();
     if (pPathExpression == nullptr)
     {
         // Build expression from what we do know
         m_strPathExpression = varObj.GetNameReal();
         return MIstatus::success;
     }
 
     // Has LLDB returned a var signature of it's own

lldb/trunk/tools/lldb-mi/MICmdInterpreter.cpp

 // Type:    Method.
 // Args:    vTextLine   - (R) Text data to interpret.
 // Return:  bool  - True = yes command token present, false = command not recognised.
 // Throws:  None.
 //--
 bool
 CMICmdInterpreter::MiHasCmdTokenEndingAlpha(const CMIUtilString &vTextLine)
 {
-    MIchar cChar = vTextLine[0];
+    char cChar = vTextLine[0];
     MIuint i = 0;
     while (::isdigit(cChar) != 0)
     {
         cChar = vTextLine[++i];
     }
     if (::isalpha(cChar) == 0)
         return false;
     if (i == 0)

lldb/trunk/tools/lldb-mi/MICmnLLDBDebugSessionInfo.cpp

CMICmnLLDBDebugSessionInfo::MIResponseFormThreadInfo(const SMICmdData &vCmdData, const lldb::SBThread &vrThread,
     // Add "id"
     const CMIUtilString strId(CMIUtilString::Format("%d", rThread.GetIndexID()));
     const CMICmnMIValueConst miValueConst1(strId);
     const CMICmnMIValueResult miValueResult1("id", miValueConst1);
     if (!vwrMIValueTuple.Add(miValueResult1))
         return MIstatus::failure;
 
     // Add "target-id"
-    const MIchar *pThreadName = rThread.GetName();
+    const char *pThreadName = rThread.GetName();
     const MIuint len = (pThreadName != nullptr) ? CMIUtilString(pThreadName).length() : 0;
     const bool bHaveName = ((pThreadName != nullptr) && (len > 0) && (len < 32) &&
                             CMIUtilString::IsAllValidAlphaAndNumeric(pThreadName)); // 32 is arbitary number
-    const MIchar *pThrdFmt = bHaveName ? "%s" : "Thread %d";
+    const char *pThrdFmt = bHaveName ? "%s" : "Thread %d";
     CMIUtilString strThread;
     if (bHaveName)
         strThread = CMIUtilString::Format(pThrdFmt, pThreadName);
     else
         strThread = CMIUtilString::Format(pThrdFmt, rThread.GetIndexID());
     const CMICmnMIValueConst miValueConst2(strThread);
     const CMICmnMIValueResult miValueResult2("target-id", miValueConst2);
     if (!vwrMIValueTuple.Add(miValueResult2))
CMICmnLLDBDebugSessionInfo::GetFrameInfo(const lldb::SBFrame &vrFrame, lldb::addr_t &vwPc, CMIUtilString &vwFnName,
                                          CMIUtilString &vwFileName, CMIUtilString &vwPath, MIuint &vwnLine)
 {
     lldb::SBFrame &rFrame = const_cast<lldb::SBFrame &>(vrFrame);
 
     static char pBuffer[MAX_PATH];
     const MIuint nBytes = rFrame.GetLineEntry().GetFileSpec().GetPath(&pBuffer[0], sizeof(pBuffer));
     MIunused(nBytes);
     CMIUtilString strResolvedPath(&pBuffer[0]);
-    const MIchar *pUnkwn = "??";
+    const char *pUnkwn = "??";
     if (!ResolvePath(pUnkwn, strResolvedPath))
         return MIstatus::failure;
     vwPath = strResolvedPath;
 
     vwPc = rFrame.GetPC();
 
-    const MIchar *pFnName = rFrame.GetFunctionName();
+    const char *pFnName = rFrame.GetFunctionName();
     vwFnName = (pFnName != nullptr) ? pFnName : pUnkwn;
 
-    const MIchar *pFileName = rFrame.GetLineEntry().GetFileSpec().GetFilename();
+    const char *pFileName = rFrame.GetLineEntry().GetFileSpec().GetFilename();
     vwFileName = (pFileName != nullptr) ? pFileName : pUnkwn;
 
     vwnLine = rFrame.GetLineEntry().GetLine();
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------

 //--
 bool
 CMICmnLLDBDebugSessionInfo::GetBrkPtInfo(const lldb::SBBreakpoint &vBrkPt, SBrkPtInfo &vrwBrkPtInfo) const
 {
     lldb::SBBreakpoint &rBrkPt = const_cast<lldb::SBBreakpoint &>(vBrkPt);
     lldb::SBBreakpointLocation brkPtLoc = rBrkPt.GetLocationAtIndex(0);
     lldb::SBAddress brkPtAddr = brkPtLoc.GetAddress();
     lldb::SBSymbolContext symbolCntxt = brkPtAddr.GetSymbolContext(lldb::eSymbolContextEverything);
-    const MIchar *pUnkwn = "??";
+    const char *pUnkwn = "??";
     lldb::SBModule rModule = symbolCntxt.GetModule();
-    const MIchar *pModule = rModule.IsValid() ? rModule.GetFileSpec().GetFilename() : pUnkwn;
+    const char *pModule = rModule.IsValid() ? rModule.GetFileSpec().GetFilename() : pUnkwn;
     MIunused(pModule);
-    const MIchar *pFile = pUnkwn;
-    const MIchar *pFn = pUnkwn;
-    const MIchar *pFilePath = pUnkwn;
+    const char *pFile = pUnkwn;
+    const char *pFn = pUnkwn;
+    const char *pFilePath = pUnkwn;
     size_t nLine = 0;
     lldb::addr_t nAddr = brkPtAddr.GetLoadAddress(GetTarget());
     if (nAddr == LLDB_INVALID_ADDRESS)
         nAddr = brkPtAddr.GetFileAddress();
 
     lldb::SBCompileUnit rCmplUnit = symbolCntxt.GetCompileUnit();
     if (rCmplUnit.IsValid())
     {

lldb/trunk/tools/lldb-mi/MICmnLLDBDebugSessionInfoVarObj.h

enum varType_e
         eVarType_Composite, // i.e. struct
         eVarType_Internal,  // i.e. int
         eVarType_count      // Always last one
     };
 
     // Statics:
   public:
     static varFormat_e GetVarFormatForString(const CMIUtilString &vrStrFormat);
-    static varFormat_e GetVarFormatForChar(const MIchar &vrcFormat);
+    static varFormat_e GetVarFormatForChar(const char &vrcFormat);
     static CMIUtilString GetValueStringFormatted(const lldb::SBValue &vrValue, const varFormat_e veVarFormat);
     static void VarObjAdd(const CMICmnLLDBDebugSessionInfoVarObj &vrVarObj);
     static void VarObjDelete(const CMIUtilString &vrVarName);
     static bool VarObjGet(const CMIUtilString &vrVarName, CMICmnLLDBDebugSessionInfoVarObj &vrwVarObj);
     static void VarObjUpdate(const CMICmnLLDBDebugSessionInfoVarObj &vrVarObj);
     static void VarObjIdInc(void);
     static MIuint VarObjIdGet(void);
     static void VarObjIdResetToZero(void);
public:
 
     // Typedefs:
   private:
     typedef std::map<CMIUtilString, CMICmnLLDBDebugSessionInfoVarObj> MapKeyToVarObj_t;
     typedef std::pair<CMIUtilString, CMICmnLLDBDebugSessionInfoVarObj> MapPairKeyToVarObj_t;
 
     // Statics:
   private:
-    static CMIUtilString GetStringFormatted(const MIuint64 vnValue, const MIchar *vpStrValueNatural, varFormat_e veVarFormat);
+    static CMIUtilString GetStringFormatted(const MIuint64 vnValue, const char *vpStrValueNatural, varFormat_e veVarFormat);
 
     // Methods:
   private:
     bool CopyOther(const CMICmnLLDBDebugSessionInfoVarObj &vrOther);
     bool MoveOther(CMICmnLLDBDebugSessionInfoVarObj &vrwOther);
 
     // Attributes:
   private:
-    static const MIchar *ms_aVarFormatStrings[];
-    static const MIchar *ms_aVarFormatChars[];
+    static const char *ms_aVarFormatStrings[];
+    static const char *ms_aVarFormatChars[];
     static MapKeyToVarObj_t ms_mapVarIdToVarObj;
     static MIuint ms_nVarUniqueId;
     static varFormat_e ms_eDefaultFormat;    // overrides "natural" format
     //
     // *** Upate the copy move constructors and assignment operator ***
     varFormat_e m_eVarFormat;
     varType_e m_eVarType;
     CMIUtilString m_strName;
     lldb::SBValue m_SBValue;
     CMIUtilString m_strNameReal;
     CMIUtilString m_strFormattedValue;
     CMIUtilString m_strVarObjParentName;
     // *** Upate the copy move constructors and assignment operator ***
 };

lldb/trunk/tools/lldb-mi/MICmnLLDBDebugSessionInfoVarObj.cpp

 //===-- MICmnLLDBDebugSessionInfoVarObj.cpp ---------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // In-house headers:
 #include "MICmnLLDBDebugSessionInfoVarObj.h"
 #include "MICmnLLDBProxySBValue.h"
 #include "MICmnLLDBUtilSBValue.h"
 
 // Instantiations:
-const MIchar *CMICmnLLDBDebugSessionInfoVarObj::ms_aVarFormatStrings[] = {
+const char *CMICmnLLDBDebugSessionInfoVarObj::ms_aVarFormatStrings[] = {
     // CODETAG_SESSIONINFO_VARFORMAT_ENUM
     // *** Order is import here.
     "<Invalid var format>", "binary", "octal", "decimal", "hexadecimal", "natural"};
-const MIchar *CMICmnLLDBDebugSessionInfoVarObj::ms_aVarFormatChars[] = {
+const char *CMICmnLLDBDebugSessionInfoVarObj::ms_aVarFormatChars[] = {
     // CODETAG_SESSIONINFO_VARFORMAT_ENUM
     // *** Order is import here.
     "<Invalid var format>", "t", "o", "d", "x", "N"};
 CMICmnLLDBDebugSessionInfoVarObj::MapKeyToVarObj_t CMICmnLLDBDebugSessionInfoVarObj::ms_mapVarIdToVarObj;
 MIuint CMICmnLLDBDebugSessionInfoVarObj::ms_nVarUniqueId = 0; // Index from 0
 CMICmnLLDBDebugSessionInfoVarObj::varFormat_e CMICmnLLDBDebugSessionInfoVarObj::ms_eDefaultFormat = eVarFormat_Natural;
 
 //++ ------------------------------------------------------------------------------------

 // Throws:  None.
 //--
 CMICmnLLDBDebugSessionInfoVarObj::varFormat_e
 CMICmnLLDBDebugSessionInfoVarObj::GetVarFormatForString(const CMIUtilString &vrStrFormat)
 {
     // CODETAG_SESSIONINFO_VARFORMAT_ENUM
     for (MIuint i = 0; i < eVarFormat_count; i++)
     {
-        const MIchar *pVarFormatString = ms_aVarFormatStrings[i];
+        const char *pVarFormatString = ms_aVarFormatStrings[i];
         if (vrStrFormat == pVarFormatString)
             return static_cast<varFormat_e>(i);
     }
 
     return eVarFormat_Invalid;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve the var format enumeration for the specified character.
 // Type:    Static method.
 // Args:    vrcFormat   - (R) Character representing the var format.
 // Return:  varFormat_e - Var format enumeration.
 //                      - No match found return eVarFormat_Invalid.
 // Throws:  None.
 //--
 CMICmnLLDBDebugSessionInfoVarObj::varFormat_e
-CMICmnLLDBDebugSessionInfoVarObj::GetVarFormatForChar(const MIchar &vrcFormat)
+CMICmnLLDBDebugSessionInfoVarObj::GetVarFormatForChar(const char &vrcFormat)
 {
     if ('r' == vrcFormat)
         return eVarFormat_Hex;
 
     // CODETAG_SESSIONINFO_VARFORMAT_ENUM
     for (MIuint i = 0; i < eVarFormat_count; i++)
     {
-        const MIchar *pVarFormatChar = ms_aVarFormatChars[i];
+        const char *pVarFormatChar = ms_aVarFormatChars[i];
         if (*pVarFormatChar == vrcFormat)
             return static_cast<varFormat_e>(i);
     }
 
     return eVarFormat_Invalid;
 }
 
 //++ ------------------------------------------------------------------------------------

 // Type:    Static method.
 // Args:    vnValue             - (R) The number value to get formatted.
 //          vpStrValueNatural   - (R) The natural representation of the number value.
 //          veVarFormat         - (R) Var format enumeration.
 // Returns: CMIUtilString       - Numerical formatted string.
 // Throws:  None.
 //--
 CMIUtilString
-CMICmnLLDBDebugSessionInfoVarObj::GetStringFormatted(const MIuint64 vnValue, const MIchar *vpStrValueNatural,
+CMICmnLLDBDebugSessionInfoVarObj::GetStringFormatted(const MIuint64 vnValue, const char *vpStrValueNatural,
                                                      const CMICmnLLDBDebugSessionInfoVarObj::varFormat_e veVarFormat)
 {
     CMIUtilString strFormattedValue;
     CMICmnLLDBDebugSessionInfoVarObj::varFormat_e veFormat = veVarFormat;
     if (ms_eDefaultFormat != eVarFormat_Invalid && veVarFormat == eVarFormat_Natural)
     {
         veFormat = ms_eDefaultFormat;
     }

lldb/trunk/tools/lldb-mi/MICmnLLDBDebugger.cpp

 {
     MIuint existingMask = 0;
     if (!BroadcasterGetMask(vBroadcasterClass, existingMask))
         return MIstatus::failure;
 
     if (!ClientSaveMask(vClientName, vBroadcasterClass, vEventMask))
         return MIstatus::failure;
 
-    const MIchar *pBroadCasterName = vBroadcasterClass.c_str();
+    const char *pBroadCasterName = vBroadcasterClass.c_str();
     MIuint eventMask = vEventMask;
     eventMask += existingMask;
     const MIuint result = m_lldbListener.StartListeningForEventClass(m_lldbDebugger, pBroadCasterName, eventMask);
     if (result == 0)
     {
         SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_LLDBDEBUGGER_ERR_STARTLISTENER), pBroadCasterName));
         return MIstatus::failure;
     }

 //          vEventMask      - (R) The mask of events to listen for.
 // Return:  MIstatus::success - Functionality succeeded.
 //          MIstatus::failure - Functionality failed.
 // Throws:  None.
 //--
 bool
 CMICmnLLDBDebugger::RegisterForEvent(const CMIUtilString &vClientName, const lldb::SBBroadcaster &vBroadcaster, const MIuint vEventMask)
 {
-    const MIchar *pBroadcasterName = vBroadcaster.GetName();
+    const char *pBroadcasterName = vBroadcaster.GetName();
     if (pBroadcasterName == nullptr)
     {
         SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_LLDBDEBUGGER_ERR_BROARDCASTER_NAME), MIRSRC(IDS_WORD_INVALIDNULLPTR)));
         return MIstatus::failure;
     }
     CMIUtilString broadcasterName(pBroadcasterName);
     if (broadcasterName.length() == 0)
     {
for (MIuint i = 0; i < 32; i++)
         const MIuint clientBit = bit & clientsEventMask;
         const MIuint othersBit = bit & otherClientsEventMask;
         if ((clientBit != 0) && (othersBit == 0))
         {
             newEventMask += clientBit;
         }
     }
 
-    const MIchar *pBroadCasterName = vBroadcasterClass.c_str();
+    const char *pBroadCasterName = vBroadcasterClass.c_str();
     if (!m_lldbListener.StopListeningForEventClass(m_lldbDebugger, pBroadCasterName, newEventMask))
     {
         SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_LLDBDEBUGGER_ERR_STOPLISTENER), vClientName.c_str(), pBroadCasterName));
         return MIstatus::failure;
     }
 
     return BroadcasterSaveMask(vBroadcasterClass, otherClientsEventMask);
 }

lldb/trunk/tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.cpp

 //          MIstatus::failure - Functionality failed.
 // Throws:  None.
 //--
 bool
 CMICmnLLDBDebuggerHandleEvents::HandleEventSBProcess(const lldb::SBEvent &vEvent)
 {
     bool bOk = MIstatus::success;
 
-    const MIchar *pEventType = "";
+    const char *pEventType = "";
     const MIuint nEventType = vEvent.GetType();
     switch (nEventType)
     {
         case lldb::SBProcess::eBroadcastBitInterrupt:
             pEventType = "eBroadcastBitInterrupt";
             break;
         case lldb::SBProcess::eBroadcastBitProfileData:
             pEventType = "eBroadcastBitProfileData";

 //          MIstatus::failure - Functionality failed.
 // Throws:  None.
 //--
 bool
 CMICmnLLDBDebuggerHandleEvents::HandleEventSBBreakPoint(const lldb::SBEvent &vEvent)
 {
     bool bOk = MIstatus::success;
 
-    const MIchar *pEventType = "";
+    const char *pEventType = "";
     const lldb::BreakpointEventType eEvent = lldb::SBBreakpoint::GetBreakpointEventTypeFromEvent(vEvent);
     switch (eEvent)
     {
         case lldb::eBreakpointEventTypeThreadChanged:
             pEventType = "eBreakpointEventTypeThreadChanged";
             break;
         case lldb::eBreakpointEventTypeLocationsRemoved:
             pEventType = "eBreakpointEventTypeLocationsRemoved";
else
         // Create a breakpoint information object
         sBrkPtInfo.m_bDisp = brkPt.IsOneShot();
         sBrkPtInfo.m_bEnabled = brkPt.IsEnabled();
         sBrkPtInfo.m_bHaveArgOptionThreadGrp = false;
         sBrkPtInfo.m_strOptThrdGrp.clear();
         sBrkPtInfo.m_strOrigLoc = CMIUtilString::Format("%s:%d", sBrkPtInfo.m_fileName.c_str(), sBrkPtInfo.m_nLine);
         sBrkPtInfo.m_nIgnore = brkPt.GetIgnoreCount();
         sBrkPtInfo.m_bPending = false;
-        const MIchar *pStrCondition = brkPt.GetCondition();
+        const char *pStrCondition = brkPt.GetCondition();
         sBrkPtInfo.m_bCondition = (pStrCondition != nullptr) ? true : false;
         sBrkPtInfo.m_strCondition = (pStrCondition != nullptr) ? pStrCondition : "??";
         sBrkPtInfo.m_bBrkPtThreadId = (brkPt.GetThreadID() != 0) ? true : false;
         sBrkPtInfo.m_nBrkPtThreadId = brkPt.GetThreadID();
     }
 
     CMICmnMIValueTuple miValueTuple;
     if (!rSessionInfo.MIResponseFormBrkPtInfo(sBrkPtInfo, miValueTuple))

 //--
 bool
 CMICmnLLDBDebuggerHandleEvents::HandleEventSBThread(const lldb::SBEvent &vEvent)
 {
     if (!ChkForStateChanges())
         return MIstatus::failure;
 
     bool bOk = MIstatus::success;
-    const MIchar *pEventType = "";
+    const char *pEventType = "";
     const MIuint nEventType = vEvent.GetType();
     switch (nEventType)
     {
         case lldb::SBThread::eBroadcastBitStackChanged:
             pEventType = "eBroadcastBitStackChanged";
             bOk = HandleEventSBThreadBitStackChanged(vEvent);
             break;
         case lldb::SBThread::eBroadcastBitThreadSuspended:

 //--
 bool
 CMICmnLLDBDebuggerHandleEvents::HandleEventSBTarget(const lldb::SBEvent &vEvent)
 {
     if (!ChkForStateChanges())
         return MIstatus::failure;
 
     bool bOk = MIstatus::success;
-    const MIchar *pEventType = "";
+    const char *pEventType = "";
     const MIuint nEventType = vEvent.GetType();
     switch (nEventType)
     {
         case lldb::SBTarget::eBroadcastBitBreakpointChanged:
             pEventType = "eBroadcastBitBreakpointChanged";
             break;
         case lldb::SBTarget::eBroadcastBitModulesLoaded:
             pEventType = "eBroadcastBitModulesLoaded";

 // Throws:  None.
 //--
 bool
 CMICmnLLDBDebuggerHandleEvents::HandleEventSBCommandInterpreter(const lldb::SBEvent &vEvent)
 {
     // This function is not used
     // *** This function is under development
 
-    const MIchar *pEventType = "";
+    const char *pEventType = "";
     const MIuint nEventType = vEvent.GetType();
     switch (nEventType)
     {
         case lldb::SBCommandInterpreter::eBroadcastBitThreadShouldExit:
             pEventType = "eBroadcastBitThreadShouldExit";
         // ToDo: IOR: Reminder to maybe handle this here
         // const MIuint nEventType = event.GetType();
         // if (nEventType & lldb::SBCommandInterpreter::eBroadcastBitThreadShouldExit)
CMICmnLLDBDebuggerHandleEvents::HandleProcessEventBroadcastBitStateChanged(const lldb::SBEvent &vEvent)
     {
         const CMIUtilString msg(CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_PROCESS_INVALID), "SBProcess",
                                                       "HandleProcessEventBroadcastBitStateChanged()"));
         SetErrorDescription(msg);
         return MIstatus::failure;
     }
 
     bool bShouldBrk = true;
-    const MIchar *pEventType = "";
+    const char *pEventType = "";
     switch (eEventState)
     {
         case lldb::eStateUnloaded:
             pEventType = "eStateUnloaded";
             break;
         case lldb::eStateConnected:
             pEventType = "eStateConnected";
             break;

 // Throws:  None.
 //--
 bool
 CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStateStopped(const lldb::SBEvent &vrEvent, bool &vwrbShouldBrk)
 {
     if (!UpdateSelectedThread())
         return MIstatus::failure;
 
-    const MIchar *pEventType = "";
+    const char *pEventType = "";
     bool bOk = MIstatus::success;
     lldb::SBProcess sbProcess = CMICmnLLDBDebugSessionInfo::Instance().GetProcess();
     const lldb::StopReason eStoppedReason = sbProcess.GetSelectedThread().GetStopReason();
     switch (eStoppedReason)
     {
         case lldb::eStopReasonInvalid:
             pEventType = "eStopReasonInvalid";
             vwrbShouldBrk = false;
CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStopSignal(const lldb::SBEvent &vrEvent)
     else
     {
         // MI print "*stopped,reason=\"signal-received\",signal-name=\"%s\",thread-id=\"%d\",stopped-threads=\"all\""
         // MI print "*stopped,reason=\"signal-received\",signal=\"%d\",thread-id=\"%d\",stopped-threads=\"all\""
         const CMICmnMIValueConst miValueConst("signal-received");
         const CMICmnMIValueResult miValueResult("reason", miValueConst);
         CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult);
         lldb::SBUnixSignals sbUnixSignals = sbProcess.GetUnixSignals();
-        const MIchar *pSignal = sbUnixSignals.GetSignalAsCString(nStopReason);
+        const char *pSignal = sbUnixSignals.GetSignalAsCString(nStopReason);
         if (pSignal)
         {
             const CMICmnMIValueConst miValueConst2(pSignal);
             const CMICmnMIValueResult miValueResult2("signal-name", miValueConst2);
             bOk = miOutOfBandRecord.Add(miValueResult2);
         }
         else
         {

lldb/trunk/tools/lldb-mi/MICmnLLDBProxySBValue.cpp

 // Return:  MIstatus::success - Functionality succeeded.
 //          MIstatus::failure - Functionality failed, not suitable type.
 // Throws:  None.
 //--
 bool
 CMICmnLLDBProxySBValue::GetCString(const lldb::SBValue &vrValue, CMIUtilString &vwCString)
 {
     lldb::SBValue &rValue = const_cast<lldb::SBValue &>(vrValue);
-    const MIchar *pCType = rValue.GetTypeName();
+    const char *pCType = rValue.GetTypeName();
     if (pCType == nullptr)
         return MIstatus::failure;
 
-    const MIchar *pType = "unsigned char *";
+    const char *pType = "unsigned char *";
     if (!CMIUtilString::Compare(pCType, pType))
         return MIstatus::failure;
 
     const CMIUtilString strAddr(rValue.GetValue());
     MIint64 nNum = 0;
     if (!strAddr.ExtractNumber(nNum))
         return MIstatus::failure;
 
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
     lldb::SBProcess sbProcess = rSessionInfo.GetProcess();
     MIuint nBufferSize = 64;
     bool bNeedResize = false;
-    MIchar *pBuffer = static_cast<MIchar *>(::malloc(nBufferSize));
+    char *pBuffer = static_cast<char *>(::malloc(nBufferSize));
     do
     {
         lldb::SBError error;
         const size_t nReadSize = sbProcess.ReadCStringFromMemory((lldb::addr_t)nNum, pBuffer, nBufferSize, error);
         if (nReadSize == (nBufferSize - 1))
         {
             bNeedResize = true;
             nBufferSize = nBufferSize << 1;
-            pBuffer = static_cast<MIchar *>(::realloc(pBuffer, nBufferSize));
+            pBuffer = static_cast<char *>(::realloc(pBuffer, nBufferSize));
         }
         else
             bNeedResize = false;
     } while (bNeedResize);
 
     vwCString = pBuffer;
     free((void *)pBuffer);
 
     return MIstatus::success;
 }

lldb/trunk/tools/lldb-mi/MICmnLLDBUtilSBValue.h

private:
     CMIUtilString GetSimpleValueChar(void) const;
     CMIUtilString GetSimpleValueCStringPointer(void) const;
     CMIUtilString GetSimpleValueCStringArray(void) const;
     bool GetCompositeValue(const bool vbPrintFieldNames, CMICmnMIValueTuple &vwrMiValueTuple, const MIuint vnDepth = 1) const;
 
     // Attributes:
   private:
     lldb::SBValue &m_rValue;
-    const MIchar *m_pUnkwn;
-    const MIchar *m_pComposite;
+    const char *m_pUnkwn;
+    const char *m_pComposite;
     bool m_bValidSBValue;    // True = SBValue is a valid object, false = not valid.
     bool m_bHandleCharType;  // True = Yes return text molding to char type, false = just return data.
     bool m_bHandleArrayType; // True = Yes return special stub for array type, false = just return data.
 };

lldb/trunk/tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString   - Name of the variable or "??" for unknown.
 // Throws:  None.
 //--
 CMIUtilString
 CMICmnLLDBUtilSBValue::GetName(void) const
 {
-    const MIchar *pName = m_bValidSBValue ? m_rValue.GetName() : nullptr;
+    const char *pName = m_bValidSBValue ? m_rValue.GetName() : nullptr;
     const CMIUtilString text((pName != nullptr) ? pName : m_pUnkwn);
 
     return text;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve from the LLDB SB Value object the value of the variable described in
 //          text. If the value is invalid (or the SBValue object invalid) then "??" is
CMICmnLLDBUtilSBValue::GetSimpleValue(const bool vbHandleArrayType, CMIUtilString &vwrValue) const
     {
         if (m_bHandleCharType && IsCharType())
         {
             vwrValue = GetSimpleValueChar();
             return MIstatus::success;
         }
         else
         {
-            const MIchar *pValue = m_rValue.GetValue();
+            const char *pValue = m_rValue.GetValue();
             vwrValue = pValue != nullptr ? pValue : m_pUnkwn;
             return MIstatus::success;
         }
     }
     else if (IsPointerType())
     {
         if (m_bHandleCharType && IsFirstChildCharType())
         {
             vwrValue = GetSimpleValueCStringPointer();
             return MIstatus::success;
         }
         else
         {
-            const MIchar *pValue = m_rValue.GetValue();
+            const char *pValue = m_rValue.GetValue();
             vwrValue = pValue != nullptr ? pValue : m_pUnkwn;
             return MIstatus::success;
         }
     }
     else if (IsArrayType())
     {
         CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
         bool bPrintCharArrayAsString = false;

 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString   - The c-string value of the variable.
 // Throws:  None.
 //--
 CMIUtilString
 CMICmnLLDBUtilSBValue::GetSimpleValueCStringPointer(void) const
 {
-    const MIchar *value = m_rValue.GetValue();
+    const char *value = m_rValue.GetValue();
     if (value == nullptr)
         return m_pUnkwn;
 
     lldb::SBValue child = m_rValue.GetChildAtIndex(0);
     const lldb::BasicType eType = child.GetType().GetBasicType();
     switch (eType)
     {
         default:

 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString   - The type name or "??".
 // Throws:  None.
 //--
 CMIUtilString
 CMICmnLLDBUtilSBValue::GetTypeName(void) const
 {
-    const MIchar *pName = m_bValidSBValue ? m_rValue.GetTypeName() : nullptr;
+    const char *pName = m_bValidSBValue ? m_rValue.GetTypeName() : nullptr;
     const CMIUtilString text((pName != nullptr) ? pName : m_pUnkwn);
 
     return text;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve the value object's display type name if valid.
 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString   - The type name or "??".
 // Throws:  None.
 //--
 CMIUtilString
 CMICmnLLDBUtilSBValue::GetTypeNameDisplay(void) const
 {
-    const MIchar *pName = m_bValidSBValue ? m_rValue.GetDisplayTypeName() : nullptr;
+    const char *pName = m_bValidSBValue ? m_rValue.GetDisplayTypeName() : nullptr;
     const CMIUtilString text((pName != nullptr) ? pName : m_pUnkwn);
 
     return text;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve whether the value object's is valid or not.
 // Type:    Method.

 // Return:  bool    - True = valid, false = not valid.
 // Throws:  None.
 //--
 bool
 CMICmnLLDBUtilSBValue::HasName(void) const
 {
     bool bHasAName = false;
 
-    const MIchar *pName = m_bValidSBValue ? m_rValue.GetDisplayTypeName() : nullptr;
+    const char *pName = m_bValidSBValue ? m_rValue.GetDisplayTypeName() : nullptr;
     if (pName != nullptr)
     {
         bHasAName = (CMIUtilString(pName).length() > 0);
     }
 
     return bHasAName;
 }
 

lldb/trunk/tools/lldb-mi/MICmnLogMediumFile.h

private:
     /* ctor */ CMICmnLogMediumFile(void);
     /* ctor */ CMICmnLogMediumFile(const CMICmnLogMediumFile &);
     void operator=(const CMICmnLogMediumFile &);
 
     bool FileWriteEnglish(const CMIUtilString &vData);
     bool FileFormFileNamePath(void);
     CMIUtilString MassagedData(const CMIUtilString &vData, const CMICmnLog::ELogVerbosity veType);
     bool FileWriteHeader(void);
-    MIchar ConvertLogVerbosityTypeToId(const CMICmnLog::ELogVerbosity veType) const;
+    char ConvertLogVerbosityTypeToId(const CMICmnLog::ELogVerbosity veType) const;
     CMIUtilString ConvertCr(const CMIUtilString &vData) const;
 
     // Attributes:
   private:
     const CMIUtilString m_constThisMediumName;
     const CMIUtilString m_constMediumFileNameFormat;
     //
     CMIUtilString m_strMediumFileName;
     CMIUtilString m_strMediumFileDirectory;
     CMIUtilString m_fileNamePath;
     MIuint m_eVerbosityType;
     CMIUtilString m_strDate;
     CMIUtilString m_fileHeaderTxt;
     CMIUtilFileStd m_file;
     CMIUtilDateTimeStd m_dateTime;
 };

lldb/trunk/tools/lldb-mi/MICmnLogMediumFile.cpp

 // Return:  CMIUtilString - Massaged data.
 // Throws:  None.
 //--
 CMIUtilString
 CMICmnLogMediumFile::MassagedData(const CMIUtilString &vData, const CMICmnLog::ELogVerbosity veType)
 {
     const CMIUtilString strCr("\n");
     CMIUtilString data;
-    const MIchar verbosityCode(ConvertLogVerbosityTypeToId(veType));
+    const char verbosityCode(ConvertLogVerbosityTypeToId(veType));
     const CMIUtilString dt(CMIUtilString::Format("%s %s", m_strDate.c_str(), m_dateTime.GetTime().c_str()));
 
     data = CMIUtilString::Format("%c,%s,%s", verbosityCode, dt.c_str(), vData.c_str());
     data = ConvertCr(data);
 
     // Look for EOL...
     const MIint pos = vData.rfind(strCr);
     if (pos == (MIint)vData.size())
         return data;
 
     // ... did not have an EOL so add one
     data += GetLineReturn();
 
     return data;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Convert the Log's verbosity type number into a single char character.
 // Type:    Method.
 // Args:    veType  - (R) Message type.
 // Return:  wchar_t - A letter.
 // Throws:  None.
 //--
-MIchar
+char
 CMICmnLogMediumFile::ConvertLogVerbosityTypeToId(const CMICmnLog::ELogVerbosity veType) const
 {
-    MIchar c = 0;
+    char c = 0;
     if (veType != 0)
     {
         MIuint cnt = 0;
         MIuint number(veType);
         while (1 != number)
         {
             number = number >> 1;
             ++cnt;

lldb/trunk/tools/lldb-mi/MICmnMIOutOfBandRecord.cpp

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmnMIOutOfBandRecord::BuildAsyncRecord(void)
 {
-    const MIchar *pFormat = "%s%s";
+    const char *pFormat = "%s%s";
     const CMIUtilString &rStrAsyncRecord(ms_MapOutOfBandToOutOfBandText[m_eResultAsyncRecordClass]);
     const CMIUtilString &rStrToken(ms_constMapAsyncRecordTextToToken[m_eResultAsyncRecordClass]);
     m_strAsyncRecord = CMIUtilString::Format(pFormat, rStrToken.c_str(), rStrAsyncRecord.c_str());
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------

lldb/trunk/tools/lldb-mi/MICmnMIResultRecord.cpp

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmnMIResultRecord::BuildResultRecord(void)
 {
-    const MIchar *pFormat = "%s%s%s";
+    const char *pFormat = "%s%s%s";
     const CMIUtilString &rStrResultRecord(ms_MapResultClassToResultClassText[m_eResultRecordResultClass]);
     m_strResultRecord =
         CMIUtilString::Format(pFormat, m_strResultRecordToken.c_str(), ms_constStrResultRecordHat.c_str(), rStrResultRecord.c_str());
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------

lldb/trunk/tools/lldb-mi/MICmnMIValueConst.cpp

CMICmnMIValueConst::BuildConst(void)
     {
         const CMIUtilString strValue(m_strPartConst.StripCREndOfLine());
         if (m_bNoQuotes)
         {
             m_strValue = strValue;
         }
         else
         {
-            const MIchar *pFormat = "%s%s%s";
+            const char *pFormat = "%s%s%s";
             m_strValue = CMIUtilString::Format(pFormat, ms_constStrDblQuote.c_str(), strValue.c_str(), ms_constStrDblQuote.c_str());
         }
     }
     else
     {
-        const MIchar *pFormat = "%s%s";
+        const char *pFormat = "%s%s";
         m_strValue = CMIUtilString::Format(pFormat, ms_constStrDblQuote.c_str(), ms_constStrDblQuote.c_str());
     }
 
     return MIstatus::success;
 }

lldb/trunk/tools/lldb-mi/MICmnMIValueList.cpp

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmnMIValueList::BuildList(void)
 {
-    const MIchar *pFormat = "[%s]";
+    const char *pFormat = "[%s]";
     m_strValue = CMIUtilString::Format(pFormat, m_strValue.c_str());
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Add another MI result object to  the value list's of list is results.
 //          Only result obejcts can be added to a list of result otherwise this function
CMICmnMIValueList::BuildList(const CMICmnMIValueResult &vResult)
     if (m_bJustConstructed)
     {
         m_bJustConstructed = false;
         m_strValue = vResult.GetString();
         return BuildList();
     }
 
     const CMIUtilString data(ExtractContentNoBrackets());
-    const MIchar *pFormat = "[%s,%s]";
+    const char *pFormat = "[%s,%s]";
     m_strValue = CMIUtilString::Format(pFormat, data.c_str(), vResult.GetString().c_str());
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Add another MI value object to  the value list's of list is values.
 //          Only values objects can be added to a list of values otherwise this function
if (m_bJustConstructed)
         return BuildList();
     }
 
     // Remove already present '[' and ']' from the start and end
     m_strValue = m_strValue.Trim();
     size_t len = m_strValue.size();
     if ( (len > 1) && (m_strValue[0] == '[') && (m_strValue[len - 1] == ']') )
         m_strValue = m_strValue.substr(1, len - 2);
-    const MIchar *pFormat = "[%s,%s]";
+    const char *pFormat = "[%s,%s]";
     m_strValue = CMIUtilString::Format(pFormat, m_strValue.c_str(), vValue.GetString().c_str());
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve the contents of *this value object but without the outer most
 //          brackets.

lldb/trunk/tools/lldb-mi/MICmnMIValueResult.cpp

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmnMIValueResult::BuildResult(void)
 {
-    const MIchar *pFormat = m_bUseSpacing ? "%s %s %s" : "%s%s%s";
+    const char *pFormat = m_bUseSpacing ? "%s %s %s" : "%s%s%s";
     m_strValue = CMIUtilString::Format(pFormat, m_strPartVariable.c_str(), ms_constStrEqual.c_str(), m_partMIValue.GetString().c_str());
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Build the MI value result string.
 // Type:    Method.
 // Args:    vrVariable  - (R) MI value's name.
 //          vrValue     - (R) The MI value.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmnMIValueResult::BuildResult(const CMIUtilString &vVariable, const CMICmnMIValue &vValue)
 {
-    const MIchar *pFormat = m_bUseSpacing ? "%s, %s %s %s" : "%s,%s%s%s";
+    const char *pFormat = m_bUseSpacing ? "%s, %s %s %s" : "%s,%s%s%s";
     m_strValue =
         CMIUtilString::Format(pFormat, m_strValue.c_str(), vVariable.c_str(), ms_constStrEqual.c_str(), vValue.GetString().c_str());
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Append another MI value object to *this MI value result.

lldb/trunk/tools/lldb-mi/MICmnMIValueTuple.cpp

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmnMIValueTuple::BuildTuple(void)
 {
-    const MIchar *pFormat = "{%s}";
+    const char *pFormat = "{%s}";
     m_strValue = CMIUtilString::Format(pFormat, m_strValue.c_str());
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Add another MI result object to the value's list of tuples.
 // Type:    Method.
CMICmnMIValueTuple::BuildTuple(const CMICmnMIValueResult &vResult)
     {
         m_strValue = m_strValue.substr(1, m_strValue.size() - 1);
     }
     if (m_strValue[m_strValue.size() - 1] == '}')
     {
         m_strValue = m_strValue.substr(0, m_strValue.size() - 1);
     }
 
-    const MIchar *pFormat = m_bSpaceAfterComma ? "{%s, %s}" : "{%s,%s}";
+    const char *pFormat = m_bSpaceAfterComma ? "{%s, %s}" : "{%s,%s}";
     m_strValue = CMIUtilString::Format(pFormat, m_strValue.c_str(), vResult.GetString().c_str());
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Add string value to the value's list of tuples.
 // Type:    Method.
CMICmnMIValueTuple::BuildTuple(const CMIUtilString &vValue)
     if (m_bJustConstructed)
     {
         m_bJustConstructed = false;
         m_strValue = vValue;
         return BuildTuple();
     }
 
     const CMIUtilString data(ExtractContentNoBrackets());
-    const MIchar *pFormat = m_bSpaceAfterComma ? "{%s, %s}" : "{%s,%s}";
+    const char *pFormat = m_bSpaceAfterComma ? "{%s, %s}" : "{%s,%s}";
     m_strValue = CMIUtilString::Format(pFormat, data.c_str(), vValue.c_str());
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Add another MI value object to  the value list's of list is values.
 //          Only values objects can be added to a list of values otherwise this function

lldb/trunk/tools/lldb-mi/MICmnResources.h

public:
     bool Initialize(void);
     bool Shutdown(void);
 
     CMIUtilString GetString(const MIuint vResourceId) const;
     bool HasString(const MIuint vResourceId) const;
 
     // Typedef:
   private:
-    typedef std::map<MIuint, const MIchar *> MapRscrIdToTextData_t;
-    typedef std::pair<MIuint, const MIchar *> MapPairRscrIdToTextData_t;
+    typedef std::map<MIuint, const char *> MapRscrIdToTextData_t;
+    typedef std::pair<MIuint, const char *> MapPairRscrIdToTextData_t;
 
     // Enumerations:
   private:
     enum Buffer_e
     {
         eBufferSize = 2048
     };
 
     // Structs:
   private:
     struct SRsrcTextData
     {
         MIuint id;
-        const MIchar *pTextData;
+        const char *pTextData;
     };
 
     // Methods:
   private:
     /* ctor */ CMICmnResources(void);
     /* ctor */ CMICmnResources(const CMICmnResources &);
     void operator=(const CMICmnResources &);
 

lldb/trunk/tools/lldb-mi/MICmnResources.cpp

if (it == m_mapRscrIdToTextData.end())
         {
             vrwResourceString = CMIUtilString::Format(MIRSRC(IDS_RESOURCES_ERR_STRING_NOT_FOUND), vResourceId);
             return MIstatus::failure;
         }
     }
 
     const MIuint nRsrcId((*it).first);
     MIunused(nRsrcId);
-    const MIchar *pRsrcData((*it).second);
+    const char *pRsrcData((*it).second);
 
     // Return result
     vrwResourceString = pRsrcData;
 
     return MIstatus::success;
 }

lldb/trunk/tools/lldb-mi/MICmnStreamStdin.h

class CMICmnStreamStdin : public CMICmnBase, public MI::ISingleton<CMICmnStreamStdin>
   public:
     bool Initialize(void);
     bool Shutdown(void);
     //
     const CMIUtilString &GetPrompt(void) const;
     bool SetPrompt(const CMIUtilString &vNewPrompt);
     void SetEnablePrompt(const bool vbYes);
     bool GetEnablePrompt(void) const;
-    const MIchar *ReadLine(CMIUtilString &vwErrMsg);
+    const char *ReadLine(CMIUtilString &vwErrMsg);
 
     // Methods:
   private:
     /* ctor */ CMICmnStreamStdin(void);
     /* ctor */ CMICmnStreamStdin(const CMICmnStreamStdin &);
     void operator=(const CMICmnStreamStdin &);
 
     // Overridden:
   private:
     // From CMICmnBase
     /* dtor */ virtual ~CMICmnStreamStdin(void);
 
     // Attributes:
   private:
     CMIUtilString m_strPromptCurrent; // Command line prompt as shown to the user
     bool m_bShowPrompt;               // True = Yes prompt is shown/output to the user (stdout), false = no prompt
     static const int m_constBufferSize = 2048;
-    MIchar *m_pCmdBuffer;
+    char *m_pCmdBuffer;
 };

lldb/trunk/tools/lldb-mi/MICmnStreamStdin.cpp

CMICmnStreamStdin::Initialize(void)
     CMIUtilString errMsg;
 
     // Note initialisation order is important here as some resources depend on previous
     MI::ModuleInit<CMICmnLog>(IDS_MI_INIT_ERR_LOG, bOk, errMsg);
     MI::ModuleInit<CMICmnResources>(IDS_MI_INIT_ERR_RESOURCES, bOk, errMsg);
 
     if (bOk)
     {
-        m_pCmdBuffer = new MIchar[m_constBufferSize];
+        m_pCmdBuffer = new char[m_constBufferSize];
     }
     else
     {
         CMIUtilString strInitError(CMIUtilString::Format(MIRSRC(IDS_MI_INIT_ERR_STREAMSTDIN), errMsg.c_str()));
         SetErrorDescription(strInitError);
 
         return MIstatus::failure;
     }

 {
     return m_bShowPrompt;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Wait on new line of data from stdin stream (completed by '\n' or '\r').
 // Type:    Method.
 // Args:    vwErrMsg    - (W) Empty string ok or error description.
-// Return:  MIchar * - text buffer pointer or NULL on failure.
+// Return:  char * - text buffer pointer or NULL on failure.
 // Throws:  None.
 //--
-const MIchar *
+const char *
 CMICmnStreamStdin::ReadLine(CMIUtilString &vwErrMsg)
 {
     vwErrMsg.clear();
 
     // Read user input
-    const MIchar *pText = ::fgets(&m_pCmdBuffer[0], m_constBufferSize, stdin);
+    const char *pText = ::fgets(&m_pCmdBuffer[0], m_constBufferSize, stdin);
     if (pText == nullptr)
     {
 #ifdef _MSC_VER
         // Was Ctrl-C hit?
         // On Windows, Ctrl-C gives an ERROR_OPERATION_ABORTED as error on the command-line.
         // The end-of-file indicator is also set, so without this check we will exit next if statement.
         if (::GetLastError() == ERROR_OPERATION_ABORTED)
             return nullptr;
 #endif
         if (::feof(stdin))
         {
             const bool bForceExit = true;
             CMIDriver::Instance().SetExitApplicationFlag(bForceExit);
         }
         else if (::ferror(stdin) != 0)
             vwErrMsg = ::strerror(errno);
         return nullptr;
     }
 
     // Strip off new line characters
-    for (MIchar *pI = m_pCmdBuffer; *pI != '\0'; pI++)
+    for (char *pI = m_pCmdBuffer; *pI != '\0'; pI++)
     {
         if ((*pI == '\n') || (*pI == '\r'))
         {
             *pI = '\0';
             break;
         }
     }
 
     return pText;
 }

lldb/trunk/tools/lldb-mi/MIDataTypes.h

 #endif // _WIN64
 
 //--------------------------------------------------------------------------------------
 // Common types:
 
 // Fundamentals:
 typedef float MIflt;
 typedef double MIdbl;
-typedef char MIchar;                 // Defaults to signed char, i.e. MIschar.
-typedef signed char MIschar;         // Range: -128 to 127. More explicit than using MIchar.
-typedef unsigned char MIuchar;       // Range: 0 to 255.
 typedef long long MIint64;           // 64bit signed integer.
 typedef unsigned long long MIuint64; // 64bit unsigned integer.
 
 // using namespace std; // Better to put this or std:: at translation units scope.
 
 //--------------------------------------------------------------------------------------
 // Common routines:
 
 //--------------------------------------------------------------------------------------

lldb/trunk/tools/lldb-mi/MIDriver.cpp

if (m_bHaveCommandFileNamePathOnCmdLine)
         const bool bAsyncMode = false;
         ExecuteCommandFile(bAsyncMode);
     }
 
     // While the app is active
     while (bOk && !m_bExitApp)
     {
         CMIUtilString errorText;
-        const MIchar *pCmd = m_rStdin.ReadLine (errorText);
+        const char *pCmd = m_rStdin.ReadLine (errorText);
         if (pCmd != nullptr)
         {
             CMIUtilString lineText(pCmd);
             if (!lineText.empty ())
             {
                 // Check that the handler thread is alive (otherwise we stuck here)
                 assert(CMICmnLLDBDebugger::Instance().ThreadIsActive());
 
CMIDriver::InterpretCommandFallThruDriver(const CMIUtilString &vTextLine, bool &vwbCmdYesValid)
     //{
     //  CMIUtilString errMsg;
     //  bOk = DoFallThruToAnotherDriver( vStdInBuffer, errMsg );
     //  if( !bOk )
     //  {
     //      errMsg = errMsg.StripCREndOfLine();
     //      errMsg = errMsg.StripCRAll();
     //      const CMIDriverBase * pOtherDriver = GetDriverToFallThruTo();
-    //      const MIchar * pName = pOtherDriver->GetDriverName().c_str();
-    //      const MIchar * pId = pOtherDriver->GetDriverId().c_str();
+    //      const char * pName = pOtherDriver->GetDriverName().c_str();
+    //      const char * pId = pOtherDriver->GetDriverId().c_str();
     //      const CMIUtilString msg( CMIUtilString::Format( MIRSRC( IDS_DRIVER_ERR_FALLTHRU_DRIVER_ERR ), pName, pId, errMsg.c_str() )
     //);
     //      m_pLog->WriteMsg( msg );
     //  }
     //}
     //
     // vwbCmdYesValid = bOk;
     // CMIUtilString strNot;

lldb/trunk/tools/lldb-mi/MIDriverMgr.cpp

if (m_pDriverCurrent == nullptr)
         return MIstatus::failure;
     }
 
     const lldb::SBError error(m_pDriverCurrent->DoParseArgs(argc, argv, vpStdOut, vwbExiting));
     bool bOk = !error.Fail();
     if (!bOk)
     {
         CMIUtilString errMsg;
-        const MIchar *pErrorCstr = error.GetCString();
+        const char *pErrorCstr = error.GetCString();
         if (pErrorCstr != nullptr)
             errMsg = CMIUtilString::Format(MIRSRC(IDS_DRIVER_ERR_PARSE_ARGS), m_pDriverCurrent->GetName().c_str(), pErrorCstr);
         else
             errMsg = CMIUtilString::Format(MIRSRC(IDS_DRIVER_ERR_PARSE_ARGS_UNKNOWN), m_pDriverCurrent->GetName().c_str());
 
         bOk = CMICmnStreamStdout::Instance().Write(errMsg, true);
     }
 

lldb/trunk/tools/lldb-mi/MIUtilDateTimeStd.h

public:
     // Overrideable:
   public:
     // From CMICmnBase
     /* dtor */ virtual ~CMIUtilDateTimeStd(void);
 
     // Attributes:
   private:
     std::time_t m_rawTime;
-    MIchar m_pScratch[16];
+    char m_pScratch[16];
 };

lldb/trunk/tools/lldb-mi/MIUtilFileStd.h

 // Gotchas: None.
 // Authors: Aidan Dodds 10/03/2014.
 // Changes: None.
 //--
 class CMIUtilFileStd : public CMICmnBase
 {
     // Static:
   public:
-    static MIchar GetSlash(void);
+    static char GetSlash(void);
 
     // Methods:
   public:
     /* ctor */ CMIUtilFileStd(void);
     //
     bool CreateWrite(const CMIUtilString &vFileNamePath, bool &vwrbNewCreated);
     bool Write(const CMIUtilString &vData);
-    bool Write(const MIchar *vpData, const MIuint vCharCnt);
+    bool Write(const char *vpData, const MIuint vCharCnt);
     void Close(void);
     bool IsOk(void) const;
     bool IsFileExist(const CMIUtilString &vFileNamePath) const;
     const CMIUtilString &GetLineReturn(void) const;
     static CMIUtilString StripOffFileName(const CMIUtilString &vDirectoryPath);
 
     // Overridden:
   public:

lldb/trunk/tools/lldb-mi/MIUtilFileStd.cpp

 // Type:    Method.
 // Args:    vData       - (R) Text data.
 //          vCharCnt    - (R) Text data length.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
-CMIUtilFileStd::Write(const MIchar *vpData, const MIuint vCharCnt)
+CMIUtilFileStd::Write(const char *vpData, const MIuint vCharCnt)
 {
     if (vCharCnt == 0)
         return MIstatus::success;
 
     if (m_bFileError)
         return MIstatus::failure;
 
     if (m_pFileHandle == nullptr)
CMIUtilFileStd::StripOffFileName(const CMIUtilString &vDirectoryPath)
     return strPath;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Return either backslash or forward slash appropriate to the OS this applilcation
 //          is running on.
 // Type:    Static method.
 // Args:    None.
-// Return:  MIchar - '/' or '\' character.
+// Return:  char - '/' or '\' character.
 // Throws:  None.
 //--
-MIchar
+char
 CMIUtilFileStd::GetSlash(void)
 {
 #if !defined(_MSC_VER)
     return '/';
 #else
     return '\\';
 #endif // !defined( _MSC_VER )
 }

lldb/trunk/tools/lldb-mi/MIUtilString.h

class CMIUtilString : public std::string
   public:
     typedef std::vector<CMIUtilString> VecString_t;
 
     // Static method:
   public:
     static CMIUtilString Format(const CMIUtilString vFormating, ...);
     static CMIUtilString FormatBinary(const MIuint64 vnDecimal);
     static CMIUtilString FormatValist(const CMIUtilString &vrFormating, va_list vArgs);
-    static bool IsAllValidAlphaAndNumeric(const MIchar *vpText);
+    static bool IsAllValidAlphaAndNumeric(const char *vpText);
     static bool Compare(const CMIUtilString &vrLhs, const CMIUtilString &vrRhs);
     static CMIUtilString ConvertToPrintableASCII(const char vChar);
     static CMIUtilString ConvertToPrintableASCII(const char16_t vChar16);
     static CMIUtilString ConvertToPrintableASCII(const char32_t vChar32);
 
     // Methods:
   public:
     /* ctor */ CMIUtilString(void);
-    /* ctor */ CMIUtilString(const MIchar *vpData);
-    /* ctor */ CMIUtilString(const MIchar *const *vpData);
+    /* ctor */ CMIUtilString(const char *vpData);
+    /* ctor */ CMIUtilString(const char *const *vpData);
     //
     bool ExtractNumber(MIint64 &vwrNumber) const;
     CMIUtilString FindAndReplace(const CMIUtilString &vFind, const CMIUtilString &vReplaceWith) const;
     bool IsNumber(void) const;
     bool IsHexadecimalNumber(void) const;
     bool IsQuoted(void) const;
-    CMIUtilString RemoveRepeatedCharacters(const MIchar vChar);
+    CMIUtilString RemoveRepeatedCharacters(const char vChar);
     MIuint Split(const CMIUtilString &vDelimiter, VecString_t &vwVecSplits) const;
     MIuint SplitConsiderQuotes(const CMIUtilString &vDelimiter, VecString_t &vwVecSplits) const;
     MIuint SplitLines(VecString_t &vwVecSplits) const;
     CMIUtilString StripCREndOfLine(void) const;
     CMIUtilString StripCRAll(void) const;
     CMIUtilString Trim(void) const;
-    CMIUtilString Trim(const MIchar vChar) const;
+    CMIUtilString Trim(const char vChar) const;
     MIuint FindFirst(const CMIUtilString &vrPattern, const MIuint vnPos = 0) const;
     MIuint FindFirst(const CMIUtilString &vrPattern, const bool vbSkipQuotedText, bool &vrwbNotFoundClosedQuote,
                      const MIuint vnPos = 0) const;
     MIuint FindFirstNot(const CMIUtilString &vrPattern, const MIuint vnPos = 0) const;
     CMIUtilString Escape(const bool vbEscapeQuotes = false) const;
     CMIUtilString AddSlashes(void) const;
     CMIUtilString StripSlashes(void) const;
     //
-    CMIUtilString &operator=(const MIchar *vpRhs);
+    CMIUtilString &operator=(const char *vpRhs);
     CMIUtilString &operator=(const std::string &vrRhs);
 
     // Overrideable:
   public:
     /* dtor */ virtual ~CMIUtilString(void);
 
     // Static method:
   private:
     static CMIUtilString FormatPriv(const CMIUtilString &vrFormat, va_list vArgs);
 
     // Methods:
   private:
     bool ExtractNumberFromHexadecimal(MIint64 &vwrNumber) const;
-    CMIUtilString RemoveRepeatedCharacters(const MIint vnPos, const MIchar vChar);
+    CMIUtilString RemoveRepeatedCharacters(const MIint vnPos, const char vChar);
     MIuint FindFirstQuote(const MIuint vnPos) const;
 };

lldb/trunk/tools/lldb-mi/MIUtilString.cpp

 
 //++ ------------------------------------------------------------------------------------
 // Details: CMIUtilString constructor.
 // Type:    Method.
 // Args:    vpData  - Pointer to UTF8 text data.
 // Return:  None.
 // Throws:  None.
 //--
-CMIUtilString::CMIUtilString(const MIchar *vpData)
+CMIUtilString::CMIUtilString(const char *vpData)
     : std::string(vpData)
 {
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMIUtilString constructor.
 // Type:    Method.
 // Args:    vpData  - Pointer to UTF8 text data.
 // Return:  None.
 // Throws:  None.
 //--
-CMIUtilString::CMIUtilString(const MIchar *const *vpData)
+CMIUtilString::CMIUtilString(const char *const *vpData)
     : std::string((const char *)vpData)
 {
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMIUtilString assignment operator.
 // Type:    Method.
 // Args:    vpRhs   - Pointer to UTF8 text data.
 // Return:  CMIUtilString & - *this string.
 // Throws:  None.
 //--
-CMIUtilString &CMIUtilString::operator=(const MIchar *vpRhs)
+CMIUtilString &CMIUtilString::operator=(const char *vpRhs)
 {
     if (*this == vpRhs)
         return *this;
 
     if (vpRhs != nullptr)
     {
         assign(vpRhs);
     }

 // Details: Determine if the text is all valid alpha numeric characters. Letters can be
 //          either upper or lower case.
 // Type:    Static method.
 // Args:    vpText  - (R) The text data to examine.
 // Return:  bool - True = yes all alpha, false = one or more chars is non alpha.
 // Throws:  None.
 //--
 bool
-CMIUtilString::IsAllValidAlphaAndNumeric(const MIchar *vpText)
+CMIUtilString::IsAllValidAlphaAndNumeric(const char *vpText)
 {
     const MIuint len = ::strlen(vpText);
     if (len == 0)
         return false;
 
     for (MIuint i = 0; i < len; i++, vpText++)
     {
-        const MIchar c = *vpText;
+        const char c = *vpText;
         if (::isalnum((int)c) == 0)
             return false;
     }
 
     return true;
 }
 
 //++ ------------------------------------------------------------------------------------

 // Args:    None.
 // Return:  CMIUtilString - Trimmed string.
 // Throws:  None.
 //--
 CMIUtilString
 CMIUtilString::Trim(void) const
 {
     CMIUtilString strNew(*this);
-    const MIchar *pWhiteSpace = " \t\n\v\f\r";
+    const char *pWhiteSpace = " \t\n\v\f\r";
     const MIint nPos = find_last_not_of(pWhiteSpace);
     if (nPos != (MIint)std::string::npos)
     {
         strNew = substr(0, nPos + 1).c_str();
     }
     const MIint nPos2 = strNew.find_first_not_of(pWhiteSpace);
     if (nPos2 != (MIint)std::string::npos)
     {
         strNew = strNew.substr(nPos2).c_str();
     }
 
     return strNew;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Remove from either end of *this string the specified character.
 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString - Trimmed string.
 // Throws:  None.
 //--
 CMIUtilString
-CMIUtilString::Trim(const MIchar vChar) const
+CMIUtilString::Trim(const char vChar) const
 {
     CMIUtilString strNew(*this);
     const MIint nLen = strNew.length();
     if (nLen > 1)
     {
         if ((strNew[0] == vChar) && (strNew[nLen - 1] == vChar))
             strNew = strNew.substr(1, nLen - 2).c_str();
     }
CMIUtilString::FormatBinary(const MIuint64 vnDecimal)
     MIuint nLen = 0;
     MIuint64 nNum = vnDecimal;
     while ((nNum > 0) && (nLen < nConstBits))
     {
         nRem[i++] = nNum % 2;
         nNum = nNum >> 1;
         nLen++;
     }
-    MIchar pN[nConstBits + 1];
+    char pN[nConstBits + 1];
     MIuint j = 0;
     for (i = nLen; i > 0; --i, j++)
     {
         pN[j] = '0' + nRem[i - 1];
     }
     pN[j] = 0; // String NUL termination
 
     strBinaryNumber = CMIUtilString::Format("0b%s", &pN[0]);
 
     return strBinaryNumber;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Remove from a string doubled up characters so only one set left. Characters
 //          are only removed if the previous character is already a same character.
 // Type:    Method.
 // Args:    vChar   - (R) The character to search for and remove adjacent duplicates.
 // Return:  CMIUtilString - New version of the string.
 // Throws:  None.
 //--
 CMIUtilString
-CMIUtilString::RemoveRepeatedCharacters(const MIchar vChar)
+CMIUtilString::RemoveRepeatedCharacters(const char vChar)
 {
     return RemoveRepeatedCharacters(0, vChar);
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Recursively remove from a string doubled up characters so only one set left.
 //          Characters are only removed if the previous character is already a same
 //          character.
 // Type:    Method.
 // Args:    vChar   - (R) The character to search for and remove adjacent duplicates.
 //          vnPos   - (R) Character position in the string.
 // Return:  CMIUtilString - New version of the string.
 // Throws:  None.
 //--
 CMIUtilString
-CMIUtilString::RemoveRepeatedCharacters(const MIint vnPos, const MIchar vChar)
+CMIUtilString::RemoveRepeatedCharacters(const MIint vnPos, const char vChar)
 {
-    const MIchar cQuote = '"';
+    const char cQuote = '"';
 
     // Look for first quote of two
     MIint nPos = find(cQuote, vnPos);
     if (nPos == (MIint)std::string::npos)
         return *this;
 
     const MIint nPosNext = nPos + 1;
     if (nPosNext > (MIint)length())

 // Type:    Method.
 // Args:    None.
 // Return:  bool - True = Yes string is quoted, false = no quoted.
 // Throws:  None.
 //--
 bool
 CMIUtilString::IsQuoted(void) const
 {
-    const MIchar cQuote = '"';
+    const char cQuote = '"';
 
     if (at(0) != cQuote)
         return false;
 
     const MIint nLen = length();
     if ((nLen > 0) && (at(nLen - 1) != cQuote))
         return false;
 

 // Type:    Method.
 // Args:    vnPos   - (R) Position of the first character in the string to be considered in the search.
 // Return:  MIuint - The position of the quotation mark.
 // Throws:  None.
 //--
 MIuint
 CMIUtilString::FindFirstQuote(const MIuint vnPos) const
 {
-    const MIchar cBckSlash('\\');
-    const MIchar cQuote('"');
+    const char cBckSlash('\\');
+    const char cQuote('"');
     const MIuint nLen(length());
 
     MIuint nPos = vnPos;
     do
     {
         const MIuint nBckSlashPos(find(cBckSlash, nPos));
         const MIuint nQuotePos(find(cQuote, nPos));
         if ((nBckSlashPos == (MIuint)std::string::npos) || (nQuotePos == (MIuint)std::string::npos))

 CMIUtilString
 CMIUtilString::Escape(const bool vbEscapeQuotes /* = false */) const
 {
     const MIuint nLen(length());
     CMIUtilString strNew;
     strNew.reserve(nLen);
     for (MIuint nIndex(0); nIndex < nLen; ++nIndex)
     {
-        const MIchar cUnescapedChar((*this)[nIndex]);
+        const char cUnescapedChar((*this)[nIndex]);
         if (cUnescapedChar == '"' && vbEscapeQuotes)
             strNew.append("\\\"");
         else
             strNew.append(ConvertToPrintableASCII((char)cUnescapedChar));
     }
     return strNew;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Get string with backslashes in front of double quote '"' and backslash '\\'
 //          characters.
 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString - The wrapped version of the initial string.
 // Throws:  None.
 //--
 CMIUtilString
 CMIUtilString::AddSlashes(void) const
 {
-    const MIchar cBckSlash('\\');
+    const char cBckSlash('\\');
     const MIuint nLen(length());
     CMIUtilString strNew;
     strNew.reserve(nLen);
 
     MIuint nOffset(0);
     while (nOffset < nLen)
     {
         const MIuint nUnescapedCharPos(find_first_of("\"\\", nOffset));
         const bool bUnescapedCharNotFound(nUnescapedCharPos == (MIuint)std::string::npos);
         if (bUnescapedCharNotFound)
         {
             const MIuint nAppendAll((MIuint)std::string::npos);
             strNew.append(*this, nOffset, nAppendAll);
             break;
         }
         const MIuint nAppendLen(nUnescapedCharPos - nOffset);
         strNew.append(*this, nOffset, nAppendLen);
         strNew.push_back(cBckSlash);
-        const MIchar cUnescapedChar((*this)[nUnescapedCharPos]);
+        const char cUnescapedChar((*this)[nUnescapedCharPos]);
         strNew.push_back(cUnescapedChar);
         nOffset = nUnescapedCharPos + 1;
     }
 
     return strNew;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Remove backslashes added by CMIUtilString::AddSlashes.
 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString - The initial version of wrapped string.
 // Throws:  None.
 //--
 CMIUtilString
 CMIUtilString::StripSlashes(void) const
 {
-    const MIchar cBckSlash('\\');
+    const char cBckSlash('\\');
     const MIuint nLen(length());
     CMIUtilString strNew;
     strNew.reserve(nLen);
 
     MIuint nOffset(0);
     while (nOffset < nLen)
     {
         const MIuint nBckSlashPos(find(cBckSlash, nOffset));
         const bool bBckSlashNotFound(nBckSlashPos == (MIuint)std::string::npos);
         if (bBckSlashNotFound)
         {
             const MIuint nAppendAll((MIuint)std::string::npos);
             strNew.append(*this, nOffset, nAppendAll);
             break;
         }
         const MIuint nAppendLen(nBckSlashPos - nOffset);
         strNew.append(*this, nOffset, nAppendLen);
         const bool bBckSlashIsLast(nBckSlashPos == nLen);
         if (bBckSlashIsLast)
         {
             strNew.push_back(cBckSlash);
             break;
         }
-        const MIchar cEscapedChar((*this)[nBckSlashPos + 1]);
+        const char cEscapedChar((*this)[nBckSlashPos + 1]);
         const MIuint nEscapedCharPos(std::string("\"\\").find(cEscapedChar));
         const bool bEscapedCharNotFound(nEscapedCharPos == (MIuint)std::string::npos);
         if (bEscapedCharNotFound)
             strNew.push_back(cBckSlash);
         strNew.push_back(cEscapedChar);
         nOffset = nBckSlashPos + 2;
     }