eventdft_cmd.c

/*****
  command line parser -- generated by clig
  (http://wsd.iitb.fhg.de/~kir/clighome/)

  The command line parser `clig':
  (C) 1995-2004 Harald Kirsch (clig@geggus.net)
*****/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <float.h>
#include <math.h>

#include "eventdft_cmd.h"

char *Program;

/*@-null*/

static Cmdline cmd = {
  /***** -days: Events are in days since MJD0 (default is seconds) */
  /* daysP = */ 0,
  /***** -mjds: Events are in MJDs */
  /* mjdsP = */ 0,
  /***** -double: Events are in binary double precision (default is ASCII) */
  /* doubleP = */ 0,
  /***** -iout: Send the list of freqs and incoherently summed powers to stdout */
  /* ioutP = */ 0,
  /***** -cout: Send the list of freqs and coherently summed powers to stdout */
  /* coutP = */ 0,
  /***** -nocoherent: Do not sum powers coherently in the search */
  /* nocoherentP = */ 0,
  /***** -noincoherent: Do not sum powers incoherently in the search */
  /* noincoherentP = */ 0,
  /***** -nostatus: Do not print percent complete status to STDOUT */
  /* nostatusP = */ 0,
  /***** -fmin: Lowest freq to search (hz) */
  /* fminP = */ 1,
  /* fmin = */ 0.01,
  /* fminC = */ 1,
  /***** -fmax: Highest freq to search (hz) */
  /* fmaxP = */ 1,
  /* fmax = */ 1000.0,
  /* fmaxC = */ 1,
  /***** -fdotbyf: Frequency Derivative / Freq to apply to the events before DFTing */
  /* fdotbyfP = */ 0,
  /* fdotbyf = */ (double)0,
  /* fdotbyfC = */ 0,
  /***** -ifs: Approx number of independent freqs in search */
  /* ifsP = */ 0,
  /* ifs = */ (double)0,
  /* ifsC = */ 0,
  /***** -mjd0: The fiducial time (in MJD) to use as T0 (default sets T0 to the first event) */
  /* MJD0P = */ 1,
  /* MJD0 = */ 0.0,
  /* MJD0C = */ 1,
  /***** -time: The total duration in sec to accept events from the input file (default uses all events) */
  /* TP = */ 1,
  /* T = */ 0.0,
  /* TC = */ 1,
  /***** -start: The fraction of the way through T (beginning at MJD0) to start looking at events (default is 0.0) */
  /* startTP = */ 1,
  /* startT = */ 0.0,
  /* startTC = */ 1,
  /***** -end: The fraction of the way through T (beginning at MJD0) to stop looking at events (default is 1.0) */
  /* endTP = */ 1,
  /* endT = */ 1.0,
  /* endTC = */ 1,
  /***** -offset: A time offset to add to the 1st event in the same units as the events */
  /* offsetP = */ 1,
  /* offset = */ 0.0,
  /* offsetC = */ 1,
  /***** -numsum: Maximum number of harmonics to sum */
  /* numsumP = */ 1,
  /* numsum = */ 8,
  /* numsumC = */ 1,
  /***** -osamp: Factor to oversample normal (1/T) Fourier spacing */
  /* osampP = */ 0,
  /* osamp = */ (int)0,
  /* osampC = */ 0,
  /***** -ncands: Number of candidates to return */
  /* ncandsP = */ 1,
  /* ncands = */ 50,
  /* ncandsC = */ 1,
  /***** uninterpreted rest of command line */
  /* argc = */ 0,
  /* argv = */ (char**)0,
  /***** the original command line concatenated */
  /* all_args = */ NULL
};

/*@=null*/

/***** let LCLint run more smoothly */
/*@-predboolothers*/
/*@-boolops*/


/******************************************************************/
/*****
 This is a bit tricky. We want to make a difference between overflow
 and underflow and we want to allow v==Inf or v==-Inf but not
 v>FLT_MAX. 

 We don't use fabs to avoid linkage with -lm.
*****/
static void
checkFloatConversion(double v, char *option, char *arg)
{
  char *err = NULL;

  if( (errno==ERANGE && v!=0.0) /* even double overflowed */
      || (v<HUGE_VAL && v>-HUGE_VAL && (v<0.0?-v:v)>(double)FLT_MAX) ) {
    err = "large";
  } else if( (errno==ERANGE && v==0.0) 
	     || (v!=0.0 && (v<0.0?-v:v)<(double)FLT_MIN) ) {
    err = "small";
  }
  if( err ) {
    fprintf(stderr, 
	    "%s: parameter `%s' of option `%s' to %s to represent\n",
	    Program, arg, option, err);
    exit(EXIT_FAILURE);
  }
}

