| /*===-- fpcmp.c - LLVM Floating point comparison tool ---------------------===*\ |
| |* *| |
| |* Part of the LLVM Project, under the Apache License v2.0 with LLVM *| |
| |* Exceptions. *| |
| |* See https://llvm.org/LICENSE.txt for license information. *| |
| |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception *| |
| |* *| |
| \*===----------------------------------------------------------------------===*/ |
| |
| /* Note that this file is essentially a bastardized C version of |
| * FileUtilities.cpp from LLVM. */ |
| |
| #include <ctype.h> |
| #include <math.h> |
| #include <stddef.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| const char *g_program; |
| |
| /* *** */ |
| |
| typedef int bool; |
| #define true ((bool) 1) |
| #define false ((bool) 0) |
| |
| 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 isDigitChar(char C) { |
| switch (C) { |
| case '0': case '1': case '2': case '3': case '4': |
| case '5': case '6': case '7': case '8': case '9': |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| static bool isPossibleStartOfNumber(char C) { |
| return isDigitChar(C) || isSignedChar(C) || C == '.'; |
| } |
| |
| static const char *AdvanceNumber(const char *StartPos, const char *End) { |
| 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; |
| |
| // Post-decimal digits (require at least one when period present) |
| bool HasPostDecimalDigit = false; |
| while (Pos < End && isDigitChar(*Pos)) { |
| HasPostDecimalDigit = true; |
| |
| ++Pos; |
| EndOfNumber = Pos; |
| } |
| if (!HasPostDecimalDigit) |
| return EndOfNumber; |
| } |
| |
| // Require a valid number before the exponent. |
| // (e.g. don't recognize '+e1' as a number) |
| if (!EndOfNumber) |
| return EndOfNumber; |
| |
| // Exponent separator |
| if (Pos < End && isExponentChar(*Pos)) { |
| ++Pos; |
| |
| // Exponent sign (optional) |
| if (Pos < End && isSignedChar(*Pos)) |
| ++Pos; |
| |
| // Exponent digits (require at least one when 'e' present) |
| while (Pos < End && isDigitChar(*Pos)) { |
| ++Pos; |
| EndOfNumber = Pos; |
| } |
| } |
| |
| return EndOfNumber; |
| } |
| |
| static bool skip_whitespace(const char **FP, const char *FEnd) { |
| bool skipped_some = false; |
| while (*FP < FEnd && isspace((unsigned char)**FP)) { |
| skipped_some = true; |
| ++*FP; |
| } |
| return skipped_some; |
| } |
| |
| /// 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) { |
| const char *F1NumEnd, *F2NumEnd; |
| const ptrdiff_t F1Len = F1End - F1P; |
| const ptrdiff_t F2Len = F2End - F2P; |
| double V1 = 0.0, V2 = 0.0; |
| |
| // Fast character-by-character comparison of the numbers. |
| if (F1Len == F2Len && memcmp(F1P, F2P, F1Len) == 0) |
| return false; |
| |
| // 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, (char **)(&F1NumEnd)); |
| V2 = strtod(F2P, (char **)(&F2NumEnd)); |
| |
| if (*F1NumEnd == 'D' || *F1NumEnd == 'd') { |
| // Copy string into tmp buffer to replace the 'D' with an 'e'. |
| char *StrTmp = malloc(F1Len + 1); |
| memcpy(StrTmp, F1P, F1Len + 1); |
| |
| // Strange exponential notation! |
| StrTmp[(unsigned)(F1NumEnd - F1P)] = 'e'; |
| |
| V1 = strtod(&StrTmp[0], (char **)(&F1NumEnd)); |
| F1NumEnd = F1P + (F1NumEnd - &StrTmp[0]); |
| |
| free(StrTmp); |
| } |
| |
| if (*F2NumEnd == 'D' || *F2NumEnd == 'd') { |
| // Copy string into tmp buffer to replace the 'D' with an 'e'. |
| char *StrTmp = malloc(F2Len + 1); |
| memcpy(StrTmp, F2P, F2Len + 1); |
| |
| // Strange exponential notation! |
| StrTmp[(unsigned)(F2NumEnd - F2P)] = 'e'; |
| |
| V2 = strtod(&StrTmp[0], (char **)(&F2NumEnd)); |
| F2NumEnd = F2P + (F2NumEnd - &StrTmp[0]); |
| |
| free(StrTmp); |
| } |
| |
| if (F1NumEnd == F1P || F2NumEnd == F2P) { |
| fprintf(stderr, ("%s: FP Comparison failed, not a numeric difference " |
| "between '%c' and '%c'\n"), g_program, F1P[0], F2P[0]); |
| return true; |
| } |
| |
| // Quick check for identical values |
| if (V1 == V2) |
| return false; |
| |
| // Check to see if these are inside the absolute tolerance |
| if (AbsTolerance == 0.0 || AbsTolerance < fabs(V1 - V2)) { |
| // Nope, check the relative tolerance... |
| double Diff; |
| if (V2) |
| Diff = fabs(V1/V2 - 1.0); |
| else if (V1) |
| Diff = fabs(V2/V1 - 1.0); |
| else |
| Diff = 0; // Both zero. |
| if (RelTolerance == 0.0 || Diff > RelTolerance) { |
| fprintf(stderr, ("%s: Compared: %e and %e\n" |
| "abs. diff = %e rel.diff = %e\n" |
| "Out of tolerance: rel/abs: %e/%e\n"), |
| g_program, V1, V2, fabs(V1-V2), Diff, RelTolerance, AbsTolerance); |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /* *** */ |
| |
| char *load_file(const char *path, long *size_out) { |
| FILE *fp; |
| long size; |
| char *data; |
| |
| /* Open the file... */ |
| fp = fopen(path, "rb"); |
| if (!fp) { |
| fprintf(stderr, "%s: error: unable to open '%s'\n", g_program, path); |
| exit(2); |
| } |
| |
| /* Determine the file size. */ |
| if (fseek(fp, 0, SEEK_END) == -1) { |
| fprintf(stderr, "%s: error: unable to seek '%s'\n", g_program, path); |
| exit(2); |
| } |
| size = ftell(fp); |
| if (fseek(fp, 0, SEEK_SET) == -1) { |
| fprintf(stderr, "%s: error: unable to seek '%s'\n", g_program, path); |
| exit(2); |
| } |
| |
| /* Avoid malloc(0). */ |
| if (size == 0) { |
| *size_out = 0; |
| return 0; |
| } |
| |
| /* Allocate a buffer for the data. */ |
| data = malloc(size + 1); |
| if (!data) { |
| fprintf(stderr, "%s: error: unable to allocate buffer for '%s'\n", |
| g_program, path); |
| exit(2); |
| } |
| |
| /* Read in the file contents. */ |
| data[size] = 0; |
| if (fread(data, size, 1, fp) != 1) { |
| fprintf(stderr, "%s: error: unable to read data for '%s'\n", |
| g_program, path); |
| exit(2); |
| } |
| |
| /* Close the file and return the data. */ |
| fclose(fp); |
| *size_out = size; |
| return data; |
| } |
| |
| int diff_file(const char *path_a, const char *path_b, bool parse_fp, |
| double absolute_tolerance, double relative_tolerance, |
| bool ignore_whitespace) { |
| /* 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); |
| free(data_b); |
| return 0; |
| } |
| |
| /* *** */ |
| |
| // Okay, now that we opened the files, scan them for the first difference. |
| const char *File1Start = data_a; |
| const char *File2Start = data_b; |
| const char *File1End = data_a + A_size; |
| const char *File2End = data_b + B_size; |
| const char *F1P = File1Start; |
| const char *F2P = File2Start; |
| |
| while (1) { |
| // Reached the end of at least one file? |
| if (F1P >= File1End || F2P >= File2End) { |
| // Skip any whitespace at the end of the file. |
| if (ignore_whitespace) { |
| skip_whitespace(&F1P, File1End); |
| skip_whitespace(&F2P, File2End); |
| } |
| break; |
| } |
| |
| // Scan for the end of file or next difference. |
| if (*F1P == *F2P && (!parse_fp || !isPossibleStartOfNumber(*F1P))) { |
| ++F1P, ++F2P; |
| continue; |
| } |
| |
| // With whitespace ignored, skip whitespace chars (if any) and recheck for |
| // the next difference. Otherwise, only ignore whitespace before numbers. |
| const char *F1NumStart = F1P; |
| const char *F2NumStart = F2P; |
| if (ignore_whitespace) { |
| if (skip_whitespace(&F1P, File1End) | skip_whitespace(&F2P, File2End)) |
| continue; |
| } else if (parse_fp) { |
| skip_whitespace(&F1NumStart, File1End); |
| skip_whitespace(&F2NumStart, File2End); |
| } |
| |
| if (!parse_fp) { |
| // In non-floating point mode, recheck for character difference after |
| // skipping whitespace. |
| if (F1P < File1End && F2P < File2End && *F1P == *F2P) { |
| ++F1P, ++F2P; |
| continue; |
| } |
| break; |
| } |
| |
| const char *F1NumEnd = AdvanceNumber(F1NumStart, File1End); |
| const char *F2NumEnd = AdvanceNumber(F2NumStart, File2End); |
| |
| // 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; |
| |
| // Otherwise, try over with the next pair to eventually find the |
| // difference or a matching number. Consider: |
| // |
| // +1.0 |
| // ++1.0 |
| // |
| // Starting with the first + characters, the first will be recognized as a |
| // number, but not the second. Only when comparing the second characters |
| // both will be recognized as numbers. |
| ++F1P, ++F2P; |
| continue; |
| } |
| |
| // Now that we are at the start of the numbers, compare them, exiting if |
| // they don't match. |
| if (CompareNumbers(F1NumStart, F2NumStart, F1NumEnd, F2NumEnd, |
| absolute_tolerance, relative_tolerance)) { |
| free(data_a); |
| free(data_b); |
| return 1; |
| } |
| |
| // Numbers compare equal, continue after the numbers. |
| F1P = F1NumEnd; |
| F2P = F2NumEnd; |
| } |
| |
| // 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 (!F1AtEnd && !F2AtEnd) { |
| fprintf(stderr, |
| "%s: Comparison failed, textual difference between '%c' and '%c'\n", |
| g_program, F1P[0], F2P[0]); |
| free(data_a); |
| free(data_b); |
| return 1; |
| } |
| if (!F1AtEnd || !F2AtEnd) { |
| fprintf(stderr, |
| "%s: Comparison failed, unexpected end of one of the files\n", |
| g_program); |
| free(data_a); |
| free(data_b); |
| return 1; |
| } |
| |
| 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", |
| g_program); |
| fprintf(stderr, "Search two text files for differences.\n" |
| "If either -a or -r is specified (even if zero), floating " |
| "numbers are parsed and considered equal if neither the " |
| "absolute nor relative tolerance is exceeded.\n" |
| "The -i switch also ignores whitespace differences.\n"); |
| exit(2); |
| } |
| |
| int main(int argc, char * const argv[]) { |
| double relative_tolerance = 0.0; |
| double absolute_tolerance = 0.0; |
| bool parse_fp = false; |
| bool ignore_whitespace = false; |
| int i; |
| |
| g_program = argv[0]; |
| for (i = 1; i != argc; ++i) { |
| const char *arg = argv[i]; |
| if (arg[0] != '-') |
| break; |
| |
| if (strlen(arg) != 2) { |
| fprintf(stderr, "error: invalid argument '%s'\n\n", arg); |
| usage(); |
| } |
| |
| switch (arg[1]) { |
| case 'a': |
| case 'r': |
| if (i + 1 == argc) { |
| fprintf(stderr, "error: missing argument to '%s'\n\n", arg); |
| usage(); |
| } else { |
| char *endp = 0; |
| double value = strtod(argv[++i], &endp); |
| if (endp == 0 || *endp != '\0') { |
| fprintf(stderr, "error: invalid argument to '%s': '%s'\n\n", arg, |
| argv[i]); |
| usage(); |
| } |
| if (arg[1] == 'a') |
| absolute_tolerance = value; |
| else |
| relative_tolerance = value; |
| parse_fp = true; |
| } |
| break; |
| |
| case 'i': |
| ignore_whitespace = 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_file(argv[i], argv[i + 1], parse_fp, absolute_tolerance, |
| relative_tolerance, ignore_whitespace); |
| } |