sddsdiff.c File Reference

Detailed Description

Compare two SDDS files for differences in definitions and data.

The program sddsdiff compares two SDDS (Self Describing Data Sets) files by analyzing their definitions (columns, parameters, arrays) and data, supporting various comparison criteria such as exact matches, numerical tolerances, and absolute differences. It provides detailed reports on discrepancies in definitions or data values.

Usage

sddsdiff <file1> <file2>
         [-compareCommon[=column|parameter|array]] 
         [-columns=<col1>[,<col2>...]]
         [-parameters=<par1>[,<par2>...]]
         [-arrays=<array1>[,<array2>...]] 
          [-tolerance=<value>] 
         [-relativeTolerance=<value>]
         [-precision=<integer>]
 
         [-format=float=<string>|double=<string>|longdouble=<string>|string=<string>] 
         [-exact] 
         [-absolute] 
         [-rowlabel=<column-name>[,nocomparison]] 
         [-ignoreUnits] 

Options

Option	Description
-compareCommon	Compare only common columns, parameters, or arrays.
-columns	Specify columns to compare.
-parameters	Specify parameters to compare.
-arrays	Specify arrays to compare.
-tolerance	Set absolute numerical comparison tolerance.
-relativeTolerance	Set relative tolerance using min(abs(value1), abs(value2)) * value.
-precision	Set the precision for numerical comparison.
-format	Specify the format for printing float, double, long double, or string data.
-exact	Compare values exactly (mutually exclusive with tolerance and precision).
-absolute	Compare absolute values.
-rowlabel	Use a column to label rows for comparison.
-ignoreUnits	Ignore units during the comparison.

Incompatibilities

• -exact is incompatible with:
  • -tolerance
  • -precision

Copyright

