path: root/utils/FileCheck/FileCheck.cpp

//===- FileCheck.cpp - Check that File's Contents match what is expected --===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// FileCheck does a line-by line check of a file that validates whether it
// contains the expected content.  This is useful for regression tests etc.
//
// This program exits with an error status of 2 on error, exit status of 0 if
// the file matched the expected contents, and exit status of 1 if it did not
// contain the expected contents.
//
//===----------------------------------------------------------------------===//

#include "llvm/Support/CommandLine.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/PrettyStackTrace.h"
#include "llvm/Support/Regex.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/System/Signals.h"
using namespace llvm;

static cl::opt<std::string>
CheckFilename(cl::Positional, cl::desc("<check-file>"), cl::Required);

static cl::opt<std::string>
InputFilename("input-file", cl::desc("File to check (defaults to stdin)"),
              cl::init("-"), cl::value_desc("filename"));

static cl::opt<std::string>
CheckPrefix("check-prefix", cl::init("CHECK"),
            cl::desc("Prefix to use from check file (defaults to 'CHECK')"));

static cl::opt<bool>
NoCanonicalizeWhiteSpace("strict-whitespace",
              cl::desc("Do not treat all horizontal whitespace as equivalent"));

//===----------------------------------------------------------------------===//
// Pattern Handling Code.
//===----------------------------------------------------------------------===//

class Pattern {
  /// Chunks - The pattern chunks to match.  If the bool is false, it is a fixed
  /// string match, if it is true, it is a regex match.
  SmallVector<std::pair<StringRef, bool>, 4> Chunks;
public:
  
  Pattern() { }
  
  bool ParsePattern(StringRef PatternStr, SourceMgr &SM);
  
  /// Match - Match the pattern string against the input buffer Buffer.  This
  /// returns the position that is matched or npos if there is no match.  If
  /// there is a match, the size of the matched string is returned in MatchLen.
  size_t Match(StringRef Buffer, size_t &MatchLen) const;
};

bool Pattern::ParsePattern(StringRef PatternStr, SourceMgr &SM) {
  // Ignore trailing whitespace.
  while (!PatternStr.empty() &&
         (PatternStr.back() == ' ' || PatternStr.back() == '\t'))
    PatternStr = PatternStr.substr(0, PatternStr.size()-1);
  
  // Check that there is something on the line.
  if (PatternStr.empty()) {
    SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()),
                    "found empty check string with prefix '"+CheckPrefix+":'",
                    "error");
    return true;
  }
  
  // Scan the pattern to break it into regex and non-regex pieces.
  while (!PatternStr.empty()) {
    // Handle fixed string matches.
    if (PatternStr.size() < 2 ||
        PatternStr[0] != '{' || PatternStr[1] != '{') {
      // Find the end, which is the start of the next regex.
      size_t FixedMatchEnd = PatternStr.find("{{");
      
      Chunks.push_back(std::make_pair(PatternStr.substr(0, FixedMatchEnd),
                                      false));
      PatternStr = PatternStr.substr(FixedMatchEnd);
      continue;
    }
    
    // Otherwise, this is the start of a regex match.  Scan for the }}.
    size_t End = PatternStr.find("}}");
    if (End == StringRef::npos) {
      SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()),
                      "found start of regex string with no end '}}'", "error");
      return true;
    }
    
    Regex R(PatternStr.substr(2, End-2));
    std::string Error;
    if (!R.isValid(Error)) {
      SM.PrintMessage(SMLoc::getFromPointer(PatternStr.data()+2),
                      "invalid regex: " + Error, "error");
      return true;
    }
    
    Chunks.push_back(std::make_pair(PatternStr.substr(2, End-2), true));
    PatternStr = PatternStr.substr(End+2);
  }

  return false;
}