int
getIntOpt(int argc, char **argv, int i, int *value, int force)
{
  char *end;
  long v;

  if( ++i>=argc ) goto nothingFound;

  errno = 0;
  v = strtol(argv[i], &end, 0);

  /***** check for conversion error */
  if( end==argv[i] ) goto nothingFound;

  /***** check for surplus non-whitespace */
  while( isspace((int) *end) ) end+=1;
  if( *end ) goto nothingFound;

  /***** check if it fits into an int */
  if( errno==ERANGE || v>(long)INT_MAX || v<(long)INT_MIN ) {
    fprintf(stderr, 
	    "%s: parameter `%s' of option `%s' to large to represent\n",
	    Program, argv[i], argv[i-1]);
    exit(EXIT_FAILURE);
  }
  *value = (int)v;

  return i;

nothingFound:
  if( !force ) return i-1;

  fprintf(stderr, 
	  "%s: missing or malformed integer value after option `%s'\n",
	  Program, argv[i-1]);
    exit(EXIT_FAILURE);
}
/**********************************************************************/

int
getIntOpts(int argc, char **argv, int i, 
	   int **values,
	   int cmin, int cmax)
/*****
  We want to find at least cmin values and at most cmax values.
  cmax==-1 then means infinitely many are allowed.
*****/
{
  int alloced, used;
  char *end;
  long v;
  if( i+cmin >= argc ) {
    fprintf(stderr, 
	    "%s: option `%s' wants at least %d parameters\n",
	    Program, argv[i], cmin);
    exit(EXIT_FAILURE);
  }

  /***** 
    alloc a bit more than cmin values. It does not hurt to have room
    for a bit more values than cmax.
  *****/
  alloced = cmin + 4;
  *values = (int*)calloc((size_t)alloced, sizeof(int));
  if( ! *values ) {
outMem:
    fprintf(stderr, 
	    "%s: out of memory while parsing option `%s'\n",
	    Program, argv[i]);
    exit(EXIT_FAILURE);
  }

  for(used=0; (cmax==-1 || used<cmax) && used+i+1<argc; used++) {
    if( used==alloced ) {
      alloced += 8;
      *values = (int *) realloc(*values, alloced*sizeof(int));
      if( !*values ) goto outMem;
    }

    errno = 0;
    v = strtol(argv[used+i+1], &end, 0);

    /***** check for conversion error */
    if( end==argv[used+i+1] ) break;

    /***** check for surplus non-whitespace */
    while( isspace((int) *end) ) end+=1;
    if( *end ) break;

    /***** check for overflow */
    if( errno==ERANGE || v>(long)INT_MAX || v<(long)INT_MIN ) {
      fprintf(stderr, 
	      "%s: parameter `%s' of option `%s' to large to represent\n",
	      Program, argv[i+used+1], argv[i]);
      exit(EXIT_FAILURE);
    }

    (*values)[used] = (int)v;

  }
    
  if( used<cmin ) {
    fprintf(stderr, 
	    "%s: parameter `%s' of `%s' should be an "
	    "integer value\n",
	    Program, argv[i+used+1], argv[i]);
    exit(EXIT_FAILURE);
  }

  return i+used;
}
/**********************************************************************/

int
getLongOpt(int argc, char **argv, int i, long *value, int force)
{
  char *end;

  if( ++i>=argc ) goto nothingFound;

  errno = 0;
  *value = strtol(argv[i], &end, 0);

  /***** check for conversion error */
  if( end==argv[i] ) goto nothingFound;

  /***** check for surplus non-whitespace */
  while( isspace((int) *end) ) end+=1;
  if( *end ) goto nothingFound;

  /***** check for overflow */
  if( errno==ERANGE ) {
    fprintf(stderr, 
	    "%s: parameter `%s' of option `%s' to large to represent\n",
	    Program, argv[i], argv[i-1]);
    exit(EXIT_FAILURE);
  }
  return i;

nothingFound:
  /***** !force means: this parameter may be missing.*/
  if( !force ) return i-1;

  fprintf(stderr, 
	  "%s: missing or malformed value after option `%s'\n",
	  Program, argv[i-1]);
    exit(EXIT_FAILURE);
}
/**********************************************************************/

int
getLongOpts(int argc, char **argv, int i, 
	    long **values,
	    int cmin, int cmax)