• (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
• (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.

License

This file is distributed under the terms of the Software License Agreement found in the file LICENSE included with this distribution.

Author

H. Shang, R. Soliday, L. Emery, M. Borland

Definition in file sddsdiff.c.

#include "mdb.h"
#include "SDDS.h"
#include "scan.h"
#include "SDDSutils.h"
#include <float.h>

Go to the source code of this file.

Functions
long	CompareDefinitions (SDDS_DATASET *dataset1, SDDS_DATASET *dataset2, char *file1, char *file2, int32_t *names, char ***name, int32_t **dataType, long type, long compareCommon, char *rowLabelColumn, long notCompareRowLabel, short ignoreUnits)
long	CompareData (SDDS_DATASET *dataset1, SDDS_DATASET *dataset2, char *file1, char *file2, long names, char **name, int32_t *dataType, long type, long page, long double tolerance, long double relativeTolerance, long double precisionTolerance, char *floatFormat, char *doubleFormat, char *ldoubleFormat, char *stringFormat, long absolute, void *rowLabel, long rowLabelType, char *labelName)
long	compare_two_data (void *data1, void *data2, long index, long datatype, long first, long flags, char *name, long page, long double tolerance, long double relativeTolerance, long double precisionTolerance, char *floatFormat, char *doubleFormat, char *ldoubleFormat, char *stringFormat, char *longFormat, char *ulongFormat, char *shortFormat, char *ushortFormat, char *charFormat, long absolute, long parameter, char *labelName)
void	printTitle (long flags, char *name, long page, long absolute, char *labelName)
int	main (int argc, char **argv)

Function Documentation

compare_two_data()

long compare_two_data	(	void *	data1,
		void *	data2,
		long	index,
		long	datatype,
		long	first,
		long	flags,
		char *	name,
		long	page,
		long double	tolerance,
		long double	relativeTolerance,
		long double	precisionTolerance,
		char *	floatFormat,
		char *	doubleFormat,
		char *	ldoubleFormat,
		char *	stringFormat,
		char *	longFormat,
		char *	ulongFormat,
		char *	shortFormat,
		char *	ushortFormat,
		char *	charFormat,
		long	absolute,
		long	parameter,
		char *	labelName )

Definition at line 953 of file sddsdiff.c.

                                                                      {
  char *str1, *str2;
  long double ldval1, ldval2, ldenominator, ldabs1, ldabs2, lddiff;
  double dval1, dval2, denominator, dabs1, dabs2, ddiff;
  float fval1, fval2, fabs1, fabs2, fdenominator, fdiff;
  int32_t lval1, lval2, labs1, labs2, ldiff, uldiff;
  uint32_t ulval1, ulval2;
  int64_t llval1, llval2, llabs1, llabs2, lldiff, ulldiff;
  uint64_t ullval1, ullval2;
  short sval1, sval2, sabs1, sabs2, sdiff, usdiff;
  unsigned short usval1, usval2;
  char cval1, cval2;
  long returnValue = 0, printIndex;
  long double tol, scale;
 
  printIndex = index + 1;
  if (parameter)
    printIndex = page;
 
  if (tolerance < 0)
    tol = 0L;
  else
    tol = tolerance;
 
  switch (datatype) {
  case SDDS_STRING:
    str1 = *((char **)data1 + index);
    str2 = *((char **)data2 + index);
    returnValue = strcmp(trim_spaces(str1), trim_spaces(str2));
    if (returnValue != 0) {
      if (first)
        printTitle(flags, name, page, absolute, labelName);
      if (labelName) {
        fprintf(stdout, stringFormat, str1, str2, returnValue);
      } else
        fprintf(stdout, stringFormat, printIndex, str1, str2, returnValue);
    }
    break;
  case SDDS_LONGDOUBLE:
    ldval1 = *((long double *)data1 + index);
    ldval2 = *((long double *)data2 + index);
    if (absolute) {
      ldabs1 = fabsl(ldval1);
      ldabs2 = fabsl(ldval2);
    } else {
      ldabs1 = ldval1;
      ldabs2 = ldval2;
    }
    lddiff = ldabs1 - ldabs2;
    if ((isnan(ldval1) && !isnan(ldval2)) || (isinf(ldval1) && !isinf(ldval2)))
      returnValue = 1;
    else if (ldabs1 != ldabs2) {
      if (relativeTolerance) {
        scale = MIN(fabsl(ldval1), fabsl(ldval2));
        if (fabsl(lddiff) > scale * relativeTolerance)
          returnValue = 1;
      } else if (tolerance) {
        if (fabsl(lddiff) > tol)
          returnValue = 1;
      } else {
        if (ldabs1 == 0L || ldabs2 == 0L) {
          if (fabsl(ldabs1 - ldabs2) > precisionTolerance)
            returnValue = 1;
        } else {
          ldabs1 = fabsl(ldval1);
          ldabs2 = fabsl(ldval2);
          ldenominator = (ldabs1 < ldabs2) ? ldabs1 : ldabs2;
          if (fabsl(ldval1 - ldval2) / ldenominator > precisionTolerance)
            returnValue = 1;
        }
      }
    }
    if (returnValue) {
      if (first)
        printTitle(flags, name, page, absolute, labelName);
      if (labelName)
        fprintf(stdout, ldoubleFormat, ldval1, ldval2, lddiff);
      else
        fprintf(stdout, ldoubleFormat, printIndex, ldval1, ldval2, lddiff);
    }
    break;
  case SDDS_DOUBLE:
    dval1 = *((double *)data1 + index);
    dval2 = *((double *)data2 + index);
    if (absolute) {
      dabs1 = fabs(dval1);
      dabs2 = fabs(dval2);
    } else {
      dabs1 = dval1;
      dabs2 = dval2;
    }
    ddiff = dabs1 - dabs2;
    if ((isnan(dval1) && !isnan(dval2)) || (isinf(dval1) && !isinf(dval2)))
      returnValue = 1;
    else if (dabs1 != dabs2) {
      if (relativeTolerance) {
        scale = MIN(fabs(dval1), fabs(dval2));
        if (fabs(ddiff) > scale * relativeTolerance)
          returnValue = 1;
      } else if (tolerance) {
        if (fabs(ddiff) > tol)
          returnValue = 1;
      } else {
        if (dabs1 == 0 || dabs2 == 0) {
          if (fabs(dabs1 - dabs2) > precisionTolerance)
            returnValue = 1;
        } else {
          dabs1 = fabs(dval1);
          dabs2 = fabs(dval2);
          denominator = (dabs1 < dabs2) ? dabs1 : dabs2;
          if (fabs(dval1 - dval2) / denominator > precisionTolerance)
            returnValue = 1;
        }
      }
    }
    if (returnValue) {
      if (first)
        printTitle(flags, name, page, absolute, labelName);
      if (labelName)
        fprintf(stdout, doubleFormat, dval1, dval2, ddiff);
      else
        fprintf(stdout, doubleFormat, printIndex, dval1, dval2, ddiff);
    }
    break;
  case SDDS_FLOAT:
    fval1 = *((float *)data1 + index);
    fval2 = *((float *)data2 + index);
    if (absolute) {
      fabs1 = fabs(fval1);
      fabs2 = fabs(fval2);
    } else {
      fabs1 = fval1;
      fabs2 = fval2;
    }
    fdiff = fabs1 - fabs2;
    if ((isnan(fval1) && !isnan(fval2)) || (isinf(fval1) && !isinf(fval2)))
      returnValue = 1;
    else if (fabs1 != fabs2) {
      if (relativeTolerance) {
        scale = MIN(fabs(fval1), fabs(fval2));
        if (fabs(fdiff) > scale * relativeTolerance)
          returnValue = 1;
      } else if (tolerance) {
        if (fabs(fdiff) > tol)
          returnValue = 1;
      } else {
        if (fabs1 == 0 || fabs2 == 0) {
          if (fabs(fabs1 - fabs2) > precisionTolerance)
            returnValue = 1;
        } else {
          fabs1 = fabs(fval1);
          fabs2 = fabs(fval2);
          fdenominator = (fabs1 < fabs2) ? fabs1 : fabs2;
          if (fabs(fval1 - fval2) / fdenominator > precisionTolerance)
            returnValue = 1;
        }
      }
    }
    if (returnValue) {
      if (first)
        printTitle(flags, name, page, absolute, labelName);
      if (labelName)
        fprintf(stdout, floatFormat, fval1, fval2, fdiff);
      else
        fprintf(stdout, floatFormat, printIndex, fval1, fval2, fdiff);
    }
    break;
  case SDDS_ULONG64:
    ullval1 = *((uint64_t *)data1 + index);
    ullval2 = *((uint64_t *)data2 + index);
    ulldiff = ullval1 - ullval2;
    if (labs(ulldiff) > tol)
      returnValue = 1;
    if (returnValue) {
      if (first)
        printTitle(flags, name, page, absolute, labelName);
      if (labelName)
        fprintf(stdout, ulongFormat, ullval1, ullval2, ulldiff);
      else
        fprintf(stdout, ulongFormat, printIndex, ullval1, ullval2, ulldiff);
    }
    break;
  case SDDS_LONG64:
    llval1 = *((int64_t *)data1 + index);
    llval2 = *((int64_t *)data2 + index);
    if (absolute) {
      llabs1 = labs(llval1);
      llabs2 = labs(llval2);
    } else {
      llabs1 = llval1;
      llabs2 = llval2;
    }
    lldiff = llabs1 - llabs2;
    if (llabs(lldiff) > tol)
      returnValue = 1;
    if (returnValue) {
      if (first)
        printTitle(flags, name, page, absolute, labelName);
      if (labelName)
        fprintf(stdout, longFormat, llval1, llval2, lldiff);
      else
        fprintf(stdout, longFormat, printIndex, llval1, llval2, lldiff);
    }
    break;
  case SDDS_ULONG:
    ulval1 = *((uint32_t *)data1 + index);
    ulval2 = *((uint32_t *)data2 + index);
    uldiff = ulval1 - ulval2;
    if (labs(uldiff) > tol)
      returnValue = 1;
    if (returnValue) {
      if (first)
        printTitle(flags, name, page, absolute, labelName);
      if (labelName)
        fprintf(stdout, ulongFormat, ulval1, ulval2, uldiff);
      else
        fprintf(stdout, ulongFormat, printIndex, ulval1, ulval2, uldiff);
    }
    break;
  case SDDS_LONG:
    lval1 = *((int32_t *)data1 + index);
    lval2 = *((int32_t *)data2 + index);
    if (absolute) {
      labs1 = abs(lval1);
      labs2 = abs(lval2);
    } else {
      labs1 = lval1;
      labs2 = lval2;
    }
    ldiff = labs1 - labs2;
    if (labs(ldiff) > tol)
      returnValue = 1;
    if (returnValue) {
      if (first)
        printTitle(flags, name, page, absolute, labelName);
      if (labelName)
        fprintf(stdout, longFormat, lval1, lval2, ldiff);
      else
        fprintf(stdout, longFormat, printIndex, lval1, lval2, ldiff);
    }
    break;
  case SDDS_SHORT:
    sval1 = *((short *)data1 + index);
    sval2 = *((short *)data2 + index);
    if (absolute) {
      sabs1 = abs(sval1);
      sabs2 = abs(sval2);
    } else {
      sabs1 = sval1;
      sabs2 = sval2;
    }
    sdiff = sabs1 - sabs2;
    if (abs(sdiff) > tol)
      returnValue = 1;
    if (returnValue) {
      if (first)
        printTitle(flags, name, page, absolute, labelName);
      if (labelName)
        fprintf(stdout, shortFormat, sval1, sval2, sdiff);
      else
        fprintf(stdout, shortFormat, printIndex, sval1, sval2, sdiff);
    }
    break;
  case SDDS_USHORT:
    usval1 = *((unsigned short *)data1 + index);
    usval2 = *((unsigned short *)data2 + index);
    usdiff = usval1 - usval2;
    if (abs(usdiff) > tol)
      returnValue = 1;
    if (returnValue) {
      if (first)
        printTitle(flags, name, page, absolute, labelName);
      if (labelName)
        fprintf(stdout, ushortFormat, usval1, usval2, usdiff);
      else
        fprintf(stdout, ushortFormat, printIndex, usval1, usval2, usdiff);
    }
    break;
  case SDDS_CHARACTER:
    cval1 = *((char *)data1 + index);
    cval2 = *((char *)data2 + index);
    if (cval1 != cval2) {
      returnValue = 1;
      if (first)
        printTitle(flags, name, page, absolute, labelName);
      if (labelName)
        fprintf(stdout, charFormat, cval1, cval2, cval1 - cval2);
      else
        fprintf(stdout, charFormat, printIndex, cval1, cval2, cval1 - cval2);
    }
    break;
  default:
    fprintf(stderr, "Unknown data type %ld.\n", datatype);
    exit(EXIT_FAILURE);
  }
  return returnValue;
}

CompareData()

long CompareData	(	SDDS_DATASET *	dataset1,
		SDDS_DATASET *	dataset2,
		char *	file1,
		char *	file2,
		long	names,
		char **	name,
		int32_t *	dataType,
		long	type,
		long	page,
		long double	tolerance,
		long double	relativeTolerance,
		long double	precisionTolerance,
		char *	floatFormat,
		char *	doubleFormat,
		char *	ldoubleFormat,
		char *	stringFormat,
		long	absolute,
		void *	rowLabel,
		long	rowLabelType,
		char *	labelName )

Definition at line 772 of file sddsdiff.c.

                                                                                                             {
  long diff = 0, i, first = 1;
  int64_t rows, j;
  char fFormat[2048], dFormat[2048], ldFormat[2048], strFormat[2048], lFormat[2048], ulFormat[2048], ushortFormat[2048], shortFormat[2048], cFormat[2048], labelFormat[1024];
  SDDS_ARRAY *array1, *array2;
  void *data1, *data2;
 
  array1 = array2 = NULL;
  data1 = data2 = NULL;
 
  if (!rowLabel) {
    snprintf(fFormat, sizeof(fFormat), "%%20ld%s%s%s\n", floatFormat, floatFormat, floatFormat);
    snprintf(dFormat, sizeof(dFormat), "%%20ld%s%s%s\n", doubleFormat, doubleFormat, doubleFormat);
    snprintf(ldFormat, sizeof(ldFormat), "%%20ld%s%s%s\n", ldoubleFormat, ldoubleFormat, ldoubleFormat);
    snprintf(strFormat, sizeof(strFormat), "%%20ld%s%s%%25ld\n", stringFormat, stringFormat);
    snprintf(lFormat, sizeof(lFormat), "%s", "%20ld%25ld%25ld\n");
    snprintf(ulFormat, sizeof(ulFormat), "%s", "%20ld%25lu%25lu%25ld\n");
    snprintf(shortFormat, sizeof(shortFormat), "%s", "%20ld%25hd%25hd%25hd\n");
    snprintf(ushortFormat, sizeof(ushortFormat), "%s", "%20ld%25hu%25hu%25hd\n");
    snprintf(cFormat, sizeof(cFormat), "%s", "%20ld%25c%25c%25d\n");
  }
  switch (type) {
  case SDDS_COLUMN_TYPE:
    rows = SDDS_CountRowsOfInterest(dataset1);
    if (!rows)
      break;
    for (i = 0; i < names; i++) {
      first = 1;
      if (!(data1 = SDDS_GetColumn(dataset1, name[i])) || !(data2 = SDDS_GetColumn(dataset2, name[i]))) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
        exit(EXIT_FAILURE);
      }
      for (j = 0; j < rows; j++) {
        if (rowLabel) {
          switch (rowLabelType) {
          case SDDS_STRING:
            snprintf(labelFormat, sizeof(labelFormat), "%20s", ((char **)rowLabel)[j]);
            break;
          case SDDS_LONGDOUBLE:
            snprintf(labelFormat, sizeof(labelFormat), "%20.15Le", ((long double *)rowLabel)[j]);
            break;
          case SDDS_DOUBLE:
            snprintf(labelFormat, sizeof(labelFormat), "%20.10e", ((double *)rowLabel)[j]);
            break;
          case SDDS_FLOAT:
            snprintf(labelFormat, sizeof(labelFormat), "%20.5e", ((float *)rowLabel)[j]);
            break;
          case SDDS_ULONG64:
            snprintf(labelFormat, sizeof(labelFormat), "%20" PRIu64, ((uint64_t *)rowLabel)[j]);
            break;
          case SDDS_LONG64:
            snprintf(labelFormat, sizeof(labelFormat), "%20" PRId64, ((int64_t *)rowLabel)[j]);
            break;
          case SDDS_ULONG:
            snprintf(labelFormat, sizeof(labelFormat), "%20" PRIu32, ((uint32_t *)rowLabel)[j]);
            break;
          case SDDS_LONG:
            snprintf(labelFormat, sizeof(labelFormat), "%20" PRId32, ((int32_t *)rowLabel)[j]);
            break;
          case SDDS_USHORT:
            snprintf(labelFormat, sizeof(labelFormat), "%20hu", ((unsigned short *)rowLabel)[j]);
            break;
          case SDDS_SHORT:
            snprintf(labelFormat, sizeof(labelFormat), "%20hd", ((short *)rowLabel)[j]);
            break;
          case SDDS_CHARACTER:
            snprintf(labelFormat, sizeof(labelFormat), "%20c", ((char *)rowLabel)[j]);
            break;
          default:
            fprintf(stderr, "Unknown data type for rowlabel.\n");
            exit(EXIT_FAILURE);
          }
          snprintf(fFormat, sizeof(fFormat), "%s%s%s%s\n", labelFormat, floatFormat, floatFormat, floatFormat);
          snprintf(dFormat, sizeof(dFormat), "%s%s%s%s\n", labelFormat, doubleFormat, doubleFormat, doubleFormat);
          snprintf(ldFormat, sizeof(ldFormat), "%s%s%s%s\n", labelFormat, ldoubleFormat, ldoubleFormat, ldoubleFormat);
          snprintf(strFormat, sizeof(strFormat), "%s%s%s%%25ld\n", labelFormat, stringFormat, stringFormat);
          snprintf(lFormat, sizeof(lFormat), "%s%%25ld%%25ld%%25ld\n", labelFormat);
          snprintf(ulFormat, sizeof(ulFormat), "%s%%25lu%%25lu%%25ld\n", labelFormat);
          snprintf(shortFormat, sizeof(shortFormat), "%s%%25hd%%25hd%%25hd\n", labelFormat);
          snprintf(ushortFormat, sizeof(ushortFormat), "%s%%25hu%%25hu%%25hd\n", labelFormat);
          snprintf(cFormat, sizeof(cFormat), "%s%%25c%%25c%%25d\n", labelFormat);
        }
        if (compare_two_data(data1, data2, j, dataType[i], first, SDDS_COLUMN_TYPE, name[i], page, tolerance, relativeTolerance, precisionTolerance, fFormat, dFormat, ldFormat, strFormat, lFormat, ulFormat, shortFormat, ushortFormat, cFormat, absolute, 0, rowLabelColumn) != 0) {
          diff++;
          if (first)
            first = 0;
        }
        if (dataType[i] == SDDS_STRING) {
          free((char *)((char **)data1)[j]);
          free((char *)((char **)data2)[j]);
        }
      }
      free((char **)data1);
      free((char **)data2);
      data1 = data2 = NULL;
    }
    break;
  case SDDS_PARAMETER_TYPE:
    for (i = 0; i < names; i++) {
      first = 1;
      if (!(data1 = SDDS_GetParameter(dataset1, name[i], NULL)) || !(data2 = SDDS_GetParameter(dataset2, name[i], NULL))) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
        exit(EXIT_FAILURE);
      }
      if (compare_two_data(data1, data2, 0, dataType[i], first, SDDS_PARAMETER_TYPE, name[i], page, tolerance, relativeTolerance, precisionTolerance, fFormat, dFormat, ldFormat, strFormat, lFormat, ulFormat, shortFormat, ushortFormat, cFormat, absolute, 1, NULL) != 0) {
        diff++;
        if (first)
          first = 0;
      }
      if (dataType[i] == SDDS_STRING) {
        free(*((char **)data1));
        free(*((char **)data2));
      }
      free(data1);
      free(data2);
      data1 = data2 = NULL;
    }
    break;
  case SDDS_ARRAY_TYPE:
    for (i = 0; i < names; i++) {
      first = 1;
      if (!(array1 = SDDS_GetArray(dataset1, name[i], NULL)) || !(array2 = SDDS_GetArray(dataset2, name[i], NULL))) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
        exit(EXIT_FAILURE);
      }
      if (array1->elements != array2->elements) {
        fprintf(stderr, "Array \"%s\" has %" PRId32 " elements in \"%s\", but %" PRId32 " elements in \"%s\".\n", name[i], array1->elements, file1, array2->elements, file2);
        diff++;
      } else {
        for (j = 0; j < array1->elements; j++) {
          if (compare_two_data(array1->data, array2->data, j, dataType[i], first, SDDS_ARRAY_TYPE, name[i], page, tolerance, relativeTolerance, precisionTolerance, fFormat, dFormat, ldFormat, strFormat, lFormat, ulFormat, shortFormat, ushortFormat, cFormat, absolute, 0, NULL) != 0) {
            diff++;
            if (first)
              first = 0;
          }
        }
      }
      SDDS_FreeArray(array1);
      SDDS_FreeArray(array2);
      array1 = array2 = NULL;
    }
    break;
  }
  return diff;
}

