options.c

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#include <config.h>

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include <assert.h>

#ifdef HAPLO_HAVE_DMALLOC
#include <dmalloc.h>
#endif

#include <jwsc/base/error.h>
#include <jwsc/base/option.h>
#include <jwsc/vector/vector.h>

#include "haplo_groups.h"
#include "options.h"


#define  HEADER_IN                 0
#define  HEADER_OUT                0
#define  EXCLUDE_ONE               0
#define  NUM_THREADS               1
#define  INPUT_FORMAT              HAPLO_INPUT_TXT
#define  INPUT_DTD_FNAME           0
#define  OUTPUT_FORMAT             HAPLO_OUTPUT_TXT
#define  LABELS_FNAME              0
#define  LABELS_DTD_FNAME          0
#define  FIRST_MARKER_COL          2
#define  NUM_MARKERS               9
#define  AUX_INPUT_FNAME           0
#define  AUX_LABEL_COL             0
#define  AUX_FIRST_MARKER_COL      2
#define  AUX_NUM_MARKERS           9
#define  NB_FREQ_FNAME             0
#define  NB_FREQ_DTD_FNAME         0
#define  NB_GAUSS_FNAME            0
#define  NB_GAUSS_DTD_FNAME        0
#define  NB_GMM_FNAME              0
#define  NB_GMM_DTD_FNAME          0
#define  MV_GMM_FNAME              0
#define  MV_GMM_DTD_FNAME          0
#define  MV_MMM_FNAME              0
#define  MV_MMM_DTD_FNAME          0
#define  SVM_FNAME                 0
#define  SVM_DTD_FNAME             0
#define  WEKA_J48_FNAME            0
#define  WEKA_PART_FNAME           0
#define  WEKA_JAR_FNAME            0
#define  WEKA_DTD_FNAME            0
#define  NEAREST_FNAME             0
#define  NEAREST_DTD_FNAME         0
#define  NEAREST_MAX_D             1
#define  BMM_TREE_FNAME            0
#define  BMM_INFO_FNAME            0
#define  BMM_CONF_THRESH_FNAME     0
#define  GMM_BMM_TREE_FNAME        0
#define  GMM_BMM_INFO_FNAME        0
#define  GMM_BMM_CONF_THRESH_FNAME 0
#define  MODEL_DIRNAME             "."


extern Option_no_arg opts_no_arg[];
extern Option_with_arg opts_with_arg[];
extern uint32_t get_num_opts_no_arg();
extern uint32_t get_num_opts_with_arg();
extern void print_usage();


uint8_t sequential_markers = 0;


uint8_t aux_sequential_markers = 0;


Error* process_help_opt()
{
    print_usage();
    exit(EXIT_SUCCESS);
    return NULL;
}

Error* process_version_opt()
{
    fprintf(stderr, "%s\n", HAPLO_PACKAGE_STRING);
    exit(EXIT_SUCCESS);
    return NULL;
}

Error* process_header_in_opt()
{
    opts.header_in = 1;
    return NULL;
}

Error* process_header_out_opt()
{
    opts.header_out = 1;
    return NULL;
}

Error* process_exclude_one_opt()
{
    opts.exclude_one = 1;
    return NULL;
}

Error* process_options_opt(Option_arg arg)
{
    Error* err;
    int    slen = 256;
    char   s[slen];

    if (arg == NULL)
    {
        return JWSC_EARG("Option 'options' requires an argument");
    }

    if ((err = process_options_from_file(arg, get_num_opts_no_arg(), 
                    opts_no_arg, get_num_opts_with_arg(), opts_with_arg)) 
            != NULL)
    {
        snprintf(s, slen, "%s: %s", arg, err->msg);
        return JWSC_EARG(s);
    }

    return NULL;
}