/// Match - Match the pattern string against the input buffer Buffer.  This
/// returns the position that is matched or npos if there is no match.  If
/// there is a match, the size of the matched string is returned in MatchLen.
size_t Pattern::Match(StringRef Buffer, size_t &MatchLen) const {
  size_t FirstMatch = StringRef::npos;
  MatchLen = 0;
  
  SmallVector<StringRef, 4> MatchInfo;
  
  while (!Buffer.empty()) {
    StringRef MatchAttempt = Buffer;
    
    unsigned ChunkNo = 0, e = Chunks.size();
    for (; ChunkNo != e; ++ChunkNo) {
      StringRef PatternStr = Chunks[ChunkNo].first;
      
      size_t ThisMatch = StringRef::npos;
      size_t ThisLength = StringRef::npos;
      if (!Chunks[ChunkNo].second) {
        // Fixed string match.
        ThisMatch = MatchAttempt.find(Chunks[ChunkNo].first);
        ThisLength = Chunks[ChunkNo].first.size();
      } else if (Regex(Chunks[ChunkNo].first, Regex::Sub).match(MatchAttempt, &MatchInfo)) {
        // Successful regex match.
        assert(!MatchInfo.empty() && "Didn't get any match");
        StringRef FullMatch = MatchInfo[0];
        MatchInfo.clear();
        
        ThisMatch = FullMatch.data()-MatchAttempt.data();
        ThisLength = FullMatch.size();
      }
      
      // Otherwise, what we do depends on if this is the first match or not.  If
      // this is the first match, it doesn't match to match at the start of
      // MatchAttempt.
      if (ChunkNo == 0) {
        // If the first match fails then this pattern will never match in
        // Buffer.
        if (ThisMatch == StringRef::npos)
          return ThisMatch;
        
        FirstMatch = ThisMatch;
        MatchAttempt = MatchAttempt.substr(FirstMatch);
        ThisMatch = 0;
      }
      
      // If this chunk didn't match, then the entire pattern didn't match from
      // FirstMatch, try later in the buffer.
      if (ThisMatch == StringRef::npos)
        break;
      
      // Ok, if the match didn't match at the beginning of MatchAttempt, then we
      // have something like "ABC{{DEF}} and something was in-between.  Reject
      // the match.
      if (ThisMatch != 0)
        break;
      
      // Otherwise, match the string and move to the next chunk.
      MatchLen += ThisLength;
      MatchAttempt = MatchAttempt.substr(ThisLength);
    }

    // If the whole thing matched, we win.
    if (ChunkNo == e)
      return FirstMatch;
    
    // Otherwise, try matching again after FirstMatch to see if this pattern
    // matches later in the buffer.
    Buffer = Buffer.substr(FirstMatch+1);
  }
  
  // If we ran out of stuff to scan, then we didn't match.
  return StringRef::npos;
}


//===----------------------------------------------------------------------===//
// Check Strings.
//===----------------------------------------------------------------------===//

/// CheckString - This is a check that we found in the input file.
struct CheckString {
  /// Pat - The pattern to match.
  Pattern Pat;
  
  /// Loc - The location in the match file that the check string was specified.
  SMLoc Loc;
  
  /// IsCheckNext - This is true if this is a CHECK-NEXT: directive (as opposed
  /// to a CHECK: directive.
  bool IsCheckNext;
  
  /// NotStrings - These are all of the strings that are disallowed from
  /// occurring between this match string and the previous one (or start of
  /// file).
  std::vector<std::pair<SMLoc, Pattern> > NotStrings;
  
  CheckString(const Pattern &P, SMLoc L, bool isCheckNext)
    : Pat(P), Loc(L), IsCheckNext(isCheckNext) {}
};

/// CanonicalizeInputFile - Remove duplicate horizontal space from the specified
/// memory buffer, free it, and return a new one.
static MemoryBuffer *CanonicalizeInputFile(MemoryBuffer *MB) {
  SmallVector<char, 16> NewFile;
  NewFile.reserve(MB->getBufferSize());
  
  for (const char *Ptr = MB->getBufferStart(), *End = MB->getBufferEnd();
       Ptr != End; ++Ptr) {
    // If C is not a horizontal whitespace, skip it.
    if (*Ptr != ' ' && *Ptr != '\t') {
      NewFile.push_back(*Ptr);
      continue;
    }
    
    // Otherwise, add one space and ad