[lldb-mi] Use size_t where appropriate.

[brucem]

Summary

Many places should have been using size_t rather than MIuint or
MIint. This is particularly true for code that uses std::string::find(),
std::string::rfind(), std::string::size(), and related methods.

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

 // Throws:  None.
 //--
 bool
 CMICmdArgContext::RemoveArg(const CMIUtilString &vArg)
 {
     if (vArg.empty())
         return MIstatus::success;
 
-    const MIuint nLen = vArg.length();
-    const MIuint nLenCntxt = m_strCmdArgsAndOptions.length();
+    const size_t nLen = vArg.length();
+    const size_t nLenCntxt = m_strCmdArgsAndOptions.length();
     if (nLen > nLenCntxt)
         return MIstatus::failure;
 
-    MIuint nExtraSpace = 0;
-    MIint nPos = m_strCmdArgsAndOptions.find(vArg);
+    size_t nExtraSpace = 0;
+    size_t nPos = m_strCmdArgsAndOptions.find(vArg);
     while (1)
     {
-        if (nPos == (MIint)std::string::npos)
+        if (nPos == std::string::npos)
             return MIstatus::success;
 
         bool bPass1 = false;
         if (nPos != 0)
         {
             if (m_strCmdArgsAndOptions[nPos - 1] == ' ')
                 bPass1 = true;
         }
         else
             bPass1 = true;
 
-        const MIuint nEnd = nPos + nLen;
+        const size_t nEnd = nPos + nLen;
 
         if (bPass1)
         {
             bool bPass2 = false;
             if (nEnd < nLenCntxt)
             {
                 if (m_strCmdArgsAndOptions[nEnd] == ' ')
                 {
                     bPass2 = true;
                     nExtraSpace = 1;
                 }
             }
             else
                 bPass2 = true;
 
             if (bPass2)
                 break;
         }
 
         nPos = m_strCmdArgsAndOptions.find(vArg, nEnd);
     }
 
-    const MIuint nPosEnd = nLen + nExtraSpace;
+    const size_t nPosEnd = nLen + nExtraSpace;
     m_strCmdArgsAndOptions = m_strCmdArgsAndOptions.replace(nPos, nPosEnd, "").c_str();
     m_strCmdArgsAndOptions = m_strCmdArgsAndOptions.Trim();
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Remove the argument at the Nth word position along in the context string.

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

 //--
 CMIUtilString
 CMICmdArgValFile::GetFileNamePath(const CMIUtilString &vrTxt) const
 {
     CMIUtilString fileNamePath(vrTxt);
 
     // Look for a space in the path
     const char cSpace = ' ';
-    const MIint nPos = fileNamePath.find(cSpace);
-    if (nPos != (MIint)std::string::npos)
+    const size_t nPos = fileNamePath.find(cSpace);
+    if (nPos != std::string::npos)
         fileNamePath = CMIUtilString::Format("\"%s\"", fileNamePath.c_str());
 
     return fileNamePath;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Examine the string and determine if it is a valid file name path.
 // Type:    Method.
 // Args:    vrFileNamePath  - (R) File's name and directory path.
 // Return:  bool -  True = yes valid file path, false = no.
 // Throws:  None.
 //--
 bool
 CMICmdArgValFile::IsFilePath(const CMIUtilString &vrFileNamePath) const
 {
     if (vrFileNamePath.empty())
         return false;
 
     const bool bHavePosSlash = (vrFileNamePath.find_first_of("/") != std::string::npos);
     const bool bHaveBckSlash = (vrFileNamePath.find_first_of("\\") != std::string::npos);
 
     // Look for --someLongOption
-    MIint nPos = vrFileNamePath.find_first_of("--");
+    size_t nPos = vrFileNamePath.find_first_of("--");
     const bool bLong = (nPos == 0);
     if (bLong)
         return false;
 
     // Look for -f type short parameters
     nPos = vrFileNamePath.find_first_of("-");
     const bool bShort = (nPos == 0);
     if (bShort)

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

 bool
 CMICmdArgValOptionLong::IsArgLongOption(const CMIUtilString &vrTxt) const
 {
     const bool bHavePosSlash = (vrTxt.find_first_of("/") != std::string::npos);
     const bool bHaveBckSlash = (vrTxt.find_first_of("\\") != std::string::npos);
     if (bHavePosSlash || bHaveBckSlash)
         return false;
 
-    const MIint nPos = vrTxt.find_first_of("--");
+    const size_t nPos = vrTxt.find_first_of("--");
     if (nPos != 0)
         return false;
 
     if (vrTxt.length() < 3)
         return false;
 
     const CMIUtilString strArg = vrTxt.substr(2).c_str();
     if (strArg.IsNumber())

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

 CMICmdArgValString::IsStringArgQuotedText(const CMIUtilString &vrTxt) const
 {
     // Accept anything as string word
     if (m_bHandleAnything)
         return true;
 
     // CODETAG_QUOTEDTEXT_SIMILAR_CODE
     const char cQuote = '"';
-    const MIint nPos = vrTxt.find(cQuote);
-    if (nPos == (MIint)std::string::npos)
+    const size_t nPos = vrTxt.find(cQuote);
+    if (nPos == std::string::npos)
         return false;
 
     // Is one and only quote at end of the string
-    if (nPos == (MIint)(vrTxt.length() - 1))
+    if (nPos == (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 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
-    const MIint nPos2 = vrTxt.rfind(cQuote);
-    if (nPos2 == (MIint)std::string::npos)
+    const size_t nPos2 = vrTxt.rfind(cQuote);
+    if (nPos2 == std::string::npos)
         return false;
 
     // Make sure not same quote, need two quotes
     if (nPos == nPos2)
         return MIstatus::failure;
 
     return true;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Examine the string and determine if it is a valid string type argument.
 //          Take into account quotes surrounding the text. Take into account string format
 //          embedded quotes surrounding the text i.e. "\\\"%5d\\\"". Note this function falls
 //          through to IsStringArgQuotedText() should the criteria match fail.
 // Type:    Method.
 // 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 char cBckSlash = '\\';
-    const MIint nPos = vrTxt.find(cBckSlash);
-    if (nPos == (MIint)std::string::npos)
+    const size_t nPos = vrTxt.find(cBckSlash);
+    if (nPos == std::string::npos)
         return false;
 
     // Slash must be the first character in the string or be preceded by a space
     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)
+    const size_t nPos2 = vrTxt.rfind(cBckSlash);
+    if (nPos2 == std::string::npos)
         return false;
 
     // Make sure not same back slash, need two slashes
     if (nPos == nPos2)
         return MIstatus::failure;
 
     return false;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Examine the string and determine if it is a valid string type argument.
 //          Take into account quotes surrounding the text. Take into account string format
 //          embedded quotes surrounding the text i.e. "\\\"%5d\\\"". Note this function falls
 //          through to IsStringArgQuotedTextEmbedded() should the criteria match fail.
 // Type:    Method.
 // Args:    vrTxt   - (R) Some text.
 // Return:  bool    - True = yes valid arg, false = no.
 // Throws:  None.
 //--
 bool
 CMICmdArgValString::IsStringArgQuotedQuotedTextEmbedded(const CMIUtilString &vrTxt) const
 {
-    const MIint nPos = vrTxt.find("\"\\\"");
-    if (nPos == (MIint)std::string::npos)
+    const size_t nPos = vrTxt.find("\"\\\"");
+    if (nPos == std::string::npos)
         return false;
 
-    const MIint nPos2 = vrTxt.rfind("\\\"\"");
-    if (nPos2 == (MIint)std::string::npos)
+    const size_t nPos2 = vrTxt.rfind("\\\"\"");
+    if (nPos2 == std::string::npos)
         return false;
 
-    const MIint nLen = vrTxt.length();
+    const size_t nLen = vrTxt.length();
     if ((nLen > 5) && ((nPos + 2) == (nPos2 - 2)))
         return false;
 
     return true;
 }

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

if (strLocation.at(0) == '*')
         // Parse argument:
         // *0x12345
         //  ^^^^^^^ -- address
         const CMIUtilString strAddress(strLocation.c_str() + 1);
         strCmdOptionsLocation = CMIUtilString::Format("--address %s", strAddress.c_str());
     }
     else
     {
-        const MIuint nLineStartPos = strLocation.rfind(':');
-        if ((nLineStartPos == (MIuint)std::string::npos) || (nLineStartPos == 0) || (nLineStartPos == strLocation.length() - 1))
+        const size_t nLineStartPos = strLocation.rfind(':');
+        if ((nLineStartPos == std::string::npos) || (nLineStartPos == 0) || (nLineStartPos == strLocation.length() - 1))
         {
             SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_INVALID_LOCATION_FORMAT), m_cmdData.strMiCmd.c_str(), strLocation.c_str())
                          .c_str());
             return MIstatus::failure;
         }
         // Parse argument:
         // hello.cpp:5
         // ^^^^^^^^^ -- file
else if (m_lldbResult.GetOutputSize() > 0)
         for (MIuint i = 0; i < nLines; ++i)
         {
             // String looks like:
             // LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/to/file:3[:1]
             const CMIUtilString &rLine(vecLines[i]);
 
             // LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/to/file:3[:1]
             // ^^^^^^^^^ -- property
-            const MIuint nPropertyStartPos = rLine.find_first_not_of(' ');
-            const MIuint nPropertyEndPos = rLine.find(':');
-            const MIuint nPropertyLen = nPropertyEndPos - nPropertyStartPos;
+            const size_t nPropertyStartPos = rLine.find_first_not_of(' ');
+            const size_t nPropertyEndPos = rLine.find(':');
+            const size_t nPropertyLen = nPropertyEndPos - nPropertyStartPos;
             const CMIUtilString strProperty(rLine.substr(nPropertyStartPos, nPropertyLen).c_str());
 
             // Skip all except LineEntry
             if (!CMIUtilString::Compare(strProperty, "LineEntry"))
                 continue;
 
             // LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/to/file:3[:1]
             //              ^^^^^^^^^^^^^^^^^^ -- start address
-            const MIuint nStartAddressStartPos = rLine.find("[");
-            const MIuint nStartAddressEndPos = rLine.find("-");
-            const MIuint nStartAddressLen = nStartAddressEndPos - nStartAddressStartPos - 1;
+            const size_t nStartAddressStartPos = rLine.find("[");
+            const size_t nStartAddressEndPos = rLine.find("-");
+            const size_t nStartAddressLen = nStartAddressEndPos - nStartAddressStartPos - 1;
             const CMIUtilString strStartAddress(rLine.substr(nStartAddressStartPos + 1, nStartAddressLen).c_str());
             const CMICmnMIValueConst miValueConst(strStartAddress);
             const CMICmnMIValueResult miValueResult("start", miValueConst);
             CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Done, miValueResult);
 
             // LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/to/file:3[:1]
             //                                 ^^^^^^^^^^^^^^^^^^ -- end address
-            const MIuint nEndAddressEndPos = rLine.find(")");
-            const MIuint nEndAddressLen = nEndAddressEndPos - nStartAddressEndPos - 1;
+            const size_t nEndAddressEndPos = rLine.find(")");
+            const size_t nEndAddressLen = nEndAddressEndPos - nStartAddressEndPos - 1;
             const CMIUtilString strEndAddress(rLine.substr(nStartAddressEndPos + 1, nEndAddressLen).c_str());
             const CMICmnMIValueConst miValueConst2(strEndAddress);
             const CMICmnMIValueResult miValueResult2("end", miValueConst2);
             bool bOk = miRecordResult.Add(miValueResult2);
             if (!bOk)
                 return MIstatus::failure;
 
             // LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/to/file:3[:1]
             //                                                       ^^^^^^^^^^^^^ -- file
             //                                                                     ^ -- line
             //                                                                        ^ -- column (optional)
-            const MIuint nFileStartPos = rLine.find_first_not_of(' ', nEndAddressEndPos + 2);
-            const MIuint nFileOrLineEndPos = rLine.rfind(':');
-            const MIuint nFileOrLineStartPos = rLine.rfind(':', nFileOrLineEndPos - 1);
-            const MIuint nFileEndPos = nFileStartPos < nFileOrLineStartPos ? nFileOrLineStartPos : nFileOrLineEndPos;
-            const MIuint nFileLen = nFileEndPos - nFileStartPos;
+            const size_t nFileStartPos = rLine.find_first_not_of(' ', nEndAddressEndPos + 2);
+            const size_t nFileOrLineEndPos = rLine.rfind(':');
+            const size_t nFileOrLineStartPos = rLine.rfind(':', nFileOrLineEndPos - 1);
+            const size_t nFileEndPos = nFileStartPos < nFileOrLineStartPos ? nFileOrLineStartPos : nFileOrLineEndPos;
+            const size_t nFileLen = nFileEndPos - nFileStartPos;
             const CMIUtilString strFile(rLine.substr(nFileStartPos, nFileLen).c_str());
             const CMICmnMIValueConst miValueConst3(strFile);
             const CMICmnMIValueResult miValueResult3("file", miValueConst3);
             bOk = miRecordResult.Add(miValueResult3);
             if (!bOk)
                 return MIstatus::failure;
 
             // LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/to/file:3[:1]
             //                                                                     ^ -- line
-            const MIuint nLineStartPos = nFileEndPos + 1;
-            const MIuint nLineEndPos = rLine.find(':', nLineStartPos);
-            const MIuint nLineLen = nLineEndPos != (MIuint)std::string::npos ? nLineEndPos - nLineStartPos - 1
-                                                                             : (MIuint)std::string::npos;
+            const size_t nLineStartPos = nFileEndPos + 1;
+            const size_t nLineEndPos = rLine.find(':', nLineStartPos);
+            const size_t nLineLen = nLineEndPos != std::string::npos ? nLineEndPos - nLineStartPos - 1
+                                                                     : std::string::npos;
             const CMIUtilString strLine(rLine.substr(nLineStartPos, nLineLen).c_str());
             const CMICmnMIValueConst miValueConst4(strLine);
             const CMICmnMIValueResult miValueResult4("line", miValueConst4);
             bOk = miRecordResult.Add(miValueResult4);
             if (!bOk)
                 return MIstatus::failure;
 
             // MI print "%s^done,start=\"%d\",end=\"%d\"",file=\"%s\",line=\"%d\"

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

else
         for (MIuint i = 1; i < nLines; ++i)
         {
             // String looks like:
             // 0x0000000100000e70: /path/to/file:3[:4]
             const CMIUtilString &rLine(vecLines[i]);
 
             // 0x0000000100000e70: /path/to/file:3[:4]
             // ^^^^^^^^^^^^^^^^^^ -- pc
-            const MIuint nAddrEndPos = rLine.find(':');
+            const size_t nAddrEndPos = rLine.find(':');
             const CMIUtilString strAddr(rLine.substr(0, nAddrEndPos).c_str());
             const CMICmnMIValueConst miValueConst(strAddr);
             const CMICmnMIValueResult miValueResult("pc", miValueConst);
             CMICmnMIValueTuple miValueTuple(miValueResult);
 
             // 0x0000000100000e70: /path/to/file:3[:4]
             //                                   ^ -- line
-            const MIuint nLineOrColumnStartPos = rLine.rfind(':');
+            const size_t nLineOrColumnStartPos = rLine.rfind(':');
             const CMIUtilString strLineOrColumn(rLine.substr(nLineOrColumnStartPos + 1).c_str());
-            const MIuint nPathOrLineStartPos = rLine.rfind(':', nLineOrColumnStartPos - 1);
-            const MIuint nPathOrLineLen = nLineOrColumnStartPos - nPathOrLineStartPos - 1;
+            const size_t nPathOrLineStartPos = rLine.rfind(':', nLineOrColumnStartPos - 1);
+            const size_t nPathOrLineLen = nLineOrColumnStartPos - nPathOrLineStartPos - 1;
             const CMIUtilString strPathOrLine(rLine.substr(nPathOrLineStartPos + 1, nPathOrLineLen).c_str());
             const CMIUtilString strLine(strPathOrLine.IsNumber() ? strPathOrLine : strLineOrColumn);
             const CMICmnMIValueConst miValueConst2(strLine);
             const CMICmnMIValueResult miValueResult2("line", miValueConst2);
             bool bOk = miValueTuple.Add(miValueResult2);
 
             bOk = bOk && miValueList.Add(miValueTuple);
             if (!bOk)

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

CMICmdFactory::IsValid(const CMIUtilString &vMiCmd) const
     bool bValid = true;
 
     if (vMiCmd.empty())
     {
         bValid = false;
         return false;
     }
 
-    const MIint nPos = vMiCmd.find(" ");
-    if (nPos != (MIint)std::string::npos)
+    const size_t nPos = vMiCmd.find(" ");
+    if (nPos != std::string::npos)
         bValid = false;
 
     return bValid;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Check a command is already registered.
 // Type:    Method.

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

 // Args:    vTextLine   - (R) Text data to interpret.
 // Return:  bool  - True = yes command token present, false = command not recognised.
 // Throws:  None.
 //--
 bool
 CMICmdInterpreter::MiHasCmdTokenEndingHyphen(const CMIUtilString &vTextLine)
 {
     // The hyphen is mandatory
-    const MIint nPos = vTextLine.find("-", 0);
-    if ((nPos == (MIint)std::string::npos))
+    const size_t nPos = vTextLine.find("-", 0);
+    if ((nPos == std::string::npos))
         return false;
 
     if (MiHasCmdTokenPresent(vTextLine))
     {
         const std::string strNum = vTextLine.substr(0, nPos);
         if (!CMIUtilString(strNum.c_str()).IsNumber())
             return false;
 

 // Type:    Method.
 // Args:    vTextLine - (R) Text data to interpret.
 // Return:  bool  - True = yes command token present, false = token not present.
 // Throws:  None.
 //--
 bool
 CMICmdInterpreter::MiHasCmdTokenPresent(const CMIUtilString &vTextLine)
 {
-    const MIint nPos = vTextLine.find("-", 0);
+    const size_t nPos = vTextLine.find("-", 0);
     return (nPos > 0);
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Does the command name entered match the criteria for a MI command format.
 //          Is a recognised command present? The command name is entered into the
 //          command meta data structure whether correct or not for reporting or later
 //          command execution purposes. Command options is present are also put into the
 //          command meta data structure.
 // Type:    Method.
 // Args:    vTextLine   - (R) Command information structure.
 // Return:  bool  - True = yes command name present, false = command not recognised.
 // Throws:  None.
 //--
 bool
 CMICmdInterpreter::MiHasCmd(const CMIUtilString &vTextLine)
 {
-    MIint nPos = 0;
+    size_t nPos = 0;
     if (m_miCmdData.bMIOldStyle)
     {
         char cChar = vTextLine[0];
-        MIuint i = 0;
+        size_t i = 0;
         while (::isdigit(cChar) != 0)
         {
             cChar = vTextLine[++i];
         }
         nPos = --i;
     }
     else
     {
         nPos = vTextLine.find("-", 0);
     }
 
     bool bFoundCmd = false;
-    const MIint nLen = vTextLine.length();
-    const MIint nPos2 = vTextLine.find(" ", nPos);
-    if (nPos2 != (MIint)std::string::npos)
+    const size_t nLen = vTextLine.length();
+    const size_t nPos2 = vTextLine.find(" ", nPos);
+    if (nPos2 != std::string::npos)
     {
         if (nPos2 == nLen)
             return false;
         const CMIUtilString cmd = CMIUtilString(vTextLine.substr(nPos + 1, nPos2 - nPos - 1).c_str());
         if (cmd.empty())
             return false;
 
         m_miCmdData.strMiCmd = cmd;

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

CMICmnLogMediumFile::MassagedData(const CMIUtilString &vData, const CMICmnLog::ELogVerbosity veType)
     CMIUtilString data;
     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())
+    const size_t pos = vData.rfind(strCr);
+    if (pos == vData.size())
         return data;
 
     // ... did not have an EOL so add one
     data += GetLineReturn();
 
     return data;
 }
 

 CMICmnLogMediumFile::ConvertCr(const CMIUtilString &vData) const
 {
     const CMIUtilString strCr("\n");
     const CMIUtilString &rCrCmpat(GetLineReturn());
 
     if (strCr == rCrCmpat)
         return vData;
 
-    const MIuint nSizeCmpat(rCrCmpat.size());
-    const MIuint nSize(strCr.size());
+    const size_t nSizeCmpat(rCrCmpat.size());
+    const size_t nSize(strCr.size());
     CMIUtilString strConv(vData);
-    MIint pos = strConv.find(strCr);
-    while (pos != (MIint)CMIUtilString::npos)
+    size_t pos = strConv.find(strCr);
+    while (pos != CMIUtilString::npos)
     {
         strConv.replace(pos, nSize, rCrCmpat);
         pos = strConv.find(strCr, pos + nSizeCmpat);
     }
 
     return strConv;
 }
 

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

CMIDriver::WrapCLICommandIntoMICommand(const CMIUtilString &vTextLine) const
     // 1. Skip a command token
     // For example:
     // 001-file-exec-and-symbols "/path/to/file"
     // 001target create "/path/to/file"
     //    ^ -- command starts here (in both cases)
     // Also possible case when command not found:
     // 001
     //    ^ -- i.e. only tokens are present (or empty string at all)
-    const MIuint nCommandOffset = vTextLine.find_first_not_of(digits);
+    const size_t nCommandOffset = vTextLine.find_first_not_of(digits);
 
     // 2. Check if command is empty
     // For example:
     // 001-file-exec-and-symbols "/path/to/file"
     // 001target create "/path/to/file"
     //    ^ -- command not empty (in both cases)
     // or:
     // 001
     //    ^ -- command wasn't found
-    const bool bIsEmptyCommand = (nCommandOffset == (MIuint)CMIUtilString::npos);
+    const bool bIsEmptyCommand = (nCommandOffset == CMIUtilString::npos);
 
     // 3. Check and exit if it isn't a CLI command
     // For example:
     // 001-file-exec-and-symbols "/path/to/file"
     // 001
     //    ^ -- it isn't CLI command (in both cases)
     // or:
     // 001target create "/path/to/file"

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

if (bHaveArgs)
                 bHaveArgVersionLong = true;
             }
             if (0 == strArg.compare("--log"))
             {
                 bHaveArgLog = true;
             }
             if (0 == strArg.compare(0,10,"--log-dir="))
             {
-                strLogDir = strArg.substr(10,CMIUtilString::npos);
+                strLogDir = strArg.substr(10, CMIUtilString::npos);
                 bHaveArgLogDir = true;
             }
             if ((0 == strArg.compare("--help")) || (0 == strArg.compare("-h")))
             {
                 bHaveArgHelp = true;
             }
         }
     }

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

 // Type:    Method.
 // Args:    vDirectoryPath  - (R) Text directory path.
 // Return:  CMIUtilString - Directory path.
 // Throws:  None.
 //--
 CMIUtilString
 CMIUtilFileStd::StripOffFileName(const CMIUtilString &vDirectoryPath)
 {
-    const MIint nPos = vDirectoryPath.rfind('\\');
-    MIint nPos2 = vDirectoryPath.rfind('/');
-    if ((nPos == (MIint)std::string::npos) && (nPos2 == (MIint)std::string::npos))
+    const size_t nPos = vDirectoryPath.rfind('\\');
+    size_t nPos2 = vDirectoryPath.rfind('/');
+    if ((nPos == std::string::npos) && (nPos2 == std::string::npos))
         return vDirectoryPath;
 
     if (nPos > nPos2)
         nPos2 = nPos;
 
     const CMIUtilString strPath(vDirectoryPath.substr(0, nPos2).c_str());
     return strPath;
 }

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

public:
     /* 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 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;
+    size_t Split(const CMIUtilString &vDelimiter, VecString_t &vwVecSplits) const;
+    size_t SplitConsiderQuotes(const CMIUtilString &vDelimiter, VecString_t &vwVecSplits) const;
+    size_t SplitLines(VecString_t &vwVecSplits) const;
     CMIUtilString StripCREndOfLine(void) const;
     CMIUtilString StripCRAll(void) const;
     CMIUtilString Trim(void) 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;
+    size_t FindFirst(const CMIUtilString &vrPattern, size_t vnPos = 0) const;
+    size_t FindFirst(const CMIUtilString &vrPattern, bool vbSkipQuotedText, bool &vrwbNotFoundClosedQuote,
+                     size_t vnPos = 0) const;
+    size_t FindFirstNot(const CMIUtilString &vrPattern, size_t vnPos = 0) const;
+    CMIUtilString Escape(bool vbEscapeQuotes = false) const;
     CMIUtilString AddSlashes(void) const;
     CMIUtilString StripSlashes(void) const;
     //
     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 char vChar);
-    MIuint FindFirstQuote(const MIuint vnPos) const;
+    CMIUtilString RemoveRepeatedCharacters(size_t vnPos, const char vChar);
+    size_t FindFirstQuote(size_t vnPos) const;
 };

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

 
 //++ ------------------------------------------------------------------------------------
 // Details: Splits string into array of strings using delimiter. If multiple delimiter
 //          are found in sequence then they are not added to the list of splits.
 // Type:    Method.
 // Args:    vData       - (R) String data to be split up.
 //          vDelimiter  - (R) Delimiter char or text.
 //          vwVecSplits - (W) Container of splits found in string data.
-// Return:  MIuint - Number of splits found in the string data.
+// Return:  size_t - Number of splits found in the string data.
 // Throws:  None.
 //--
-MIuint
+size_t
 CMIUtilString::Split(const CMIUtilString &vDelimiter, VecString_t &vwVecSplits) const
 {
     vwVecSplits.clear();
 
     if (this->empty() || vDelimiter.empty())
         return 0;
 
-    const MIuint nLen(length());
-    MIuint nOffset(0);
+    const size_t nLen(length());
+    size_t nOffset(0);
     do
     {
         // Find first occurrence which doesn't match to the delimiter
-        const MIuint nSectionPos(FindFirstNot(vDelimiter, nOffset));
-        if (nSectionPos == (MIuint)std::string::npos)
+        const size_t nSectionPos(FindFirstNot(vDelimiter, nOffset));
+        if (nSectionPos == std::string::npos)
             break;
 
         // Find next occurrence of the delimiter after section
-        MIuint nNextDelimiterPos(FindFirst(vDelimiter, nSectionPos));
-        if (nNextDelimiterPos == (MIuint)std::string::npos)
+        size_t nNextDelimiterPos(FindFirst(vDelimiter, nSectionPos));
+        if (nNextDelimiterPos == std::string::npos)
             nNextDelimiterPos = nLen;
 
         // Extract string between delimiters
-        const MIuint nSectionLen(nNextDelimiterPos - nSectionPos);
+        const size_t nSectionLen(nNextDelimiterPos - nSectionPos);
         const std::string strSection(substr(nSectionPos, nSectionLen));
         vwVecSplits.push_back(strSection.c_str());
 
         // Next
         nOffset = nNextDelimiterPos + 1;
     }
     while (nOffset < nLen);
 
     return vwVecSplits.size();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Splits string into array of strings using delimiter. However the string is
 //          also considered for text surrounded by quotes. Text with quotes including the
 //          delimiter is treated as a whole. If multiple delimiter are found in sequence
 //          then they are not added to the list of splits. Quotes that are embedded in
 //          the string as string formatted quotes are ignored (proceeded by a '\\') i.e.
 //          "\"MI GDB local C++.cpp\":88".
 // Type:    Method.
 // Args:    vData       - (R) String data to be split up.
 //          vDelimiter  - (R) Delimiter char or text.
 //          vwVecSplits - (W) Container of splits found in string data.
-// Return:  MIuint - Number of splits found in the string data.
+// Return:  size_t - Number of splits found in the string data.
 // Throws:  None.
 //--
-MIuint
+size_t
 CMIUtilString::SplitConsiderQuotes(const CMIUtilString &vDelimiter, VecString_t &vwVecSplits) const
 {
     vwVecSplits.clear();
 
     if (this->empty() || vDelimiter.empty())
         return 0;
 
-    const MIuint nLen(length());
-    MIuint nOffset(0);
+    const size_t nLen(length());
+    size_t nOffset(0);
     do
     {
         // Find first occurrence which doesn't match to the delimiter
-        const MIuint nSectionPos(FindFirstNot(vDelimiter, nOffset));
-        if (nSectionPos == (MIuint)std::string::npos)
+        const size_t nSectionPos(FindFirstNot(vDelimiter, nOffset));
+        if (nSectionPos == std::string::npos)
             break;
 
         // Find next occurrence of the delimiter after (quoted) section
         const bool bSkipQuotedText(true);
         bool bUnmatchedQuote(false);
-        MIuint nNextDelimiterPos(FindFirst(vDelimiter, bSkipQuotedText, bUnmatchedQuote, nSectionPos));
+        size_t nNextDelimiterPos(FindFirst(vDelimiter, bSkipQuotedText, bUnmatchedQuote, nSectionPos));
         if (bUnmatchedQuote)
         {
             vwVecSplits.clear();
             return 0;
         }
-        if (nNextDelimiterPos == (MIuint)std::string::npos)
+        if (nNextDelimiterPos == std::string::npos)
             nNextDelimiterPos = nLen;
 
         // Extract string between delimiters
-        const MIuint nSectionLen(nNextDelimiterPos - nSectionPos);
+        const size_t nSectionLen(nNextDelimiterPos - nSectionPos);
         const std::string strSection(substr(nSectionPos, nSectionLen));
         vwVecSplits.push_back(strSection.c_str());
 
         // Next
         nOffset = nNextDelimiterPos + 1;
     }
     while (nOffset < nLen);
 
     return vwVecSplits.size();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Split string into lines using \n and return an array of strings.
 // Type:    Method.
 // Args:    vwVecSplits - (W) Container of splits found in string data.
-// Return:  MIuint - Number of splits found in the string data.
+// Return:  size_t - Number of splits found in the string data.
 // Throws:  None.
 //--
-MIuint
+size_t
 CMIUtilString::SplitLines(VecString_t &vwVecSplits) const
 {
     return Split("\n", vwVecSplits);
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Remove '\n' from the end of string if found. It does not alter
 //          *this string.
 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString - New version of the string.
 // Throws:  None.
 //--
 CMIUtilString
 CMIUtilString::StripCREndOfLine(void) const
 {
-    const MIint nPos = rfind('\n');
-    if (nPos == (MIint)std::string::npos)
+    const size_t nPos = rfind('\n');
+    if (nPos == std::string::npos)
         return *this;
 
     const CMIUtilString strNew(substr(0, nPos).c_str());
 
     return strNew;
 }
 
 //++ ------------------------------------------------------------------------------------

 // Throws:  None.
 //--
 CMIUtilString
 CMIUtilString::FindAndReplace(const CMIUtilString &vFind, const CMIUtilString &vReplaceWith) const
 {
     if (vFind.empty() || this->empty())
         return *this;
 
-    MIint nPos = find(vFind);
-    if (nPos == (MIint)std::string::npos)
+    size_t nPos = find(vFind);
+    if (nPos == std::string::npos)
         return *this;
 
     CMIUtilString strNew(*this);
-    while (nPos != (MIint)std::string::npos)
+    while (nPos != std::string::npos)
     {
         strNew.replace(nPos, vFind.length(), vReplaceWith);
         nPos += vReplaceWith.length();
         nPos = strNew.find(vFind, nPos);
     }
 
     return strNew;
 }

 CMIUtilString::IsNumber(void) const
 {
     if (empty())
         return false;
 
     if ((at(0) == '-') && (length() == 1))
         return false;
 
-    const MIint nPos = find_first_not_of("-.0123456789");
-    if (nPos != (MIint)std::string::npos)
+    const size_t nPos = find_first_not_of("-.0123456789");
+    if (nPos != std::string::npos)
         return false;
 
     return true;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Check if *this string is a hexadecimal number.
 // Type:    Method.
 // Args:    None.
 // Return:  bool - True = yes number, false not a number.
 // Throws:  None.
 //--
 bool
 CMIUtilString::IsHexadecimalNumber(void) const
 {
     // Compare '0x..' prefix
     if ((strncmp(c_str(), "0x", 2) != 0) && (strncmp(c_str(), "0X", 2) != 0))
         return false;
 
     // Skip '0x..' prefix
-    const MIint nPos = find_first_not_of("01234567890ABCDEFabcedf", 2);
-    if (nPos != (MIint)std::string::npos)
+    const size_t nPos = find_first_not_of("01234567890ABCDEFabcedf", 2);
+    if (nPos != std::string::npos)
         return false;
 
     return true;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Extract the number from the string. The number can be either a hexadecimal or
 //          natural number. It cannot contain other non-numeric characters.

 // Return:  bool - True = yes number, false not a number.
 // Throws:  None.
 //--
 bool
 CMIUtilString::ExtractNumberFromHexadecimal(MIint64 &vwrNumber) const
 {
     vwrNumber = 0;
 
-    const MIint nPos = find_first_not_of("xX01234567890ABCDEFabcedf");
-    if (nPos != (MIint)std::string::npos)
+    const size_t nPos = find_first_not_of("xX01234567890ABCDEFabcedf");
+    if (nPos != std::string::npos)
         return false;
 
     errno = 0;
     const MIuint64 nNum = ::strtoull(this->c_str(), nullptr, 16);
     if (errno == ERANGE)
         return false;
 
     vwrNumber = static_cast<MIint64>(nNum);
 
     return true;
 }
 
 //++ ------------------------------------------------------------------------------------
 // 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 char *vpText)
 {
-    const MIuint len = ::strlen(vpText);
+    const size_t len = ::strlen(vpText);
     if (len == 0)
         return false;
 
-    for (MIuint i = 0; i < len; i++, vpText++)
+    for (size_t i = 0; i < len; i++, vpText++)
     {
         const char c = *vpText;
         if (::isalnum((int)c) == 0)
             return false;
     }
 
     return true;
 }

 // Return:  CMIUtilString - Trimmed string.
 // Throws:  None.
 //--
 CMIUtilString
 CMIUtilString::Trim(void) const
 {
     CMIUtilString strNew(*this);
     const char *pWhiteSpace = " \t\n\v\f\r";
-    const MIint nPos = find_last_not_of(pWhiteSpace);
-    if (nPos != (MIint)std::string::npos)
+    const size_t nPos = find_last_not_of(pWhiteSpace);
+    if (nPos != 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)
+    const size_t nPos2 = strNew.find_first_not_of(pWhiteSpace);
+    if (nPos2 != 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 char vChar) const
 {
     CMIUtilString strNew(*this);
-    const MIint nLen = strNew.length();
+    const size_t nLen = strNew.length();
     if (nLen > 1)
     {
         if ((strNew[0] == vChar) && (strNew[nLen - 1] == vChar))
             strNew = strNew.substr(1, nLen - 2).c_str();
     }
 
     return strNew;
 }

 }
 
 //++ ------------------------------------------------------------------------------------
 // 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.
+//          vnPos   - Character position in the string.
 // Return:  CMIUtilString - New version of the string.
 // Throws:  None.
 //--
 CMIUtilString
-CMIUtilString::RemoveRepeatedCharacters(const MIint vnPos, const char vChar)
+CMIUtilString::RemoveRepeatedCharacters(size_t vnPos, const char vChar)
 {
     const char cQuote = '"';
 
     // Look for first quote of two
-    MIint nPos = find(cQuote, vnPos);
-    if (nPos == (MIint)std::string::npos)
+    const size_t nPos = find(cQuote, vnPos);
+    if (nPos == std::string::npos)
         return *this;
 
-    const MIint nPosNext = nPos + 1;
-    if (nPosNext > (MIint)length())
+    const size_t nPosNext = nPos + 1;
+    if (nPosNext > length())
         return *this;
 
     if (at(nPosNext) == cQuote)
     {
         *this = substr(0, nPos) + substr(nPosNext, length());
         RemoveRepeatedCharacters(nPosNext, vChar);
     }
 

 bool
 CMIUtilString::IsQuoted(void) const
 {
     const char cQuote = '"';
 
     if (at(0) != cQuote)
         return false;
 
-    const MIint nLen = length();
+    const size_t nLen = length();
     if ((nLen > 0) && (at(nLen - 1) != cQuote))
         return false;
 
     return true;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Find first occurrence in *this string which matches the pattern.
 // Type:    Method.
 // Args:    vrPattern   - (R) The pattern to search for.
-//          vnPos       - (R) The starting position at which to start searching. (Dflt = 0)
-// Return:  MIuint - The position of the first substring that match.
+//          vnPos       - The starting position at which to start searching. (Dflt = 0)
+// Return:  size_t - The position of the first substring that match.
 // Throws:  None.
 //--
-MIuint
-CMIUtilString::FindFirst(const CMIUtilString &vrPattern, const MIuint vnPos /* = 0 */) const
+size_t
+CMIUtilString::FindFirst(const CMIUtilString &vrPattern, size_t vnPos /* = 0 */) const
 {
     return find(vrPattern, vnPos);
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Find first occurrence in *this string which matches the pattern and isn't surrounded by quotes.
 // Type:    Method.
 // Args:    vrPattern                 - (R) The pattern to search for.
 //          vbSkipQuotedText          - (R) True = don't look at quoted text, false = otherwise.
 //          vrwbNotFoundClosedQuote   - (W) True = parsing error: unmatched quote, false = otherwise.
-//          vnPos                     - (R) Position of the first character in the string to be considered in the search. (Dflt = 0)
-// Return:  MIuint - The position of the first substring that matches and isn't quoted.
+//          vnPos                     - Position of the first character in the string to be considered in the search. (Dflt = 0)
+// Return:  size_t - The position of the first substring that matches and isn't quoted.
 // Throws:  None.
 //--
-MIuint
+size_t
 CMIUtilString::FindFirst(const CMIUtilString &vrPattern, const bool vbSkipQuotedText, bool &vrwbNotFoundClosedQuote,
-                         const MIuint vnPos /* = 0 */) const
+                         size_t vnPos /* = 0 */) const
 {
     vrwbNotFoundClosedQuote = false;
 
     if (!vbSkipQuotedText)
         return FindFirst(vrPattern, vnPos);
 
-    const MIuint nLen(length());
+    const size_t nLen(length());
 
-    MIuint nPos = vnPos;
+    size_t nPos = vnPos;
     do
     {
-        const MIuint nQuotePos(FindFirstQuote(nPos));
-        const MIuint nPatternPos(FindFirst(vrPattern, nPos));
-        if (nQuotePos == (MIuint)std::string::npos)
+        const size_t nQuotePos(FindFirstQuote(nPos));
+        const size_t nPatternPos(FindFirst(vrPattern, nPos));
+        if (nQuotePos == std::string::npos)
             return nPatternPos;
 
-        const MIuint nQuoteClosedPos = FindFirstQuote(nQuotePos + 1);
-        if (nQuoteClosedPos == (MIuint)std::string::npos)
+        const size_t nQuoteClosedPos = FindFirstQuote(nQuotePos + 1);
+        if (nQuoteClosedPos == std::string::npos)
         {
             vrwbNotFoundClosedQuote = true;
-            return (MIuint)std::string::npos;
+            return std::string::npos;
         }
 
-        if ((nPatternPos == (MIuint)std::string::npos) || (nPatternPos < nQuotePos))
+        if ((nPatternPos == std::string::npos) || (nPatternPos < nQuotePos))
             return nPatternPos;
 
         nPos = nQuoteClosedPos + 1;
     }
     while (nPos < nLen);
 
-    return (MIuint)std::string::npos;
+    return std::string::npos;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Find first occurrence in *this string which doesn't match the pattern.
 // Type:    Method.
 // Args:    vrPattern   - (R) The pattern to search for.
-//          vnPos       - (R) Position of the first character in the string to be considered in the search. (Dflt = 0)
-// Return:  MIuint - The position of the first character that doesn't match.
+//          vnPos       - Position of the first character in the string to be considered in the search. (Dflt = 0)
+// Return:  size_t - The position of the first character that doesn't match.
 // Throws:  None.
 //--
-MIuint
-CMIUtilString::FindFirstNot(const CMIUtilString &vrPattern, const MIuint vnPos /* = 0 */) const
+size_t
+CMIUtilString::FindFirstNot(const CMIUtilString &vrPattern, size_t vnPos /* = 0 */) const
 {
-    const MIuint nLen(length());
-    const MIuint nPatternLen(vrPattern.length());
+    const size_t nLen(length());
+    const size_t nPatternLen(vrPattern.length());
 
-    MIuint nPatternPos(vnPos);
+    size_t nPatternPos(vnPos);
     do
     {
         const bool bMatchPattern(compare(nPatternPos, nPatternLen, vrPattern) == 0);
         if (!bMatchPattern)
             return nPatternPos;
         nPatternPos += nPatternLen;
     }
     while (nPatternPos < nLen);
 
-    return (MIuint)std::string::npos;
+    return std::string::npos;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Find first occurrence of not escaped quotation mark in *this string.
 // 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.
+// Args:    vnPos   - Position of the first character in the string to be considered in the search.
+// Return:  size_t - The position of the quotation mark.
 // Throws:  None.
 //--
-MIuint
-CMIUtilString::FindFirstQuote(const MIuint vnPos) const
+size_t
+CMIUtilString::FindFirstQuote(size_t vnPos) const
 {
     const char cBckSlash('\\');
     const char cQuote('"');
-    const MIuint nLen(length());
+    const size_t nLen(length());
 
-    MIuint nPos = vnPos;
+    size_t 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))
+        const size_t nBckSlashPos(find(cBckSlash, nPos));
+        const size_t nQuotePos(find(cQuote, nPos));
+        if ((nBckSlashPos == std::string::npos) || (nQuotePos == std::string::npos))
             return nQuotePos;
 
         if (nQuotePos < nBckSlashPos)
             return nQuotePos;
 
         // Skip 2 characters: First is '\', second is that which is escaped by '\'
         nPos = nBckSlashPos + 2;
     }
     while (nPos < nLen);
 
-    return (MIuint)std::string::npos;
+    return std::string::npos;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Get escaped string from *this string.
 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString - The escaped version of the initial string.
 // Throws:  None.
 //--
 CMIUtilString
-CMIUtilString::Escape(const bool vbEscapeQuotes /* = false */) const
+CMIUtilString::Escape(bool vbEscapeQuotes /* = false */) const
 {
-    const MIuint nLen(length());
+    const size_t nLen(length());
     CMIUtilString strNew;
     strNew.reserve(nLen);
-    for (MIuint nIndex(0); nIndex < nLen; ++nIndex)
+    for (size_t nIndex(0); nIndex < nLen; ++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 char cBckSlash('\\');
-    const MIuint nLen(length());
+    const size_t nLen(length());
     CMIUtilString strNew;
     strNew.reserve(nLen);
 
-    MIuint nOffset(0);
+    size_t nOffset(0);
     while (nOffset < nLen)
     {
-        const MIuint nUnescapedCharPos(find_first_of("\"\\", nOffset));
-        const bool bUnescapedCharNotFound(nUnescapedCharPos == (MIuint)std::string::npos);
+        const size_t nUnescapedCharPos(find_first_of("\"\\", nOffset));
+        const bool bUnescapedCharNotFound(nUnescapedCharPos == std::string::npos);
         if (bUnescapedCharNotFound)
         {
-            const MIuint nAppendAll((MIuint)std::string::npos);
+            const size_t nAppendAll(std::string::npos);
             strNew.append(*this, nOffset, nAppendAll);
             break;
         }
-        const MIuint nAppendLen(nUnescapedCharPos - nOffset);
+        const size_t nAppendLen(nUnescapedCharPos - nOffset);
         strNew.append(*this, nOffset, nAppendLen);
         strNew.push_back(cBckSlash);
         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 char cBckSlash('\\');
-    const MIuint nLen(length());
+    const size_t nLen(length());
     CMIUtilString strNew;
     strNew.reserve(nLen);
 
-    MIuint nOffset(0);
+    size_t nOffset(0);
     while (nOffset < nLen)
     {
-        const MIuint nBckSlashPos(find(cBckSlash, nOffset));
-        const bool bBckSlashNotFound(nBckSlashPos == (MIuint)std::string::npos);
+        const size_t nBckSlashPos(find(cBckSlash, nOffset));
+        const bool bBckSlashNotFound(nBckSlashPos == std::string::npos);
         if (bBckSlashNotFound)
         {
-            const MIuint nAppendAll((MIuint)std::string::npos);
+            const size_t nAppendAll(std::string::npos);
             strNew.append(*this, nOffset, nAppendAll);
             break;
         }
-        const MIuint nAppendLen(nBckSlashPos - nOffset);
+        const size_t nAppendLen(nBckSlashPos - nOffset);
         strNew.append(*this, nOffset, nAppendLen);
         const bool bBckSlashIsLast(nBckSlashPos == nLen);
         if (bBckSlashIsLast)
         {
             strNew.push_back(cBckSlash);
             break;
         }
         const char cEscapedChar((*this)[nBckSlashPos + 1]);
-        const MIuint nEscapedCharPos(std::string("\"\\").find(cEscapedChar));
-        const bool bEscapedCharNotFound(nEscapedCharPos == (MIuint)std::string::npos);
+        const size_t nEscapedCharPos(std::string("\"\\").find(cEscapedChar));
+        const bool bEscapedCharNotFound(nEscapedCharPos == std::string::npos);
         if (bEscapedCharNotFound)
             strNew.push_back(cBckSlash);
         strNew.push_back(cEscapedChar);
         nOffset = nBckSlashPos + 2;
     }
 
     return strNew;
 }