Error* process_num_threads_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'num-threads' requires an argument");
    }
    if (sscanf(arg, "%u", &(opts.num_threads)) != 1 || 
            opts.num_threads < 1)
    {
        return JWSC_EARG("Option 'num-threads' must be > 0");
    }

    return NULL;
}

Error* process_seed_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'seed' requires an argument");
    }
    if (sscanf(arg, "%u", &(opts.seed)) != 1)
    {
        return JWSC_EARG("Option 'seed' requires an argument");
    }

    srand(opts.seed);

    return NULL;
}

static Error* process_input_format_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'input-format' requires an argument");
    }
    if (strncmp(arg, "txt", 3) == 0)
    {
        opts.input_format = HAPLO_INPUT_TXT;
    }
    else if (strncmp(arg, "csv", 3) == 0)
    {
        opts.input_format = HAPLO_INPUT_CSV;
    }
    else if (strncmp(arg, "xml", 3) == 0)
    {
        opts.input_format = HAPLO_INPUT_XML;
    }
    else
    {
        return JWSC_EARG("Option 'input-format' must be one of {txt, csv, xml}");
    }
    return NULL;
}

Error* process_input_dtd_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'input-dtd' requires an argument");
    }
    opts.input_dtd_fname = arg;

    return NULL;
}

static Error* process_output_format_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'output-format' requires an argument");
    }
    if (strncmp(arg, "txt", 3) == 0)
    {
        opts.output_format = HAPLO_OUTPUT_TXT;
    }
    else if (strncmp(arg, "csv", 3) == 0)
    {
        opts.output_format = HAPLO_OUTPUT_CSV;
    }
    else if (strncmp(arg, "xml", 3) == 0)
    {
        opts.output_format = HAPLO_OUTPUT_XML;
    }
    else
    {
        return JWSC_EARG("Option 'output-format' must be one of {txt, csv, xml}");
    }
    return NULL;
}

Error* process_labels_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'labels' requires an argument");
    }
    opts.labels_fname = arg;

    return NULL;
}

Error* process_labels_dtd_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'labels-dtd' requires an argument");
    }
    opts.labels_dtd_fname = arg;

    return NULL;
}

Error* process_id_cols_opt(Option_arg arg)
{
    uint32_t num_ids;
    uint32_t id_col;
    uint32_t n;
    char*    str;
    char*    token;

    if (arg == NULL)
    {
        return JWSC_EARG("Option 'id-cols' requires an argument");
    }

    n = strlen(arg);
    str = malloc((n+1)*sizeof(char));
    strncpy(str, arg, n);
    str[ n ] = 0;
    token = str;

    free_vector_u32(opts.id_cols);
    opts.id_cols = NULL;
    num_ids = 0;

    while ((token = strtok(token, ",")) != NULL)
    {
        if (sscanf(token, "%u", &id_col) != 1)
        {
            return JWSC_EARG("Option 'id-cols' must be >= 0");
        }
        if (num_ids == 0 && id_col == 0)
        {
            break;
        }
        else if (num_ids > 0 && id_col == 0)
        {
            return JWSC_EARG("Option 'id-cols': IDs must be > 0");
        }
        create_vector_u32(&(opts.id_cols), num_ids+1);
        opts.id_cols->elts[ num_ids++ ] = id_col;
        token = NULL;
    }

    free(str);

    return NULL;
}

Error* process_label_col_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'label-col' requires an argument");
    }
    if (sscanf(arg, "%u", &(opts.label_col)) != 1)
    {
        return JWSC_EARG("Option 'label-col' must be >= 0");
    }

    return NULL;
}

Error* process_first_marker_col_opt(Option_arg arg)
{
    if (opts.marker_cols)
    {
        return JWSC_EARG("Option '1st-marker-col' cannot be used with 'marker-cols'");
    }
    if (arg == NULL)
    {
        return JWSC_EARG("Option '1st-marker-col' requires an argument");
    }
    if (sscanf(arg, "%u", &(opts.first_marker_col)) != 1 || 
            opts.first_marker_col < 1)
    {
        return JWSC_EARG("Option '1st-marker-col' must be > 0");
    }
    sequential_markers = 1;

    return NULL;
}