/*****
  We want to find at least cmin values and at most cmax values.
  cmax==-1 then means infinitely many are allowed.
*****/
{
  int alloced, used;
  char *end;

  if( i+cmin >= argc ) {
    fprintf(stderr, 
	    "%s: option `%s' wants at least %d parameters\n",
	    Program, argv[i], cmin);
    exit(EXIT_FAILURE);
  }

  /***** 
    alloc a bit more than cmin values. It does not hurt to have room
    for a bit more values than cmax.
  *****/
  alloced = cmin + 4;
  *values = (long int *)calloc((size_t)alloced, sizeof(long));
  if( ! *values ) {
outMem:
    fprintf(stderr, 
	    "%s: out of memory while parsing option `%s'\n",
	    Program, argv[i]);
    exit(EXIT_FAILURE);
  }

  for(used=0; (cmax==-1 || used<cmax) && used+i+1<argc; used++) {
    if( used==alloced ) {
      alloced += 8;
      *values = (long int*) realloc(*values, alloced*sizeof(long));
      if( !*values ) goto outMem;
    }

    errno = 0;
    (*values)[used] = strtol(argv[used+i+1], &end, 0);

    /***** check for conversion error */
    if( end==argv[used+i+1] ) break;

    /***** check for surplus non-whitespace */
    while( isspace((int) *end) ) end+=1; 
    if( *end ) break;

    /***** check for overflow */
    if( errno==ERANGE ) {
      fprintf(stderr, 
	      "%s: parameter `%s' of option `%s' to large to represent\n",
	      Program, argv[i+used+1], argv[i]);
      exit(EXIT_FAILURE);
    }

  }
    
  if( used<cmin ) {
    fprintf(stderr, 
	    "%s: parameter `%s' of `%s' should be an "
	    "integer value\n",
	    Program, argv[i+used+1], argv[i]);
    exit(EXIT_FAILURE);
  }

  return i+used;
}
/**********************************************************************/

int
getFloatOpt(int argc, char **argv, int i, float *value, int force)
{
  char *end;
  double v;

  if( ++i>=argc ) goto nothingFound;

  errno = 0;
  v = strtod(argv[i], &end);

  /***** check for conversion error */
  if( end==argv[i] ) goto nothingFound;

  /***** check for surplus non-whitespace */
  while( isspace((int) *end) ) end+=1;
  if( *end ) goto nothingFound;

  /***** check for overflow */
  checkFloatConversion(v, argv[i-1], argv[i]);

  *value = (float)v;

  return i;

nothingFound:
  if( !force ) return i-1;

  fprintf(stderr,
	  "%s: missing or malformed float value after option `%s'\n",
	  Program, argv[i-1]);
  exit(EXIT_FAILURE);
 
}
/**********************************************************************/

int
getFloatOpts(int argc, char **argv, int i, 
	   float **values,
	   int cmin, int cmax)
/*****
  We want to find at least cmin values and at most cmax values.
  cmax==-1 then means infinitely many are allowed.
*****/
{
  int alloced, used;
  char *end;
  double v;

  if( i+cmin >= argc ) {
    fprintf(stderr, 
	    "%s: option `%s' wants at least %d parameters\n",
	    Program, argv[i], cmin);
    exit(EXIT_FAILURE);
  }

  /***** 
    alloc a bit more than cmin values.
  *****/
  alloced = cmin + 4;
  *values = (float*)calloc((size_t)alloced, sizeof(float));
  if( ! *values ) {
outMem:
    fprintf(stderr, 
	    "%s: out of memory while parsing option `%s'\n",
	    Program, argv[i]);
    exit(EXIT_FAILURE);
  }

  for(used=0; (cmax==-1 || used<cmax) && used+i+1<argc; used++) {
    if( used==alloced ) {
      alloced += 8;
      *values = (float *) realloc(*values, alloced*sizeof(float));
      if( !*values ) goto outMem;
    }

    errno = 0;
    v = strtod(argv[used+i+1], &end);

    /***** check for conversion error */
    if( end==argv[used+i+1] ) break;

    /***** check for surplus non-whitespace */
    while( isspace((int) *end) ) end+=1;
    if( *end ) break;

    /***** check for overflow */
    checkFloatConversion(v, argv[i], argv[i+used+1]);
    
    (*values)[used] = (float)v;
  }
    
  if( used<cmin ) {
    fprintf(stderr, 
	    "%s: parameter `%s' of `%s' should be a "
	    "floating-point value\n",
	    Program, argv[i+used+1], argv[i]);
    exit(EXIT_FAILURE);
  }

  return i+used;
}
/**********************************************************************/

int
getDoubleOpt(int argc, char **argv, int i, double *value, int force)
{
  char *end;

  if( ++i>=argc ) goto nothingFound;

  errno = 0;
  *value = strtod(argv[i], &end);

  /***** check for conversion error */
  if( end==argv[i] ) goto nothingFound;

  /***** check for surplus non-whitespace */
  while( isspace((int) *end) ) end+=1;
  if( *end ) goto nothingFound;

  /***** check for overflow */
  if( errno==ERANGE ) {
    fprintf(stderr, 
	    "%s: parameter `%s' of option `%s' to %s to represent\n",
	    Program, argv[i], argv[i-1],
	    (*value==0.0 ? "small" : "large"));
    exit(EXIT_FAILURE);
  }

  return i;

nothingFound:
  if( !force ) return i-1;

  fprintf(stderr,
	  "%s: missing or malformed value after option `%s'\n",
	  Program, argv[i-1]);
  exit(EXIT_FAILURE);
 
}
/**********************************************************************/

int
getDoubleOpts(int argc, char **argv, int i, 
	   double **values,
	   int cmin, int cmax)
