sddsendian.c File Reference

Converts between big-endian and little-endian formats for SDDS files. More...

#include "mdb.h"
#include "SDDS.h"
#include "scan.h"

Go to the source code of this file.

Macros
#define	N_OPTIONS   3

Enumerations
enum	OptionType { SET_PIPE = 0 , NONNATIVE = 1 , SET_MAJOR_ORDER = 2 }

Functions
int	main (int argc, char **argv)

Variables
char *	option [N_OPTIONS]
char *	USAGE

Detailed Description

Converts between big-endian and little-endian formats for SDDS files.

This program processes Self-Describing Data Sets (SDDS) to convert data between big-endian and little-endian byte orders. It supports both binary and ASCII SDDS files and provides options for handling data piping and specifying row or column major order.

Features

• Converts data between big-endian and little-endian formats.
• Handles non-native byte order files with the -nonNative option.
• Supports data piping with the -pipe option.
• Allows specification of row or column major order using -majorOrder.

Usage

sddsendian [options] <input> <output>

Options:

• -pipe=[input][,output] Use pipe for input and/or output.
• -majorOrder=row|column Set the major order to row or column.
• -nonNative Handle non-native byte order files.

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

M. Borland, R. Soliday, H. Shang

Definition in file sddsendian.c.

Macro Definition Documentation

N_OPTIONS

#define N_OPTIONS   3

Definition at line 47 of file sddsendian.c.

Enumeration Type Documentation

OptionType

enum OptionType

Enumeration for supported command-line options

