sddsbinarystring.c File Reference

Program for converting integer type columns into binary string representations. More...

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

Go to the source code of this file.

Enumerations
enum	OptionType { SET_COLUMN , SET_PIPE , N_OPTIONS }
	Enumeration for command-line options. More...

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

Variables
char *	option [N_OPTIONS]
	String representation of the command-line options.
char *	usage
	Usage message for the program.

Detailed Description

Program for converting integer type columns into binary string representations.

This program reads integer columns from an SDDS (Self-Describing Data Set) file and converts their values into binary string representations. The resulting binary strings are written into new columns appended to the output SDDS file. This program supports piping for input and output as well as wildcard matching for column names.

Features:

• Converts integer columns into binary string columns.
• Supports piping for input and output.
• Handles both 16-bit and 32-bit integers.
• Can process column names using wildcards.

Usage:

sddsbinarystring [<source-file>] [<target-file>] [-pipe=[input][,output]] [-column=

• If no column names are specified, all integer columns will be converted.
• Binary string columns are named as <originalColumnName>BinaryString.
• Input and output files can be specified or provided via pipe.

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, L. Emery, R. Soliday

Definition in file sddsbinarystring.c.

Enumeration Type Documentation

OptionType

enum OptionType

Enumeration for command-line options.

Definition at line 44 of file sddsbinarystring.c.

             {
  SET_COLUMN,
  SET_PIPE,
  N_OPTIONS
} OptionType;

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 74 of file sddsbinarystring.c.

                                {
  SDDS_DATASET sdds_dataset, sdds_orig;
  long i, j, i_arg;
  SCANNED_ARG *s_arg;
  long tmpfile_used, no_warnings, integer_columns, digits;
  int32_t column_matches;
  long index, type;
  int64_t i_row, rows;
  void *data;
  int32_t columns;
  short *integer_type;
  char *input, *output, **column_name, **column_match, **integer_column;
  char buff[1024], **binary_string;
  unsigned long pipe_flags;
 
  /* Initialize variables */
  tmpfile_used = 0;
  pipe_flags = 0;
  input = output = NULL;
  data = NULL;
  no_warnings = 0;
 
  binary_string = NULL;
  buff[0] = 0;
 
  columns = column_matches = integer_columns = 0;
  column_name = column_match = integer_column = NULL;
  integer_type = NULL;
 
  /* Register the program name for error handling */
  SDDS_RegisterProgramName(argv[0]);
  argc = scanargs(&s_arg, argc, argv);
  if (argc < 2)
    bomb(NULL, usage);
 
  /* Parse command-line arguments */
  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 SET_COLUMN:
        if (s_arg[i_arg].n_items < 2)
          SDDS_Bomb("invalid -columns syntax");
        column_match =
          tmalloc(sizeof(*column_match) *
                  (column_matches = s_arg[i_arg].n_items - 1));
        for (i = 0; i < column_matches; i++)
          column_match[i] = s_arg[i_arg].list[i + 1];
        break;
      case SET_PIPE:
        if (!processPipeOption(s_arg[i_arg].list + 1,
                               s_arg[i_arg].n_items - 1, &pipe_flags))
          SDDS_Bomb("invalid -pipe syntax");
        break;
      default:
        fprintf(stderr, "Error (%s): unknown switch: %s\n",
                argv[0], s_arg[i_arg].list[0]);
        exit(1);
        break;
      }
    } else {
      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 input and output file names */
  processFilenames("sddsbinarystring", &input, &output, pipe_flags,
                   no_warnings, &tmpfile_used);
 
#ifdef DEBUG
  fprintf(stderr, "Initializing input and output files.\n");
#endif
  /* Initialize the SDDS input */
  if (!SDDS_InitializeInput(&sdds_orig, input)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(1);
  }
 
  /* Retrieve column names based on user input */
  if (!column_match)
    column_name = SDDS_GetColumnNames(&sdds_orig, &columns);
  else {
    column_name =
      getMatchingSDDSNames(&sdds_orig, column_match, column_matches,
                           &columns, SDDS_MATCH_COLUMN);
    free(column_match);
  }
 
  /* Identify integer columns for conversion */
  for (i = 0; i < columns; i++) {
    index = SDDS_GetColumnIndex(&sdds_orig, column_name[i]);
    type = SDDS_GetColumnType(&sdds_orig, index);
    if (type == SDDS_SHORT || type == SDDS_USHORT || type == SDDS_LONG || type == SDDS_ULONG || type == SDDS_LONG64 || type == SDDS_ULONG64) {
      integer_column =
        SDDS_Realloc(integer_column,
                     sizeof(*integer_column) * (integer_columns + 1));
      integer_type =
        SDDS_Realloc(integer_type,
                     sizeof(*integer_type) * (integer_columns + 1));
      integer_column[integer_columns] = NULL;
 
      SDDS_CopyString(&integer_column[integer_columns], column_name[i]);
      integer_type[integer_columns] = type;
      integer_columns++;
    }
  }
  SDDS_FreeStringArray(column_name, columns);
  free(column_name);
 
  /* Exit if no integer columns are found */
  if (!integer_columns) {
    fprintf(stderr, "There are no integer columns in %s for converting.\n",
            input);
    exit(1);
  }
 
  /* Initialize the SDDS output */
  if (!SDDS_InitializeCopy(&sdds_dataset, &sdds_orig, output, "w")) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    exit(1);
  }
 
  /* Define new columns for binary strings */
  for (i = 0; i < integer_columns; i++) {
    sprintf(buff, "%sBinaryString", integer_column[i]);
    if (!SDDS_DefineSimpleColumn(&sdds_dataset, buff, NULL, SDDS_STRING))
      SDDS_PrintErrors(stderr,
                       SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
  }
  if (!SDDS_WriteLayout(&sdds_dataset))
    SDDS_PrintErrors(stderr,
                     SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
#ifdef DEBUG
  fprintf(stderr, "Reading integer data from input file.\n");
#endif
  /* Read and process each page */
  while (SDDS_ReadPage(&sdds_orig) > 0) {
    if ((rows = SDDS_CountRowsOfInterest(&sdds_orig)) < 0)
      continue;
    binary_string = malloc(sizeof(*binary_string) * rows);
    if (!SDDS_CopyPage(&sdds_dataset, &sdds_orig))
      SDDS_PrintErrors(stderr,
                       SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
    /* Process each integer column */
    for (i = 0; i < integer_columns; i++) {
      if (!(data = SDDS_GetInternalColumn(&sdds_orig, integer_column[i])))
        SDDS_PrintErrors(stderr,
                         SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
      /* Determine the number of bits for binary conversion */
      if (integer_type[i] == SDDS_SHORT || integer_type[i] == SDDS_USHORT)
        digits = 16;
      else if (integer_type[i] == SDDS_LONG || integer_type[i] == SDDS_ULONG)
        digits = 32;
      else
        digits = 64;
 
      /* Convert each value to binary string */
      for (i_row = 0; i_row < rows; i_row++) {
        binary_string[i_row] = NULL;
        binary_string[i_row] =
          (char *)malloc(sizeof(**binary_string) * (digits + 1));
 
        for (j = 0; j < digits; j++) {
          if (integer_type[i] == SDDS_SHORT)
            binary_string[i_row][digits - 1 - j] = (((short*)data)[i_row] >> j & 0x1) ? '1' : '0';
          else if (integer_type[i] == SDDS_USHORT)
            binary_string[i_row][digits - 1 - j] = (((unsigned short*)data)[i_row] >> j & 0x1) ? '1' : '0';
          else if (integer_type[i] == SDDS_LONG)
            binary_string[i_row][digits - 1 - j] = (((int32_t*)data)[i_row] >> j & 0x1) ? '1' : '0';
          else if (integer_type[i] == SDDS_ULONG)
            binary_string[i_row][digits - 1 - j] = (((uint32_t*)data)[i_row] >> j & 0x1) ? '1' : '0';
          else if (integer_type[i] == SDDS_LONG64)
            binary_string[i_row][digits - 1 - j] = (((int64_t*)data)[i_row] >> j & 0x1) ? '1' : '0';
          else if (integer_type[i] == SDDS_ULONG64)
            binary_string[i_row][digits - 1 - j] = (((uint64_t*)data)[i_row] >> j & 0x1) ? '1' : '0';
        }
        binary_string[i_row][digits] = 0;
      }
 
      /* Add binary string column to the dataset */
      sprintf(buff, "%sBinaryString", integer_column[i]);
      if (!SDDS_SetColumn(&sdds_dataset, SDDS_BY_NAME, binary_string,
                          rows, buff))
        SDDS_PrintErrors(stderr,
                         SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      SDDS_FreeStringArray(binary_string, rows);
    }
    free(binary_string);
    binary_string = NULL;
 
    /* Write the processed page */
    if (!SDDS_WritePage(&sdds_dataset))
      SDDS_PrintErrors(stderr,
                       SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
  }
 
  /* Finalize and clean up */
  if (!SDDS_Terminate(&sdds_orig) || !SDDS_Terminate(&sdds_dataset))
    SDDS_PrintErrors(stderr,
                     SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
  if (tmpfile_used && !replaceFileAndBackUp(input, output))
    exit(1);
  SDDS_FreeStringArray(integer_column, integer_columns);
  free(integer_column);
  free_scanargs(&s_arg, argc);
  return 0;
}

Variable Documentation

option

char* option[N_OPTIONS]

Initial value:

=
  {
    "column",
    "pipe",
  }

String representation of the command-line options.

Definition at line 53 of file sddsbinarystring.c.

  {
    "column",
    "pipe",
  };

usage

char* usage

Initial value:

=
  "Usage: sddsbinarystring [<source-file>] [<target-file>]\n"
  "       [-pipe=[input][,output]]\n"
  "       [-column=<list of column names>]\n\n"
  "Description:\n"
  "sddsbinarystring converts integer columns into binary string representations.\n"
  "Binary string columns are appended as <oldColumnName>BinaryString.\n\n"
  "Options:\n"
  "-column   List of columns to convert. Wildcards are accepted.\n"
  "-pipe     Use pipes for input and/or output.\n\n"
  "Author: Hairong (" __DATE__ " " __TIME__ ", SVN revision: " SVN_VERSION ")\n"

Usage message for the program.

Definition at line 62 of file sddsbinarystring.c.