/*****
  We want to find at least cmin values and at most cmax values.
  cmax==-1 then means infinitely many are allowed.
*****/
{
  int alloced, used;
  char *end;

  if( i+cmin >= argc ) {
    fprintf(stderr, 
	    "%s: option `%s' wants at least %d parameters\n",
	    Program, argv[i], cmin);
    exit(EXIT_FAILURE);
  }

  /***** 
    alloc a bit more than cmin values.
  *****/
  alloced = cmin + 4;
  *values = (double*)calloc((size_t)alloced, sizeof(double));
  if( ! *values ) {
outMem:
    fprintf(stderr, 
	    "%s: out of memory while parsing option `%s'\n",
	    Program, argv[i]);
    exit(EXIT_FAILURE);
  }

  for(used=0; (cmax==-1 || used<cmax) && used+i+1<argc; used++) {
    if( used==alloced ) {
      alloced += 8;
      *values = (double *) realloc(*values, alloced*sizeof(double));
      if( !*values ) goto outMem;
    }

    errno = 0;
    (*values)[used] = strtod(argv[used+i+1], &end);

    /***** check for conversion error */
    if( end==argv[used+i+1] ) break;

    /***** check for surplus non-whitespace */
    while( isspace((int) *end) ) end+=1;
    if( *end ) break;

    /***** check for overflow */
    if( errno==ERANGE ) {
      fprintf(stderr, 
	      "%s: parameter `%s' of option `%s' to %s to represent\n",
	      Program, argv[i+used+1], argv[i],
	      ((*values)[used]==0.0 ? "small" : "large"));
      exit(EXIT_FAILURE);
    }

  }
    
  if( used<cmin ) {
    fprintf(stderr, 
	    "%s: parameter `%s' of `%s' should be a "
	    "double value\n",
	    Program, argv[i+used+1], argv[i]);
    exit(EXIT_FAILURE);
  }

  return i+used;
}
/**********************************************************************/

/**
  force will be set if we need at least one argument for the option.
*****/
int
getStringOpt(int argc, char **argv, int i, char **value, int force)
{
  i += 1;
  if( i>=argc ) {
    if( force ) {
      fprintf(stderr, "%s: missing string after option `%s'\n",
	      Program, argv[i-1]);
      exit(EXIT_FAILURE);
    } 
    return i-1;
  }
  
  if( !force && argv[i][0] == '-' ) return i-1;
  *value = argv[i];
  return i;
}
/**********************************************************************/

int
getStringOpts(int argc, char **argv, int i, 
	   char*  **values,
	   int cmin, int cmax)
/*****
  We want to find at least cmin values and at most cmax values.
  cmax==-1 then means infinitely many are allowed.
*****/
{
  int alloced, used;

  if( i+cmin >= argc ) {
    fprintf(stderr, 
	    "%s: option `%s' wants at least %d parameters\n",
	    Program, argv[i], cmin);
    exit(EXIT_FAILURE);
  }

  alloced = cmin + 4;
    
  *values = (char**)calloc((size_t)alloced, sizeof(char*));
  if( ! *values ) {
outMem:
    fprintf(stderr, 
	    "%s: out of memory during parsing of option `%s'\n",
	    Program, argv[i]);
    exit(EXIT_FAILURE);
  }

  for(used=0; (cmax==-1 || used<cmax) && used+i+1<argc; used++) {
    if( used==alloced ) {
      alloced += 8;
      *values = (char **)realloc(*values, alloced*sizeof(char*));
      if( !*values ) goto outMem;
    }

    if( used>=cmin && argv[used+i+1][0]=='-' ) break;
    (*values)[used] = argv[used+i+1];
  }
    
  if( used<cmin ) {
    fprintf(stderr, 
    "%s: less than %d parameters for option `%s', only %d found\n",
	    Program, cmin, argv[i], used);
    exit(EXIT_FAILURE);
  }

  return i+used;
}
/**********************************************************************/

void
checkIntLower(char *opt, int *values, int count, int max)
{
  int i;

  for(i=0; i<count; i++) {
    if( values[i]<=max ) continue;
    fprintf(stderr, 
	    "%s: parameter %d of option `%s' greater than max=%d\n",
	    Program, i+1, opt, max);
    exit(EXIT_FAILURE);
  }
}
/**********************************************************************/

void
checkIntHigher(char *opt, int *values, int count, int min)
{
  int i;

  for(i=0; i<count; i++) {
    if( values[i]>=min ) continue;
    fprintf(stderr, 
	    "%s: parameter %d of option `%s' smaller than min=%d\n",
	    Program, i+1, opt, min);
    exit(EXIT_FAILURE);
  }
}
/**********************************************************************/

void
checkLongLower(char *opt, long *values, int count, long max)
{
  int i;

  for(i=0; i<count; i++) {
    if( values[i]<=max ) continue;
    fprintf(stderr, 
	    "%s: parameter %d of option `%s' greater than max=%ld\n",
	    Program, i+1, opt, max);
    exit(EXIT_FAILURE);
  }
}
/**********************************************************************/

