llvm-6502/lib/Support/FileUtilities.cpp
Chris Lattner a7750c1142 Change DiffFilesWithTolerance to be written in terms of MemoryBuffer,
not an mmapped file.  This more closely matches its requirements and
provides an implicitly null terminated buffer, something this
routine had to emulate itself before.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@49024 91177308-0d34-0410-b5e6-96231b3b80d8
2008-04-01 03:39:49 +00:00

264 lines
8.9 KiB
C++

//===- Support/FileUtilities.cpp - File System Utilities ------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements a family of utility functions which are useful for doing
// various things with files.
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/FileUtilities.h"
#include "llvm/System/Path.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/ADT/OwningPtr.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringExtras.h"
#include <cstdlib>
#include <cstring>
#include <cctype>
using namespace llvm;
static bool isSignedChar(char C) {
return (C == '+' || C == '-');
}
static bool isExponentChar(char C) {
switch (C) {
case 'D': // Strange exponential notation.
case 'd': // Strange exponential notation.
case 'e':
case 'E': return true;
default: return false;
}
}
static bool isNumberChar(char C) {
switch (C) {
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
case '.': return true;
default: return isSignedChar(C) || isExponentChar(C);
}
}
static const char *BackupNumber(const char *Pos, const char *FirstChar) {
// If we didn't stop in the middle of a number, don't backup.
if (!isNumberChar(*Pos)) return Pos;
// Otherwise, return to the start of the number.
while (Pos > FirstChar && isNumberChar(Pos[-1])) {
--Pos;
if (Pos > FirstChar && isSignedChar(Pos[0]) && !isExponentChar(Pos[-1]))
break;
}
return Pos;
}
/// EndOfNumber - Return the first character that is not part of the specified
/// number. This assumes that the buffer is null terminated, so it won't fall
/// off the end.
static const char *EndOfNumber(const char *Pos) {
while (isNumberChar(*Pos))
++Pos;
return Pos;
}
/// CompareNumbers - compare two numbers, returning true if they are different.
static bool CompareNumbers(const char *&F1P, const char *&F2P,
const char *F1End, const char *F2End,
double AbsTolerance, double RelTolerance,
std::string *ErrorMsg) {
const char *F1NumEnd, *F2NumEnd;
double V1 = 0.0, V2 = 0.0;
// If one of the positions is at a space and the other isn't, chomp up 'til
// the end of the space.
while (isspace(*F1P) && F1P != F1End)
++F1P;
while (isspace(*F2P) && F2P != F2End)
++F2P;
// If we stop on numbers, compare their difference.
if (!isNumberChar(*F1P) || !isNumberChar(*F2P)) {
// The diff failed.
F1NumEnd = F1P;
F2NumEnd = F2P;
} else {
// Note that some ugliness is built into this to permit support for numbers
// that use "D" or "d" as their exponential marker, e.g. "1.234D45". This
// occurs in 200.sixtrack in spec2k.
V1 = strtod(F1P, const_cast<char**>(&F1NumEnd));
V2 = strtod(F2P, const_cast<char**>(&F2NumEnd));
if (*F1NumEnd == 'D' || *F1NumEnd == 'd') {
// Copy string into tmp buffer to replace the 'D' with an 'e'.
SmallString<200> StrTmp(F1P, EndOfNumber(F1NumEnd)+1);
StrTmp[F1NumEnd-F1P] = 'e'; // Strange exponential notation!
V1 = strtod(&StrTmp[0], const_cast<char**>(&F1NumEnd));
F1NumEnd = F1P + (F1NumEnd-&StrTmp[0]);
}
if (*F2NumEnd == 'D' || *F2NumEnd == 'd') {
// Copy string into tmp buffer to replace the 'D' with an 'e'.
SmallString<200> StrTmp(F2P, EndOfNumber(F2NumEnd)+1);
StrTmp[F2NumEnd-F2P] = 'e'; // Strange exponential notation!
V2 = strtod(&StrTmp[0], const_cast<char**>(&F2NumEnd));
F2NumEnd = F2P + (F2NumEnd-&StrTmp[0]);
}
}
if (F1NumEnd == F1P || F2NumEnd == F2P) {
if (ErrorMsg) {
*ErrorMsg = "FP Comparison failed, not a numeric difference between '";
*ErrorMsg += F1P[0];
*ErrorMsg += "' and '";
*ErrorMsg += F2P[0];
*ErrorMsg += "'";
}
return true;
}
// Check to see if these are inside the absolute tolerance
if (AbsTolerance < std::abs(V1-V2)) {
// Nope, check the relative tolerance...
double Diff;
if (V2)
Diff = std::abs(V1/V2 - 1.0);
else if (V1)
Diff = std::abs(V2/V1 - 1.0);
else
Diff = 0; // Both zero.
if (Diff > RelTolerance) {
if (ErrorMsg) {
*ErrorMsg = "Compared: " + ftostr(V1) + " and " + ftostr(V2) + "\n";
*ErrorMsg += "abs. diff = " + ftostr(std::abs(V1-V2)) +
" rel.diff = " + ftostr(Diff) + "\n";
*ErrorMsg += "Out of tolerance: rel/abs: " + ftostr(RelTolerance) +
"/" + ftostr(AbsTolerance);
}
return true;
}
}
// Otherwise, advance our read pointers to the end of the numbers.
F1P = F1NumEnd; F2P = F2NumEnd;
return false;
}
/// DiffFilesWithTolerance - Compare the two files specified, returning 0 if the
/// files match, 1 if they are different, and 2 if there is a file error. This
/// function differs from DiffFiles in that you can specify an absolete and
/// relative FP error that is allowed to exist. If you specify a string to fill
/// in for the error option, it will set the string to an error message if an
/// error occurs, allowing the caller to distinguish between a failed diff and a
/// file system error.
///
int llvm::DiffFilesWithTolerance(const sys::PathWithStatus &FileA,
const sys::PathWithStatus &FileB,
double AbsTol, double RelTol,
std::string *Error) {
const sys::FileStatus *FileAStat = FileA.getFileStatus(false, Error);
if (!FileAStat)
return 2;
const sys::FileStatus *FileBStat = FileB.getFileStatus(false, Error);
if (!FileBStat)
return 2;
// Check for zero length files because some systems croak when you try to
// mmap an empty file.
size_t A_size = FileAStat->getSize();
size_t B_size = FileBStat->getSize();
// If they are both zero sized then they're the same
if (A_size == 0 && B_size == 0)
return 0;
// If only one of them is zero sized then they can't be the same
if ((A_size == 0 || B_size == 0)) {
if (Error)
*Error = "Files differ: one is zero-sized, the other isn't";
return 1;
}
// Now its safe to mmap the files into memory becasue both files
// have a non-zero size.
OwningPtr<MemoryBuffer> F1(MemoryBuffer::getFile(FileA.c_str(), FileA.size(),
Error));
OwningPtr<MemoryBuffer> F2(MemoryBuffer::getFile(FileB.c_str(), FileB.size(),
Error));
if (F1 == 0 || F2 == 0)
return 2;
// Okay, now that we opened the files, scan them for the first difference.
const char *File1Start = F1->getBufferStart();
const char *File2Start = F2->getBufferStart();
const char *File1End = F1->getBufferEnd();
const char *File2End = F2->getBufferEnd();
const char *F1P = File1Start;
const char *F2P = File2Start;
if (A_size == B_size) {
// Are the buffers identical? Common case: Handle this efficiently.
if (std::memcmp(File1Start, File2Start, A_size) == 0)
return 0;
if (AbsTol == 0 && RelTol == 0) {
if (Error)
*Error = "Files differ without tolerance allowance";
return 1; // Files different!
}
}
bool CompareFailed = false;
while (1) {
// Scan for the end of file or next difference.
while (F1P < File1End && F2P < File2End && *F1P == *F2P)
++F1P, ++F2P;
if (F1P >= File1End || F2P >= File2End) break;
// Okay, we must have found a difference. Backup to the start of the
// current number each stream is at so that we can compare from the
// beginning.
F1P = BackupNumber(F1P, File1Start);
F2P = BackupNumber(F2P, File2Start);
// Now that we are at the start of the numbers, compare them, exiting if
// they don't match.
if (CompareNumbers(F1P, F2P, File1End, File2End, AbsTol, RelTol, Error)) {
CompareFailed = true;
break;
}
}
// Okay, we reached the end of file. If both files are at the end, we
// succeeded.
bool F1AtEnd = F1P >= File1End;
bool F2AtEnd = F2P >= File2End;
if (!CompareFailed && (!F1AtEnd || !F2AtEnd)) {
// Else, we might have run off the end due to a number: backup and retry.
if (F1AtEnd && isNumberChar(F1P[-1])) --F1P;
if (F2AtEnd && isNumberChar(F2P[-1])) --F2P;
F1P = BackupNumber(F1P, File1Start);
F2P = BackupNumber(F2P, File2Start);
// Now that we are at the start of the numbers, compare them, exiting if
// they don't match.
if (CompareNumbers(F1P, F2P, File1End, File2End, AbsTol, RelTol, Error))
CompareFailed = true;
// If we found the end, we succeeded.
if (F1P < File1End || F2P < File2End)
CompareFailed = true;
}
return CompareFailed;
}