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