Error* process_num_markers_opt(Option_arg arg)
{
    if (opts.marker_cols)
    {
        return JWSC_EARG("Option 'num-markers' cannot be used with 'marker-cols'");
    }
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'num-markers' requires an argument");
    }
    if (sscanf(arg, "%u", &(opts.num_markers)) != 1 || opts.num_markers < 1)
    {
        return JWSC_EARG("Option 'num-markers' must be > 0");
    }
    sequential_markers = 1;

    return NULL;
}

Error* process_marker_cols_opt(Option_arg arg)
{
    uint32_t n;
    uint32_t m;
    char*    str;
    char*    token;

    if (sequential_markers)
    {
        return JWSC_EARG("Option 'marker-cols' cannot be used with 'num-markers' or 'marker-col'");
    }

    if (arg == NULL)
    {
        return JWSC_EARG("Option 'marker-cols' requires an argument");
    }

    n = strlen(arg);
    str = malloc((n+1)*sizeof(char));
    strncpy(str, arg, n);
    str[ n ] = 0;
    token = str;

    opts.num_markers = 0;

    while ((token = strtok(token, ",")) != NULL)
    {
        if (sscanf(token, "%u", &m) != 1 || m < 1)
        {
            return JWSC_EARG("Option 'marker-cols': Invalid marker");
        }
        create_vector_u32(&(opts.marker_cols), opts.num_markers+1);
        opts.marker_cols->elts[ opts.num_markers++ ] = m;
        token = NULL;
    }

    free(str);
    
    if (opts.num_markers == 0)
    {
        return JWSC_EARG("Option 'marker_cols' must number > 0");
    }
    opts.first_marker_col = opts.marker_cols->elts[ 0 ];

    return NULL;
}

Error* process_aux_input_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'aux-input' requires an argument");
    }
    opts.aux_input_fname = arg;

    return NULL;
}

Error* process_aux_id_cols_opt(Option_arg arg)
{
    uint32_t num_ids;
    uint32_t id_col;
    uint32_t n;
    char*    str;
    char*    token;

    if (arg == NULL)
    {
        return JWSC_EARG("Option 'aux-id-cols' requires an argument");
    }

    n = strlen(arg);
    str = malloc((n+1)*sizeof(char));
    strncpy(str, arg, n);
    str[ n ] = 0;
    token = str;

    num_ids = 0;

    while ((token = strtok(token, ",")) != NULL)
    {
        if (sscanf(token, "%u", &id_col) != 1)
        {
            return JWSC_EARG("Option 'aux-id-cols' must be >= 0");
        }
        if (num_ids == 0 && id_col == 0)
        {
            break;
        }
        else if (num_ids > 0 && id_col == 0)
        {
            return JWSC_EARG("Option 'aux-id-cols': IDs must be > 0");
        }
        create_vector_u32(&(opts.aux_id_cols), num_ids+1);
        opts.aux_id_cols->elts[ num_ids++ ] = id_col;
        token = NULL;
    }

    free(str);

    return NULL;
}

Error* process_aux_label_col_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'aux-label-col' requires an argument");
    }
    if (sscanf(arg, "%u", &(opts.aux_label_col)) != 1)
    {
        return JWSC_EARG("Option 'aux-label-col' must be >= 0");
    }

    return NULL;
}

Error* process_aux_first_marker_col_opt(Option_arg arg)
{
    if (opts.aux_marker_cols)
    {
        return JWSC_EARG("Option 'aux-1st-marker-col' cannot be used with 'aux-marker-cols'");
    }
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'aux-1st-marker-col' requires an argument");
    }
    if (sscanf(arg, "%u", &(opts.aux_first_marker_col)) != 1 || 
            opts.aux_first_marker_col < 1)
    {
        return JWSC_EARG("Option 'aux-1st-marker-col' must be > 0");
    }
    aux_sequential_markers = 1;

    return NULL;
}