Definition at line 41 of file sddsendian.c.

             {
  SET_PIPE = 0,
  NONNATIVE = 1,
  SET_MAJOR_ORDER = 2
} OptionType;

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 72 of file sddsendian.c.

                                {
  SDDS_DATASET SDDSin, SDDSout;
  long i_arg, tmpfile_used;
  SCANNED_ARG *s_arg;
  char *input, *output, *description_text, *description_contents;
  unsigned long pipe_flags, major_order_flag;
  long page_number, non_native = 0;
  char *output_endianess = NULL;
  char buffer[40];
  short column_major_order = -1;
 
  // Register the program name for SDDS utilities
  SDDS_RegisterProgramName(argv[0]);
 
  // Parse command-line arguments
  argc = scanargs(&s_arg, argc, argv);
  if (argc < 2) // Ensure at least one argument is provided
    bomb(NULL, USAGE);
 
  // Initialize variables for input/output files and options
  input = output = description_text = description_contents = NULL;
  pipe_flags = 0;
 
  // Process each command-line argument
  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], "_"); // Normalize option string
      switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) {
      case SET_MAJOR_ORDER:
        major_order_flag = 0;
        s_arg[i_arg].n_items--;
        // Parse major order option
        if (s_arg[i_arg].n_items > 0 && (!scanItemList(&major_order_flag, s_arg[i_arg].list + 1,
                                                       &s_arg[i_arg].n_items, 0, "row", -1, NULL, 0,
                                                       SDDS_ROW_MAJOR_ORDER, "column", -1, NULL, 0,
                                                       SDDS_COLUMN_MAJOR_ORDER, NULL)))
          SDDS_Bomb("invalid -majorOrder syntax/values");
        if (major_order_flag & SDDS_COLUMN_MAJOR_ORDER)
          column_major_order = 1; // Set column major order
        else if (major_order_flag & SDDS_ROW_MAJOR_ORDER)
          column_major_order = 0; // Set row major order
        break;
      case SET_PIPE:
        // Parse pipe option
        if (!processPipeOption(s_arg[i_arg].list + 1,
                               s_arg[i_arg].n_items - 1, &pipe_flags))
          SDDS_Bomb("invalid -pipe syntax");
        break;
      case NONNATIVE:
        non_native = 1; // Enable non-native byte order handling
        break;
      default:
        // Handle unknown options
        fprintf(stderr, "Error (%s): unknown switch: %s\n", argv[0],
                s_arg[i_arg].list[0]);
        exit(1);
        break;
      }
    } else {
      // Assign input and output filenames
      if (input == NULL)
        input = s_arg[i_arg].list[0];
      else if (output == NULL)
        output = s_arg[i_arg].list[0];
      else
        SDDS_Bomb("too many filenames");
    }
  }
 
  // Process filenames and handle temporary files
  processFilenames("sddsendian", &input, &output, pipe_flags, 0,
                   &tmpfile_used);
 
  // Check and clear output endianess environment variable
  output_endianess = getenv("SDDS_OUTPUT_ENDIANESS");
 
  if (output_endianess) {
    putenv("SDDS_OUTPUT_ENDIANESS=");
  }
 
  // Initialize the input SDDS dataset
  if (!SDDS_InitializeInput(&SDDSin, input)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(1);
  }
 
  // Retrieve description text if available
  if (!description_text)
    SDDS_GetDescription(&SDDSin, &description_text, &description_contents);
 
  // Initialize the output SDDS dataset and set data mode
  if (!SDDS_InitializeCopy(&SDDSout, &SDDSin, output, "w") || !SDDS_SetDataMode(&SDDSout, non_native ? SDDS_BINARY : -SDDS_BINARY)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(1);
  }
 
  // Set column/row major order based on parsed options
  if (column_major_order != -1)
    SDDSout.layout.data_mode.column_major = column_major_order;
  else
    SDDSout.layout.data_mode.column_major = SDDSin.layout.data_mode.column_major;
 
  // Write the layout of the output file
  if (!SDDS_WriteLayout(&SDDSout)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(1);
  }
 
  // Process pages in the input file and write to the output file
  if (non_native) {
    while ((page_number = SDDS_ReadNonNativePage(&SDDSin)) >= 0) {
      if (!SDDS_CopyPage(&SDDSout, &SDDSin) || !SDDS_WritePage(&SDDSout)) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
        exit(1);
      }
    }
  } else {
    while ((page_number = SDDS_ReadPage(&SDDSin)) >= 0) {
      if (!SDDS_CopyPage(&SDDSout, &SDDSin) || !SDDS_WriteNonNativeBinaryPage(&SDDSout)) {
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
        exit(1);
      }
    }
  }
 
  // Terminate the input and output datasets
  if (!SDDS_Terminate(&SDDSin) || !SDDS_Terminate(&SDDSout)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(1);
  }
 
  // Replace temporary files if necessary
  if (tmpfile_used && !replaceFileAndBackUp(input, output))
    exit(1);
 
  // Restore output endianess environment variable if it was set
  if (output_endianess) {
    sprintf(buffer, "SDDS_OUTPUT_ENDIANESS=%s", output_endianess);
    putenv(buffer);
  }
 
  return 0; // Return success
}

Variable Documentation

option

char* option[N_OPTIONS]

Initial value:

=
  {
    "pipe",
    "nonNative",
    "majorOrder",
  }

Array of option names corresponding to the OptionType enum

Definition at line 50 of file sddsendian.c.

  {
    "pipe",
    "nonNative",
    "majorOrder",
  };

USAGE

char* USAGE

Initial value:

= "Usage: sddsendian [options] <input> <output>\n\
\nOptions:\n\
  -pipe=[input][,output]   Use pipe for input and/or output.\n\
  -majorOrder=row|column   Set the major order to row or column.\n\
  -nonNative               Handle non-native byte order files.\n\
\nDescription:\n\
  Converts between big-endian and little-endian formats.\n\
  This program is designed to handle Self-Describing Data Sets (SDDS)\n\
  efficiently, allowing for platform-independent data sharing.\n\
\nAuthors:\n\
  Michael Borland and Robert Soliday\n\
\nVersion:\n\
  Link date: " __DATE__ " " __TIME__ ", SVN revision: " SVN_VERSION "\n"

Usage string displayed for the program

Definition at line 58 of file sddsendian.c.