/* Numdiff - compare putatively similar files, ignoring small numeric differences Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Ivano Primi This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include "numdiff.h" #include "xalloc.h" extern Real Zero; /* Care that internally the field numbers start from zero, not from one */ const long FIELDNO_MAX = (8 * FIELDMASK_SIZE); const char separator = ':'; static const struct numfmt defaults = {CURRENCY, DP, THSEP, GROUPING, POS_SIGN, NEG_SIGN, ECH, IU}; /* Create a new stack of threshold values, then push onto the stack the element { threshold = 0.0, beg1 = 0, end1 = FIELDNO_MAX-1, beg2 = 0, end2 = FIELDNO_MAX-1, double_range_spec = 0 } and return a pointer to the top of the stack. */ thrlist thrlist_new (void) { thrlist list; list = (thrlist) xmalloc (sizeof (thrlist_node)); initR (&list->threshold); /* copyR (&list->threshold, Zero); */ list->beg1 = list->beg2 = 0; list->end1 = list->end2 = FIELDNO_MAX - 1; list->double_range_spec = 0; list->next = NULL; return list; } /* If the string STR begins with a valid range of positive integer values, then set *B to (start value - 1), *E to (end value - 1), and, if TAIL != NULL, set *TAIL so that it points to the first character of STR after the range specification. Finally, return THRLIST_OK (0). For example, if STR == "1-10#abc", then *B will be set to 0, *E to 9, and *TAIL will point to the character '#'. If the string STR does not begin with a valid range of positive integer values, then leave *B, *E and *TAIL unchanged and return the error code THRLIST_INVALID_FORMAT. Remarks: 1. The following abbreviated range specifications are admitted, where N is a positive integer value and M == FIELDNO_MAX : N stays for N-N -N stays for 1-N N- stays for N-M . 2. The extremal values of a valid range are integer numbers between 1 and FIELDNO_MAX. In addition, the start value may not be greater than the end value. In case these conditions are not both true the function returns THRLIST_INVALID_FORMAT. */ static int set_interval (const char *str, unsigned long *b, unsigned long *e, char **tail) { long beg, end; char *ptr, *endptr; beg = end = -1; if (!str || !*str) return THRLIST_INVALID_FORMAT; /* illegal input */ /* If we arrive here we are sure that *str != '\0' ! */ if ((beg = strtol (str, &endptr, 10)) == 0 || beg > FIELDNO_MAX || beg < -FIELDNO_MAX) return THRLIST_INVALID_FORMAT; /* illegal input */ else if (beg < 0) { if (*endptr == '\0' || *endptr == separator) { end = -beg; beg = 1; } else return THRLIST_INVALID_FORMAT; } else if (*endptr == '\0' || *endptr == separator) end = beg; else if (*endptr == '-') { ptr = endptr + 1; if (*ptr == '\0' || *ptr == separator) end = FIELDNO_MAX; else { if ((end = strtol (ptr, &endptr, 10)) <= 0 || (*endptr != '\0' && *endptr != separator) || end > FIELDNO_MAX) return THRLIST_INVALID_FORMAT; /* illegal input */ } } if (beg > end) return THRLIST_INVALID_FORMAT; else { *b = (unsigned long)(beg-1); *e = (unsigned long)(end-1); if (tail != NULL) *tail = endptr; return THRLIST_OK; } } /* If the string DEF contains a specification of the form RANGE1:RANGE2, where the ranges RANGE1 and RANGE2 are both in the form accepted by the function set_interval() and have the same length, then set *BEG1, *END1, *BEG2 and *END2 to the extremal values of RANGE1 and RANGE2, respectively, after decrementing them of 1. Then set *DBL_RNG_SPEC to 1 and return THRLIST_OK to the calling function. If the string DEF contains a specification of the form RANGE, where RANGE is in the form accepted by the function set_interval(), then set *BEG1 and *BEG2 to (start_value_of_RANGE - 1), *END1 and *END2 (end_value_of_RANGE - 1), and *DBL_RNG_SPEC to zero. Then return THRLIST_OK to the calling function. If DEF does not contain a valid specification of the form RANGE or RANGE1:RANGE2 then return THRLIST_INVALID_FORMAT. If the given specification is valid, but RANGE1 and RANGE2 do not have the same length, then return THRLIST_INVALID_RANGES. Remark: In the last two cases after returning from the function the values of *BEG1, *BEG2, *END1, *END2 and *DBL_RNG_SPEC can not be trusted. */ static int set_intervals (const char *def, unsigned long *beg1, unsigned long *beg2, unsigned long *end1, unsigned long *end2, int *dbl_rng_spec) { char *endptr; int rv; rv = set_interval (def, beg1, end1, &endptr); if (rv != 0) return rv; else if (*endptr == separator) { rv = set_interval (endptr + 1, beg2, end2, &endptr); if ((rv != 0) || (*endptr != '\0')) return THRLIST_INVALID_FORMAT; else { *dbl_rng_spec = 1; return (*end2 + *beg1 == *end1 + *beg2) ? THRLIST_OK : THRLIST_INVALID_RANGES; } } else { /* *endptr == '\0' */ *beg2 = *beg1; *end2 = *end1; *dbl_rng_spec = 0; return THRLIST_OK; } } /* Push onto the stack pointed to by PLIST a new element according to the specification contained in the string DEF. This specification must have the form 1. THRESHOLD or 2. THRESHOLD:RANGE or 3. THRESHOLD:RANGE1:RANGE2 where THRESHOLD is a non-negative real (decimal) number, and RANGE or RANGE1:RANGE2 must be a valid specification for the function set_intervals(). In case 1. and 2. set the field DOUBLE_RANGE_SPEC of the just pushed element to zero, otherwise set it to 1. If DEF does not contain a valid specification, then do nothing but return a suitable error code (either THRLIST_INVALID_FORMAT or THRLIST_INVALID_RANGES). Otherwise, return THRLIST_OK. */ int thrlist_add (thrlist *plist, const char* def) { int rv, dbl_rng_spec; Real r; unsigned long beg1, beg2, end1, end2; thrlist_node *pnode; char *endptr; if (!def || !*def) return THRLIST_INVALID_FORMAT; /* no input */ /* If we arrive here we are sure that *def != '\0' ! */ initR (&r); str2R (def, &endptr, ISCALE, &defaults, &r); if (endptr == def || cmp(r, Zero) < 0) { delR (&r); return THRLIST_INVALID_FORMAT; /* no valid positive number */ } else { if (*endptr == '\0') { beg1 = beg2 = 0; end1 = end2 = FIELDNO_MAX - 1; dbl_rng_spec = 0; } else if (*endptr == separator) { if ( (rv = set_intervals (endptr + 1, &beg1, &beg2, &end1, &end2, &dbl_rng_spec)) != 0) { delR (&r); return rv; } } else { delR (&r); return THRLIST_INVALID_FORMAT; } pnode = (thrlist_node*) xmalloc (sizeof (thrlist_node)); initR (&pnode->threshold); copyR (&pnode->threshold, r); delR (&r); pnode->beg1 = beg1; pnode->beg2 = beg2; pnode->end1 = end1; pnode->end2 = end2; pnode->double_range_spec = dbl_rng_spec; pnode->next = *plist; *plist = pnode; return THRLIST_OK; } } /* Look in the stack LIST for the first element E from the top such that either E.DOUBLE_RANGE_SPEC == 0 and E.BEG1 <= FIELDNO1 <= E.END1, E.BEG2 <= FIELDNO2 <= E.END2, or E.DOUBLE_RANGE_SPEC == 1 and E.BEG1 <= FIELDNO1 <= E.END1, FIELDNO2 == E.BEG2 + FIELDNO1 - E.BEG1 . Then return the value of the comparison test between R and E.THRESHOLD. If there is no element E in LIST satisfying one of the previous conditions (this should never happen if LIST has been created by thrlist_new()), then interrupt the main program via exit(EXIT_TROUBLE) after printing a suitable error message on stdout. */ int thrlist_cmp (Real r, thrlist list, unsigned long fieldno1, unsigned long fieldno2) { thrlist_node *pnode, *pnext; pnode = list; while (pnode != NULL) { pnext = pnode->next; if ( (pnode->double_range_spec) ) { if (fieldno1 >= pnode->beg1 && fieldno1 <= pnode->end1 && fieldno2 == pnode->beg2 + fieldno1 - pnode->beg1) { return cmp (r, pnode->threshold); /* found */ } } else { if (fieldno1 >= pnode->beg1 && fieldno1 <= pnode->end1 && fieldno2 >= pnode->beg2 && fieldno2 <= pnode->end2) { return cmp (r, pnode->threshold); /* found */ } } pnode = pnext; } /* The code execution should NEVER reach this point. */ printf (_("Fatal error occurred during comparison of two numerical fields\n")); exit (EXIT_TROUBLE); } /* Dispose the stack pointed to by PLIST (free and clean the memory). */ void thrlist_dispose (thrlist *plist) { thrlist_node *pnode, *pnext; if (plist != NULL) { pnode = *plist; while (pnode != NULL) { pnext = pnode->next; delR (&pnode->threshold); free ((void*)pnode); pnode = pnext; } *plist = NULL; } }