Error* process_aux_num_markers_opt(Option_arg arg)
{
    if (opts.aux_marker_cols)
    {
        return JWSC_EARG("Option 'aux-num-markers' cannot be used with 'aux-marker-cols'");
    }
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'aux-num-markers' requires an argument");
    }
    if (sscanf(arg, "%u", &(opts.aux_num_markers)) != 1 || 
            opts.aux_num_markers < 1)
    {
        return JWSC_EARG("Option 'aux-num-markers' must be > 0");
    }
    aux_sequential_markers = 1;

    return NULL;
}

Error* process_aux_marker_cols_opt(Option_arg arg)
{
    uint32_t n;
    uint32_t m;
    char*    str;
    char*    token;

    if (aux_sequential_markers)
    {
        return JWSC_EARG("Option 'aux-marker-cols' cannot be used with 'aux-num-markers' or 'aux-marker-col'");
    }

    if (arg == NULL)
    {
        return JWSC_EARG("Option 'aux-marker-cols' requires an argument");
    }

    n = strlen(arg);
    str = malloc((n+1)*sizeof(char));
    strncpy(str, arg, n);
    str[ n ] = 0;
    token = str;

    opts.aux_num_markers = 0;

    while ((token = strtok(token, ",")) != NULL)
    {
        if (sscanf(token, "%u", &m) != 1 || m < 1)
        {
            return JWSC_EARG("Option 'aux-marker-cols': Invalid marker");
        }
        create_vector_u32(&(opts.aux_marker_cols), opts.aux_num_markers+1);
        opts.aux_marker_cols->elts[ opts.aux_num_markers++ ] = m;
        token = NULL;
    }

    free(str);
    
    if (opts.aux_num_markers == 0)
    {
        return JWSC_EARG("Option 'aux-marker-cols' must number > 0");
    }
    opts.aux_first_marker_col = opts.aux_marker_cols->elts[ 0 ];

    return NULL;
}

Error* process_num_gmm_bmm_markers_opt(Option_arg arg)
{
    uint32_t n,m;

    if (arg == NULL)
    {
        return JWSC_EARG("Option 'num-gmm-bmm-markers' requires an argument");
    }
    if (sscanf(arg, "%d,%d", &n, &m) < 2)
    {
        return JWSC_EARG("Option 'num-markers' has format gmm,bmm");
    }
    opts.num_gmm_markers = (uint32_t)n;

    return NULL;
}

Error* process_model_dir_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'model-dir' requires an argument");
    }
    opts.model_dirname = arg;

    return NULL;
}

Error* process_nb_freq_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'nb-freq' requires an argument");
    }
    opts.nb_freq_fname = arg;

    return NULL;
}

Error* process_nb_freq_dtd_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'nb-freq-dtd' requires an argument");
    }
    opts.nb_freq_dtd_fname = arg;

    return NULL;
}

Error* process_nb_gauss_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'nb-gauss' requires an argument");
    }
    opts.nb_gauss_fname = arg;

    return NULL;
}

Error* process_nb_gauss_dtd_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'nb-gauss-dtd' requires an argument");
    }
    opts.nb_gauss_dtd_fname = arg;

    return NULL;
}

Error* process_nb_gmm_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'nb-gmm' requires an argument");
    }
    opts.nb_gmm_fname = arg;

    return NULL;
}

Error* process_nb_gmm_dtd_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'nb-gmm-dtd' requires an argument");
    }
    opts.nb_gmm_dtd_fname = arg;

    return NULL;
}

Error* process_mv_gmm_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'mv-gmm' requires an argument");
    }
    opts.mv_gmm_fname = arg;

    return NULL;
}