CompareDefinitions()

long CompareDefinitions	(	SDDS_DATASET *	dataset1,
		SDDS_DATASET *	dataset2,
		char *	file1,
		char *	file2,
		int32_t *	names,
		char ***	name,
		int32_t **	dataType,
		long	type,
		long	compareCommon,
		char *	rowLabelColumn,
		long	notCompareRowLabel,
		short	ignoreUnits )

Definition at line 491 of file sddsdiff.c.

                                                                                                                                                                                                                                                     {
  size_t same_items;
  long sames, free_same_name = 0;
  int32_t *same, *datatype;
  int32_t names1, names2;
  char **name1, **name2, *def, **same_name;
  long type1, type2, i, returnValue = 0, first = 1;
  int32_t index1, index2;
  char *units1, *units2;
  units1 = units2 = NULL;
  name1 = name2 = same_name = NULL;
  names1 = names2 = 0;
  def = NULL;
  same_items = 0;
  same = datatype = NULL;
 
  type1 = type2 = -1;
 
  switch (type) {
  case SDDS_COLUMN_TYPE:
    name1 = SDDS_GetColumnNames(dataset1, &names1);
    name2 = SDDS_GetColumnNames(dataset2, &names2);
    SDDS_CopyString(&def, "column");
    break;
  case SDDS_PARAMETER_TYPE:
    name1 = SDDS_GetParameterNames(dataset1, &names1);
    name2 = SDDS_GetParameterNames(dataset2, &names2);
    SDDS_CopyString(&def, "parameter");
    break;
  case SDDS_ARRAY_TYPE:
    name1 = SDDS_GetArrayNames(dataset1, &names1);
    name2 = SDDS_GetArrayNames(dataset2, &names2);
    SDDS_CopyString(&def, "array");
    break;
  default:
    fprintf(stderr, "Unknown type given for CompareDefinitions().\n");
    return 1;
  }
  if (names1 == 0 && names2 == 0)
    return 0;
  if (*names) {
    if (!names1 || !names2) {
      fprintf(stderr, "Error: One of the files does not have any %s.\n", def);
      returnValue = 1;
    }
    if (!returnValue) {
      for (i = 0; i < *names; i++) {
        if (rowLabelColumn && notCompareRowLabel && strcmp((*name)[i], rowLabelColumn) == 0)
          continue;
        if (-1 == match_string((*name)[i], name1, names1, EXACT_MATCH)) {
          fprintf(stderr, "Error: File \"%s\" does not have %s \"%s\".\n", file1, def, (*name)[i]);
          returnValue = 1;
          break;
        }
        if (-1 == match_string((*name)[i], name2, names2, EXACT_MATCH)) {
          fprintf(stderr, "Error: File \"%s\" does not have %s \"%s\".\n", file2, def, (*name)[i]);
          returnValue = 1;
          break;
        }
      }
    }
    if (returnValue) {
      for (i = 0; i < names1; i++)
        free(name1[i]);
      free(name1);
      for (i = 0; i < names2; i++)
        free(name2[i]);
      free(name2);
      free(def);
      return returnValue;
    }
    same_items = *names;
    same_name = *name;
    compareCommon = 0;
  } else {
    if (!names1 && !names2) {
      free(def);
      return 0;
    }
    if (compareCommon && (!names1 || !names2)) {
      if (names1) {
        for (i = 0; i < names1; i++)
          free(name1[i]);
        free(name1);
      }
      if (names2) {
        for (i = 0; i < names2; i++)
          free(name2[i]);
        free(name2);
      }
      *names = 0;
      return 0;
    }
    if (names1 != names2 && !compareCommon && !notCompareRowLabel)
      returnValue = 1;
    if (returnValue) {
      fprintf(stderr, "Error: Two files have different numbers of %ss:\n    \"%s\" has %" PRId32 " %ss while \"%s\" has %" PRId32 " %ss.\n", def, file1, names1, def, file2, names2, def);
      for (i = 0; i < names2; i++)
        free(name2[i]);
      free(name2);
      for (i = 0; i < names1; i++)
        free(name1[i]);
      free(name1);
      free(def);
      return returnValue;
    }
    same_items = 0;
    for (i = 0; i < names1; i++) {
      if (rowLabelColumn && notCompareRowLabel && strcmp(rowLabelColumn, name1[i]) == 0)
        continue;
      if (-1 == match_string(name1[i], name2, names2, EXACT_MATCH)) {
        if (!compareCommon) {
          if (first) {
            fprintf(stderr, "    Following %ss of \"%s\" are not in \"%s\":\n", def, file1, file2);
            first = 0;
          }
          fprintf(stderr, "      %s\n", name1[i]);
          returnValue++;
        }
      } else {
        same_name = (char **)SDDS_Realloc(same_name, sizeof(*same_name) * (same_items + 1));
        same_name[same_items] = name1[i];
        same_items++;
      }
    }
    if (!compareCommon) {
      if (!first)
        fprintf(stderr, "\n");
      first = 1;
      for (i = 0; i < names2; i++) {
        if (rowLabelColumn && notCompareRowLabel && strcmp(rowLabelColumn, name2[i]) == 0)
          continue;
        if (-1 == match_string(name2[i], name1, names1, EXACT_MATCH)) {
          if (first) {
            fprintf(stderr, "    Following %ss of \"%s\" are not in \"%s\":\n", def, file2, file1);
            first = 0;
          }
          fprintf(stderr, "      %s\n", name2[i]);
          returnValue++;
        }
      }
      if (!first)
        fprintf(stderr, "\n");
    }
    if (same_items)
      free_same_name = 1;
  }
  sames = same_items;
  if (same_items) {
    datatype = (int32_t *)malloc(sizeof(*datatype) * same_items);
    same = (int32_t *)malloc(sizeof(*same) * same_items);
    /* Check the units and type */
    for (i = 0; i < same_items; i++) {
      same[i] = 1;
      switch (type) {
      case SDDS_COLUMN_TYPE:
        index1 = SDDS_GetColumnIndex(dataset1, same_name[i]);
        index2 = SDDS_GetColumnIndex(dataset2, same_name[i]);
        type1 = SDDS_GetColumnType(dataset1, index1);
        type2 = SDDS_GetColumnType(dataset2, index2);
        if (!ignoreUnits) {
          if (SDDS_GetColumnInformation(dataset1, "units", &units1, SDDS_GET_BY_INDEX, index1) != SDDS_STRING) {
            SDDS_SetError("Units field of column has wrong data type!");
            SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
            exit(EXIT_FAILURE);
          }
          if (SDDS_GetColumnInformation(dataset2, "units", &units2, SDDS_GET_BY_INDEX, index2) != SDDS_STRING) {
            SDDS_SetError("Units field of column has wrong data type!");
            SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
            exit(EXIT_FAILURE);
          }
        }
        break;
      case SDDS_PARAMETER_TYPE:
        index1 = SDDS_GetParameterIndex(dataset1, same_name[i]);
        index2 = SDDS_GetParameterIndex(dataset2, same_name[i]);
        type1 = SDDS_GetParameterType(dataset1, index1);
        type2 = SDDS_GetParameterType(dataset2, index2);
        if (!ignoreUnits) {
          if (SDDS_GetParameterInformation(dataset1, "units", &units1, SDDS_GET_BY_INDEX, index1) != SDDS_STRING) {
            SDDS_SetError("Units field of parameter has wrong data type!");
            SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
            exit(EXIT_FAILURE);
          }
          if (SDDS_GetParameterInformation(dataset2, "units", &units2, SDDS_GET_BY_INDEX, index2) != SDDS_STRING) {
            SDDS_SetError("Units field of parameter has wrong data type!");
            SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
            exit(EXIT_FAILURE);
          }
        }
        break;
      case SDDS_ARRAY_TYPE:
        index1 = SDDS_GetArrayIndex(dataset1, same_name[i]);
        index2 = SDDS_GetArrayIndex(dataset2, same_name[i]);
        type1 = SDDS_GetArrayType(dataset1, index1);
        type2 = SDDS_GetArrayType(dataset2, index2);
        if (!ignoreUnits) {
          if (SDDS_GetArrayInformation(dataset1, "units", &units1, SDDS_GET_BY_INDEX, index1) != SDDS_STRING) {
            SDDS_SetError("Units field of array has wrong data type!");
            SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
            exit(EXIT_FAILURE);
          }
          if (SDDS_GetArrayInformation(dataset2, "units", &units2, SDDS_GET_BY_INDEX, index2) != SDDS_STRING) {
            SDDS_SetError("Units field of array has wrong data type!");
            SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
            exit(EXIT_FAILURE);
          }
        }
        break;
      }
      datatype[i] = type1;
      if (type1 != type2) {
        if (first && !compareCommon) {
          fprintf(stderr, "The type of the following %ss do not match in the two files:\n", def);
          fprintf(stderr, "%20s\t%20s\t%20s\n", "Name", file1, file2);
          first = 0;
        }
        if (!compareCommon) {
          fprintf(stderr, "%20s\t%20s\t%20s\n", same_name[i], SDDS_type_name[type1 - 1], SDDS_type_name[type2 - 1]);
          returnValue++;
        }
        sames--;
        same[i] = 0;
      } else if ((units1 && units2 && strcasecmp(units1, units2) != 0) || (units1 && !units2) || (!units1 && units2)) {
        if (first && !compareCommon) {
          fprintf(stderr, "The units of the following %ss do not match in the two files:\n", def);
          fprintf(stderr, "%20s\t%20s\t%20s\n", "Name", file1, file2);
          first = 0;
        }
        if (!compareCommon) {
          if (units1 && units2)
            fprintf(stderr, "%20s\t%20s\t%20s\n", same_name[i], units1, units2);
          else if (units1)
            fprintf(stderr, "%20s\t%20s\t%20s\n", same_name[i], units1, "   ");
          else if (units2)
            fprintf(stderr, "%20s\t%20s\t%20s\n", same_name[i], "   ", units2);
          returnValue++;
        }
        sames--;
        same[i] = 0;
      }
      free(units1);
      free(units2);
      units1 = units2 = NULL;
      if (returnValue && !compareCommon)
        break;
    }
    if (!compareCommon && returnValue) {
      sames = 0;
    }
  }
  if (sames) {
    if (!(*names)) {
      for (i = 0; i < same_items; i++) {
        if (same[i]) {
          *name = (char **)SDDS_Realloc(*name, sizeof(**name) * (*names + 1));
          *dataType = (int32_t *)SDDS_Realloc(*dataType, sizeof(**dataType) * (*names + 1));
          SDDS_CopyString(*name + *names, same_name[i]);
          (*dataType)[*names] = datatype[i];
          (*names)++;
        }
      }
      free(datatype);
    } else
      *dataType = datatype;
  }
 
  for (i = 0; i < names2; i++)
    free(name2[i]);
  free(name2);
  for (i = 0; i < names1; i++)
    free(name1[i]);
  free(name1);
  if (same)
    free(same);
  if (free_same_name)
    free(same_name);
  free(def);
  return compareCommon ? 0 : returnValue;
}

