Teach fpcmp about the x. FP format

[rovka]

Summary

At the moment fpcmp rejects floating point numbers with no decimal
digits after the decimal point, such as "3.". However, flang-new often
prints floating point numbers in this format and it seems to be
a perfectly respectable format (strtod is happy enough to gobble it up).

This patch updates fpcmp to allow the absence of post-decimal digits
if pre-decimal digits are present.

[Meinersbur]

I fear there is the problem that any single dot will be interpreted as a number. I tried strtod(".") (https://godbolt.org/z/Ke9n4zbn5) and it doesn't gobble it up. So we need to check that there are either digits before or after the period, but cannot omit both.

I don't think we need the compatibility flag. This patch would make fpcmp only more tolerant, so there would be any new test failures.

[rovka]

Looks like flang isn't using this format anymore. We can resurrect this patch some other time if we have a need for it. Thanks for the comments though!

[rovka]

I think I got myself confused, flang does still print values in this format, and that's what's going to be in the reference outputs. Therefore, if we want to be able to pass this test when FCVS_ALLOW_FLEXIBLE_OUTPUT is enabled, we need to teach fpcmp how to handle this.

Updated the patch per @Meinersbur 's comments, thanks!

tools/fpcmp.c

default:
     return false;
   }
 }
 
 static bool isPossibleStartOfNumber(char C) {
   return isDigitChar(C) || isSignedChar(C) || C == '.';
 }
 
-static const char *AdvanceNumber(const char *StartPos, const char *End) {
+static const char *AdvanceNumber(const char *StartPos, const char *End,
+                                 bool NeedsPostDecimalDigit) {
   const char *Pos = StartPos;
   const char *EndOfNumber = NULL;
 
   // Sign character (optional)
   if (Pos < End && isSignedChar(*Pos))
     ++Pos;
 
   // Pre-decimal digits (optional)
   while (Pos < End && isDigitChar(*Pos)) {
     ++Pos;
     EndOfNumber = Pos;
   }
 
   // Decimal separator
   if (Pos < End && *Pos == '.') {
     ++Pos;
+    EndOfNumber = Pos;
 
-    // Post-decimal digits (require at least one when period present)
+    // Post-decimal digits
     bool HasPostDecimalDigit = false;
     while (Pos < End && isDigitChar(*Pos)) {
       HasPostDecimalDigit = true;
 
       ++Pos;
       EndOfNumber = Pos;
     }
-    if (!HasPostDecimalDigit)
+
+    // Sometimes we require at least one decimal digit when the decimal point is
+    // present.
+    if (NeedsPostDecimalDigit && !HasPostDecimalDigit)
       return EndOfNumber;
   }
 
   // Require a valid number before the exponent.
   // (e.g. don't recognize '+e1' as a number)
   if (!EndOfNumber)
     return EndOfNumber;
 
char *load_file(const char *path, long *size_out) {
   /* Close the file and return the data. */
   fclose(fp);
   *size_out = size;
   return data;
 }
 
 int diff_files_with_tolerance(const char *path_a, const char *path_b,
                               double absolute_tolerance,
-                              double relative_tolerance,
-                              bool ignore_whitespace) {
+                              double relative_tolerance, bool ignore_whitespace,
+                              bool post_decimal_digit) {
   /* First, load the file buffers completely into memory. */
   long A_size, B_size;
   char *data_a = load_file(path_a, &A_size);
   char *data_b = load_file(path_b, &B_size);
 
   /* Fast path equivalent buffers. */
   if (A_size == B_size && memcmp(data_a, data_b, A_size) == 0) {
     free(data_a);
while (1) {
     if (ignore_whitespace) {
       if (skip_whitespace(&F1P, File1End) | skip_whitespace(&F2P, File2End))
         continue;
     } else {
       skip_whitespace(&F1NumStart, File1End);
       skip_whitespace(&F2NumStart, File2End);
     }
 
-    const char *F1NumEnd = AdvanceNumber(F1NumStart, File1End);
-    const char *F2NumEnd = AdvanceNumber(F2NumStart, File2End);
+    const char *F1NumEnd =
+        AdvanceNumber(F1NumStart, File1End, post_decimal_digit);
+    const char *F2NumEnd =
+        AdvanceNumber(F2NumStart, File2End, post_decimal_digit);
 
     // If one side is a number, but not the other, we found a difference.
     if (!F1NumEnd || !F2NumEnd) {
       // If there is no number starting at the current position, it might be a
       // non-numeric difference.
       if (*F1P != *F2P)
         break;
 
int diff_files_with_tolerance(const char *path_a, const char *path_b,
 
   free(data_a);
   free(data_b);
 
   return 0;
 }
 
 void usage() {
-  fprintf(stderr, "usage: %s [-a VALUE] [-r VALUE] [-i] <path-A> <path-B>\n\n",
+  fprintf(stderr,
+          "usage: %s [-a VALUE] [-r VALUE] [-i] [-d] <path-A> <path-B>\n\n",
           g_program);
   fprintf(stderr, "Compare two files using absolute and relative tolerances\n");
   fprintf(stderr, "when comparing differences between two character\n");
   fprintf(stderr, "which could be real numbers\n");
   fprintf(stderr, "The -i switch ignores whitespace differences\n");
+  fprintf(stderr,
+          "The -d switch requires at least one digit after a decimal point\n");
   exit(2);
 }
 
 int main(int argc, char * const argv[]) {
   double relative_tolerance = 0.0;
   double absolute_tolerance = 0.0;
   bool ignore_whitespace = false;
+  bool post_decimal_digit = false;
   int i;
 
   g_program = argv[0];
   for (i = 1; i != argc; ++i) {
     const char *arg = argv[i];
     if (arg[0] != '-')
         break;
 
case 'r':
           relative_tolerance = value;
       }
       break;
 
     case 'i':
       ignore_whitespace = true;
       break;
 
+    case 'd':
+      post_decimal_digit = true;
+      break;
+
     default:
       fprintf(stderr, "error: invalid argument '%s'\n\n", arg);
       usage();
     }
   }
 
   if (i + 2 != argc) {
     fprintf(stderr, "error: invalid number of arguments\n\n");
     usage();
   }
 
   return diff_files_with_tolerance(argv[i], argv[i + 1], absolute_tolerance,
-                                   relative_tolerance, ignore_whitespace);
+                                   relative_tolerance, ignore_whitespace,
+                                   post_decimal_digit);
 }