void
checkLongHigher(char *opt, long *values, int count, long min)
{
  int i;

  for(i=0; i<count; i++) {
    if( values[i]>=min ) continue;
    fprintf(stderr, 
	    "%s: parameter %d of option `%s' smaller than min=%ld\n",
	    Program, i+1, opt, min);
    exit(EXIT_FAILURE);
  }
}
/**********************************************************************/

void
checkFloatLower(char *opt, float *values, int count, float max)
{
  int i;

  for(i=0; i<count; i++) {
    if( values[i]<=max ) continue;
    fprintf(stderr, 
	    "%s: parameter %d of option `%s' greater than max=%f\n",
	    Program, i+1, opt, max);
    exit(EXIT_FAILURE);
  }
}
/**********************************************************************/

void
checkFloatHigher(char *opt, float *values, int count, float min)
{
  int i;

  for(i=0; i<count; i++) {
    if( values[i]>=min ) continue;
    fprintf(stderr, 
	    "%s: parameter %d of option `%s' smaller than min=%f\n",
	    Program, i+1, opt, min);
    exit(EXIT_FAILURE);
  }
}
/**********************************************************************/

void
checkDoubleLower(char *opt, double *values, int count, double max)
{
  int i;

  for(i=0; i<count; i++) {
    if( values[i]<=max ) continue;
    fprintf(stderr, 
	    "%s: parameter %d of option `%s' greater than max=%f\n",
	    Program, i+1, opt, max);
    exit(EXIT_FAILURE);
  }
}
/**********************************************************************/

void
checkDoubleHigher(char *opt, double *values, int count, double min)
{
  int i;

  for(i=0; i<count; i++) {
    if( values[i]>=min ) continue;
    fprintf(stderr, 
	    "%s: parameter %d of option `%s' smaller than min=%f\n",
	    Program, i+1, opt, min);
    exit(EXIT_FAILURE);
  }
}
/**********************************************************************/

static char *
catArgv(int argc, char **argv)
{
  int i;
  size_t l;
  char *s, *t;

  for(i=0, l=0; i<argc; i++) l += (1+strlen(argv[i]));
  s = (char *)malloc(l);
  if( !s ) {
    fprintf(stderr, "%s: out of memory\n", Program);
    exit(EXIT_FAILURE);
  }
  strcpy(s, argv[0]);
  t = s;
  for(i=1; i<argc; i++) {
    t = t+strlen(t);
    *t++ = ' ';
    strcpy(t, argv[i]);
  }
  return s;
}
/**********************************************************************/