main()

int main	(	int	argc,
		char **	argv )

Definition at line 154 of file sddsdiff.c.

                                {
  SCANNED_ARG *s_arg;
  SDDS_DATASET table1, table2;
  char *file1, *file2;
  long different = 0, i, pages1, pages2, pagediff = 0, i_arg, absolute = 0;
  int32_t *columnDataType, *parDataType, *arrayDataType;
  int32_t columns, parameters, arrays, columnMatches, parameterMatches, arrayMatches;
  int64_t rows1, rows2;
  char **columnName, **parameterName, **arrayName, **columnMatch, **parameterMatch, **arrayMatch;
  long column_provided, parameter_provided, array_provided, precision, labelFromSecondFile = 0, rowLabelType = 0, rowLabelIndex = -1, notCompareRowLabel = 0;
  long double tolerance = 0.0L, relativeTolerance = 0.0L, precisionTolerance = 0.0L;
  unsigned long compareCommonFlags = 0, dummyFlags = 0;
  char *floatFormat, *doubleFormat, *ldoubleFormat, *stringFormat, *rowLabelColumn;
  void *rowLabel;
  short ignoreUnits = 0;
 
  rowLabelColumn = NULL;
  rowLabel = NULL;
  floatFormat = doubleFormat = ldoubleFormat = stringFormat = NULL;
  precision = 0;
  columnDataType = parDataType = arrayDataType = NULL;
  columnName = parameterName = arrayName = NULL;
  columnMatch = parameterMatch = arrayMatch = NULL;
  columnMatches = parameterMatches = arrayMatches = 0;
  columns = parameters = arrays = 0;
  file1 = file2 = NULL;
  pages1 = pages2 = 0;
  column_provided = parameter_provided = array_provided = 0;
  SDDS_RegisterProgramName(argv[0]);
  argc = scanargs(&s_arg, argc, argv);
  if (argc < 3) {
    fprintf(stderr, "%s%s", USAGE1, USAGE2);
    exit(EXIT_FAILURE);
  }
  for (i_arg = 1; i_arg < argc; i_arg++) {
    if (s_arg[i_arg].arg_type == OPTION) {
      delete_chars(s_arg[i_arg].list[0], "_");
      switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) {
      case CLO_ROWLABEL:
        if (s_arg[i_arg].n_items < 2)
          SDDS_Bomb("Invalid -rowlabel syntax");
        rowLabelColumn = s_arg[i_arg].list[1];
        if (s_arg[i_arg].n_items > 2 &&
            strncmp_case_insensitive("nocomparison", s_arg[i_arg].list[2], strlen(s_arg[i_arg].list[2])) == 0)
          notCompareRowLabel = 1;
        break;
      case CLO_EXACT:
        tolerance = -1.0L;
        break;
      case CLO_ABSOLUTE:
        absolute = 1;
        break;
      case CLO_TOLERANCE:
        if (s_arg[i_arg].n_items != 2)
          SDDS_Bomb("Invalid -tolerance syntax");
        if (!get_longdouble(&tolerance, s_arg[i_arg].list[1]))
          SDDS_Bomb("Invalid -tolerance syntax (not a number given)");
        break;
      case CLO_RELATIVE_TOLERANCE:
        if (s_arg[i_arg].n_items != 2)
          SDDS_Bomb("Invalid -relativeTolerance syntax");
        if (!get_longdouble(&relativeTolerance, s_arg[i_arg].list[1]))
          SDDS_Bomb("Invalid -relativeTolerance syntax (not a number given)");
        break;
      case CLO_PRECISION:
        if (s_arg[i_arg].n_items != 2)
          SDDS_Bomb("Invalid -precision syntax");
        if (!get_long(&precision, s_arg[i_arg].list[1]))
          SDDS_Bomb("Invalid -precision syntax (not a number given)");
        if (precision < 0)
          precision = 0;
        break;
      case CLO_FORMAT:
        if (s_arg[i_arg].n_items < 2)
          SDDS_Bomb("Invalid -format syntax.");
        s_arg[i_arg].n_items--;
        if (!scanItemList(&dummyFlags, s_arg[i_arg].list + 1, &s_arg[i_arg].n_items, 0,
                          "float", SDDS_STRING, &floatFormat, 1, 0,
                          "double", SDDS_STRING, &doubleFormat, 1, 0,
                          "longdouble", SDDS_STRING, &ldoubleFormat, 1, 0,
                          "string", SDDS_STRING, &stringFormat, 1, 0, NULL))
          SDDS_Bomb("Invalid -format syntax");
        s_arg[i_arg].n_items++;
        if (floatFormat && !SDDS_VerifyPrintfFormat(floatFormat, SDDS_FLOAT)) {
          fprintf(stderr, "Error: Given print format (\"%s\") for float data is invalid.\n", floatFormat);
          exit(EXIT_FAILURE);
        }
        if (doubleFormat && !SDDS_VerifyPrintfFormat(doubleFormat, SDDS_DOUBLE)) {
          fprintf(stderr, "Error: Given print format (\"%s\") for double data is invalid.\n", doubleFormat);
          exit(EXIT_FAILURE);
        }
        if (ldoubleFormat && !SDDS_VerifyPrintfFormat(ldoubleFormat, SDDS_LONGDOUBLE)) {
          fprintf(stderr, "Error: Given print format (\"%s\") for long double data is invalid.\n", ldoubleFormat);
          exit(EXIT_FAILURE);
        }
        if (stringFormat && !SDDS_VerifyPrintfFormat(stringFormat, SDDS_STRING)) {
          fprintf(stderr, "Error: Given print format (\"%s\") for string data is invalid.\n", stringFormat);
          exit(EXIT_FAILURE);
        }
        break;
      case CLO_COMPARECOMMON:
        if (s_arg[i_arg].n_items == 1)
          compareCommonFlags |= COMPARE_COMMON_COLUMN | COMPARE_COMMON_PARAMETER | COMPARE_COMMON_ARRAY;
        else {
          s_arg[i_arg].n_items--;
          if (!scanItemList(&compareCommonFlags, s_arg[i_arg].list + 1, &s_arg[i_arg].n_items, 0,
                            "column", -1, NULL, 0, COMPARE_COMMON_COLUMN,
                            "parameter", -1, NULL, 0, COMPARE_COMMON_PARAMETER,
                            "array", -1, NULL, 0, COMPARE_COMMON_ARRAY, NULL))
            SDDS_Bomb("Invalid -compareCommon syntax");
          s_arg[i_arg].n_items++;
        }
        break;
      case CLO_COLUMNS:
        if (s_arg[i_arg].n_items < 2)
          SDDS_Bomb("Invalid -columns syntax");
        columnMatch = tmalloc(sizeof(*columnMatch) * (columnMatches = s_arg[i_arg].n_items - 1));
        for (i = 0; i < columnMatches; i++)
          columnMatch[i] = s_arg[i_arg].list[i + 1];
        column_provided = 1;
        break;
      case CLO_PARAMETERS:
        if (s_arg[i_arg].n_items < 2)
          SDDS_Bomb("Invalid -parameters syntax");
        parameterMatch = tmalloc(sizeof(*parameterMatch) * (parameterMatches = s_arg[i_arg].n_items - 1));
        for (i = 0; i < parameterMatches; i++)
          parameterMatch[i] = s_arg[i_arg].list[i + 1];
        parameter_provided = 1;
        break;
      case CLO_ARRAYS:
        if (s_arg[i_arg].n_items < 2)
          SDDS_Bomb("Invalid -arrays syntax");
        arrayMatch = tmalloc(sizeof(*arrayMatch) * (arrayMatches = s_arg[i_arg].n_items - 1));
        for (i = 0; i < arrayMatches; i++)
          arrayMatch[i] = s_arg[i_arg].list[i + 1];
        array_provided = 1;
        break;
      case CLO_IGNORE_UNITS:
        ignoreUnits = 1;
        break;
      default:
        fprintf(stderr, "Unknown option given (sddsdiff): %s\n", s_arg[i_arg].list[0]);
        exit(EXIT_FAILURE);
        break;
      }
    } else {
      if (!file1)
        file1 = s_arg[i_arg].list[0];
      else if (!file2)
        file2 = s_arg[i_arg].list[0];
      else
        SDDS_Bomb("Too many files given.");
    }
  }
  if (!floatFormat)
    SDDS_CopyString(&floatFormat, "%25.8e");
  if (!doubleFormat)
    SDDS_CopyString(&doubleFormat, "%25.16e");
  if (!ldoubleFormat)
    SDDS_CopyString(&ldoubleFormat, "%26.18Le");
  if (!stringFormat)
    SDDS_CopyString(&stringFormat, "%25s");
 
  if ((tolerance || relativeTolerance) && precision > 0) {
    SDDS_Bomb("Tolerance, relativeTolerance, and precision options are not compatible. Only one of tolerance, relativeTolerance, precision, or exact may be given.");
  }
  if (tolerance && relativeTolerance) {
    SDDS_Bomb("Tolerance and relativeTolerance options are not compatible. Only one may be given.");
  }
  if (!file1 || !file2) {
    fprintf(stderr, "Error: Two files must be provided for comparison.\n");
    exit(EXIT_FAILURE);
  }
  if (strcmp(file1, file2) == 0) {
    printf("\"%s\" and \"%s\" are identical.\n", file1, file2);
    return EXIT_SUCCESS;
  }
  if (!SDDS_InitializeInput(&table1, file1)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(EXIT_FAILURE);
  }
  if (!SDDS_InitializeInput(&table2, file2)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(EXIT_FAILURE);
  }
  if (rowLabelColumn) {
    if ((rowLabelIndex = SDDS_GetColumnIndex(&table1, rowLabelColumn)) < 0) {
      if ((rowLabelIndex = SDDS_GetColumnIndex(&table2, rowLabelColumn)) < 0) {
        fprintf(stdout, "Warning: Row label column \"%s\" does not exist in the input files. The number of rows will be labeled instead.\n", rowLabelColumn);
        rowLabelColumn = NULL;
      } else {
        labelFromSecondFile = 1;
        notCompareRowLabel = 1;
      }
    } else {
      if (SDDS_GetColumnIndex(&table2, rowLabelColumn) < 0)
        notCompareRowLabel = 1;
    }
 
    if (rowLabelColumn) {
      if (labelFromSecondFile)
        rowLabelType = SDDS_GetColumnType(&table2, rowLabelIndex);
      else
        rowLabelType = SDDS_GetColumnType(&table1, rowLabelIndex);
    }
  }
  if (!precision) {
    precisionTolerance = powl(10L, -1L * fabsl(log10l(LDBL_EPSILON)));
  } else {
    precisionTolerance = powl(10L, -1L * precision);
  }
  if (column_provided) {
    columnName = getMatchingSDDSNames(&table1, columnMatch, columnMatches, &columns, SDDS_MATCH_COLUMN);
    if (CompareDefinitions(&table1, &table2, file1, file2, &columns, &columnName, &columnDataType, SDDS_COLUMN_TYPE, compareCommonFlags & COMPARE_COMMON_COLUMN, rowLabelColumn, notCompareRowLabel, ignoreUnits))
      different = 1;
  }
  if (parameter_provided) {
    parameterName = getMatchingSDDSNames(&table1, parameterMatch, parameterMatches, &parameters, SDDS_MATCH_PARAMETER);
 
    if (CompareDefinitions(&table1, &table2, file1, file2, &parameters, &parameterName, &parDataType, SDDS_PARAMETER_TYPE, compareCommonFlags & COMPARE_COMMON_PARAMETER, NULL, 1, ignoreUnits))
      different = 1;
  }
  if (array_provided) {
    arrayName = getMatchingSDDSNames(&table1, arrayMatch, arrayMatches, &arrays, SDDS_MATCH_ARRAY);
    if (CompareDefinitions(&table1, &table2, file1, file2, &arrays, &arrayName, &arrayDataType, SDDS_ARRAY_TYPE, compareCommonFlags & COMPARE_COMMON_ARRAY, NULL, 1, ignoreUnits))
      different = 1;
  }
  if (!columns && !parameters && !arrays) {
    if (!compareCommonFlags || compareCommonFlags & COMPARE_COMMON_COLUMN)
      different += CompareDefinitions(&table1, &table2, file1, file2, &columns, &columnName, &columnDataType, SDDS_COLUMN_TYPE, compareCommonFlags & COMPARE_COMMON_COLUMN, rowLabelColumn, notCompareRowLabel, ignoreUnits);
    if (!compareCommonFlags || compareCommonFlags & COMPARE_COMMON_PARAMETER)
      different += CompareDefinitions(&table1, &table2, file1, file2, &parameters, &parameterName, &parDataType, SDDS_PARAMETER_TYPE, compareCommonFlags & COMPARE_COMMON_PARAMETER, NULL, 1, ignoreUnits);
    if (!compareCommonFlags || compareCommonFlags & COMPARE_COMMON_ARRAY)
      different += CompareDefinitions(&table1, &table2, file1, file2, &arrays, &arrayName, &arrayDataType, SDDS_ARRAY_TYPE, compareCommonFlags & COMPARE_COMMON_ARRAY, NULL, 1, ignoreUnits);
  }
  if (!different) {
    if (!columns && !parameters && !arrays) {
      fprintf(stderr, "There are no common columns, parameters, or arrays in the two files.\n");
      different = 1;
    } else {
      /* Definitions are the same, now compare the data */
      while (1) {
        pagediff = 0;
        pages1 = SDDS_ReadPage(&table1);
        pages2 = SDDS_ReadPage(&table2);
        if (pages1 > 0 && pages2 > 0) {
          /* Compare data */
          rows1 = SDDS_CountRowsOfInterest(&table1);
          rows2 = SDDS_CountRowsOfInterest(&table2);
          if (rows1 != rows2) {
            pagediff = 1;
            different = 1;
            fprintf(stderr, "The two files have different numbers of rows on page %ld: \"%s\" has %" PRId64 " rows, while \"%s\" has %" PRId64 " rows.\n",
                    pages1, file1, rows1, file2, rows2);
            break;
          } else {
            if (parameters)
               pagediff += CompareData(&table1, &table2, file1, file2, parameters, parameterName, parDataType, SDDS_PARAMETER_TYPE, pages1, tolerance, relativeTolerance, precisionTolerance, floatFormat, doubleFormat, ldoubleFormat, stringFormat, absolute, NULL, rowLabelType, NULL);
 
            if (columns && rows1) {
              if (rowLabelColumn) {
                if (labelFromSecondFile) {
                  if (!(rowLabel = SDDS_GetColumn(&table2, rowLabelColumn)))
                    SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
                } else {
                  if (!(rowLabel = SDDS_GetColumn(&table1, rowLabelColumn)))
                    SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
                }
              }
              pagediff += CompareData(&table1, &table2, file1, file2, columns, columnName, columnDataType, SDDS_COLUMN_TYPE, pages1, tolerance, relativeTolerance, precisionTolerance, floatFormat, doubleFormat, ldoubleFormat, stringFormat, absolute, rowLabel, rowLabelType, rowLabelColumn);
              if (rowLabelColumn) {
                if (rowLabelType == SDDS_STRING)
                  SDDS_FreeStringArray((char **)rowLabel, rows1);
                else
                  free(rowLabel);
                rowLabel = NULL;
              }
            }
            if (arrays)
              pagediff += CompareData(&table1, &table2, file1, file2, arrays, arrayName, arrayDataType, SDDS_ARRAY_TYPE, pages1, tolerance, relativeTolerance, precisionTolerance, floatFormat, doubleFormat, ldoubleFormat, stringFormat, absolute, NULL, rowLabelType, NULL);
            different += pagediff;
          }
        } else if (pages1 > 0 && pages2 <= 0) {
          fprintf(stderr, "\"%s\" has fewer pages than \"%s\".\n", file2, file1);
          different = 1;
          break;
        } else if (pages1 < 0 && pages2 > 0) {
          different = 1;
          fprintf(stderr, "\"%s\" has fewer pages than \"%s\".\n", file1, file2);
          break;
        } else {
          break;
        }
      }
    }
  } else {
    different = 1;
  }
  if (!different)
    printf("\"%s\" and \"%s\" are identical.\n", file1, file2);
  else
    fprintf(stderr, "\"%s\" and \"%s\" are different.\n", file1, file2);
 
  if (columns) {
    for (i = 0; i < columns; i++)
      free(columnName[i]);
    free(columnName);
    free(columnDataType);
    free(columnMatch);
  }
  if (parameters) {
    for (i = 0; i < parameters; i++)
      free(parameterName[i]);
    free(parameterName);
    free(parDataType);
    free(parameterMatch);
  }
  if (arrays) {
    for (i = 0; i < arrays; i++)
      free(arrayName[i]);
    free(arrayName);
    free(arrayDataType);
    free(arrayMatch);
  }
  free_scanargs(&s_arg, argc);
  free(stringFormat);
  free(floatFormat);
  free(doubleFormat);
  free(ldoubleFormat);
 
  if (!SDDS_Terminate(&table1) || !SDDS_Terminate(&table2)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(EXIT_FAILURE);
  }
  return EXIT_SUCCESS;
}

printTitle()

void printTitle	(	long	flags,
		char *	name,
		long	page,
		long	absolute,
		char *	labelName )

Definition at line 921 of file sddsdiff.c.

                                                                                   {
  char *type = NULL;
  char *element = NULL;
 
  switch (flags) {
  case SDDS_COLUMN_TYPE:
    SDDS_CopyString(&type, "column");
    if (labelName)
      SDDS_CopyString(&element, labelName);
    else
      SDDS_CopyString(&element, "row");
    break;
  case SDDS_PARAMETER_TYPE:
    SDDS_CopyString(&type, "parameter");
    SDDS_CopyString(&element, "page number");
    break;
  case SDDS_ARRAY_TYPE:
    SDDS_CopyString(&type, "array");
    SDDS_CopyString(&element, "element number");
    break;
  }
  if (type) {
    fprintf(stdout, "\nDifferences found in %s \"%s\" on page %ld:\n", type, name, page);
    if (absolute)
      fprintf(stdout, "%20s%25s%25s%25s\n", element, "Value in file1", "Value in file2", "Difference (abs)");
    else
      fprintf(stdout, "%20s%25s%25s%25s\n", element, "Value in file1", "Value in file2", "Difference (file1 - file2)");
    free(type);
    free(element);
  }
}