FileCheck.cpp revision 7f8e76f5140be7cc9ed1cb66cdcdedfa28147641
1//===- FileCheck.cpp - Check that File's Contents match what is expected --===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// FileCheck does a line-by line check of a file that validates whether it 11// contains the expected content. This is useful for regression tests etc. 12// 13// This program exits with an error status of 2 on error, exit status of 0 if 14// the file matched the expected contents, and exit status of 1 if it did not 15// contain the expected contents. 16// 17//===----------------------------------------------------------------------===// 18 19#include "llvm/ADT/OwningPtr.h" 20#include "llvm/Support/CommandLine.h" 21#include "llvm/Support/MemoryBuffer.h" 22#include "llvm/Support/PrettyStackTrace.h" 23#include "llvm/Support/Regex.h" 24#include "llvm/Support/SourceMgr.h" 25#include "llvm/Support/raw_ostream.h" 26#include "llvm/Support/Signals.h" 27#include "llvm/Support/system_error.h" 28#include "llvm/ADT/SmallString.h" 29#include "llvm/ADT/StringExtras.h" 30#include "llvm/ADT/StringMap.h" 31#include <algorithm> 32using namespace llvm; 33 34static cl::opt<std::string> 35CheckFilename(cl::Positional, cl::desc("<check-file>"), cl::Required); 36 37static cl::opt<std::string> 38InputFilename("input-file", cl::desc("File to check (defaults to stdin)"), 39 cl::init("-"), cl::value_desc("filename")); 40 41static cl::opt<std::string> 42CheckPrefix("check-prefix", cl::init("CHECK"), 43 cl::desc("Prefix to use from check file (defaults to 'CHECK')")); 44 45static cl::opt<bool> 46NoCanonicalizeWhiteSpace("strict-whitespace", 47 cl::desc("Do not treat all horizontal whitespace as equivalent")); 48 49//===----------------------------------------------------------------------===// 50// Pattern Handling Code. 51//===----------------------------------------------------------------------===// 52 53class Pattern { 54 SMLoc PatternLoc; 55 56 /// MatchEOF - When set, this pattern only matches the end of file. This is 57 /// used for trailing CHECK-NOTs. 58 bool MatchEOF; 59 60 /// FixedStr - If non-empty, this pattern is a fixed string match with the 61 /// specified fixed string. 62 StringRef FixedStr; 63 64 /// RegEx - If non-empty, this is a regex pattern. 65 std::string RegExStr; 66 67 /// \brief Contains the number of line this pattern is in. 68 unsigned LineNumber; 69 70 /// VariableUses - Entries in this vector map to uses of a variable in the 71 /// pattern, e.g. "foo[[bar]]baz". In this case, the RegExStr will contain 72 /// "foobaz" and we'll get an entry in this vector that tells us to insert the 73 /// value of bar at offset 3. 74 std::vector<std::pair<StringRef, unsigned> > VariableUses; 75 76 /// VariableDefs - Entries in this vector map to definitions of a variable in 77 /// the pattern, e.g. "foo[[bar:.*]]baz". In this case, the RegExStr will 78 /// contain "foo(.*)baz" and VariableDefs will contain the pair "bar",1. The 79 /// index indicates what parenthesized value captures the variable value. 80 std::vector<std::pair<StringRef, unsigned> > VariableDefs; 81 82public: 83 84 Pattern(bool matchEOF = false) : MatchEOF(matchEOF) { } 85 86 bool ParsePattern(StringRef PatternStr, SourceMgr &SM, unsigned LineNumber); 87 88 /// Match - Match the pattern string against the input buffer Buffer. This 89 /// returns the position that is matched or npos if there is no match. If 90 /// there is a match, the size of the matched string is returned in MatchLen. 91 /// 92 /// The VariableTable StringMap provides the current values of filecheck 93 /// variables and is updated if this match defines new values. 94 size_t Match(StringRef Buffer, size_t &MatchLen, 95 StringMap<StringRef> &VariableTable) const; 96 97 /// PrintFailureInfo - Print additional information about a failure to match 98 /// involving this pattern. 99 void PrintFailureInfo(const SourceMgr &SM, StringRef Buffer, 100 const StringMap<StringRef> &VariableTable) const; 101 102private: 103 static void AddFixedStringToRegEx(StringRef FixedStr, std::string &TheStr); 104 bool AddRegExToRegEx(StringRef RegExStr, unsigned &CurParen, SourceMgr &SM); 105 106 /// ComputeMatchDistance - Compute an arbitrary estimate for the quality of 107 /// matching this pattern at the start of \arg Buffer; a distance of zero 108 /// should correspond to a perfect match. 109 unsigned ComputeMatchDistance(StringRef Buffer, 110 const StringMap<StringRef> &VariableTable) const; 111 112 /// \brief Evaluates expression and stores the result to \p Value. 113 /// \return true on success. false when the expression has invalid syntax. 114 bool EvaluateExpression(StringRef Expr, std::string &Value) const; 115}; 116 117 118bool Pattern::ParsePattern(StringRef PatternStr, SourceMgr &SM, 119 unsigned LineNumber) { 120 this->LineNumber = LineNumber; 121 PatternLoc = SMLoc::getFromPointer(PatternStr.data()); 122 123 // Ignore trailing whitespace. 124 while (!PatternStr.empty() && 125 (PatternStr.back() == ' ' || PatternStr.back() == '\t')) 126 PatternStr = PatternStr.substr(0, PatternStr.size()-1); 127 128 // Check that there is something on the line. 129 if (PatternStr.empty()) { 130 SM.PrintMessage(PatternLoc, SourceMgr::DK_Error, 131 "found empty check string with prefix '" + 132 CheckPrefix+":'"); 133 return true; 134 } 135 136 // Check to see if this is a fixed string, or if it has regex pieces. 137 if (PatternStr.size() < 2 || 138 (PatternStr.find("{{") == StringRef::npos && 139 PatternStr.find("[[") == StringRef::npos)) { 140 FixedStr = PatternStr; 141 return false; 142 } 143 144 // Paren value #0 is for the fully matched string. Any new parenthesized 145 // values add from there. 146 unsigned CurParen = 1; 147 148 // Otherwise, there is at least one regex piece. Build up the regex pattern 149 // by escaping scary characters in fixed strings, building up one big regex. 150 while (!PatternStr.empty()) { 151 // RegEx matches. 152 if (PatternStr.startswith("{{")) { 153 154 // Otherwise, this is the start of a regex match. Scan for the }}. 155 size_t End = PatternStr.find("}}"); 156 if (End == StringRef::npos) { 157 SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()), 158 SourceMgr::DK_Error, 159 "found start of regex string with no end '}}'"); 160 return true; 161 } 162 163 // Enclose {{}} patterns in parens just like [[]] even though we're not 164 // capturing the result for any purpose. This is required in case the 165 // expression contains an alternation like: CHECK: abc{{x|z}}def. We 166 // want this to turn into: "abc(x|z)def" not "abcx|zdef". 167 RegExStr += '('; 168 ++CurParen; 169 170 if (AddRegExToRegEx(PatternStr.substr(2, End-2), CurParen, SM)) 171 return true; 172 RegExStr += ')'; 173 174 PatternStr = PatternStr.substr(End+2); 175 continue; 176 } 177 178 // Named RegEx matches. These are of two forms: [[foo:.*]] which matches .* 179 // (or some other regex) and assigns it to the FileCheck variable 'foo'. The 180 // second form is [[foo]] which is a reference to foo. The variable name 181 // itself must be of the form "[a-zA-Z_][0-9a-zA-Z_]*", otherwise we reject 182 // it. This is to catch some common errors. 183 if (PatternStr.startswith("[[")) { 184 // Verify that it is terminated properly. 185 size_t End = PatternStr.find("]]"); 186 if (End == StringRef::npos) { 187 SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()), 188 SourceMgr::DK_Error, 189 "invalid named regex reference, no ]] found"); 190 return true; 191 } 192 193 StringRef MatchStr = PatternStr.substr(2, End-2); 194 PatternStr = PatternStr.substr(End+2); 195 196 // Get the regex name (e.g. "foo"). 197 size_t NameEnd = MatchStr.find(':'); 198 StringRef Name = MatchStr.substr(0, NameEnd); 199 200 if (Name.empty()) { 201 SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error, 202 "invalid name in named regex: empty name"); 203 return true; 204 } 205 206 // Verify that the name/expression is well formed. FileCheck currently 207 // supports @LINE, @LINE+number, @LINE-number expressions. The check here 208 // is relaxed, more strict check is performed in \c EvaluateExpression. 209 bool IsExpression = false; 210 for (unsigned i = 0, e = Name.size(); i != e; ++i) { 211 if (i == 0 && Name[i] == '@') { 212 if (NameEnd != StringRef::npos) { 213 SM.PrintMessage(SMLoc::getFromPointer(Name.data()), 214 SourceMgr::DK_Error, 215 "invalid name in named regex definition"); 216 return true; 217 } 218 IsExpression = true; 219 continue; 220 } 221 if (Name[i] != '_' && !isalnum(Name[i]) && 222 (!IsExpression || (Name[i] != '+' && Name[i] != '-'))) { 223 SM.PrintMessage(SMLoc::getFromPointer(Name.data()+i), 224 SourceMgr::DK_Error, "invalid name in named regex"); 225 return true; 226 } 227 } 228 229 // Name can't start with a digit. 230 if (isdigit(Name[0])) { 231 SM.PrintMessage(SMLoc::getFromPointer(Name.data()), SourceMgr::DK_Error, 232 "invalid name in named regex"); 233 return true; 234 } 235 236 // Handle [[foo]]. 237 if (NameEnd == StringRef::npos) { 238 VariableUses.push_back(std::make_pair(Name, RegExStr.size())); 239 continue; 240 } 241 242 // Handle [[foo:.*]]. 243 VariableDefs.push_back(std::make_pair(Name, CurParen)); 244 RegExStr += '('; 245 ++CurParen; 246 247 if (AddRegExToRegEx(MatchStr.substr(NameEnd+1), CurParen, SM)) 248 return true; 249 250 RegExStr += ')'; 251 } 252 253 // Handle fixed string matches. 254 // Find the end, which is the start of the next regex. 255 size_t FixedMatchEnd = PatternStr.find("{{"); 256 FixedMatchEnd = std::min(FixedMatchEnd, PatternStr.find("[[")); 257 AddFixedStringToRegEx(PatternStr.substr(0, FixedMatchEnd), RegExStr); 258 PatternStr = PatternStr.substr(FixedMatchEnd); 259 } 260 261 return false; 262} 263 264void Pattern::AddFixedStringToRegEx(StringRef FixedStr, std::string &TheStr) { 265 // Add the characters from FixedStr to the regex, escaping as needed. This 266 // avoids "leaning toothpicks" in common patterns. 267 for (unsigned i = 0, e = FixedStr.size(); i != e; ++i) { 268 switch (FixedStr[i]) { 269 // These are the special characters matched in "p_ere_exp". 270 case '(': 271 case ')': 272 case '^': 273 case '$': 274 case '|': 275 case '*': 276 case '+': 277 case '?': 278 case '.': 279 case '[': 280 case '\\': 281 case '{': 282 TheStr += '\\'; 283 // FALL THROUGH. 284 default: 285 TheStr += FixedStr[i]; 286 break; 287 } 288 } 289} 290 291bool Pattern::AddRegExToRegEx(StringRef RegexStr, unsigned &CurParen, 292 SourceMgr &SM) { 293 Regex R(RegexStr); 294 std::string Error; 295 if (!R.isValid(Error)) { 296 SM.PrintMessage(SMLoc::getFromPointer(RegexStr.data()), SourceMgr::DK_Error, 297 "invalid regex: " + Error); 298 return true; 299 } 300 301 RegExStr += RegexStr.str(); 302 CurParen += R.getNumMatches(); 303 return false; 304} 305 306bool Pattern::EvaluateExpression(StringRef Expr, std::string &Value) const { 307 // The only supported expression is @LINE([\+-]\d+)? 308 if (!Expr.startswith("@LINE")) 309 return false; 310 Expr = Expr.substr(StringRef("@LINE").size()); 311 int Offset = 0; 312 if (!Expr.empty()) { 313 if (Expr[0] == '+') 314 Expr = Expr.substr(1); 315 else if (Expr[0] != '-') 316 return false; 317 if (Expr.getAsInteger(10, Offset)) 318 return false; 319 } 320 Value = llvm::itostr(LineNumber + Offset); 321 return true; 322} 323 324/// Match - Match the pattern string against the input buffer Buffer. This 325/// returns the position that is matched or npos if there is no match. If 326/// there is a match, the size of the matched string is returned in MatchLen. 327size_t Pattern::Match(StringRef Buffer, size_t &MatchLen, 328 StringMap<StringRef> &VariableTable) const { 329 // If this is the EOF pattern, match it immediately. 330 if (MatchEOF) { 331 MatchLen = 0; 332 return Buffer.size(); 333 } 334 335 // If this is a fixed string pattern, just match it now. 336 if (!FixedStr.empty()) { 337 MatchLen = FixedStr.size(); 338 return Buffer.find(FixedStr); 339 } 340 341 // Regex match. 342 343 // If there are variable uses, we need to create a temporary string with the 344 // actual value. 345 StringRef RegExToMatch = RegExStr; 346 std::string TmpStr; 347 if (!VariableUses.empty()) { 348 TmpStr = RegExStr; 349 350 unsigned InsertOffset = 0; 351 for (unsigned i = 0, e = VariableUses.size(); i != e; ++i) { 352 std::string Value; 353 354 if (VariableUses[i].first[0] == '@') { 355 if (!EvaluateExpression(VariableUses[i].first, Value)) 356 return StringRef::npos; 357 } else { 358 StringMap<StringRef>::iterator it = 359 VariableTable.find(VariableUses[i].first); 360 // If the variable is undefined, return an error. 361 if (it == VariableTable.end()) 362 return StringRef::npos; 363 364 // Look up the value and escape it so that we can plop it into the regex. 365 AddFixedStringToRegEx(it->second, Value); 366 } 367 368 // Plop it into the regex at the adjusted offset. 369 TmpStr.insert(TmpStr.begin()+VariableUses[i].second+InsertOffset, 370 Value.begin(), Value.end()); 371 InsertOffset += Value.size(); 372 } 373 374 // Match the newly constructed regex. 375 RegExToMatch = TmpStr; 376 } 377 378 379 SmallVector<StringRef, 4> MatchInfo; 380 if (!Regex(RegExToMatch, Regex::Newline).match(Buffer, &MatchInfo)) 381 return StringRef::npos; 382 383 // Successful regex match. 384 assert(!MatchInfo.empty() && "Didn't get any match"); 385 StringRef FullMatch = MatchInfo[0]; 386 387 // If this defines any variables, remember their values. 388 for (unsigned i = 0, e = VariableDefs.size(); i != e; ++i) { 389 assert(VariableDefs[i].second < MatchInfo.size() && 390 "Internal paren error"); 391 VariableTable[VariableDefs[i].first] = MatchInfo[VariableDefs[i].second]; 392 } 393 394 MatchLen = FullMatch.size(); 395 return FullMatch.data()-Buffer.data(); 396} 397 398unsigned Pattern::ComputeMatchDistance(StringRef Buffer, 399 const StringMap<StringRef> &VariableTable) const { 400 // Just compute the number of matching characters. For regular expressions, we 401 // just compare against the regex itself and hope for the best. 402 // 403 // FIXME: One easy improvement here is have the regex lib generate a single 404 // example regular expression which matches, and use that as the example 405 // string. 406 StringRef ExampleString(FixedStr); 407 if (ExampleString.empty()) 408 ExampleString = RegExStr; 409 410 // Only compare up to the first line in the buffer, or the string size. 411 StringRef BufferPrefix = Buffer.substr(0, ExampleString.size()); 412 BufferPrefix = BufferPrefix.split('\n').first; 413 return BufferPrefix.edit_distance(ExampleString); 414} 415 416void Pattern::PrintFailureInfo(const SourceMgr &SM, StringRef Buffer, 417 const StringMap<StringRef> &VariableTable) const{ 418 // If this was a regular expression using variables, print the current 419 // variable values. 420 if (!VariableUses.empty()) { 421 for (unsigned i = 0, e = VariableUses.size(); i != e; ++i) { 422 SmallString<256> Msg; 423 raw_svector_ostream OS(Msg); 424 StringRef Var = VariableUses[i].first; 425 if (Var[0] == '@') { 426 std::string Value; 427 if (EvaluateExpression(Var, Value)) { 428 OS << "with expression \""; 429 OS.write_escaped(Var) << "\" equal to \""; 430 OS.write_escaped(Value) << "\""; 431 } else { 432 OS << "uses incorrect expression \""; 433 OS.write_escaped(Var) << "\""; 434 } 435 } else { 436 StringMap<StringRef>::const_iterator it = VariableTable.find(Var); 437 438 // Check for undefined variable references. 439 if (it == VariableTable.end()) { 440 OS << "uses undefined variable \""; 441 OS.write_escaped(Var) << "\""; 442 } else { 443 OS << "with variable \""; 444 OS.write_escaped(Var) << "\" equal to \""; 445 OS.write_escaped(it->second) << "\""; 446 } 447 } 448 449 SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, 450 OS.str()); 451 } 452 } 453 454 // Attempt to find the closest/best fuzzy match. Usually an error happens 455 // because some string in the output didn't exactly match. In these cases, we 456 // would like to show the user a best guess at what "should have" matched, to 457 // save them having to actually check the input manually. 458 size_t NumLinesForward = 0; 459 size_t Best = StringRef::npos; 460 double BestQuality = 0; 461 462 // Use an arbitrary 4k limit on how far we will search. 463 for (size_t i = 0, e = std::min(size_t(4096), Buffer.size()); i != e; ++i) { 464 if (Buffer[i] == '\n') 465 ++NumLinesForward; 466 467 // Patterns have leading whitespace stripped, so skip whitespace when 468 // looking for something which looks like a pattern. 469 if (Buffer[i] == ' ' || Buffer[i] == '\t') 470 continue; 471 472 // Compute the "quality" of this match as an arbitrary combination of the 473 // match distance and the number of lines skipped to get to this match. 474 unsigned Distance = ComputeMatchDistance(Buffer.substr(i), VariableTable); 475 double Quality = Distance + (NumLinesForward / 100.); 476 477 if (Quality < BestQuality || Best == StringRef::npos) { 478 Best = i; 479 BestQuality = Quality; 480 } 481 } 482 483 // Print the "possible intended match here" line if we found something 484 // reasonable and not equal to what we showed in the "scanning from here" 485 // line. 486 if (Best && Best != StringRef::npos && BestQuality < 50) { 487 SM.PrintMessage(SMLoc::getFromPointer(Buffer.data() + Best), 488 SourceMgr::DK_Note, "possible intended match here"); 489 490 // FIXME: If we wanted to be really friendly we would show why the match 491 // failed, as it can be hard to spot simple one character differences. 492 } 493} 494 495//===----------------------------------------------------------------------===// 496// Check Strings. 497//===----------------------------------------------------------------------===// 498 499/// CheckString - This is a check that we found in the input file. 500struct CheckString { 501 /// Pat - The pattern to match. 502 Pattern Pat; 503 504 /// Loc - The location in the match file that the check string was specified. 505 SMLoc Loc; 506 507 /// IsCheckNext - This is true if this is a CHECK-NEXT: directive (as opposed 508 /// to a CHECK: directive. 509 bool IsCheckNext; 510 511 /// NotStrings - These are all of the strings that are disallowed from 512 /// occurring between this match string and the previous one (or start of 513 /// file). 514 std::vector<std::pair<SMLoc, Pattern> > NotStrings; 515 516 CheckString(const Pattern &P, SMLoc L, bool isCheckNext) 517 : Pat(P), Loc(L), IsCheckNext(isCheckNext) {} 518}; 519 520/// CanonicalizeInputFile - Remove duplicate horizontal space from the specified 521/// memory buffer, free it, and return a new one. 522static MemoryBuffer *CanonicalizeInputFile(MemoryBuffer *MB) { 523 SmallString<128> NewFile; 524 NewFile.reserve(MB->getBufferSize()); 525 526 for (const char *Ptr = MB->getBufferStart(), *End = MB->getBufferEnd(); 527 Ptr != End; ++Ptr) { 528 // Eliminate trailing dosish \r. 529 if (Ptr <= End - 2 && Ptr[0] == '\r' && Ptr[1] == '\n') { 530 continue; 531 } 532 533 // If current char is not a horizontal whitespace, dump it to output as is. 534 if (*Ptr != ' ' && *Ptr != '\t') { 535 NewFile.push_back(*Ptr); 536 continue; 537 } 538 539 // Otherwise, add one space and advance over neighboring space. 540 NewFile.push_back(' '); 541 while (Ptr+1 != End && 542 (Ptr[1] == ' ' || Ptr[1] == '\t')) 543 ++Ptr; 544 } 545 546 // Free the old buffer and return a new one. 547 MemoryBuffer *MB2 = 548 MemoryBuffer::getMemBufferCopy(NewFile.str(), MB->getBufferIdentifier()); 549 550 delete MB; 551 return MB2; 552} 553 554 555/// ReadCheckFile - Read the check file, which specifies the sequence of 556/// expected strings. The strings are added to the CheckStrings vector. 557static bool ReadCheckFile(SourceMgr &SM, 558 std::vector<CheckString> &CheckStrings) { 559 // Open the check file, and tell SourceMgr about it. 560 OwningPtr<MemoryBuffer> File; 561 if (error_code ec = 562 MemoryBuffer::getFileOrSTDIN(CheckFilename.c_str(), File)) { 563 errs() << "Could not open check file '" << CheckFilename << "': " 564 << ec.message() << '\n'; 565 return true; 566 } 567 MemoryBuffer *F = File.take(); 568 569 // If we want to canonicalize whitespace, strip excess whitespace from the 570 // buffer containing the CHECK lines. 571 if (!NoCanonicalizeWhiteSpace) 572 F = CanonicalizeInputFile(F); 573 574 SM.AddNewSourceBuffer(F, SMLoc()); 575 576 // Find all instances of CheckPrefix followed by : in the file. 577 StringRef Buffer = F->getBuffer(); 578 579 std::vector<std::pair<SMLoc, Pattern> > NotMatches; 580 581 unsigned LineNumber = 1; 582 583 while (1) { 584 // See if Prefix occurs in the memory buffer. 585 size_t PrefixLoc = Buffer.find(CheckPrefix); 586 // If we didn't find a match, we're done. 587 if (PrefixLoc == StringRef::npos) 588 break; 589 590 // Recalculate line number. 591 LineNumber += Buffer.substr(0, PrefixLoc).count('\n'); 592 593 Buffer = Buffer.substr(PrefixLoc); 594 595 const char *CheckPrefixStart = Buffer.data(); 596 597 // When we find a check prefix, keep track of whether we find CHECK: or 598 // CHECK-NEXT: 599 bool IsCheckNext = false, IsCheckNot = false; 600 601 // Verify that the : is present after the prefix. 602 if (Buffer[CheckPrefix.size()] == ':') { 603 Buffer = Buffer.substr(CheckPrefix.size()+1); 604 } else if (Buffer.size() > CheckPrefix.size()+6 && 605 memcmp(Buffer.data()+CheckPrefix.size(), "-NEXT:", 6) == 0) { 606 Buffer = Buffer.substr(CheckPrefix.size()+6); 607 IsCheckNext = true; 608 } else if (Buffer.size() > CheckPrefix.size()+5 && 609 memcmp(Buffer.data()+CheckPrefix.size(), "-NOT:", 5) == 0) { 610 Buffer = Buffer.substr(CheckPrefix.size()+5); 611 IsCheckNot = true; 612 } else { 613 Buffer = Buffer.substr(1); 614 continue; 615 } 616 617 // Okay, we found the prefix, yay. Remember the rest of the line, but 618 // ignore leading and trailing whitespace. 619 Buffer = Buffer.substr(Buffer.find_first_not_of(" \t")); 620 621 // Scan ahead to the end of line. 622 size_t EOL = Buffer.find_first_of("\n\r"); 623 624 // Remember the location of the start of the pattern, for diagnostics. 625 SMLoc PatternLoc = SMLoc::getFromPointer(Buffer.data()); 626 627 // Parse the pattern. 628 Pattern P; 629 if (P.ParsePattern(Buffer.substr(0, EOL), SM, LineNumber)) 630 return true; 631 632 Buffer = Buffer.substr(EOL); 633 634 635 // Verify that CHECK-NEXT lines have at least one CHECK line before them. 636 if (IsCheckNext && CheckStrings.empty()) { 637 SM.PrintMessage(SMLoc::getFromPointer(CheckPrefixStart), 638 SourceMgr::DK_Error, 639 "found '"+CheckPrefix+"-NEXT:' without previous '"+ 640 CheckPrefix+ ": line"); 641 return true; 642 } 643 644 // Handle CHECK-NOT. 645 if (IsCheckNot) { 646 NotMatches.push_back(std::make_pair(SMLoc::getFromPointer(Buffer.data()), 647 P)); 648 continue; 649 } 650 651 652 // Okay, add the string we captured to the output vector and move on. 653 CheckStrings.push_back(CheckString(P, 654 PatternLoc, 655 IsCheckNext)); 656 std::swap(NotMatches, CheckStrings.back().NotStrings); 657 } 658 659 // Add an EOF pattern for any trailing CHECK-NOTs. 660 if (!NotMatches.empty()) { 661 CheckStrings.push_back(CheckString(Pattern(true), 662 SMLoc::getFromPointer(Buffer.data()), 663 false)); 664 std::swap(NotMatches, CheckStrings.back().NotStrings); 665 } 666 667 if (CheckStrings.empty()) { 668 errs() << "error: no check strings found with prefix '" << CheckPrefix 669 << ":'\n"; 670 return true; 671 } 672 673 return false; 674} 675 676static void PrintCheckFailed(const SourceMgr &SM, const CheckString &CheckStr, 677 StringRef Buffer, 678 StringMap<StringRef> &VariableTable) { 679 // Otherwise, we have an error, emit an error message. 680 SM.PrintMessage(CheckStr.Loc, SourceMgr::DK_Error, 681 "expected string not found in input"); 682 683 // Print the "scanning from here" line. If the current position is at the 684 // end of a line, advance to the start of the next line. 685 Buffer = Buffer.substr(Buffer.find_first_not_of(" \t\n\r")); 686 687 SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), SourceMgr::DK_Note, 688 "scanning from here"); 689 690 // Allow the pattern to print additional information if desired. 691 CheckStr.Pat.PrintFailureInfo(SM, Buffer, VariableTable); 692} 693 694/// CountNumNewlinesBetween - Count the number of newlines in the specified 695/// range. 696static unsigned CountNumNewlinesBetween(StringRef Range) { 697 unsigned NumNewLines = 0; 698 while (1) { 699 // Scan for newline. 700 Range = Range.substr(Range.find_first_of("\n\r")); 701 if (Range.empty()) return NumNewLines; 702 703 ++NumNewLines; 704 705 // Handle \n\r and \r\n as a single newline. 706 if (Range.size() > 1 && 707 (Range[1] == '\n' || Range[1] == '\r') && 708 (Range[0] != Range[1])) 709 Range = Range.substr(1); 710 Range = Range.substr(1); 711 } 712} 713 714int main(int argc, char **argv) { 715 sys::PrintStackTraceOnErrorSignal(); 716 PrettyStackTraceProgram X(argc, argv); 717 cl::ParseCommandLineOptions(argc, argv); 718 719 SourceMgr SM; 720 721 // Read the expected strings from the check file. 722 std::vector<CheckString> CheckStrings; 723 if (ReadCheckFile(SM, CheckStrings)) 724 return 2; 725 726 // Open the file to check and add it to SourceMgr. 727 OwningPtr<MemoryBuffer> File; 728 if (error_code ec = 729 MemoryBuffer::getFileOrSTDIN(InputFilename.c_str(), File)) { 730 errs() << "Could not open input file '" << InputFilename << "': " 731 << ec.message() << '\n'; 732 return 2; 733 } 734 MemoryBuffer *F = File.take(); 735 736 if (F->getBufferSize() == 0) { 737 errs() << "FileCheck error: '" << InputFilename << "' is empty.\n"; 738 return 2; 739 } 740 741 // Remove duplicate spaces in the input file if requested. 742 if (!NoCanonicalizeWhiteSpace) 743 F = CanonicalizeInputFile(F); 744 745 SM.AddNewSourceBuffer(F, SMLoc()); 746 747 /// VariableTable - This holds all the current filecheck variables. 748 StringMap<StringRef> VariableTable; 749 750 // Check that we have all of the expected strings, in order, in the input 751 // file. 752 StringRef Buffer = F->getBuffer(); 753 754 const char *LastMatch = Buffer.data(); 755 756 for (unsigned StrNo = 0, e = CheckStrings.size(); StrNo != e; ++StrNo) { 757 const CheckString &CheckStr = CheckStrings[StrNo]; 758 759 StringRef SearchFrom = Buffer; 760 761 // Find StrNo in the file. 762 size_t MatchLen = 0; 763 size_t MatchPos = CheckStr.Pat.Match(Buffer, MatchLen, VariableTable); 764 Buffer = Buffer.substr(MatchPos); 765 766 // If we didn't find a match, reject the input. 767 if (MatchPos == StringRef::npos) { 768 PrintCheckFailed(SM, CheckStr, SearchFrom, VariableTable); 769 return 1; 770 } 771 772 StringRef SkippedRegion(LastMatch, Buffer.data()-LastMatch); 773 774 // If this check is a "CHECK-NEXT", verify that the previous match was on 775 // the previous line (i.e. that there is one newline between them). 776 if (CheckStr.IsCheckNext) { 777 // Count the number of newlines between the previous match and this one. 778 assert(LastMatch != F->getBufferStart() && 779 "CHECK-NEXT can't be the first check in a file"); 780 781 unsigned NumNewLines = CountNumNewlinesBetween(SkippedRegion); 782 if (NumNewLines == 0) { 783 SM.PrintMessage(CheckStr.Loc, SourceMgr::DK_Error, 784 CheckPrefix+"-NEXT: is on the same line as previous match"); 785 SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), 786 SourceMgr::DK_Note, "'next' match was here"); 787 SM.PrintMessage(SMLoc::getFromPointer(LastMatch), SourceMgr::DK_Note, 788 "previous match was here"); 789 return 1; 790 } 791 792 if (NumNewLines != 1) { 793 SM.PrintMessage(CheckStr.Loc, SourceMgr::DK_Error, CheckPrefix+ 794 "-NEXT: is not on the line after the previous match"); 795 SM.PrintMessage(SMLoc::getFromPointer(Buffer.data()), 796 SourceMgr::DK_Note, "'next' match was here"); 797 SM.PrintMessage(SMLoc::getFromPointer(LastMatch), SourceMgr::DK_Note, 798 "previous match was here"); 799 return 1; 800 } 801 } 802 803 // If this match had "not strings", verify that they don't exist in the 804 // skipped region. 805 for (unsigned ChunkNo = 0, e = CheckStr.NotStrings.size(); 806 ChunkNo != e; ++ChunkNo) { 807 size_t MatchLen = 0; 808 size_t Pos = CheckStr.NotStrings[ChunkNo].second.Match(SkippedRegion, 809 MatchLen, 810 VariableTable); 811 if (Pos == StringRef::npos) continue; 812 813 SM.PrintMessage(SMLoc::getFromPointer(LastMatch+Pos), SourceMgr::DK_Error, 814 CheckPrefix+"-NOT: string occurred!"); 815 SM.PrintMessage(CheckStr.NotStrings[ChunkNo].first, SourceMgr::DK_Note, 816 CheckPrefix+"-NOT: pattern specified here"); 817 return 1; 818 } 819 820 821 // Otherwise, everything is good. Step over the matched text and remember 822 // the position after the match as the end of the last match. 823 Buffer = Buffer.substr(MatchLen); 824 LastMatch = Buffer.data(); 825 } 826 827 return 0; 828} 829