Convert some breakpoint code to use StringRef.

Differential revision: https://reviews.llvm.org/D25158

llvm-svn: 283345

lldb/source/Breakpoint/BreakpointIDList.cpp

@@ -57,19 +57,12 @@ bool BreakpointIDList::AddBreakpointID(BreakpointID bp_id) {
 }
 
 bool BreakpointIDList::AddBreakpointID(const char *bp_id_str) {
-  BreakpointID temp_bp_id;
-  break_id_t bp_id;
-  break_id_t loc_id;
+  auto bp_id = BreakpointID::ParseCanonicalReference(bp_id_str);
+  if (!bp_id.hasValue())
+    return false;
 
-  bool success =
-      BreakpointID::ParseCanonicalReference(bp_id_str, &bp_id, &loc_id);
-
-  if (success) {
-    temp_bp_id.SetID(bp_id, loc_id);
-    m_breakpoint_ids.push_back(temp_bp_id);
-  }
-
-  return success;
+  m_breakpoint_ids.push_back(*bp_id);
+  return true;
 }
 
 bool BreakpointIDList::FindBreakpointID(BreakpointID &bp_id,
@@ -88,15 +81,11 @@ bool BreakpointIDList::FindBreakpointID(BreakpointID &bp_id,
 
 bool BreakpointIDList::FindBreakpointID(const char *bp_id_str,
                                         size_t *position) const {
-  BreakpointID temp_bp_id;
-  break_id_t bp_id;
-  break_id_t loc_id;
-
-  if (BreakpointID::ParseCanonicalReference(bp_id_str, &bp_id, &loc_id)) {
-    temp_bp_id.SetID(bp_id, loc_id);
-    return FindBreakpointID(temp_bp_id, position);
-  } else
+  auto bp_id = BreakpointID::ParseCanonicalReference(bp_id_str);
+  if (!bp_id.hasValue())
     return false;
+
+  return FindBreakpointID(*bp_id, position);
 }
 
 void BreakpointIDList::InsertStringArray(const char **string_array,
@@ -106,20 +95,14 @@ void BreakpointIDList::InsertStringArray(const char **string_array,
     return;
 
   for (uint32_t i = 0; i < array_size; ++i) {
-    break_id_t bp_id;
-    break_id_t loc_id;
-
-    if (BreakpointID::ParseCanonicalReference(string_array[i], &bp_id,
-                                              &loc_id)) {
-      if (bp_id != LLDB_INVALID_BREAK_ID) {
-        BreakpointID temp_bp_id(bp_id, loc_id);
-        m_breakpoint_ids.push_back(temp_bp_id);
-      } else {
-        result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n",
-                                     string_array[i]);
-        result.SetStatus(eReturnStatusFailed);
-        return;
-      }
+    auto bp_id = BreakpointID::ParseCanonicalReference(string_array[i]);
+    if (bp_id.hasValue()) {
+      m_breakpoint_ids.push_back(*bp_id);
+    } else {
+      result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n",
+                                   string_array[i]);
+      result.SetStatus(eReturnStatusFailed);
+      return;
     }
   }
   result.SetStatus(eReturnStatusSuccessFinishNoResult);
@@ -142,9 +125,9 @@ void BreakpointIDList::FindAndReplaceIDRanges(Args &old_args, Target *target,
                                               bool allow_locations,
                                               CommandReturnObject &result,
                                               Args &new_args) {
-  std::string range_start;
-  const char *range_end;
-  const char *current_arg;
+  llvm::StringRef range_from;
+  llvm::StringRef range_to;
+  llvm::StringRef current_arg;
   const size_t num_old_args = old_args.GetArgumentCount();
   std::set<std::string> names_found;
 
@@ -152,24 +135,22 @@ void BreakpointIDList::FindAndReplaceIDRanges(Args &old_args, Target *target,
     bool is_range = false;
 
     current_arg = old_args.GetArgumentAtIndex(i);
-    if (!allow_locations && strchr(current_arg, '.') != nullptr) {
+    if (!allow_locations && current_arg.contains('.')) {
       result.AppendErrorWithFormat(
-          "Breakpoint locations not allowed, saw location: %s.", current_arg);
+          "Breakpoint locations not allowed, saw location: %s.",
+          current_arg.str().c_str());
       new_args.Clear();
       return;
     }
 
-    size_t range_start_len = 0;
-    size_t range_end_pos = 0;
+    llvm::StringRef range_expr;
     Error error;
 
-    if (BreakpointIDList::StringContainsIDRangeExpression(
-            current_arg, &range_start_len, &range_end_pos)) {
+    std::tie(range_from, range_to) =
+        BreakpointIDList::SplitIDRangeExpression(current_arg);
+    if (!range_from.empty() && !range_to.empty()) {
       is_range = true;
-      range_start.assign(current_arg, range_start_len);
-      range_end = current_arg + range_end_pos;
-    } else if (BreakpointID::StringIsBreakpointName(
-                   llvm::StringRef(current_arg), error)) {
+    } else if (BreakpointID::StringIsBreakpointName(current_arg, error)) {
       if (!error.Success()) {
         new_args.Clear();
         result.AppendError(error.AsCString());
@@ -183,28 +164,27 @@ void BreakpointIDList::FindAndReplaceIDRanges(Args &old_args, Target *target,
                BreakpointID::IsValidIDExpression(current_arg) &&
                BreakpointID::IsValidIDExpression(
                    old_args.GetArgumentAtIndex(i + 2))) {
-      range_start.assign(current_arg);
-      range_end = old_args.GetArgumentAtIndex(i + 2);
+      range_from = current_arg;
+      range_to = old_args.GetArgumentAtIndex(i + 2);
       is_range = true;
       i = i + 2;
     } else {
       // See if user has specified id.*
-      std::string tmp_str = old_args.GetArgumentAtIndex(i);
+      llvm::StringRef tmp_str = old_args.GetArgumentAtIndex(i);
       size_t pos = tmp_str.find('.');
-      if (pos != std::string::npos) {
-        std::string bp_id_str = tmp_str.substr(0, pos);
-        if (BreakpointID::IsValidIDExpression(bp_id_str.c_str()) &&
-            tmp_str[pos + 1] == '*' && tmp_str.length() == (pos + 2)) {
-          break_id_t bp_id;
-          break_id_t bp_loc_id;
+      if (pos != llvm::StringRef::npos) {
+        llvm::StringRef bp_id_str = tmp_str.substr(0, pos);
+        if (BreakpointID::IsValidIDExpression(bp_id_str) &&
+            tmp_str[pos + 1] == '*' && tmp_str.size() == (pos + 2)) {
 
-          BreakpointID::ParseCanonicalReference(bp_id_str.c_str(), &bp_id,
-                                                &bp_loc_id);
-          BreakpointSP breakpoint_sp = target->GetBreakpointByID(bp_id);
+          BreakpointSP breakpoint_sp;
+          auto bp_id = BreakpointID::ParseCanonicalReference(bp_id_str);
+          if (bp_id.hasValue())
+            breakpoint_sp = target->GetBreakpointByID(bp_id->GetBreakpointID());
           if (!breakpoint_sp) {
             new_args.Clear();
             result.AppendErrorWithFormat("'%d' is not a valid breakpoint ID.\n",
-                                         bp_id);
+                                         bp_id->GetBreakpointID());
             result.SetStatus(eReturnStatusFailed);
             return;
           }
@@ -213,127 +193,120 @@ void BreakpointIDList::FindAndReplaceIDRanges(Args &old_args, Target *target,
             BreakpointLocation *bp_loc =
                 breakpoint_sp->GetLocationAtIndex(j).get();
             StreamString canonical_id_str;
-            BreakpointID::GetCanonicalReference(&canonical_id_str, bp_id,
-                                                bp_loc->GetID());
+            BreakpointID::GetCanonicalReference(
+                &canonical_id_str, bp_id->GetBreakpointID(), bp_loc->GetID());
             new_args.AppendArgument(canonical_id_str.GetString());
           }
         }
       }
     }
 
-    if (is_range) {
-      break_id_t start_bp_id;
-      break_id_t end_bp_id;
-      break_id_t start_loc_id;
-      break_id_t end_loc_id;
+    if (!is_range) {
+      new_args.AppendArgument(current_arg);
+      continue;
+    }
 
-      BreakpointID::ParseCanonicalReference(range_start.c_str(), &start_bp_id,
-                                            &start_loc_id);
-      BreakpointID::ParseCanonicalReference(range_end, &end_bp_id, &end_loc_id);
+    auto start_bp = BreakpointID::ParseCanonicalReference(range_from);
+    auto end_bp = BreakpointID::ParseCanonicalReference(range_to);
 
-      if ((start_bp_id == LLDB_INVALID_BREAK_ID) ||
-          (!target->GetBreakpointByID(start_bp_id))) {
+    if (!start_bp.hasValue() ||
+        !target->GetBreakpointByID(start_bp->GetBreakpointID())) {
+      new_args.Clear();
+      result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n",
+                                   range_from.str().c_str());
+      result.SetStatus(eReturnStatusFailed);
+      return;
+    }
+
+    if (!end_bp.hasValue() ||
+        !target->GetBreakpointByID(end_bp->GetBreakpointID())) {
+      new_args.Clear();
+      result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n",
+                                   range_to.str().c_str());
+      result.SetStatus(eReturnStatusFailed);
+      return;
+    }
+    break_id_t start_bp_id = start_bp->GetBreakpointID();
+    break_id_t start_loc_id = start_bp->GetLocationID();
+    break_id_t end_bp_id = end_bp->GetBreakpointID();
+    break_id_t end_loc_id = end_bp->GetLocationID();
+    if (((start_bp_id == LLDB_INVALID_BREAK_ID) &&
+            (end_bp_id != LLDB_INVALID_BREAK_ID)) ||
+        ((start_loc_id != LLDB_INVALID_BREAK_ID) &&
+         (end_loc_id == LLDB_INVALID_BREAK_ID))) {
+      new_args.Clear();
+      result.AppendErrorWithFormat("Invalid breakpoint id range:  Either "
+                                   "both ends of range must specify"
+                                   " a breakpoint location, or neither can "
+                                   "specify a breakpoint location.\n");
+      result.SetStatus(eReturnStatusFailed);
+      return;
+    }
+
+    // We have valid range starting & ending breakpoint IDs.  Go through all
+    // the breakpoints in the target and find all the breakpoints that fit
+    // into this range, and add them to new_args.
+
+    // Next check to see if we have location id's.  If so, make sure the
+    // start_bp_id and end_bp_id are for the same breakpoint; otherwise we
+    // have an illegal range: breakpoint id ranges that specify bp locations
+    // are NOT allowed to cross major bp id numbers.
+
+    if ((start_loc_id != LLDB_INVALID_BREAK_ID) ||
+        (end_loc_id != LLDB_INVALID_BREAK_ID)) {
+      if (start_bp_id != end_bp_id) {
         new_args.Clear();
-        result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n",
-                                     range_start.c_str());
+        result.AppendErrorWithFormat(
+            "Invalid range: Ranges that specify particular breakpoint "
+            "locations"
+            " must be within the same major breakpoint; you specified two"
+            " different major breakpoints, %d and %d.\n",
+            start_bp_id, end_bp_id);
         result.SetStatus(eReturnStatusFailed);
         return;
       }
+    }
 
-      if ((end_bp_id == LLDB_INVALID_BREAK_ID) ||
-          (!target->GetBreakpointByID(end_bp_id))) {
-        new_args.Clear();
-        result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n",
-                                     range_end);
-        result.SetStatus(eReturnStatusFailed);
-        return;
-      }
+    const BreakpointList &breakpoints = target->GetBreakpointList();
+    const size_t num_breakpoints = breakpoints.GetSize();
+    for (size_t j = 0; j < num_breakpoints; ++j) {
+      Breakpoint *breakpoint = breakpoints.GetBreakpointAtIndex(j).get();
+      break_id_t cur_bp_id = breakpoint->GetID();
 
-      if (((start_loc_id == LLDB_INVALID_BREAK_ID) &&
-           (end_loc_id != LLDB_INVALID_BREAK_ID)) ||
-          ((start_loc_id != LLDB_INVALID_BREAK_ID) &&
-           (end_loc_id == LLDB_INVALID_BREAK_ID))) {
-        new_args.Clear();
-        result.AppendErrorWithFormat("Invalid breakpoint id range:  Either "
-                                     "both ends of range must specify"
-                                     " a breakpoint location, or neither can "
-                                     "specify a breakpoint location.\n");
-        result.SetStatus(eReturnStatusFailed);
-        return;
-      }
+      if ((cur_bp_id < start_bp_id) || (cur_bp_id > end_bp_id))
+        continue;
 
-      // We have valid range starting & ending breakpoint IDs.  Go through all
-      // the breakpoints in the
-      // target and find all the breakpoints that fit into this range, and add
-      // them to new_args.
+      const size_t num_locations = breakpoint->GetNumLocations();
 
-      // Next check to see if we have location id's.  If so, make sure the
-      // start_bp_id and end_bp_id are
-      // for the same breakpoint; otherwise we have an illegal range: breakpoint
-      // id ranges that specify
-      // bp locations are NOT allowed to cross major bp id numbers.
-
-      if ((start_loc_id != LLDB_INVALID_BREAK_ID) ||
-          (end_loc_id != LLDB_INVALID_BREAK_ID)) {
-        if (start_bp_id != end_bp_id) {
-          new_args.Clear();
-          result.AppendErrorWithFormat(
-              "Invalid range: Ranges that specify particular breakpoint "
-              "locations"
-              " must be within the same major breakpoint; you specified two"
-              " different major breakpoints, %d and %d.\n",
-              start_bp_id, end_bp_id);
-          result.SetStatus(eReturnStatusFailed);
-          return;
-        }
-      }
-
-      const BreakpointList &breakpoints = target->GetBreakpointList();
-      const size_t num_breakpoints = breakpoints.GetSize();
-      for (size_t j = 0; j < num_breakpoints; ++j) {
-        Breakpoint *breakpoint = breakpoints.GetBreakpointAtIndex(j).get();
-        break_id_t cur_bp_id = breakpoint->GetID();
-
-        if ((cur_bp_id < start_bp_id) || (cur_bp_id > end_bp_id))
-          continue;
-
-        const size_t num_locations = breakpoint->GetNumLocations();
-
-        if ((cur_bp_id == start_bp_id) &&
-            (start_loc_id != LLDB_INVALID_BREAK_ID)) {
-          for (size_t k = 0; k < num_locations; ++k) {
-            BreakpointLocation *bp_loc =
-                breakpoint->GetLocationAtIndex(k).get();
-            if ((bp_loc->GetID() >= start_loc_id) &&
-                (bp_loc->GetID() <= end_loc_id)) {
-              StreamString canonical_id_str;
-              BreakpointID::GetCanonicalReference(&canonical_id_str, cur_bp_id,
-                                                  bp_loc->GetID());
-              new_args.AppendArgument(canonical_id_str.GetString());
-            }
+      if ((cur_bp_id == start_bp_id) &&
+          (start_loc_id != LLDB_INVALID_BREAK_ID)) {
+        for (size_t k = 0; k < num_locations; ++k) {
+          BreakpointLocation *bp_loc = breakpoint->GetLocationAtIndex(k).get();
+          if ((bp_loc->GetID() >= start_loc_id) &&
+              (bp_loc->GetID() <= end_loc_id)) {
+            StreamString canonical_id_str;
+            BreakpointID::GetCanonicalReference(&canonical_id_str, cur_bp_id,
+                                                bp_loc->GetID());
+            new_args.AppendArgument(canonical_id_str.GetString());
           }
-        } else if ((cur_bp_id == end_bp_id) &&
-                   (end_loc_id != LLDB_INVALID_BREAK_ID)) {
-          for (size_t k = 0; k < num_locations; ++k) {
-            BreakpointLocation *bp_loc =
-                breakpoint->GetLocationAtIndex(k).get();
-            if (bp_loc->GetID() <= end_loc_id) {
-              StreamString canonical_id_str;
-              BreakpointID::GetCanonicalReference(&canonical_id_str, cur_bp_id,
-                                                  bp_loc->GetID());
-              new_args.AppendArgument(canonical_id_str.GetString());
-            }
-          }
-        } else {
-          StreamString canonical_id_str;
-          BreakpointID::GetCanonicalReference(&canonical_id_str, cur_bp_id,
-                                              LLDB_INVALID_BREAK_ID);
-          new_args.AppendArgument(canonical_id_str.GetString());
         }
+      } else if ((cur_bp_id == end_bp_id) &&
+                 (end_loc_id != LLDB_INVALID_BREAK_ID)) {
+        for (size_t k = 0; k < num_locations; ++k) {
+          BreakpointLocation *bp_loc = breakpoint->GetLocationAtIndex(k).get();
+          if (bp_loc->GetID() <= end_loc_id) {
+            StreamString canonical_id_str;
+            BreakpointID::GetCanonicalReference(&canonical_id_str, cur_bp_id,
+                                                bp_loc->GetID());
+            new_args.AppendArgument(canonical_id_str.GetString());
+          }
+        }
+      } else {
+        StreamString canonical_id_str;
+        BreakpointID::GetCanonicalReference(&canonical_id_str, cur_bp_id,
+                                            LLDB_INVALID_BREAK_ID);
+        new_args.AppendArgument(canonical_id_str.GetString());
       }
-    } else // else is_range was false
-    {
-      new_args.AppendArgument(llvm::StringRef::withNullAsEmpty(current_arg));
     }
   }
 
@@ -354,45 +327,22 @@ void BreakpointIDList::FindAndReplaceIDRanges(Args &old_args, Target *target,
   result.SetStatus(eReturnStatusSuccessFinishNoResult);
 }
 
-bool BreakpointIDList::StringContainsIDRangeExpression(const char *in_string,
-                                                       size_t *range_start_len,
-                                                       size_t *range_end_pos) {
-  bool is_range_expression = false;
-  std::string arg_str = in_string;
-  std::string::size_type idx;
-  std::string::size_type start_pos = 0;
+std::pair<llvm::StringRef, llvm::StringRef>
+BreakpointIDList::SplitIDRangeExpression(llvm::StringRef in_string) {
+  for (auto specifier_str : BreakpointID::GetRangeSpecifiers()) {
+    size_t idx = in_string.find(specifier_str);
+    if (idx == llvm::StringRef::npos)
+      continue;
+    llvm::StringRef right1 = in_string.drop_front(idx);
 
-  *range_start_len = 0;
-  *range_end_pos = 0;
+    llvm::StringRef from = in_string.take_front(idx);
+    llvm::StringRef to = right1.drop_front(specifier_str.size());
 
-  int specifiers_size = 0;
-  for (int i = 0; BreakpointID::g_range_specifiers[i] != nullptr; ++i)
-    ++specifiers_size;
-
-  for (int i = 0; i < specifiers_size && !is_range_expression; ++i) {
-    const char *specifier_str = BreakpointID::g_range_specifiers[i];
-    size_t len = strlen(specifier_str);
-    idx = arg_str.find(BreakpointID::g_range_specifiers[i]);
-    if (idx != std::string::npos) {
-      *range_start_len = idx - start_pos;
-      std::string start_str = arg_str.substr(start_pos, *range_start_len);
-      if (idx + len < arg_str.length()) {
-        *range_end_pos = idx + len;
-        std::string end_str = arg_str.substr(*range_end_pos);
-        if (BreakpointID::IsValidIDExpression(start_str.c_str()) &&
-            BreakpointID::IsValidIDExpression(end_str.c_str())) {
-          is_range_expression = true;
-          //*range_start = start_str;
-          //*range_end = end_str;
-        }
-      }
+    if (BreakpointID::IsValidIDExpression(from) &&
+        BreakpointID::IsValidIDExpression(to)) {
+      return std::make_pair(from, to);
     }
   }
 
-  if (!is_range_expression) {
-    *range_start_len = 0;
-    *range_end_pos = 0;
-  }
-
-  return is_range_expression;
+  return std::pair<llvm::StringRef, llvm::StringRef>();
 }