void
showOptionValues(void)
{
  int i;

  printf("Full command line is:\n`%s'\n", cmd.all_args);

  /***** -days: Events are in days since MJD0 (default is seconds) */
  if( !cmd.daysP ) {
    printf("-days not found.\n");
  } else {
    printf("-days found:\n");
  }

  /***** -mjds: Events are in MJDs */
  if( !cmd.mjdsP ) {
    printf("-mjds not found.\n");
  } else {
    printf("-mjds found:\n");
  }

  /***** -double: Events are in binary double precision (default is ASCII) */
  if( !cmd.doubleP ) {
    printf("-double not found.\n");
  } else {
    printf("-double found:\n");
  }

  /***** -iout: Send the list of freqs and incoherently summed powers to stdout */
  if( !cmd.ioutP ) {
    printf("-iout not found.\n");
  } else {
    printf("-iout found:\n");
  }

  /***** -cout: Send the list of freqs and coherently summed powers to stdout */
  if( !cmd.coutP ) {
    printf("-cout not found.\n");
  } else {
    printf("-cout found:\n");
  }

  /***** -nocoherent: Do not sum powers coherently in the search */
  if( !cmd.nocoherentP ) {
    printf("-nocoherent not found.\n");
  } else {
    printf("-nocoherent found:\n");
  }

  /***** -noincoherent: Do not sum powers incoherently in the search */
  if( !cmd.noincoherentP ) {
    printf("-noincoherent not found.\n");
  } else {
    printf("-noincoherent found:\n");
  }

  /***** -nostatus: Do not print percent complete status to STDOUT */
  if( !cmd.nostatusP ) {
    printf("-nostatus not found.\n");
  } else {
    printf("-nostatus found:\n");
  }

  /***** -fmin: Lowest freq to search (hz) */
  if( !cmd.fminP ) {
    printf("-fmin not found.\n");
  } else {
    printf("-fmin found:\n");
    if( !cmd.fminC ) {
      printf("  no values\n");
    } else {
      printf("  value = `%.40g'\n", cmd.fmin);
    }
  }

  /***** -fmax: Highest freq to search (hz) */
  if( !cmd.fmaxP ) {
    printf("-fmax not found.\n");
  } else {
    printf("-fmax found:\n");
    if( !cmd.fmaxC ) {
      printf("  no values\n");
    } else {
      printf("  value = `%.40g'\n", cmd.fmax);
    }
  }

  /***** -fdotbyf: Frequency Derivative / Freq to apply to the events before DFTing */
  if( !cmd.fdotbyfP ) {
    printf("-fdotbyf not found.\n");
  } else {
    printf("-fdotbyf found:\n");
    if( !cmd.fdotbyfC ) {
      printf("  no values\n");
    } else {
      printf("  value = `%.40g'\n", cmd.fdotbyf);
    }
  }

  /***** -ifs: Approx number of independent freqs in search */
  if( !cmd.ifsP ) {
    printf("-ifs not found.\n");
  } else {
    printf("-ifs found:\n");
    if( !cmd.ifsC ) {
      printf("  no values\n");
    } else {
      printf("  value = `%.40g'\n", cmd.ifs);
    }
  }

  /***** -mjd0: The fiducial time (in MJD) to use as T0 (default sets T0 to the first event) */
  if( !cmd.MJD0P ) {
    printf("-mjd0 not found.\n");
  } else {
    printf("-mjd0 found:\n");
    if( !cmd.MJD0C ) {
      printf("  no values\n");
    } else {
      printf("  value = `%.40g'\n", cmd.MJD0);
    }
  }

  /***** -time: The total duration in sec to accept events from the input file (default uses all events) */
  if( !cmd.TP ) {
    printf("-time not found.\n");
  } else {
    printf("-time found:\n");
    if( !cmd.TC ) {
      printf("  no values\n");
    } else {
      printf("  value = `%.40g'\n", cmd.T);
    }
  }

  /***** -start: The fraction of the way through T (beginning at MJD0) to start looking at events (default is 0.0) */
  if( !cmd.startTP ) {
    printf("-start not found.\n");
  } else {
    printf("-start found:\n");
    if( !cmd.startTC ) {
      printf("  no values\n");
    } else {
      printf("  value = `%.40g'\n", cmd.startT);
    }
  }

  /***** -end: The fraction of the way through T (beginning at MJD0) to stop looking at events (default is 1.0) */
  if( !cmd.endTP ) {
    printf("-end not found.\n");
  } else {
    printf("-end found:\n");
    if( !cmd.endTC ) {
      printf("  no values\n");
    } else {
      printf("  value = `%.40g'\n", cmd.endT);
    }
  }

  /***** -offset: A time offset to add to the 1st event in the same units as the events */
  if( !cmd.offsetP ) {
    printf("-offset not found.\n");
  } else {
    printf("-offset found:\n");
    if( !cmd.offsetC ) {
      printf("  no values\n");
    } else {
      printf("  value = `%.40g'\n", cmd.offset);
    }
  }

  /***** -numsum: Maximum number of harmonics to sum */
  if( !cmd.numsumP ) {
    printf("-numsum not found.\n");
  } else {
    printf("-numsum found:\n");
    if( !cmd.numsumC ) {
      printf("  no values\n");
    } else {
      printf("  value = `%d'\n", cmd.numsum);
    }
  }

  /***** -osamp: Factor to oversample normal (1/T) Fourier spacing */
  if( !cmd.osampP ) {
    printf("-osamp not found.\n");
  } else {
    printf("-osamp found:\n");
    if( !cmd.osampC ) {
      printf("  no values\n");
    } else {
      printf("  value = `%d'\n", cmd.osamp);
    }
  }

  /***** -ncands: Number of candidates to return */
  if( !cmd.ncandsP ) {
    printf("-ncands not found.\n");
  } else {
    printf("-ncands found:\n");
    if( !cmd.ncandsC ) {
      printf("  no values\n");
    } else {
      printf("  value = `%d'\n", cmd.ncands);
    }
  }
  if( !cmd.argc ) {
    printf("no remaining parameters in argv\n");
  } else {
    printf("argv =");
    for(i=0; i<cmd.argc; i++) {
      printf(" `%s'", cmd.argv[i]);
    }
    printf("\n");
  }
}
/**********************************************************************/

