HP aCC chokes on this, but it's not required anyway: according to

[oota-llvm.git] / lib / Support / FileUtilities.cpp

diff --git a/lib/Support/FileUtilities.cpp b/lib/Support/FileUtilities.cpp
index 7ae476b5975d104cb6e15a7d35687d493e2d221a..ae851c7f549b873a9aabdcadad33ea5973534346 100644 (file)
--- a/lib/Support/FileUtilities.cpp
+++ b/lib/Support/FileUtilities.cpp
@@ -1,10 +1,10 @@
 //===- Support/FileUtilities.cpp - File System Utilities ------------------===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
 // This file was developed by the LLVM research group and 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
@@ -17,13 +17,17 @@
 #include "llvm/System/MappedFile.h"
 #include "llvm/ADT/StringExtras.h"
 #include <cmath>
+#include <cstring>
+#include <cctype>
 using namespace llvm;
 
 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 '5': case '6': case '7': case '8': case '9':
   case '.': case '+': case '-':
+  case 'D':  // Strange exponential notation.
+  case 'd':  // Strange exponential notation.
   case 'e':
   case 'E': return true;
   default: return false;
@@ -45,11 +49,35 @@ static bool CompareNumbers(char *&F1P, char *&F2P, char *F1End, char *F2End,
                            double AbsTolerance, double RelTolerance,
                            std::string *ErrorMsg) {
   char *F1NumEnd, *F2NumEnd;
-  double V1 = 0.0, V2 = 0.0; 
-  // If we stop on numbers, compare their difference.
+  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.  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.
   if (isNumberChar(*F1P) && isNumberChar(*F2P)) {
-    V1 = strtod(F1P, &F1NumEnd);
-    V2 = strtod(F2P, &F2NumEnd);
+    bool isDNotation;
+    do {
+      isDNotation = false;
+      V1 = strtod(F1P, &F1NumEnd);
+      V2 = strtod(F2P, &F2NumEnd);
+
+      if (*F1NumEnd == 'D' || *F1NumEnd == 'd') {
+        *F1NumEnd = 'e';  // Strange exponential notation!
+        isDNotation = true;
+      }
+      if (*F2NumEnd == 'D' || *F2NumEnd == 'd') {
+        *F2NumEnd = 'e';  // Strange exponential notation!
+        isDNotation = true;
+      }
+    } while (isDNotation);
   } else {
     // Otherwise, the diff failed.
     F1NumEnd = F1P;
@@ -93,7 +121,8 @@ static bool CompareNumbers(char *&F1P, char *&F2P, char *F1End, char *F2End,
 // with a number.  Because of this, if needed, we pad the file so that it starts
 // and ends with a null character.
 static void PadFileIfNeeded(char *&FileStart, char *&FileEnd, char *&FP) {
-  if (isNumberChar(FileStart[0]) || isNumberChar(FileEnd[-1])) {
+  if (FileStart-FileEnd < 2 ||
+      isNumberChar(FileStart[0]) || isNumberChar(FileEnd[-1])) {
     unsigned FileLen = FileEnd-FileStart;
     char *NewFile = new char[FileLen+2];
     NewFile[0] = 0;              // Add null padding
@@ -118,7 +147,20 @@ int llvm::DiffFilesWithTolerance(const sys::Path &FileA,
                                  double AbsTol, double RelTol,
                                  std::string *Error) {
   try {
-    // Map in the files into memory.
+    // Check for zero length files because some systems croak when you try to
+    // mmap an empty file.
+    size_t A_size = FileA.getSize();
+    size_t B_size = FileB.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))
+      return 1;
+
+    // Now its safe to mmap the files into memory becasue both files
+    // have a non-zero size.
     sys::MappedFile F1(FileA);
     sys::MappedFile F2(FileB);
     F1.map();
@@ -127,20 +169,19 @@ int llvm::DiffFilesWithTolerance(const sys::Path &FileA,
     // Okay, now that we opened the files, scan them for the first difference.
     char *File1Start = F1.charBase();
     char *File2Start = F2.charBase();
-    char *File1End = File1Start+F1.size();
-    char *File2End = File2Start+F2.size();
+    char *File1End = File1Start+A_size;
+    char *File2End = File2Start+B_size;
     char *F1P = File1Start;
     char *F2P = File2Start;
 
-    // Scan for the end of file or first difference.
-    while (F1P < File1End && F2P < File2End && *F1P == *F2P)
-      ++F1P, ++F2P;
+    if (A_size == B_size) {
+      // Are the buffers identical?
+      if (std::memcmp(File1Start, File2Start, A_size) == 0)
+        return 0;
 
-    // Common case: identifical files.
-    if (F1P == File1End && F2P == File2End) return 0;
-
-    if (AbsTol == 0 && RelTol == 0)
-      return 1;   // Files different!
+      if (AbsTol == 0 && RelTol == 0)
+        return 1;   // Files different!
+    }
 
     char *OrigFile1Start = File1Start;
     char *OrigFile2Start = File2Start;
@@ -148,7 +189,7 @@ int llvm::DiffFilesWithTolerance(const sys::Path &FileA,
     // If the files need padding, do so now.
     PadFileIfNeeded(File1Start, File1End, F1P);
     PadFileIfNeeded(File2Start, File2End, F2P);
-    
+
     bool CompareFailed = false;
     while (1) {
       // Scan for the end of file or next difference.