Subzero: Allow overriding command-line args from the browser.

src/IceRangeSpec.cpp

 //===- subzero/src/IceRangeSpec.cpp - Include/exclude specification -------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 18 matching lines @@
 #include <string>
 #include <unordered_set>
 #include <vector>
 
 namespace Ice {
 
 bool RangeSpec::HasNames = false;
 
 namespace {
 
-/// Helper function to tokenize a string into a vector of string tokens, given a
-/// single delimiter character.  An empty string produces an empty token vector.
-/// Zero-length tokens are allowed, e.g. ",a,,,b," may tokenize to
-/// {"","a","","","b",""}.
-std::vector<std::string> tokenize(const std::string &Spec, char Delimiter) {
-  std::vector<std::string> Tokens;
-  if (!Spec.empty()) {
-    std::string::size_type StartPos = 0;
-    std::string::size_type DelimPos = 0;
-    while (DelimPos != std::string::npos) {
-      DelimPos = Spec.find(Delimiter, StartPos);
-      Tokens.emplace_back(Spec.substr(StartPos, DelimPos - StartPos));
-      StartPos = DelimPos + 1;
-    }
-  }
-  return Tokens;
-}
-
 /// Helper function to parse "X" or "X:Y" into First and Last.
 /// - "X" is treated as "X:X+1".
 /// - ":Y" is treated as "0:Y".
 /// - "X:" is treated as "X:inf"
 ///
 /// Behavior is undefined if "X" or "Y" is not a proper number (since std::stoul
 /// throws an exception).
 ///
 /// If the string doesn't contain 1 or 2 ':' delimiters, or X>=Y,
 /// report_fatal_error is called.
 void getRange(const std::string &Token, uint32_t *First, uint32_t *Last) {
   bool Error = false;
-  auto Tokens = tokenize(Token, RangeSpec::DELIM_RANGE);
+  auto Tokens = RangeSpec::tokenize(Token, RangeSpec::DELIM_RANGE);
   if (Tokens.size() == 1) {
     *First = std::stoul(Tokens[0]);
     *Last = *First + 1;
   } else if (Tokens.size() == 2) {
     *First = Tokens[0].empty() ? 0 : std::stoul(Tokens[0]);
     *Last = Tokens[1].empty() ? RangeSpec::RangeMax : std::stoul(Tokens[1]);
   } else {
     Error = true;
   }
   if (*First >= *Last) {
@@ skipping 25 matching lines @@
       D->Numbers.set(First, Last);
     }
   } else {
     // Otherwise treat it as a single name.
     D->Names.insert(Token);
   }
 }
 
 } // end of anonymous namespace
 
+std::vector<std::string> RangeSpec::tokenize(const std::string &Spec,
+                                             char Delimiter) {
+  std::vector<std::string> Tokens;
+  if (!Spec.empty()) {
+    std::string::size_type StartPos = 0;
+    std::string::size_type DelimPos = 0;
+    while (DelimPos != std::string::npos) {
+      DelimPos = Spec.find(Delimiter, StartPos);
+      Tokens.emplace_back(Spec.substr(StartPos, DelimPos - StartPos));
+      StartPos = DelimPos + 1;
+    }
+  }
+  return Tokens;
+}
+
 /// Initialize the RangeSpec with the given string.  Calling init multiple times
 /// (e.g. init("A");init("B");) is equivalent to init("A,B"); .
 void RangeSpec::init(const std::string &Spec) {
   auto Tokens = tokenize(Spec, DELIM_LIST);
   for (const auto &Token : Tokens) {
     if (Token[0] == '-') {
       exclude(Token.substr(1));
     } else {
       include(Token);
     }
@@ skipping 27 matching lines @@
 
   // Otherwise use the default decision.
   return Excludes.IsExplicit && !Includes.IsExplicit;
 }
 
 void RangeSpec::include(const std::string &Token) { record(Token, &Includes); }
 
 void RangeSpec::exclude(const std::string &Token) { record(Token, &Excludes); }
 
 } // end of namespace Ice