void
usage(void)
{
  fprintf(stderr,"%s","   [-days] [-mjds] [-double] [-iout] [-cout] [-nocoherent] [-noincoherent] [-nostatus] [-fmin fmin] [-fmax fmax] [-fdotbyf fdotbyf] [-ifs ifs] [-mjd0 MJD0] [-time T] [-start startT] [-end endT] [-offset offset] [-numsum numsum] [-osamp osamp] [-ncands ncands] [--] infile\n");
  fprintf(stderr,"%s","      Search the Discrete Fourier Transform of a set of TOAs for periodicities\n");
  fprintf(stderr,"%s","            -days: Events are in days since MJD0 (default is seconds)\n");
  fprintf(stderr,"%s","            -mjds: Events are in MJDs\n");
  fprintf(stderr,"%s","          -double: Events are in binary double precision (default is ASCII)\n");
  fprintf(stderr,"%s","            -iout: Send the list of freqs and incoherently summed powers to stdout\n");
  fprintf(stderr,"%s","            -cout: Send the list of freqs and coherently summed powers to stdout\n");
  fprintf(stderr,"%s","      -nocoherent: Do not sum powers coherently in the search\n");
  fprintf(stderr,"%s","    -noincoherent: Do not sum powers incoherently in the search\n");
  fprintf(stderr,"%s","        -nostatus: Do not print percent complete status to STDOUT\n");
  fprintf(stderr,"%s","            -fmin: Lowest freq to search (hz)\n");
  fprintf(stderr,"%s","                   1 double value between 0 and oo\n");
  fprintf(stderr,"%s","                   default: `0.01'\n");
  fprintf(stderr,"%s","            -fmax: Highest freq to search (hz)\n");
  fprintf(stderr,"%s","                   1 double value between 0 and oo\n");
  fprintf(stderr,"%s","                   default: `1000.0'\n");
  fprintf(stderr,"%s","         -fdotbyf: Frequency Derivative / Freq to apply to the events before DFTing\n");
  fprintf(stderr,"%s","                   1 double value\n");
  fprintf(stderr,"%s","             -ifs: Approx number of independent freqs in search\n");
  fprintf(stderr,"%s","                   1 double value between 0 and oo\n");
  fprintf(stderr,"%s","            -mjd0: The fiducial time (in MJD) to use as T0 (default sets T0 to the first event)\n");
  fprintf(stderr,"%s","                   1 double value between 0 and oo\n");
  fprintf(stderr,"%s","                   default: `0.0'\n");
  fprintf(stderr,"%s","            -time: The total duration in sec to accept events from the input file (default uses all events)\n");
  fprintf(stderr,"%s","                   1 double value between 0 and oo\n");
  fprintf(stderr,"%s","                   default: `0.0'\n");
  fprintf(stderr,"%s","           -start: The fraction of the way through T (beginning at MJD0) to start looking at events (default is 0.0)\n");
  fprintf(stderr,"%s","                   1 double value between 0 and oo\n");
  fprintf(stderr,"%s","                   default: `0.0'\n");
  fprintf(stderr,"%s","             -end: The fraction of the way through T (beginning at MJD0) to stop looking at events (default is 1.0)\n");
  fprintf(stderr,"%s","                   1 double value between 0 and oo\n");
  fprintf(stderr,"%s","                   default: `1.0'\n");
  fprintf(stderr,"%s","          -offset: A time offset to add to the 1st event in the same units as the events\n");
  fprintf(stderr,"%s","                   1 double value\n");
  fprintf(stderr,"%s","                   default: `0.0'\n");
  fprintf(stderr,"%s","          -numsum: Maximum number of harmonics to sum\n");
  fprintf(stderr,"%s","                   1 int value between 1 and 32\n");
  fprintf(stderr,"%s","                   default: `8'\n");
  fprintf(stderr,"%s","           -osamp: Factor to oversample normal (1/T) Fourier spacing\n");
  fprintf(stderr,"%s","                   1 int value between 1 and 1000\n");
  fprintf(stderr,"%s","          -ncands: Number of candidates to return\n");
  fprintf(stderr,"%s","                   1 int value between 1 and 1000\n");
  fprintf(stderr,"%s","                   default: `50'\n");
  fprintf(stderr,"%s","           infile: File containing input events.\n");
  fprintf(stderr,"%s","                   1 value\n");
  fprintf(stderr,"%s","  version: 2014-03-28\n");
  fprintf(stderr,"%s","  ");
  exit(EXIT_FAILURE);
}
/**********************************************************************/
Cmdline *
parseCmdline(int argc, char **argv)
{
  int i;

  Program = argv[0];
  cmd.all_args = catArgv(argc, argv);
  for(i=1, cmd.argc=1; i<argc; i++) {
    if( 0==strcmp("--", argv[i]) ) {
      while( ++i<argc ) argv[cmd.argc++] = argv[i];
      continue;
    }

    if( 0==strcmp("-days", argv[i]) ) {
      cmd.daysP = 1;
      continue;
    }

    if( 0==strcmp("-mjds", argv[i]) ) {
      cmd.mjdsP = 1;
      continue;
    }

    if( 0==strcmp("-double", argv[i]) ) {
      cmd.doubleP = 1;
      continue;
    }

    if( 0==strcmp("-iout", argv[i]) ) {
      cmd.ioutP = 1;
      continue;
    }

    if( 0==strcmp("-cout", argv[i]) ) {
      cmd.coutP = 1;
      continue;
    }

    if( 0==strcmp("-nocoherent", argv[i]) ) {
      cmd.nocoherentP = 1;
      continue;
    }

    if( 0==strcmp("-noincoherent", argv[i]) ) {
      cmd.noincoherentP = 1;
      continue;
    }

    if( 0==strcmp("-nostatus", argv[i]) ) {
      cmd.nostatusP = 1;
      continue;
    }

    if( 0==strcmp("-fmin", argv[i]) ) {
      int keep = i;
      cmd.fminP = 1;
      i = getDoubleOpt(argc, argv, i, &cmd.fmin, 1);
      cmd.fminC = i-keep;
      checkDoubleHigher("-fmin", &cmd.fmin, cmd.fminC, 0);
      continue;
    }

    if( 0==strcmp("-fmax", argv[i]) ) {
      int keep = i;
      cmd.fmaxP = 1;
      i = getDoubleOpt(argc, argv, i, &cmd.fmax, 1);
      cmd.fmaxC = i-keep;
      checkDoubleHigher("-fmax", &cmd.fmax, cmd.fmaxC, 0);
      continue;
    }

    if( 0==strcmp("-fdotbyf", argv[i]) ) {
      int keep = i;
      cmd.fdotbyfP = 1;
      i = getDoubleOpt(argc, argv, i, &cmd.fdotbyf, 1);
      cmd.fdotbyfC = i-keep;
      continue;
    }

    if( 0==strcmp("-ifs", argv[i]) ) {
      int keep = i;
      cmd.ifsP = 1;
      i = getDoubleOpt(argc, argv, i, &cmd.ifs, 1);
      cmd.ifsC = i-keep;
      checkDoubleHigher("-ifs", &cmd.ifs, cmd.ifsC, 0);
      continue;
    }

    if( 0==strcmp("-mjd0", argv[i]) ) {
      int keep = i;
      cmd.MJD0P = 1;
      i = getDoubleOpt(argc, argv, i, &cmd.MJD0, 1);
      cmd.MJD0C = i-keep;
      checkDoubleHigher("-mjd0", &cmd.MJD0, cmd.MJD0C, 0);
      continue;
    }

    if( 0==strcmp("-time", argv[i]) ) {
      int keep = i;
      cmd.TP = 1;
      i = getDoubleOpt(argc, argv, i, &cmd.T, 1);
      cmd.TC = i-keep;
      checkDoubleHigher("-time", &cmd.T, cmd.TC, 0);
      continue;
    }

    if( 0==strcmp("-start", argv[i]) ) {
      int keep = i;
      cmd.startTP = 1;
      i = getDoubleOpt(argc, argv, i, &cmd.startT, 1);
      cmd.startTC = i-keep;
      checkDoubleHigher("-start", &cmd.startT, cmd.startTC, 0);
      continue;
    }

    if( 0==strcmp("-end", argv[i]) ) {
      int keep = i;
      cmd.endTP = 1;
      i = getDoubleOpt(argc, argv, i, &cmd.endT, 1);
      cmd.endTC = i-keep;
      checkDoubleHigher("-end", &cmd.endT, cmd.endTC, 0);
      continue;
    }

    if( 0==strcmp("-offset", argv[i]) ) {
      int keep = i;
      cmd.offsetP = 1;
      i = getDoubleOpt(argc, argv, i, &cmd.offset, 1);
      cmd.offsetC = i-keep;
      continue;
    }

    if( 0==strcmp("-numsum", argv[i]) ) {
      int keep = i;
      cmd.numsumP = 1;
      i = getIntOpt(argc, argv, i, &cmd.numsum, 1);
      cmd.numsumC = i-keep;
      checkIntLower("-numsum", &cmd.numsum, cmd.numsumC, 32);
      checkIntHigher("-numsum", &cmd.numsum, cmd.numsumC, 1);
      continue;
    }

    if( 0==strcmp("-osamp", argv[i]) ) {
      int keep = i;
      cmd.osampP = 1;
      i = getIntOpt(argc, argv, i, &cmd.osamp, 1);
      cmd.osampC = i-keep;
      checkIntLower("-osamp", &cmd.osamp, cmd.osampC, 1000);
      checkIntHigher("-osamp", &cmd.osamp, cmd.osampC, 1);
      continue;
    }

    if( 0==strcmp("-ncands", argv[i]) ) {
      int keep = i;
      cmd.ncandsP = 1;
      i = getIntOpt(argc, argv, i, &cmd.ncands, 1);
      cmd.ncandsC = i-keep;
      checkIntLower("-ncands", &cmd.ncands, cmd.ncandsC, 1000);
      checkIntHigher("-ncands", &cmd.ncands, cmd.ncandsC, 1);
      continue;
    }

    if( argv[i][0]=='-' ) {
      fprintf(stderr, "\n%s: unknown option `%s'\n\n",
              Program, argv[i]);
      usage();
    }
    argv[cmd.argc++] = argv[i];
  }/* for i */


  /*@-mustfree*/
  cmd.argv = argv+1;
  /*@=mustfree*/
  cmd.argc -= 1;

  if( 1>cmd.argc ) {
    fprintf(stderr, "%s: there should be at least 1 non-option argument(s)\n",
            Program);
    exit(EXIT_FAILURE);
  }
  if( 1<cmd.argc ) {
    fprintf(stderr, "%s: there should be at most 1 non-option argument(s)\n",
            Program);
    exit(EXIT_FAILURE);
  }
  /*@-compmempass*/  return &cmd;
}