Optional<std::vector<PassBuilder::PipelineElement>> PassBuilder::parsePipelineText(StringRef Text) { std::vector<PipelineElement> ResultPipeline; SmallVector<std::vector<PipelineElement> *, 4> PipelineStack = { &ResultPipeline}; for (;;) { std::vector<PipelineElement> &Pipeline = *PipelineStack.back(); size_t Pos = Text.find_first_of(",()"); Pipeline.push_back({Text.substr(0, Pos), {}}); // If we have a single terminating name, we're done. if (Pos == Text.npos) break; char Sep = Text[Pos]; Text = Text.substr(Pos + 1); if (Sep == ',') // Just a name ending in a comma, continue. continue; if (Sep == '(') { // Push the inner pipeline onto the stack to continue processing. PipelineStack.push_back(&Pipeline.back().InnerPipeline); continue; } assert(Sep == ')' && "Bogus separator!"); // When handling the close parenthesis, we greedily consume them to avoid // empty strings in the pipeline. do { // If we try to pop the outer pipeline we have unbalanced parentheses. if (PipelineStack.size() == 1) return None; PipelineStack.pop_back(); } while (Text.consume_front(")")); // Check if we've finished parsing. if (Text.empty()) break; // Otherwise, the end of an inner pipeline always has to be followed by // a comma, and then we can continue. if (!Text.consume_front(",")) return None; } if (PipelineStack.size() > 1) // Unbalanced paretheses. return None; assert(PipelineStack.back() == &ResultPipeline && "Wrong pipeline at the bottom of the stack!"); return {std::move(ResultPipeline)}; }
static Optional<int> parseDevirtPassName(StringRef Name) { if (!Name.consume_front("devirt<") || !Name.consume_back(">")) return None; int Count; if (Name.getAsInteger(0, Count) || Count <= 0) return None; return Count; }
Expected<URI> uriFromAbsolutePath(StringRef AbsolutePath) const override { StringRef Body = AbsolutePath; if (!Body.consume_front(testRoot())) return make_error<StringError>(AbsolutePath + "does not start with " + testRoot(), inconvertibleErrorCode()); return URI(Scheme, /*Authority=*/"", sys::path::convert_to_slash(Body)); }
bool HandleComment(Preprocessor &PP, SourceRange Range) override { StringRef Text = Lexer::getSourceText(CharSourceRange::getCharRange(Range), PP.getSourceManager(), PP.getLangOpts()); if (!Text.consume_front(IWYUPragma)) return false; // FIXME(ioeric): resolve the header and store actual file path. For now, // we simply assume the written header is suitable to be #included. Includes->addMapping(PP.getSourceManager().getFilename(Range.getBegin()), isLiteralInclude(Text) ? Text.str() : ("\"" + Text + "\"").str()); return false; }
Expected<std::string> getAbsolutePath(StringRef /*Authority*/, StringRef Body, StringRef HintPath) const override { if (!HintPath.startswith(testRoot())) return make_error<StringError>( "Hint path doesn't start with test root: " + HintPath, inconvertibleErrorCode()); if (!Body.consume_front("/")) return make_error<StringError>( "Body of an unittest: URI must start with '/'", inconvertibleErrorCode()); SmallString<16> Path(Body.begin(), Body.end()); sys::path::native(Path); return testPath(Path); }
static bool parseCommand(StringRef InputString, bool &IsData, std::string &ModuleName, uint64_t &ModuleOffset) { const char kDelimiters[] = " \n\r"; ModuleName = ""; if (InputString.consume_front("CODE ")) { IsData = false; } else if (InputString.consume_front("DATA ")) { IsData = true; } else { // If no cmd, assume it's CODE. IsData = false; } const char *pos = InputString.data(); // Skip delimiters and parse input filename (if needed). if (ClBinaryName.empty()) { pos += strspn(pos, kDelimiters); if (*pos == '"' || *pos == '\'') { char quote = *pos; pos++; const char *end = strchr(pos, quote); if (!end) return false; ModuleName = std::string(pos, end - pos); pos = end + 1; } else { int name_length = strcspn(pos, kDelimiters); ModuleName = std::string(pos, name_length); pos += name_length; } } else { ModuleName = ClBinaryName; } // Skip delimiters and parse module offset. pos += strspn(pos, kDelimiters); int offset_length = strcspn(pos, kDelimiters); return !StringRef(pos, offset_length).getAsInteger(0, ModuleOffset); }
TEST_F(GDBRemoteCommunicationClientTest, TestPacketSpeedJSON) { std::thread server_thread([this] { for (;;) { StringExtractorGDBRemote request; PacketResult result = server.GetPacket(request); if (result == PacketResult::ErrorDisconnected) return; ASSERT_EQ(PacketResult::Success, result); StringRef ref = request.GetStringRef(); ASSERT_TRUE(ref.consume_front("qSpeedTest:response_size:")); int size; ASSERT_FALSE(ref.consumeInteger(10, size)) << "ref: " << ref; std::string response(size, 'X'); ASSERT_EQ(PacketResult::Success, server.SendPacket(response)); } }); StreamString ss; client.TestPacketSpeed(10, 32, 32, 4096, true, ss); client.Disconnect(); server_thread.join(); GTEST_LOG_(INFO) << "Formatted output: " << ss.GetData(); auto object_sp = StructuredData::ParseJSON(ss.GetString()); ASSERT_TRUE(bool(object_sp)); auto dict_sp = object_sp->GetAsDictionary(); ASSERT_TRUE(bool(dict_sp)); object_sp = dict_sp->GetValueForKey("packet_speeds"); ASSERT_TRUE(bool(object_sp)); dict_sp = object_sp->GetAsDictionary(); ASSERT_TRUE(bool(dict_sp)); int num_packets; ASSERT_TRUE(dict_sp->GetValueForKeyAsInteger("num_packets", num_packets)) << ss.GetString(); ASSERT_EQ(10, num_packets); }
StringRef ValueTypeByHwMode::getMVTName(MVT T) { StringRef N = llvm::getEnumName(T.SimpleTy); N.consume_front("MVT::"); return N; }