Error* process_mv_gmm_dtd_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'mv-gmm-dtd' requires an argument");
    }
    opts.mv_gmm_dtd_fname = arg;

    return NULL;
}

Error* process_mv_mmm_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'mv-mmm' requires an argument");
    }
    opts.mv_mmm_fname = arg;

    return NULL;
}

Error* process_mv_mmm_dtd_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'mv-mmm-dtd' requires an argument");
    }
    opts.mv_mmm_dtd_fname = arg;

    return NULL;
}

#ifdef HAPLO_ENABLE_SVM
Error* process_svm_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'svm' requires an argument");
    }
    opts.svm_fname = arg;

    return NULL;
}

Error* process_svm_dtd_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'svm-dtd' requires an argument");
    }
    opts.svm_dtd_fname = arg;

    return NULL;
}
#endif

#ifdef HAPLO_ENABLE_WEKA
Error* process_weka_j48_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'weka-j48' requires an argument");
    }
    opts.weka_j48_fname = arg;

    return NULL;
}

Error* process_weka_part_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'weka-part' requires an argument");
    }
    opts.weka_part_fname = arg;

    return NULL;
}

Error* process_weka_jar_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'weka-jar' requires an argument");
    }
    opts.weka_jar_fname = arg;

    return NULL;
}

Error* process_weka_dtd_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'weka-dtd' requires an argument");
    }
    opts.weka_dtd_fname = arg;

    return NULL;
}
#endif

Error* process_nearest_max_d_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'nearest-max-d' requires an argument");
    }
    if (sscanf(arg, "%u", &(opts.nearest_max_d)) < 1)
    {
        return JWSC_EARG("Option 'nearest-max-d' must be > 0");
    }

    return NULL;
}

Error* process_nearest_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'nearest' requires an argument");
    }
    opts.nearest_fname = arg;

    return NULL;
}

Error* process_nearest_dtd_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'nearest-dtd' requires an argument");
    }
    opts.nearest_dtd_fname = arg;

    return NULL;
}

Error* process_bmm_tree_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'bmm-tree' requires an argument");
    }
    opts.bmm_tree_fname = arg;

    return NULL;
}

Error* process_bmm_info_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'bmm-info' requires an argument");
    }
    opts.bmm_info_fname = arg;

    return NULL;
}

Error* process_bmm_conf_thresh_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'bmm-conf-thresh' requires an argument");
    }
    opts.bmm_conf_thresh_fname = arg;

    return NULL;
}

Error* process_gmm_bmm_tree_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'gmm-bmm-tree' requires an argument");
    }
    opts.gmm_bmm_tree_fname = arg;

    return NULL;
}

Error* process_gmm_bmm_info_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'gmm-bmm-info' requires an argument");
    }
    opts.gmm_bmm_info_fname = arg;

    return NULL;
}

Error* process_gmm_bmm_conf_thresh_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'gmm-bmm-conf-thresh' requires an argument");
    }
    opts.gmm_bmm_conf_thresh_fname = arg;

    return NULL;
}

void init_options(Option_no_arg* opts_no_arg, Option_with_arg* opts_with_arg)
{
    uint32_t i;

    char s_name;
    const char* l_name;
    const char* desc;

    Error* (*fnoarg)();
    Error* (*farg)(const char*);

    opts.header_in               = HEADER_IN;
    opts.header_out              = HEADER_OUT;
    opts.exclude_one             = EXCLUDE_ONE;
    opts.num_threads             = NUM_THREADS;
    opts.seed                    = 0;
    opts.input_format            = INPUT_FORMAT;
    opts.input_dtd_fname         = INPUT_DTD_FNAME;
    opts.output_format           = OUTPUT_FORMAT;
    opts.labels_fname            = INPUT_DTD_FNAME;
    opts.labels_dtd_fname        = INPUT_DTD_FNAME;
    opts.id_cols                 = NULL;
    opts.first_marker_col        = FIRST_MARKER_COL;
    opts.num_markers             = NUM_MARKERS;
    opts.marker_cols             = NULL;
    opts.aux_id_cols             = NULL;
    opts.aux_label_col           = AUX_LABEL_COL;
    opts.aux_first_marker_col    = AUX_FIRST_MARKER_COL;
    opts.aux_num_markers         = AUX_NUM_MARKERS;
    opts.aux_marker_cols         = NULL;
    opts.num_gmm_markers         = NUM_MARKERS;
    opts.nb_freq_fname           = NB_FREQ_FNAME;
    opts.nb_freq_dtd_fname       = NB_FREQ_DTD_FNAME;
    opts.nb_gauss_fname          = NB_GAUSS_FNAME;
    opts.nb_gauss_dtd_fname      = NB_GAUSS_DTD_FNAME;
    opts.nb_gmm_fname            = NB_GMM_FNAME;
    opts.nb_gmm_dtd_fname        = NB_GMM_DTD_FNAME;
    opts.mv_gmm_fname            = MV_GMM_FNAME;
    opts.mv_gmm_dtd_fname        = MV_GMM_DTD_FNAME;
    opts.mv_mmm_fname            = MV_MMM_FNAME;
    opts.mv_mmm_dtd_fname        = MV_MMM_DTD_FNAME;
#ifdef HAPLO_ENABLE_SVM
    opts.svm_fname               = SVM_FNAME;
    opts.svm_dtd_fname           = SVM_DTD_FNAME;
#endif
#ifdef HAPLO_ENABLE_WEKA
    opts.weka_j48_fname          = WEKA_J48_FNAME;
    opts.weka_part_fname         = WEKA_PART_FNAME;
    opts.weka_jar_fname          = WEKA_JAR_FNAME;
    opts.weka_dtd_fname          = WEKA_DTD_FNAME;
#endif
    opts.nearest_fname             = NEAREST_FNAME;
    opts.nearest_dtd_fname         = NEAREST_DTD_FNAME;
    opts.nearest_max_d             = NEAREST_MAX_D;
    opts.bmm_tree_fname            = BMM_TREE_FNAME;
    opts.bmm_info_fname            = BMM_INFO_FNAME;
    opts.bmm_conf_thresh_fname     = BMM_CONF_THRESH_FNAME;
    opts.gmm_bmm_tree_fname        = GMM_BMM_TREE_FNAME;
    opts.gmm_bmm_info_fname        = GMM_BMM_INFO_FNAME;
    opts.gmm_bmm_conf_thresh_fname = GMM_BMM_CONF_THRESH_FNAME;
    opts.model_dirname             = MODEL_DIRNAME;

    i = 0;
    l_name = "help";
    s_name = 'h';
    desc   = "Prints program usage.";
    fnoarg = process_help_opt;
    init_option_no_arg(&(opts_no_arg[i++]), l_name, s_name, desc, fnoarg);

    l_name = "version";
    s_name = 'v';
    desc   = "Prints program version.";
    fnoarg = process_version_opt;
    init_option_no_arg(&(opts_no_arg[i++]), l_name, s_name, desc, fnoarg);

    l_name = "header-in";
    s_name = 0;
    desc   = "The input data contains a header (descriptive) line, which should be discarded.";
    fnoarg = process_header_in_opt;
    init_option_no_arg(&(opts_no_arg[i++]), l_name, s_name, desc, fnoarg);

    l_name = "header-out";
    s_name = 0;
    desc   = "Write a header (descriptive) line to the first line of the output results.";
    fnoarg = process_header_out_opt;
    init_option_no_arg(&(opts_no_arg[i++]), l_name, s_name, desc, fnoarg);
    assert(i == NUM_SHARED_OPTS_NO_ARG);


    i = 0;
    l_name = "options";
    s_name = 0;
    desc   = "File containing program options. Any options appearing on the command line following this option take precendence over those in the options file.";
    farg   = process_options_opt;
    init_option_with_arg(&(opts_with_arg[i++]), l_name, s_name, desc, farg);

#ifdef HAPLO_HAVE_PTHREAD
    l_name = "num-threads";
    s_name = 0;
    desc   = "Number of concurrent threads to use at any given time.";
    farg   = process_num_threads_opt;
    init_option_with_arg(&(opts_with_arg[i++]), l_name, s_name, desc, farg);
#endif

    l_name = "seed";
    s_name = 0;
    desc   = "Random seed.";
    farg   = process_seed_opt;
    init_option_with_arg(&(opts_with_arg[i++]), l_name, s_name, desc, farg);

    l_name = "input-format";
    s_name = 0;
    desc   = "Input file format. Must be one of {txt, csv, xml}. If the input is XML, it must conform to the XML DTD haplo-input.dtd.";
    farg   = process_input_format_opt;
    init_option_with_arg(&(opts_with_arg[i++]), l_name, s_name, desc, farg);

    l_name = "input-dtd";
    s_name = 0;
    desc   = "If the input format is XML, validate it with this DTD.";
    farg   = process_input_dtd_opt;
    init_option_with_arg(&(opts_with_arg[i++]), l_name, s_name, desc, farg);

    l_name = "output-format";
    s_name = 0;
    desc   = "Output file format. Must be one of {txt, csv, xml}.";
    farg   = process_output_format_opt;
    init_option_with_arg(&(opts_with_arg[i++]), l_name, s_name, desc, farg);

    l_name = "labels";
    s_name = 0;
    desc   = "XML file containing the organization and listing of possible haplo groups labels for the samples. Must conform to the XML DTD haplo-labels.dtd.";
    farg   = process_labels_opt;
    init_option_with_arg(&(opts_with_arg[i++]), l_name, s_name, desc, farg);

    l_name = "labels-dtd";
    s_name = 0;
    desc   = "Validate the XML labels file with this DTD.";
    farg   = process_labels_dtd_opt;
    init_option_with_arg(&(opts_with_arg[i++]), l_name, s_name, desc, farg);

    l_name = "id-cols";
    s_name = 0;
    desc   = "Comma separated ordered list of columns to use for sample identification. Prefixes the output of each sample. Count begins with 1 at the first column of the file. Set to zero to ignore the id column";
    farg   = process_id_cols_opt;
    init_option_with_arg(&(opts_with_arg[i++]), l_name, s_name, desc, farg);

    l_name = "label-col";
    s_name = 0;
    desc   = "Column containing the haplo group labels. Count begins with 1 at the first column of the file. Set to zero to ignore the label column.";
    farg   = process_label_col_opt;
    init_option_with_arg(&(opts_with_arg[i++]), l_name, s_name, desc, farg);

    l_name = "1st-marker-col";
    s_name = 0;
    desc   = "Column containing the first marker. Use in conjunction with num-markers to specify the markers for reading. All other markers are assumed to follow this one. Count begins with 1.";
    farg   = process_first_marker_col_opt;
    init_option_with_arg(&(opts_with_arg[i++]), l_name, s_name, desc, farg);

    l_name = "num-markers";
    s_name = 0;
    desc   = "Number of markers to read. Use in conjunction with 1st-marker-col to specify the markers for reading.";
    farg   = process_num_markers_opt;
    init_option_with_arg(&(opts_with_arg[i++]), l_name, s_name, desc, farg);

    l_name = "marker-cols";
    s_name = 0;
    desc   = "Comma separated ordered list of markers to use for training. Use instead of 1st-marker-col and num-markers. Count begins with 1 at the first column of the CSV file.";
    farg   = process_marker_cols_opt;
    init_option_with_arg(&(opts_with_arg[i++]), l_name, s_name, desc, farg);
    assert(i == NUM_SHARED_OPTS_WITH_ARG);
}