// This file is part of PLINK 1.9, copyright (C) 2005-2024 Shaun Purcell,
// Christopher Chang.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see .
// Uncomment "#define NOLAPACK" in plink_common.h to build without LAPACK.
#include "plink_common.h"
#include
#include
#include
#include
#ifdef __APPLE__
#include
#include
#endif
#include "plink_assoc.h"
#include "plink_calc.h"
#include "plink_cnv.h"
#include "plink_data.h"
#include "plink_dosage.h"
#include "plink_family.h"
#include "plink_filter.h"
#include "plink_glm.h"
#include "plink_help.h"
#include "plink_homozyg.h"
#include "plink_lasso.h"
#include "plink_ld.h"
#include "plink_misc.h"
#include "plink_perm.h"
#ifdef __cplusplus
#ifndef _WIN32
#include "plink_rserve.h"
#endif
#endif
#include "plink_set.h"
#include "plink_stats.h"
#include "pigz.h"
#define DEFAULT_PPC_GAP 500000
#define DEFAULT_IBS_TEST_PERMS 100000
// should switch this to IMPORT_... and make it include .ped/Oxford too; only
// .bed and future .pgen format don't require an import step
#define LOAD_RARE_GRM 1
#define LOAD_RARE_GRM_BIN 2
#define LOAD_RARE_LGEN 4
#define LOAD_RARE_TRANSPOSE 8
#define LOAD_RARE_TPED 0x10
#define LOAD_RARE_TFAM 0x20
#define LOAD_RARE_TRANSPOSE_MASK (LOAD_RARE_TRANSPOSE | LOAD_RARE_TPED | LOAD_RARE_TFAM)
#define LOAD_RARE_DUMMY 0x40
#define LOAD_RARE_SIMULATE 0x80
#define LOAD_RARE_CNV 0x100
#define LOAD_RARE_GVAR 0x200
#define LOAD_RARE_23 0x400
// er, this won't actually be rare...
#define LOAD_RARE_VCF 0x800
#define LOAD_RARE_BCF 0x1000
#define LOAD_RARE_DOSAGE 0x2000
#define LOAD_PARAMS_PED 1
#define LOAD_PARAMS_MAP 2
#define LOAD_PARAMS_TEXT_ALL 3
#define LOAD_PARAMS_BED 4
#define LOAD_PARAMS_BIM 8
#define LOAD_PARAMS_FAM 0x10
#define LOAD_PARAMS_BFILE_ALL 0x1c
#define LOAD_PARAMS_OXGEN 0x20
#define LOAD_PARAMS_OXBGEN 0x40
#define LOAD_PARAMS_OXSAMPLE 0x80
#define LOAD_PARAMS_OX_ALL 0xe0
// maximum number of usable cluster computers, this is arbitrary though it
// shouldn't be larger than 2^31 - 1
#define PARALLEL_MAX 32768
static const char ver_str[] =
#ifdef STABLE_BUILD
"PLINK v1.9.0-b.7.7"
#else
"PLINK v1.9.0-b.8"
#endif
#ifdef NOLAPACK
"NL"
#endif
#ifdef __LP64__
" 64-bit"
#else
" 32-bit"
#endif
" (22 Oct 2024)";
static const char ver_str2[] =
// include leading space if day < 10, so character length stays the same
""
#ifdef STABLE_BUILD
" " // (don't want this when version number has two trailing digits)
#else
" "
#endif
#ifndef NOLAPACK
" "
#endif
" cog-genomics.org/plink/1.9/\n"
"(C) 2005-2024 Shaun Purcell, Christopher Chang GNU General Public License v3"
#if SPECIES_DEFAULT > 0
"\nRecompiled with default species = "
#if SPECIES_DEFAULT == SPECIES_COW
"cow"
#elif SPECIES_DEFAULT == SPECIES_DOG
"dog"
#elif SPECIES_DEFAULT == SPECIES_HORSE
"horse"
#elif SPECIES_DEFAULT == SPECIES_MOUSE
"mouse"
#elif SPECIES_DEFAULT == SPECIES_RICE
"rice"
#elif SPECIES_DEFAULT == SPECIES_SHEEP
"sheep"
#endif
#endif
"\n";
static const char errstr_append[] = "For more information, try \"" PROG_NAME_STR " --help \" or \"" PROG_NAME_STR " --help | more\".\n";
#ifdef STABLE_BUILD
#ifndef NOLAPACK
static const char notestr_null_calc2[] = "Commands include --make-bed, --recode, --flip-scan, --merge-list,\n--write-snplist, --list-duplicate-vars, --freqx, --missing, --test-mishap,\n--hardy, --mendel, --ibc, --impute-sex, --indep-pairphase, --r2, --show-tags,\n--blocks, --distance, --genome, --homozyg, --make-rel, --make-grm-gz,\n--rel-cutoff, --cluster, --pca, --neighbour, --ibs-test, --regress-distance,\n--model, --bd, --gxe, --logistic, --dosage, --lasso, --test-missing,\n--make-perm-pheno, --tdt, --qfam, --annotate, --clump, --gene-report,\n--meta-analysis, --epistasis, --fast-epistasis, and --score.\n\n\"" PROG_NAME_STR " --help | more\" describes all functions (warning: long).\n";
#else
static const char notestr_null_calc2[] = "Commands include --make-bed, --recode, --flip-scan, --merge-list,\n--write-snplist, --list-duplicate-vars, --freqx, --missing, --test-mishap,\n--hardy, --mendel, --ibc, --impute-sex, --indep-pairphase, --r2, --show-tags,\n--blocks, --distance, --genome, --homozyg, --make-rel, --make-grm-gz,\n--rel-cutoff, --cluster, --neighbour, --ibs-test, --regress-distance, --model,\n--bd, --gxe, --logistic, --dosage, --lasso, --test-missing, --make-perm-pheno,\n--tdt, --qfam, --annotate, --clump, --gene-report, --meta-analysis,\n--epistasis, --fast-epistasis, and --score.\n\n\"" PROG_NAME_STR " --help | more\" describes all functions (warning: long).\n";
#endif
#else
#ifndef NOLAPACK
static const char notestr_null_calc2[] = "Commands include --make-bed, --recode, --flip-scan, --merge-list,\n--write-snplist, --list-duplicate-vars, --freqx, --missing, --test-mishap,\n--hardy, --mendel, --ibc, --impute-sex, --indep-pairphase, --r2, --show-tags,\n--blocks, --distance, --genome, --homozyg, --make-rel, --make-grm-gz,\n--rel-cutoff, --cluster, --pca, --neighbour, --ibs-test, --regress-distance,\n--model, --bd, --gxe, --logistic, --dosage, --lasso, --test-missing,\n--make-perm-pheno, --unrelated-heritability, --tdt, --dfam, --qfam, --tucc,\n--annotate, --clump, --gene-report, --meta-analysis, --epistasis,\n--fast-epistasis, and --score.\n\n\"" PROG_NAME_STR " --help | more\" describes all functions (warning: long).\n";
#else
static const char notestr_null_calc2[] = "Commands include --make-bed, --recode, --flip-scan, --merge-list,\n--write-snplist, --list-duplicate-vars, --freqx, --missing, --test-mishap,\n--hardy, --mendel, --ibc, --impute-sex, --indep-pairphase, --r2, --show-tags,\n--blocks, --distance, --genome, --homozyg, --make-rel, --make-grm-gz,\n--rel-cutoff, --cluster, --neighbour, --ibs-test, --regress-distance, --model,\n--bd, --gxe, --logistic, --dosage, --lasso, --test-missing, --make-perm-pheno,\n--tdt, --dfam, --qfam, --tucc, --annotate, --clump, --gene-report,\n--meta-analysis, --epistasis, --fast-epistasis, and --score.\n\n\"" PROG_NAME_STR " --help | more\" describes all functions (warning: long).\n";
#endif
#endif
static const char errstr_nomem[] = "Error: Out of memory. The --memory flag may be helpful.\n";
static const char errstr_write[] = "Error: File write failure.\n";
static const char errstr_read[] = "Error: File read failure.\n";
void disp_exit_msg(int32_t retval) {
switch (retval) {
case RET_NOMEM:
logprint("\n");
logerrprint(errstr_nomem);
if (g_failed_alloc_attempt_size) {
LOGERRPRINTF("Failed allocation size: %" PRIuPTR "\n", g_failed_alloc_attempt_size);
}
break;
case RET_WRITE_FAIL:
logprint("\n");
logerrprint(errstr_write);
break;
case RET_READ_FAIL:
logprint("\n");
logerrprint(errstr_read);
break;
case RET_THREAD_CREATE_FAIL:
logprint("\n");
logerrprint("Error: Failed to create thread.\n");
break;
}
}
// back to our regular program
const unsigned char acgt_reverse_arr[] = "1B2DEF3HIJKLMNOPQRS4";
const unsigned char acgt_arr[] = "ACGT";
// g_one_char_strs offsets (double)
const unsigned char acgt_reverse_arr1[] = "b\204d\210\212\214f\220\222\224\226\230\232\234\236\240\242\244\246h";
const unsigned char acgt_arr1[] = "\202\206\216\250";
// const unsigned char acgt_reverse_arr1[] = "\"D$HJL&PRTVXZ\\^`bdf(";
// const unsigned char acgt_arr1[] = "BFNh";
static inline unsigned char conditional_convert(unsigned char diff, unsigned char ucc2_max, const unsigned char* convert_arr, unsigned char ucc) {
unsigned char ucc2 = ucc - diff;
return (ucc2 < ucc2_max)? convert_arr[ucc2] : ucc;
}
static inline void conditional_convert1(unsigned char diff, unsigned char ucc2_max, const unsigned char* convert_arr, char** allele_ptr) {
unsigned char ucc2 = ((unsigned char)(**allele_ptr)) - diff;
if (ucc2 < ucc2_max) {
*allele_ptr = (char*)(&(g_one_char_strs[convert_arr[ucc2]]));
}
}
void allelexxxx_recode(uint32_t allelexxxx, char** marker_allele_ptrs, uint32_t unfiltered_marker_ct, uintptr_t* marker_exclude, uint32_t marker_ct) {
uint32_t marker_uidx = 0;
uint32_t markers_done = 0;
uint32_t recode_multichar = allelexxxx & ALLELE_RECODE_MULTICHAR;
const unsigned char* convert_arr;
const unsigned char* convert_arr1;
char** map_ptr;
char** map_ptr_stop;
char* cptr;
uint32_t marker_uidx_stop;
unsigned char diff;
unsigned char ucc2_max;
unsigned char ucc;
if (allelexxxx & ALLELE_RECODE_ACGT) {
diff = 49;
ucc2_max = 4;
convert_arr = acgt_arr;
convert_arr1 = acgt_arr1;
} else {
diff = 65;
ucc2_max = 20;
convert_arr = acgt_reverse_arr;
convert_arr1 = acgt_reverse_arr1;
}
while (markers_done < marker_ct) {
marker_uidx = next_unset_unsafe(marker_exclude, marker_uidx);
marker_uidx_stop = next_set(marker_exclude, marker_uidx, unfiltered_marker_ct);
markers_done += marker_uidx_stop - marker_uidx;
map_ptr = &(marker_allele_ptrs[marker_uidx * 2]);
map_ptr_stop = &(marker_allele_ptrs[marker_uidx_stop * 2]);
marker_uidx = marker_uidx_stop;
if (recode_multichar) {
do {
cptr = *map_ptr;
if (!cptr[1]) {
conditional_convert1(diff, ucc2_max, convert_arr1, map_ptr);
} else {
ucc = *cptr;
do {
*cptr = conditional_convert(diff, ucc2_max, convert_arr, ucc);
ucc = *(++cptr);
} while (ucc);
}
} while (++map_ptr < map_ptr_stop);
} else {
do {
if (!(map_ptr[0][1])) {
conditional_convert1(diff, ucc2_max, convert_arr1, map_ptr);
}
} while (++map_ptr < map_ptr_stop);
}
}
}
void calc_marker_reverse_bin(uintptr_t* marker_reverse, uintptr_t* marker_exclude, uint32_t unfiltered_marker_ct, uint32_t marker_ct, double* set_allele_freqs) {
uint32_t marker_uidx = 0;
uint32_t markers_done = 0;
uint32_t marker_uidx_stop;
double dxx;
while (markers_done < marker_ct) {
marker_uidx = next_unset_unsafe(marker_exclude, marker_uidx);
marker_uidx_stop = next_set(marker_exclude, marker_uidx, unfiltered_marker_ct);
markers_done += marker_uidx_stop - marker_uidx;
for (; marker_uidx < marker_uidx_stop; marker_uidx++) {
dxx = set_allele_freqs[marker_uidx];
if (dxx < 0.5) {
SET_BIT(marker_uidx, marker_reverse);
set_allele_freqs[marker_uidx] = 1.0 - dxx;
}
}
}
}
void swap_reversed_marker_alleles(uintptr_t unfiltered_marker_ct, uintptr_t* marker_reverse, char** marker_allele_ptrs) {
uintptr_t marker_uidx = 0;
char* swap_ptr;
while (1) {
next_set_ul_ck(marker_reverse, unfiltered_marker_ct, &marker_uidx);
if (marker_uidx == unfiltered_marker_ct) {
return;
}
swap_ptr = marker_allele_ptrs[marker_uidx * 2];
marker_allele_ptrs[marker_uidx * 2] = marker_allele_ptrs[marker_uidx * 2 + 1];
marker_allele_ptrs[marker_uidx * 2 + 1] = swap_ptr;
marker_uidx++;
}
}
static inline int32_t bed_suffix_conflict(uint64_t calculation_type, uint32_t recode_modifier) {
return (calculation_type & CALC_MAKE_BED) || ((calculation_type & CALC_RECODE) && (recode_modifier & (RECODE_LGEN | RECODE_LGEN_REF | RECODE_RLIST)));
}
static inline uint32_t are_marker_pos_needed(uint64_t calculation_type, uint64_t misc_flags, char* cm_map_fname, char* set_fname, uint32_t min_bp_space, uint32_t genome_skip_write, uint32_t ld_modifier, uint32_t epi_modifier, uint32_t cluster_modifier) {
return (calculation_type & (CALC_MAKE_BED | CALC_MAKE_BIM | CALC_RECODE | CALC_GENOME | CALC_HOMOZYG | CALC_LD_PRUNE | CALC_MODEL | CALC_GLM | CALC_CLUMP | CALC_BLOCKS | CALC_FLIPSCAN | CALC_TDT | CALC_QFAM | CALC_FST | CALC_SHOW_TAGS | CALC_DUPVAR | CALC_RPLUGIN | CALC_TUCC)) || (misc_flags & (MISC_EXTRACT_RANGE | MISC_EXCLUDE_RANGE)) || cm_map_fname || set_fname || min_bp_space || genome_skip_write || ((calculation_type & CALC_LD) && (!(ld_modifier & LD_MATRIX_SHAPEMASK))) || ((calculation_type & CALC_EPI) && (epi_modifier & EPI_FAST_CASE_ONLY)) || ((calculation_type & CALC_CMH) && (!(cluster_modifier & CLUSTER_CMH2)));
}
static inline uint32_t are_marker_cms_needed(uint64_t calculation_type, char* cm_map_fname, Two_col_params* update_cm, Ld_info* ldip) {
if ((calculation_type & CALC_LD) && (!(ldip->modifier & LD_MATRIX_SHAPEMASK)) && (ldip->window_cm != -1)) {
return MARKER_CMS_FORCED;
}
if (calculation_type & (CALC_MAKE_BED | CALC_MAKE_BIM | CALC_RECODE | CALC_TUCC)) {
if (cm_map_fname || update_cm) {
return MARKER_CMS_FORCED;
} else {
return MARKER_CMS_OPTIONAL;
}
}
return 0;
}
static inline uint32_t are_marker_alleles_needed(uint64_t calculation_type, char* freqname, Homozyg_info* homozyg_ptr, Two_col_params* a1alleles, Two_col_params* a2alleles, uint32_t ld_modifier, uint32_t snps_only, uint32_t clump_modifier, uint32_t cluster_modifier, uint32_t rel_modifier) {
return (freqname || (calculation_type & (CALC_FREQ | CALC_HARDY | CALC_MAKE_BED | CALC_MAKE_BIM | CALC_RECODE | CALC_MODEL | CALC_GLM | CALC_LASSO | CALC_LIST_23_INDELS | CALC_EPI | CALC_TESTMISHAP | CALC_SCORE | CALC_MENDEL | CALC_TDT | CALC_FLIPSCAN | CALC_QFAM | CALC_HOMOG | CALC_DUPVAR | CALC_RPLUGIN | CALC_DFAM | CALC_TUCC)) || ((calculation_type & CALC_HOMOZYG) && (homozyg_ptr->modifier & HOMOZYG_GROUP_VERBOSE)) || ((calculation_type & CALC_LD) && (ld_modifier & LD_INPHASE)) || ((calculation_type & CALC_PCA) && (rel_modifier & REL_PCA_VAR_WTS)) || ((calculation_type & CALC_CMH) && (!(cluster_modifier & CLUSTER_CMH2))) || a1alleles || a2alleles || snps_only || (clump_modifier & (CLUMP_VERBOSE | CLUMP_BEST)));
}
static inline int32_t relationship_or_ibc_req(uint64_t calculation_type) {
return (relationship_req(calculation_type) || (calculation_type & CALC_IBC));
}
int32_t plink(char* outname, char* outname_end, char* bedname, char* bimname, char* famname, char* cm_map_fname, char* cm_map_chrname, char* phenoname, char* extractname, char* excludename, char* keepname, char* removename, char* keepfamname, char* removefamname, char* filtername, char* freqname, char* distance_wts_fname, char* read_dists_fname, char* read_dists_id_fname, char* evecname, char* mergename1, char* mergename2, char* mergename3, char* missing_mid_template, char* missing_marker_id_match, char* makepheno_str, char* phenoname_str, Two_col_params* a1alleles, Two_col_params* a2alleles, char* recode_allele_name, char* covar_fname, char* update_alleles_fname, char* read_genome_fname, Two_col_params* qual_filter, Two_col_params* update_chr, Two_col_params* update_cm, Two_col_params* update_map, Two_col_params* update_name, char* update_ids_fname, char* update_parents_fname, char* update_sex_fname, char* loop_assoc_fname, char* flip_fname, char* flip_subset_fname, char* sample_sort_fname, char* filtervals_flattened, char* condition_mname, char* condition_fname, char* filter_attrib_fname, char* filter_attrib_liststr, char* filter_attrib_sample_fname, char* filter_attrib_sample_liststr, char* rplugin_fname, char* rplugin_host_or_socket, int32_t rplugin_port, double qual_min_thresh, double qual_max_thresh, double thin_keep_prob, double thin_keep_sample_prob, uint32_t new_id_max_allele_len, uint32_t thin_keep_ct, uint32_t thin_keep_sample_ct, uint32_t min_bp_space, uint32_t mfilter_col, uint32_t fam_cols, int32_t missing_pheno, char* output_missing_pheno, uint32_t mpheno_col, uint32_t pheno_modifier, Chrom_info* chrom_info_ptr, Oblig_missing_info* om_ip, Family_info* fam_ip, double check_sex_fthresh, double check_sex_mthresh, uint32_t check_sex_f_yobs, uint32_t check_sex_m_yobs, double distance_exp, double min_maf, double max_maf, double geno_thresh, double mind_thresh, double hwe_thresh, double tail_bottom, double tail_top, uint64_t misc_flags, uint64_t filter_flags, uint64_t calculation_type, uint32_t dist_calc_type, uintptr_t groupdist_iters, uint32_t groupdist_d, uintptr_t regress_iters, uint32_t regress_d, uint32_t parallel_idx, uint32_t parallel_tot, uint32_t splitx_bound1, uint32_t splitx_bound2, uint32_t ppc_gap, uint32_t sex_missing_pheno, uint32_t update_sex_col, uint32_t hwe_modifier, uint32_t min_ac, uint32_t max_ac, uint32_t genome_modifier, double genome_min_pi_hat, double genome_max_pi_hat, Homozyg_info* homozyg_ptr, Cluster_info* cluster_ptr, uint32_t neighbor_n1, uint32_t neighbor_n2, Set_info* sip, Ld_info* ldip, Epi_info* epi_ip, Clump_info* clump_ip, Rel_info* relip, Score_info* sc_ip, uint32_t recode_modifier, uint32_t allelexxxx, uint32_t merge_type, uint32_t sample_sort, int32_t marker_pos_start, int32_t marker_pos_end, int32_t snp_window_size, char* markername_from, char* markername_to, char* markername_snp, Range_list* snps_range_list_ptr, uint32_t write_var_range_ct, uint32_t covar_modifier, Range_list* covar_range_list_ptr, uint32_t write_covar_modifier, uint32_t write_covar_dummy_max_categories, uint32_t dupvar_modifier, uint32_t mwithin_col, uint32_t model_modifier, uint32_t model_cell_ct, uint32_t model_mperm_val, uint32_t glm_modifier, double glm_vif_thresh, uint32_t glm_xchr_model, uint32_t glm_mperm_val, Range_list* parameters_range_list_ptr, Range_list* tests_range_list_ptr, double ci_size, double pfilter, double output_min_p, uint32_t mtest_adjust, double adjust_lambda, uint32_t gxe_mcovar, Aperm_info* apip, uint32_t mperm_save, uintptr_t ibs_test_perms, uint32_t perm_batch_size, double lasso_h2, uint32_t lasso_lambda_iters, double lasso_minlambda, Range_list* lasso_select_covars_range_list_ptr, uint32_t testmiss_modifier, uint32_t testmiss_mperm_val, uint32_t permphe_ct, int32_t known_procs, Ll_str** file_delete_list_ptr) {
FILE* bedfile = nullptr;
FILE* phenofile = nullptr;
uintptr_t unfiltered_marker_ct = 0;
uintptr_t* marker_exclude = nullptr;
uintptr_t marker_exclude_ct = 0;
uintptr_t marker_ct = 0;
uintptr_t max_marker_id_blen = 0;
// set_allele_freqs = .bed set bit frequency in middle of loading process, A2
// allele frequency later.
double* set_allele_freqs = nullptr;
uintptr_t unfiltered_sample_ct = 0;
uintptr_t unfiltered_sample_ct4 = 0;
uintptr_t unfiltered_sample_ctl = 0;
uintptr_t* sample_exclude = nullptr;
uintptr_t sample_exclude_ct = 0;
uintptr_t sample_ct = 0;
uint32_t* sample_sort_map = nullptr;
uintptr_t* founder_info = nullptr;
uintptr_t* sex_nm = nullptr;
uintptr_t* sex_male = nullptr;
uint32_t genome_skip_write = (cluster_ptr->ppc != 0.0) && (!(calculation_type & CALC_GENOME)) && (!read_genome_fname);
uint32_t marker_pos_needed = are_marker_pos_needed(calculation_type, misc_flags, cm_map_fname, sip->fname, min_bp_space, genome_skip_write, ldip->modifier, epi_ip->modifier, cluster_ptr->modifier);
uint32_t marker_cms_needed = are_marker_cms_needed(calculation_type, cm_map_fname, update_cm, ldip);
uint32_t marker_alleles_needed = are_marker_alleles_needed(calculation_type, freqname, homozyg_ptr, a1alleles, a2alleles, ldip->modifier, (filter_flags / FILTER_SNPS_ONLY) & 1, clump_ip->modifier, cluster_ptr->modifier, relip->modifier);
// add other nchrobs subscribers later
uint32_t nchrobs_needed = (calculation_type & CALC_GENOME) && freqname;
uint32_t uii = 0;
int64_t llxx = 0;
uint32_t nonfounders = (misc_flags / MISC_NONFOUNDERS) & 1;
uint32_t allow_no_samples = (misc_flags / MISC_ALLOW_NO_SAMPLES) & 1;
uint32_t allow_no_variants = (misc_flags / MISC_ALLOW_NO_VARS) & 1;
uint32_t pheno_all = pheno_modifier & PHENO_ALL;
char* marker_ids = nullptr;
uint32_t* marker_id_htable = nullptr;
uint32_t marker_id_htable_size = 0;
double* marker_cms = nullptr;
// marker_allele_ptrs[2 * i] is id of A1 (usually minor) allele at marker i
// marker_allele_ptrs[2 * i + 1] is id of A2 allele
// Single-character allele names point to g_one_char_strs[]; otherwise
// string allocation occurs on the heap.
char** marker_allele_ptrs = nullptr;
uintptr_t max_marker_allele_blen = 2; // er, this probably should be slen
uintptr_t* marker_reverse = nullptr;
int32_t retval = 0;
uint32_t map_is_unsorted = 0;
uint32_t affection = 0;
uint32_t gender_unk_ct = 0;
uintptr_t* pheno_nm = nullptr;
uintptr_t* pheno_nm_datagen = nullptr; // --make-bed/--recode/--write-covar
uintptr_t* orig_pheno_nm = nullptr; // --all-pheno + --pheno-merge
uintptr_t* pheno_c = nullptr;
uintptr_t* orig_pheno_c = nullptr;
uintptr_t* geno_excl_bitfield = nullptr;
uintptr_t* ac_excl_bitfield = nullptr;
double* pheno_d = nullptr;
double* orig_pheno_d = nullptr;
char* sample_ids = nullptr;
uintptr_t max_sample_id_len = 4;
char* paternal_ids = nullptr;
uintptr_t max_paternal_id_len = 2;
char* maternal_ids = nullptr;
uintptr_t max_maternal_id_len = 2;
unsigned char* bigstack_mark = nullptr;
uintptr_t cluster_ct = 0;
uint32_t* cluster_map = nullptr; // unfiltered sample IDs
// index for cluster_map, length (cluster_ct + 1)
// cluster_starts[n+1] - cluster_starts[n] = length of cluster n (0-based)
uint32_t* cluster_starts = nullptr;
char* cluster_ids = nullptr;
uintptr_t max_cluster_id_len = 2;
double* mds_plot_dmatrix_copy = nullptr;
uintptr_t* cluster_merge_prevented = nullptr;
double* cluster_sorted_ibs = nullptr;
char* cptr = nullptr;
double missing_phenod = (double)missing_pheno;
double ci_zt = 0.0;
uintptr_t bed_offset = 3;
uint32_t* marker_pos = nullptr;
uint32_t hh_exists = 0;
uint32_t pheno_ctrl_ct = 0;
uintptr_t covar_ct = 0;
char* covar_names = nullptr;
uintptr_t max_covar_name_len = 0;
uintptr_t* covar_nm = nullptr;
double* covar_d = nullptr;
uintptr_t* gxe_covar_nm = nullptr;
uintptr_t* gxe_covar_c = nullptr;
uintptr_t* pca_sample_exclude = nullptr;
uintptr_t pca_sample_ct = 0;
uintptr_t ulii = 0;
uint32_t pheno_nm_ct = 0;
uint32_t plink_maxsnp = 0;
uint32_t plink_maxfid = 0;
uint32_t plink_maxiid = 0;
uint32_t max_bim_linelen = 0;
uint32_t sample_male_ct = 0;
uint32_t sample_f_ct = 0;
uint32_t sample_f_male_ct = 0;
unsigned char* bigstack_mark2 = nullptr;
unsigned char* bigstack_mark_precluster = nullptr;
unsigned char* bigstack_mark_postcluster = nullptr;
uint32_t* nchrobs = nullptr;
int32_t* hwe_lls = nullptr;
int32_t* hwe_lhs = nullptr;
int32_t* hwe_hhs = nullptr;
int32_t* hwe_ll_cases = nullptr;
int32_t* hwe_lh_cases = nullptr;
int32_t* hwe_hh_cases = nullptr;
int32_t* hwe_ll_allfs = nullptr;
int32_t* hwe_lh_allfs = nullptr;
int32_t* hwe_hh_allfs = nullptr;
int32_t* hwe_hapl_allfs = nullptr;
int32_t* hwe_haph_allfs = nullptr;
pthread_t threads[MAX_THREADS];
uint32_t* uiptr;
double* rel_ibc;
uintptr_t uljj;
uint32_t ujj;
uint32_t ukk;
char* outname_end2;
int32_t ii;
int64_t llyy;
int64_t llzz;
Pedigree_rel_info pri;
uintptr_t marker_uidx;
if ((cm_map_fname || update_cm) && (!marker_cms_needed)) {
LOGERRPRINTF("Error: --%s results would never be used. (Did you forget --make-bed?)\n", cm_map_fname? "cm-map" : "update-cm");
goto plink_ret_INVALID_CMDLINE;
} else if (update_map && (!marker_pos_needed)) {
logerrprint("Error: --update-map results would never be used. (Did you forget --make-bed?)\n");
goto plink_ret_INVALID_CMDLINE;
}
if (ci_size != 0.0) {
ci_zt = ltqnorm(1 - (1 - ci_size) / 2);
}
if (relip->modifier & REL_CALC_COV) {
relip->ibc_type = -1;
}
// famname[0] is nonzero iff we're not in the --merge-list special case
if ((calculation_type & CALC_MAKE_BED) && famname[0]) {
#ifdef _WIN32
uii = GetFullPathName(bedname, FNAMESIZE, g_textbuf, nullptr);
if ((!uii) || (uii > FNAMESIZE))
#else
if (!realpath(bedname, g_textbuf))
#endif
{
uii = strlen(bedname);
if ((uii > 8) && ((!memcmp(&(bedname[uii - 8]), ".bed.bed", 8)) || (!memcmp(&(bedname[uii - 8]), ".bim.bed", 8)) || (!memcmp(&(bedname[uii - 8]), ".fam.bed", 8)))) {
LOGERRPRINTFWW("Error: Failed to open %s. (--bfile expects a filename *prefix*; '.bed', '.bim', and '.fam' are automatically appended.)\n", bedname);
} else {
LOGERRPRINTFWW(g_errstr_fopen, bedname);
}
goto plink_ret_OPEN_FAIL;
}
memcpy(outname_end, ".bed", 5);
if (realpath_identical(outname, g_textbuf, &(g_textbuf[FNAMESIZE + 64]))) {
logerrprint("Warning: --make-bed input and output filenames match. Appending '~' to input\nfilenames.\n");
uii = strlen(bedname);
memcpy(g_textbuf, bedname, uii + 1);
memcpy(&(bedname[uii]), "~", 2);
if (rename(g_textbuf, bedname)) {
logerrprint("Error: Failed to append '~' to input .bed filename.\n");
goto plink_ret_OPEN_FAIL;
}
uii = strlen(bimname);
memcpy(g_textbuf, bimname, uii + 1);
memcpy(&(bimname[uii]), "~", 2);
if (rename(g_textbuf, bimname)) {
logerrprint("Error: Failed to append '~' to input .bim filename.\n");
goto plink_ret_OPEN_FAIL;
}
uii = strlen(famname);
memcpy(g_textbuf, famname, uii + 1);
memcpy(&(famname[uii]), "~", 2);
if (rename(g_textbuf, famname)) {
logerrprint("Error: Failed to append '~' to input .fam filename.\n");
goto plink_ret_OPEN_FAIL;
}
}
}
if (calculation_type & CALC_MERGE) {
if (((fam_cols & FAM_COL_13456) != FAM_COL_13456) || (misc_flags & MISC_AFFECTION_01) || (missing_pheno != -9)) {
logerrprint("Error: --merge/--bmerge/--merge-list cannot be used with an irregularly\nformatted reference fileset (--no-fid, --no-parents, --no-sex, --no-pheno,\n--1, --missing-pheno). Use --make-bed first.\n");
goto plink_ret_INVALID_CMDLINE;
}
// Only append -merge to the filename stem if --make-bed or --recode lgen
// is specified.
// bugfix: also no need if --merge-mode 6 or 7.
ulii = ((merge_type & MERGE_MODE_MASK) < 6) && bed_suffix_conflict(calculation_type, recode_modifier);
if (ulii) {
memcpy(outname_end, "-merge", 6);
}
retval = merge_datasets(bedname, bimname, famname, outname, ulii? &(outname_end[6]) : outname_end, mergename1, mergename2, mergename3, sample_sort_fname, calculation_type, merge_type, sample_sort, misc_flags, chrom_info_ptr);
if (retval || (!(calculation_type & (~CALC_MERGE)))) {
goto plink_ret_1;
}
if ((merge_type & MERGE_MODE_MASK) < 6) {
uljj = (uintptr_t)(outname_end - outname) + (ulii? 6 : 0);
memcpy(memcpya(bedname, outname, uljj), ".bed", 5);
memcpy(memcpya(famname, bedname, uljj), ".fam", 5);
memcpy(memcpya(bimname, bedname, uljj), ".bim", 5);
if ((calculation_type & CALC_MAKE_BED) && ulii) {
if (push_ll_str(bedname, file_delete_list_ptr) || push_ll_str(famname, file_delete_list_ptr) || push_ll_str(bimname, file_delete_list_ptr)) {
goto plink_ret_NOMEM;
}
}
}
// do we want to permit other operations with --merge-mode 6/7 at all?
// seems like a recipe for confusion...
}
// don't use fopen_checked() here, since we want to customize the error
// message.
if (bedname[0]) {
bedfile = fopen(bedname, FOPEN_RB);
if (!bedfile) {
uii = strlen(bedname);
if ((uii > 8) && ((!memcmp(&(bedname[uii - 8]), ".bed.bed", 8)) || (!memcmp(&(bedname[uii - 8]), ".bim.bed", 8)) || (!memcmp(&(bedname[uii - 8]), ".fam.bed", 8)))) {
LOGERRPRINTFWW("Error: Failed to open %s. (--bfile expects a filename *prefix*; '.bed', '.bim', and '.fam' are automatically appended.)\n", bedname);
} else {
LOGERRPRINTFWW(g_errstr_fopen, bedname);
}
goto plink_ret_OPEN_FAIL;
}
}
// load .bim, count markers, filter chromosomes
if (bimname[0]) {
if (update_name) {
ulii = 0;
retval = scan_max_strlen(update_name->fname, update_name->colid, update_name->colx, update_name->skip, update_name->skipchar, &max_marker_id_blen, &ulii);
if (retval) {
goto plink_ret_1;
}
if (ulii > 80) {
// only warn on long new marker ID, since if there's a long old marker
// ID and no long new one, it's reasonable to infer that the user is
// fixing the problem, so we shouldn't spam them.
logerrprint("Warning: Unusually long new variant ID(s) in --update-name file. Double-check\nyour file and command-line parameters, and consider changing your naming\nscheme if you encounter memory problems.\n");
}
if (ulii > max_marker_id_blen) {
max_marker_id_blen = ulii;
}
}
if (!marker_alleles_needed) {
allelexxxx = 0;
}
retval = load_bim(bimname, &unfiltered_marker_ct, &marker_exclude_ct, &max_marker_id_blen, &marker_exclude, &set_allele_freqs, nchrobs_needed? (&nchrobs) : nullptr, &marker_allele_ptrs, &max_marker_allele_blen, &marker_ids, missing_mid_template, new_id_max_allele_len, missing_marker_id_match, chrom_info_ptr, &marker_cms, &marker_pos, misc_flags, filter_flags, marker_pos_start, marker_pos_end, snp_window_size, markername_from, markername_to, markername_snp, &map_is_unsorted, marker_pos_needed, marker_cms_needed, marker_alleles_needed, ((!(calculation_type & (~(CALC_MAKE_BED | CALC_MAKE_BIM | CALC_MAKE_FAM)))) && (mind_thresh == 1.0) && (geno_thresh == 1.0) && (hwe_thresh == 0.0) && (!update_map) && (!freqname))? nullptr : "make-bed", ".bim file", &max_bim_linelen);
if (retval) {
goto plink_ret_1;
}
if (!update_chr) {
if (finalize_chrom_info(chrom_info_ptr)) {
goto plink_ret_NOMEM;
}
}
}
// load .fam, count samples
if (famname[0]) {
uii = fam_cols & FAM_COL_6;
if (uii && phenoname) {
uii = (pheno_modifier & PHENO_MERGE) && (!makepheno_str);
}
if (!uii) {
pheno_modifier &= ~PHENO_MERGE; // nothing to merge
}
if (update_ids_fname) {
ulii = 0;
retval = scan_max_fam_indiv_strlen(update_ids_fname, 3, &max_sample_id_len);
if (retval) {
goto plink_ret_1;
}
} else if (update_parents_fname) {
retval = scan_max_strlen(update_parents_fname, 3, 4, 0, '\0', &max_paternal_id_len, &max_maternal_id_len);
if (retval) {
goto plink_ret_1;
}
}
retval = load_fam(famname, fam_cols, uii, missing_pheno, (misc_flags / MISC_AFFECTION_01) & 1, &unfiltered_sample_ct, &sample_ids, &max_sample_id_len, &paternal_ids, &max_paternal_id_len, &maternal_ids, &max_maternal_id_len, &sex_nm, &sex_male, &affection, &pheno_nm, &pheno_c, &pheno_d, &founder_info, &sample_exclude, allow_no_samples);
if (retval) {
goto plink_ret_1;
}
unfiltered_sample_ct4 = (unfiltered_sample_ct + 3) / 4;
unfiltered_sample_ctl = BITCT_TO_WORDCT(unfiltered_sample_ct);
if (misc_flags & MISC_MAKE_FOUNDERS_FIRST) {
if (make_founders(unfiltered_sample_ct, unfiltered_sample_ct, sample_ids, max_sample_id_len, paternal_ids, max_paternal_id_len, maternal_ids, max_maternal_id_len, (misc_flags / MISC_MAKE_FOUNDERS_REQUIRE_2_MISSING) & 1, sample_exclude, founder_info)) {
goto plink_ret_NOMEM;
}
}
if ((pheno_modifier & PHENO_MERGE) && pheno_all) {
if (aligned_malloc(unfiltered_sample_ctl * sizeof(intptr_t), &orig_pheno_nm)) {
goto plink_ret_NOMEM;
}
memcpy(orig_pheno_nm, pheno_nm, unfiltered_sample_ctl * sizeof(intptr_t));
if (pheno_c) {
if (aligned_malloc(unfiltered_sample_ctl * sizeof(intptr_t), &orig_pheno_c)) {
goto plink_ret_NOMEM;
}
memcpy(orig_pheno_c, pheno_c, unfiltered_sample_ctl * sizeof(intptr_t));
} else if (pheno_d) {
orig_pheno_d = (double*)malloc(unfiltered_sample_ct * sizeof(double));
if (!orig_pheno_d) {
goto plink_ret_NOMEM;
}
memcpy(orig_pheno_d, pheno_d, unfiltered_sample_ct * sizeof(double));
}
}
count_genders(sex_nm, sex_male, sample_exclude, unfiltered_sample_ct, &uii, &ujj, &gender_unk_ct);
if (gender_unk_ct) {
LOGPRINTF("%" PRIuPTR " %s (%u male%s, %u female%s, %u ambiguous) loaded from .fam.\n", unfiltered_sample_ct, species_str(unfiltered_sample_ct), uii, (uii == 1)? "" : "s", ujj, (ujj == 1)? "" : "s", gender_unk_ct);
retval = write_nosex(outname, outname_end, unfiltered_sample_ct, sample_exclude, sex_nm, gender_unk_ct, sample_ids, max_sample_id_len);
if (retval) {
goto plink_ret_1;
}
} else {
LOGPRINTF("%" PRIuPTR " %s (%d male%s, %d female%s) loaded from .fam.\n", unfiltered_sample_ct, species_str(unfiltered_sample_ct), uii, (uii == 1)? "" : "s", ujj, (ujj == 1)? "" : "s");
}
if (unfiltered_sample_ct) {
uii = popcount_longs(pheno_nm, unfiltered_sample_ctl);
if (uii) {
LOGPRINTF("%u phenotype value%s loaded from .fam.\n", uii, (uii == 1)? "" : "s");
}
if (phenoname && fopen_checked(phenoname, "r", &phenofile)) {
goto plink_ret_OPEN_FAIL;
}
if (phenofile || update_ids_fname || update_parents_fname || update_sex_fname || (filter_flags & FILTER_TAIL_PHENO)) {
bigstack_mark = g_bigstack_base;
retval = sort_item_ids(unfiltered_sample_ct, sample_exclude, 0, sample_ids, max_sample_id_len, 0, 0, strcmp_deref, &cptr, &uiptr);
if (retval) {
goto plink_ret_1;
}
if (makepheno_str) {
retval = makepheno_load(phenofile, makepheno_str, unfiltered_sample_ct, cptr, max_sample_id_len, uiptr, pheno_nm, &pheno_c);
if (retval) {
goto plink_ret_1;
}
} else if (phenofile) {
retval = load_pheno(phenofile, unfiltered_sample_ct, 0, cptr, max_sample_id_len, uiptr, missing_pheno, (misc_flags / MISC_AFFECTION_01) & 1, mpheno_col, phenoname_str, pheno_nm, &pheno_c, &pheno_d, nullptr, 0);
if (retval) {
if (retval == LOAD_PHENO_LAST_COL) {
logerrprintb();
retval = RET_INVALID_FORMAT;
bigstack_reset(bigstack_mark);
}
goto plink_ret_1;
}
}
if (filter_flags & FILTER_TAIL_PHENO) {
retval = convert_tail_pheno(unfiltered_sample_ct, pheno_nm, &pheno_c, &pheno_d, tail_bottom, tail_top, missing_phenod);
if (retval) {
goto plink_ret_1;
}
}
bigstack_reset(bigstack_mark);
}
if (pheno_c) {
if (calculation_type & (CALC_REGRESS_REL | CALC_REGRESS_DISTANCE | CALC_UNRELATED_HERITABILITY | CALC_GXE)) {
if (calculation_type & CALC_REGRESS_REL) {
logerrprint("Error: --regress-rel calculation requires a scalar phenotype.\n");
} else if (calculation_type & CALC_REGRESS_DISTANCE) {
logerrprint("Error: --regress-distance calculation requires a scalar phenotype.\n");
} else if (calculation_type & CALC_UNRELATED_HERITABILITY) {
logerrprint("Error: --unrelated-heritability requires a scalar phenotype.\n");
} else if (calculation_type & CALC_GXE) {
logerrprint("Error: --gxe requires a scalar phenotype.\n");
}
goto plink_ret_INVALID_CMDLINE;
}
} else {
if (calculation_type & CALC_CLUSTER) {
if (cluster_ptr->modifier & CLUSTER_CC) {
logerrprint("Error: --cc requires a case/control phenotype.\n");
goto plink_ret_INVALID_CMDLINE;
} else if ((cluster_ptr->max_cases != 0xffffffffU) || (cluster_ptr->max_ctrls != 0xffffffffU)) {
logerrprint("Error: --mcc requires a case/control phenotype.\n");
goto plink_ret_INVALID_CMDLINE;
}
} else if ((calculation_type & CALC_EPI) && (epi_ip->modifier & EPI_FAST)) {
logerrprint("Error: --fast-epistasis requires a case/control phenotype.\n");
goto plink_ret_INVALID_CMDLINE;
} else if (calculation_type & (CALC_IBS_TEST | CALC_GROUPDIST | CALC_FLIPSCAN)) {
if (calculation_type & (CALC_IBS_TEST | CALC_GROUPDIST)) {
logerrprint("Error: --ibs-test and --groupdist calculations require a case/control\nphenotype.\n");
} else if (calculation_type & CALC_FLIPSCAN) {
logerrprint("Error: --flip-scan requires a case/control phenotype.\n");
}
goto plink_ret_INVALID_CMDLINE;
} else if ((calculation_type & CALC_RECODE) && (recode_modifier & (RECODE_HV | RECODE_HV_1CHR))) {
logerrprint("Error: --recode HV{-1chr} requires a case/control phenotype.\n");
goto plink_ret_INVALID_CMDLINE;
} else if ((calculation_type & CALC_FST) && (misc_flags & MISC_FST_CC)) {
logerrprint("Error: \"--fst case-control\" requires a case/control phenotype.\n");
goto plink_ret_INVALID_CMDLINE;
} else if ((calculation_type & CALC_FREQ) && (misc_flags & MISC_FREQ_CC)) {
logerrprint("Error: \"--freq case-control\" requires a case/control phenotype.\n");
goto plink_ret_INVALID_CMDLINE;
}
}
if (!pheno_all) {
if (loop_assoc_fname || (!pheno_d)) {
if ((calculation_type & CALC_GLM) && (!(glm_modifier & GLM_LOGISTIC))) {
logerrprint("Error: --linear without --all-pheno requires a scalar phenotype.\n");
goto plink_ret_INVALID_CMDLINE;
} else if (calculation_type & CALC_QFAM) {
logerrprint("Error: QFAM test requires a scalar phenotype.\n");
goto plink_ret_INVALID_CMDLINE;
}
} else if (!pheno_c) {
if ((calculation_type & CALC_MODEL) && (!(model_modifier & MODEL_ASSOC))) {
logerrprint("Error: --model requires a case/control phenotype.\n");
goto plink_ret_INVALID_CMDLINE;
} else if ((calculation_type & CALC_GLM) && (glm_modifier & GLM_LOGISTIC)) {
logerrprint("Error: --logistic without --all-pheno requires a case/control phenotype.\n");
goto plink_ret_INVALID_CMDLINE;
} else if (calculation_type & (CALC_CMH | CALC_HOMOG | CALC_TESTMISS | CALC_TDT | CALC_DFAM)) {
if (calculation_type & CALC_CMH) {
logerrprint("Error: --mh and --mh2 require a case/control phenotype.\n");
} else if (calculation_type & CALC_HOMOG) {
logerrprint("Error: --homog requires a case/control phenotype.\n");
} else if (calculation_type & CALC_TESTMISS) {
logerrprint("Error: --test-missing requires a case/control phenotype.\n");
} else if (calculation_type & CALC_TDT) {
logerrprint("Error: --tdt requires a case/control phenotype.\n");
} else {
logerrprint("Error: --dfam requires a case/control phenotype.\n");
}
goto plink_ret_INVALID_CMDLINE;
}
}
}
}
}
if (cm_map_fname && unfiltered_marker_ct) {
// need sorted bps, but not marker IDs
if (map_is_unsorted & UNSORTED_BP) {
logerrprint("Error: --cm-map requires a sorted .bim file. Retry this command after using\n--make-bed to sort your data.\n");
goto plink_ret_INVALID_FORMAT;
}
retval = apply_cm_map(cm_map_fname, cm_map_chrname, unfiltered_marker_ct, marker_exclude, marker_pos, marker_cms, chrom_info_ptr);
if (retval) {
goto plink_ret_1;
}
}
if (unfiltered_marker_ct != marker_exclude_ct) {
// bugfix (12 Oct 2017): Previous plink 1.9 implementation of
// --{exclude-}snps could affect unwanted variants at the same position as
// named variant(s). Backport plink 2.0's safe implementation. This has
// the drawback of sometimes increasing the overhead associated with
// --snps, but we can live with that.
uii = update_cm || update_map || update_name || (marker_alleles_needed && (update_alleles_fname || (flip_fname && (!flip_subset_fname)))) || filter_attrib_fname || qual_filter || snps_range_list_ptr->names;
if (uii || extractname || excludename) {
// only permit duplicate marker IDs for --extract/--exclude
bigstack_mark = g_bigstack_base;
retval = alloc_and_populate_id_htable(unfiltered_marker_ct, marker_exclude, unfiltered_marker_ct - marker_exclude_ct, marker_ids, max_marker_id_blen, !uii, &marker_id_htable_size, &marker_id_htable);
if (retval) {
goto plink_ret_1;
}
if (snps_range_list_ptr->names) {
retval = snps_flag(marker_ids, marker_id_htable, snps_range_list_ptr, unfiltered_marker_ct, max_marker_id_blen, marker_id_htable_size, (filter_flags / FILTER_EXCLUDE_MARKERNAME_SNP) & 1, marker_exclude, &marker_exclude_ct);
if (retval) {
goto plink_ret_1;
}
}
if (update_cm) {
retval = update_marker_cms(update_cm, marker_id_htable, marker_id_htable_size, marker_ids, max_marker_id_blen, unfiltered_marker_ct, marker_cms);
if (retval) {
goto plink_ret_1;
}
}
if (update_map) {
retval = update_marker_pos(update_map, marker_id_htable, marker_id_htable_size, marker_ids, max_marker_id_blen, unfiltered_marker_ct, marker_exclude, &marker_exclude_ct, marker_pos, &map_is_unsorted, chrom_info_ptr);
if (retval) {
goto plink_ret_1;
}
} else if (update_name) {
retval = update_marker_names(update_name, marker_id_htable, marker_id_htable_size, marker_ids, max_marker_id_blen, unfiltered_marker_ct);
if (retval) {
goto plink_ret_1;
}
if (update_alleles_fname || (marker_alleles_needed && flip_fname && (!flip_subset_fname)) || extractname || excludename) {
bigstack_reset(bigstack_mark);
retval = alloc_and_populate_id_htable(unfiltered_marker_ct, marker_exclude, unfiltered_marker_ct - marker_exclude_ct, marker_ids, max_marker_id_blen, 0, &marker_id_htable_size, &marker_id_htable);
if (retval) {
goto plink_ret_1;
}
}
}
if (marker_alleles_needed) {
if (update_alleles_fname) {
retval = update_marker_alleles(update_alleles_fname, marker_id_htable, marker_id_htable_size, marker_ids, max_marker_id_blen, unfiltered_marker_ct, marker_exclude, marker_allele_ptrs, &max_marker_allele_blen, outname, outname_end);
if (retval) {
goto plink_ret_1;
}
}
if (flip_fname && (!flip_subset_fname)) {
retval = flip_strand(flip_fname, marker_id_htable, marker_id_htable_size, marker_ids, max_marker_id_blen, unfiltered_marker_ct, marker_exclude, marker_allele_ptrs);
if (retval) {
goto plink_ret_1;
}
}
}
if (extractname) {
if (!(misc_flags & MISC_EXTRACT_RANGE)) {
retval = extract_exclude_flag_norange(extractname, marker_id_htable, marker_id_htable_size, 0, marker_ids, max_marker_id_blen, unfiltered_marker_ct, marker_exclude, &marker_exclude_ct, allow_no_variants);
if (retval) {
goto plink_ret_1;
}
} else {
if (map_is_unsorted & UNSORTED_BP) {
logerrprint("Error: \"--extract range\" requires a sorted .bim. Retry this command after\nusing --make-bed to sort your data.\n");
goto plink_ret_INVALID_CMDLINE;
}
retval = extract_exclude_range(extractname, marker_pos, unfiltered_marker_ct, marker_exclude, &marker_exclude_ct, 0, allow_no_variants, (misc_flags / MISC_ALLOW_EXTRA_CHROMS) & 1, chrom_info_ptr);
if (retval) {
goto plink_ret_1;
}
uljj = unfiltered_marker_ct - marker_exclude_ct;
LOGPRINTF("--extract range: %" PRIuPTR " variant%s remaining.\n", uljj, (uljj == 1)? "" : "s");
}
}
if (excludename) {
if (!(misc_flags & MISC_EXCLUDE_RANGE)) {
retval = extract_exclude_flag_norange(excludename, marker_id_htable, marker_id_htable_size, 1, marker_ids, max_marker_id_blen, unfiltered_marker_ct, marker_exclude, &marker_exclude_ct, allow_no_variants);
if (retval) {
goto plink_ret_1;
}
} else {
if (map_is_unsorted & UNSORTED_BP) {
logerrprint("Error: \"--exclude range\" requires a sorted .bim. Retry this command after\nusing --make-bed to sort your data.\n");
goto plink_ret_INVALID_CMDLINE;
}
retval = extract_exclude_range(excludename, marker_pos, unfiltered_marker_ct, marker_exclude, &marker_exclude_ct, 1, allow_no_variants, (misc_flags / MISC_ALLOW_EXTRA_CHROMS) & 1, chrom_info_ptr);
if (retval) {
goto plink_ret_1;
}
uljj = unfiltered_marker_ct - marker_exclude_ct;
LOGPRINTF("--exclude range: %" PRIuPTR " variant%s remaining.\n", uljj, (uljj == 1)? "" : "s");
}
}
if (filter_attrib_fname) {
retval = filter_attrib(filter_attrib_fname, filter_attrib_liststr, marker_id_htable, marker_id_htable_size, allow_no_variants, marker_ids, max_marker_id_blen, unfiltered_marker_ct, marker_exclude, &marker_exclude_ct);
if (retval) {
goto plink_ret_1;
}
}
if (qual_filter) {
retval = filter_qual_scores(qual_filter, qual_min_thresh, qual_max_thresh, marker_id_htable, marker_id_htable_size, allow_no_variants, marker_ids, max_marker_id_blen, unfiltered_marker_ct, marker_exclude, &marker_exclude_ct);
if (retval) {
goto plink_ret_1;
}
}
bigstack_reset(bigstack_mark);
}
if (allelexxxx) {
allelexxxx_recode(allelexxxx, marker_allele_ptrs, unfiltered_marker_ct, marker_exclude, unfiltered_marker_ct - marker_exclude_ct);
}
if (thin_keep_prob != 1.0) {
if (random_thin_markers(thin_keep_prob, unfiltered_marker_ct, marker_exclude, &marker_exclude_ct, allow_no_variants)) {
goto plink_ret_ALL_MARKERS_EXCLUDED;
}
} else if (thin_keep_ct != 0xffffffffU) {
retval = random_thin_markers_ct(thin_keep_ct, unfiltered_marker_ct, marker_exclude, &marker_exclude_ct);
if (retval) {
goto plink_ret_1;
}
}
}
if (bedfile) {
if (fseeko(bedfile, 0, SEEK_END)) {
goto plink_ret_READ_FAIL;
}
llxx = ftello(bedfile);
if (!llxx) {
logerrprint("Error: Empty .bed file.\n");
goto plink_ret_INVALID_FORMAT;
}
rewind(bedfile);
uii = fread(g_textbuf, 1, 3, bedfile);
llyy = ((uint64_t)unfiltered_sample_ct4) * unfiltered_marker_ct;
llzz = ((uint64_t)unfiltered_sample_ct) * ((unfiltered_marker_ct + 3) / 4);
if ((uii == 3) && (!memcmp(g_textbuf, "l\x1b\x01", 3))) {
llyy += 3;
} else if ((uii == 3) && (!memcmp(g_textbuf, "l\x1b", 3))) {
// v1.00 sample-major
llyy = llzz + 3;
bed_offset = 2;
} else if (uii && (*g_textbuf == '\x01')) {
// v0.99 SNP-major
llyy += 1;
bed_offset = 1;
} else if (uii && (!(*g_textbuf))) {
// v0.99 sample-major
llyy = llzz + 1;
bed_offset = 2;
} else {
// pre-v0.99, sample-major, no header bytes
if (llxx != llzz) {
// probably not PLINK-format at all, so give this error instead of
// "invalid file size"
logerrprint("Error: Invalid header bytes in .bed file.\n");
goto plink_ret_INVALID_FORMAT;
}
llyy = llzz;
bed_offset = 2;
}
if (llxx != llyy) {
if ((*g_textbuf == '#') || ((uii == 3) && (!memcmp(g_textbuf, "chr", 3)))) {
logerrprint("Error: Invalid header bytes in PLINK 1 .bed file. (Is this a UCSC Genome\nBrowser BED file instead?)\n");
goto plink_ret_INVALID_FORMAT;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid .bed file size (expected %" PRId64 " bytes).\n", llyy);
goto plink_ret_INVALID_FORMAT_2;
}
}
if (bed_offset == 2) {
strcpy(outname_end, ".bed.vmaj"); // not really temporary
logprint("Sample-major .bed file detected. Transposing...\n");
fclose(bedfile);
retval = sample_major_to_snp_major(bedname, outname, unfiltered_marker_ct, unfiltered_sample_ct, llxx);
if (retval) {
goto plink_ret_1;
}
LOGPRINTFWW("Variant-major .bed written to %s .\n", outname);
strcpy(bedname, outname);
if (fopen_checked(bedname, FOPEN_RB, &bedfile)) {
goto plink_ret_OPEN_FAIL;
}
bed_offset = 3;
}
}
if (unfiltered_sample_ct && (update_ids_fname || update_parents_fname || update_sex_fname || keepname || keepfamname || removename || removefamname || filter_attrib_sample_fname || om_ip->marker_fname || filtername)) {
bigstack_mark = g_bigstack_base;
retval = sort_item_ids(unfiltered_sample_ct, sample_exclude, 0, sample_ids, max_sample_id_len, 0, 0, strcmp_deref, &cptr, &uiptr);
if (retval) {
goto plink_ret_1;
}
if (update_ids_fname) {
retval = update_sample_ids(update_ids_fname, cptr, unfiltered_sample_ct, max_sample_id_len, uiptr, sample_ids);
if (retval) {
goto plink_ret_1;
}
bigstack_reset(g_bigstack_base);
retval = sort_item_ids(unfiltered_sample_ct, sample_exclude, 0, sample_ids, max_sample_id_len, 0, 0, strcmp_deref, &cptr, &uiptr);
if (retval) {
goto plink_ret_1;
}
} else {
if (update_parents_fname) {
retval = update_sample_parents(update_parents_fname, cptr, unfiltered_sample_ct, max_sample_id_len, uiptr, paternal_ids, max_paternal_id_len, maternal_ids, max_maternal_id_len, founder_info);
if (retval) {
goto plink_ret_1;
}
}
if (update_sex_fname) {
retval = update_sample_sexes(update_sex_fname, update_sex_col, cptr, unfiltered_sample_ct, max_sample_id_len, uiptr, sex_nm, sex_male);
if (retval) {
goto plink_ret_1;
}
}
}
// sample_exclude_ct assumed to be 0 before this point
if (keepfamname) {
retval = keep_or_remove(keepfamname, cptr, unfiltered_sample_ct, max_sample_id_len, uiptr, unfiltered_sample_ct, sample_exclude, &sample_exclude_ct, 2, allow_no_samples);
if (retval) {
goto plink_ret_1;
}
}
if (keepname) {
retval = keep_or_remove(keepname, cptr, unfiltered_sample_ct, max_sample_id_len, uiptr, unfiltered_sample_ct, sample_exclude, &sample_exclude_ct, 0, allow_no_samples);
if (retval) {
goto plink_ret_1;
}
}
if (removefamname) {
retval = keep_or_remove(removefamname, cptr, unfiltered_sample_ct, max_sample_id_len, uiptr, unfiltered_sample_ct, sample_exclude, &sample_exclude_ct, 3, allow_no_samples);
if (retval) {
goto plink_ret_1;
}
}
if (removename) {
retval = keep_or_remove(removename, cptr, unfiltered_sample_ct, max_sample_id_len, uiptr, unfiltered_sample_ct, sample_exclude, &sample_exclude_ct, 1, allow_no_samples);
if (retval) {
goto plink_ret_1;
}
}
if (filter_attrib_sample_fname) {
retval = filter_attrib_sample(filter_attrib_sample_fname, filter_attrib_sample_liststr, cptr, unfiltered_sample_ct, max_sample_id_len, uiptr, unfiltered_sample_ct, allow_no_samples, sample_exclude, &sample_exclude_ct);
if (retval) {
goto plink_ret_1;
}
}
if (om_ip->marker_fname) {
// would rather do this with pre-sorted markers, but that might break
// order-of-operations assumptions in existing pipelines
if ((unfiltered_sample_ct == sample_exclude_ct) || (unfiltered_marker_ct == marker_exclude_ct)) {
// don't need this if everything that refers to om_ip is skipped
oblig_missing_cleanup(om_ip);
om_ip->cluster_ct = 0;
om_ip->entry_ct = 0;
} else {
retval = load_oblig_missing(bedfile, bed_offset, unfiltered_marker_ct, marker_exclude, marker_exclude_ct, marker_ids, max_marker_id_blen, cptr, unfiltered_sample_ct, max_sample_id_len, uiptr, unfiltered_sample_ct, sex_male, chrom_info_ptr, om_ip);
if (retval) {
goto plink_ret_1;
}
}
}
if (filtername) {
if (!mfilter_col) {
mfilter_col = 1;
}
retval = filter_samples_file(filtername, cptr, unfiltered_sample_ct, max_sample_id_len, uiptr, unfiltered_sample_ct, sample_exclude, &sample_exclude_ct, filtervals_flattened, mfilter_col, allow_no_samples);
if (retval) {
goto plink_ret_1;
}
}
bigstack_reset(bigstack_mark);
}
if (famname[0] && (unfiltered_sample_ct != sample_exclude_ct)) {
if (gender_unk_ct && (!(sex_missing_pheno & ALLOW_NO_SEX))) {
uii = popcount_longs_exclude(pheno_nm, sex_nm, unfiltered_sample_ctl);
if (uii) {
if ((!sex_missing_pheno) && (calculation_type & (CALC_MAKE_BED | CALC_MAKE_FAM | CALC_RECODE | CALC_WRITE_COVAR))) {
if (calculation_type & (~(CALC_MAKE_BED | CALC_MAKE_FAM | CALC_RECODE | CALC_WRITE_COVAR))) {
logerrprint("Error: When ambiguous-sex samples with phenotype data are present,\n--make-bed/--make-just-fam/--recode/--write-covar usually cannot be combined\nwith other commands. Split them across multiple PLINK runs, or use\n--allow-no-sex/--must-have-sex.\n");
goto plink_ret_INVALID_CMDLINE;
}
} else {
// either --must-have-sex without --allow-no-sex, or no data
// generation command
bitvec_and(sex_nm, unfiltered_sample_ctl, pheno_nm);
}
}
if (uii || pheno_all || loop_assoc_fname) {
logerrprint("Warning: Ignoring phenotypes of missing-sex samples. If you don't want those\nphenotypes to be ignored, use the --allow-no-sex flag.\n");
}
}
if (filter_flags & FILTER_PRUNE) {
bitvec_ornot(pheno_nm, unfiltered_sample_ctl, sample_exclude);
zero_trailing_bits(unfiltered_sample_ct, sample_exclude);
sample_exclude_ct = popcount_longs(sample_exclude, unfiltered_sample_ctl);
if ((sample_exclude_ct == unfiltered_sample_ct) && (!allow_no_samples)) {
LOGERRPRINTF("Error: All %s removed by --prune.\n", g_species_plural);
goto plink_ret_ALL_SAMPLES_EXCLUDED;
}
LOGPRINTF("--prune: %" PRIuPTR " %s remaining.\n", unfiltered_sample_ct - sample_exclude_ct, species_str(unfiltered_sample_ct - sample_exclude_ct));
}
if (filter_flags & (FILTER_BINARY_CASES | FILTER_BINARY_CONTROLS)) {
if (!pheno_c) {
logerrprint("Error: --filter-cases/--filter-controls requires a case/control phenotype.\n");
goto plink_ret_INVALID_CMDLINE;
}
ii = sample_exclude_ct;
// fcc == 1: exclude all zeroes in pheno_c
// fcc == 2: exclude all ones in pheno_c
// -> flip on fcc == 1
filter_samples_bitfields(unfiltered_sample_ct, sample_exclude, &sample_exclude_ct, pheno_c, (filter_flags / FILTER_BINARY_CASES) & 1, pheno_nm);
if ((sample_exclude_ct == unfiltered_sample_ct) && (!allow_no_samples)) {
LOGERRPRINTF("Error: All %s removed due to case/control status (--filter-%s).\n", g_species_plural, (filter_flags & FILTER_BINARY_CASES)? "cases" : "controls");
goto plink_ret_ALL_SAMPLES_EXCLUDED;
}
ii = sample_exclude_ct - ii;
LOGPRINTF("%d %s removed due to case/control status (--filter-%s).\n", ii, species_str(ii), (filter_flags & FILTER_BINARY_CASES)? "cases" : "controls");
}
if (filter_flags & (FILTER_BINARY_FEMALES | FILTER_BINARY_MALES)) {
ii = sample_exclude_ct;
filter_samples_bitfields(unfiltered_sample_ct, sample_exclude, &sample_exclude_ct, sex_male, (filter_flags / FILTER_BINARY_MALES) & 1, sex_nm);
if ((sample_exclude_ct == unfiltered_sample_ct) && (!allow_no_samples)) {
LOGERRPRINTF("Error: All %s removed due to gender filter (--filter-%s).\n", g_species_plural, (filter_flags & FILTER_BINARY_MALES)? "males" : "females");
goto plink_ret_ALL_SAMPLES_EXCLUDED;
}
ii = sample_exclude_ct - ii;
LOGPRINTF("%d %s removed due to gender filter (--filter-%s).\n", ii, species_str(ii), (filter_flags & FILTER_BINARY_MALES)? "males" : "females");
}
if (filter_flags & (FILTER_BINARY_FOUNDERS | FILTER_BINARY_NONFOUNDERS)) {
ii = sample_exclude_ct;
filter_samples_bitfields(unfiltered_sample_ct, sample_exclude, &sample_exclude_ct, founder_info, (filter_flags / FILTER_BINARY_FOUNDERS) & 1, nullptr);
if ((sample_exclude_ct == unfiltered_sample_ct) && (!allow_no_samples)) {
LOGERRPRINTF("Error: All %s removed due to founder status (--filter-%s).\n", g_species_plural, (filter_flags & FILTER_BINARY_FOUNDERS)? "founders" : "nonfounders");
goto plink_ret_ALL_SAMPLES_EXCLUDED;
}
ii = sample_exclude_ct - ii;
LOGPRINTF("%d %s removed due to founder status (--filter-%s).\n", ii, species_str(ii), (filter_flags & FILTER_BINARY_FOUNDERS)? "founders" : "nonfounders");
}
if (thin_keep_sample_prob != 1.0) {
if (random_thin_samples(thin_keep_sample_prob, unfiltered_sample_ct, allow_no_samples, sample_exclude, &sample_exclude_ct)) {
goto plink_ret_ALL_SAMPLES_EXCLUDED;
}
} else if (thin_keep_sample_ct != 0xffffffffU) {
retval = random_thin_samples_ct(thin_keep_sample_ct, unfiltered_sample_ct, sample_exclude, &sample_exclude_ct);
if (retval) {
goto plink_ret_1;
}
}
if (mind_thresh < 1.0) {
retval = mind_filter(bedfile, bed_offset, outname, outname_end, mind_thresh, unfiltered_marker_ct, marker_exclude, marker_exclude_ct, unfiltered_sample_ct, sample_exclude, &sample_exclude_ct, sample_ids, max_sample_id_len, sex_male, chrom_info_ptr, om_ip, allow_no_samples);
if (retval) {
goto plink_ret_1;
}
}
if (cluster_ptr->fname || (misc_flags & MISC_FAMILY_CLUSTERS)) {
// could save off bigstack_mark here and free immediately after
// load_clusters(), if clusters are *only* used for filtering. But not a
// big deal.
retval = load_clusters(cluster_ptr->fname, unfiltered_sample_ct, sample_exclude, &sample_exclude_ct, sample_ids, max_sample_id_len, mwithin_col, (misc_flags / MISC_LOAD_CLUSTER_KEEP_NA) & 1, &cluster_ct, &cluster_map, &cluster_starts, &cluster_ids, &max_cluster_id_len, cluster_ptr->keep_fname, cluster_ptr->keep_flattened, cluster_ptr->remove_fname, cluster_ptr->remove_flattened, allow_no_samples);
if (retval) {
goto plink_ret_1;
}
}
sample_ct = unfiltered_sample_ct - sample_exclude_ct;
if ((!sample_ct) && (!allow_no_samples)) {
// defensive; currently shouldn't happen since we're checking at every
// filter
LOGERRPRINTF("Error: No %s pass QC.\n", g_species_plural);
goto plink_ret_ALL_SAMPLES_EXCLUDED;
}
if ((sample_ct < 2) && (relationship_or_ibc_req(calculation_type) || distance_req(read_dists_fname, calculation_type) || (calculation_type & (CALC_GENOME | CALC_CLUSTER | CALC_NEIGHBOR)))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: At least 2 %s required for pairwise analysis.\n", g_species_plural);
goto plink_ret_INVALID_CMDLINE_2;
}
if ((parallel_tot > 1) && (calculation_type & (CALC_DISTANCE | CALC_GENOME | CALC_RELATIONSHIP)) && (parallel_tot > sample_ct / 2)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Too many --parallel jobs (maximum %" PRIuPTR "/2 = %" PRIuPTR ").\n", sample_ct, sample_ct / 2);
goto plink_ret_INVALID_CMDLINE_2;
}
}
#ifndef NOLAPACK
// Multithreaded BLAS/LAPACK call? If yes, and either user requested <=
// [0.5 * nprocs] threads or nprocs is unknown, warn that BLAS/LAPACK
// multithreading is not under PLINK's control.
uii = ((!known_procs) || (known_procs >= 2 * ((int32_t)g_thread_ct))) && ((calculation_type & (CALC_LASSO | CALC_PCA | CALC_UNRELATED_HERITABILITY)) || ((calculation_type & CALC_GLM) && pheno_d) || cluster_ptr->mds_dim_ct || ((calculation_type & CALC_LD_PRUNE) && (!(ldip->modifier & (LD_PRUNE_PAIRWISE | LD_PRUNE_PAIRPHASE)))));
#endif
if (g_thread_ct > 1) {
if ((calculation_type & (CALC_RELATIONSHIP | CALC_REL_CUTOFF | CALC_GDISTANCE_MASK | CALC_IBS_TEST | CALC_GROUPDIST | CALC_REGRESS_DISTANCE | CALC_GENOME | CALC_REGRESS_REL | CALC_UNRELATED_HERITABILITY | CALC_LD | CALC_PCA | CALC_MAKE_PERM_PHENO | CALC_QFAM)) || ((calculation_type & CALC_MODEL) && (model_modifier & (MODEL_PERM | MODEL_MPERM))) || ((calculation_type & CALC_GLM) && (glm_modifier & (GLM_PERM | GLM_MPERM))) || ((calculation_type & CALC_TESTMISS) && (testmiss_modifier & (TESTMISS_PERM | TESTMISS_MPERM))) || ((calculation_type & CALC_TDT) && (fam_ip->tdt_modifier & (TDT_PERM | TDT_MPERM))) || ((calculation_type & CALC_DFAM) && (fam_ip->dfam_modifier & (DFAM_PERM | DFAM_MPERM))) || ((calculation_type & (CALC_CLUSTER | CALC_NEIGHBOR)) && (!read_genome_fname) && ((cluster_ptr->ppc != 0.0) || (!read_dists_fname))) || ((calculation_type & CALC_EPI) && (epi_ip->modifier & (EPI_FAST | EPI_REG)))
#ifndef _WIN32
|| ((calculation_type & CALC_FREQ) && (misc_flags & MISC_FREQ_GZ))
|| ((calculation_type & CALC_MISSING_REPORT) && (misc_flags & MISC_MISSING_GZ))
|| ((calculation_type & CALC_HARDY) && (hwe_modifier & HWE_GZ))
|| ((calculation_type & CALC_HET) && (misc_flags & MISC_HET_GZ))
|| ((calculation_type & CALC_RECODE) && (((recode_modifier & (RECODE_VCF | RECODE_BGZ)) == (RECODE_VCF | RECODE_BGZ))))
#endif
) {
LOGPRINTF("Using up to %u threads (change this with --threads).\n", g_thread_ct);
} else {
#ifndef NOLAPACK
if (uii) {
logprint("Using 1 thread.\n");
} else {
#endif
logprint("Using 1 thread (no multithreaded calculations invoked).\n");
#ifndef NOLAPACK
}
#endif
}
} else {
logprint("Using 1 thread.\n");
}
#ifndef NOLAPACK
if (uii) {
logerrprint("Warning: This run includes BLAS/LAPACK linear algebra operations which\ncurrently disregard the --threads limit. If this is problematic, you may want\nto recompile against single-threaded BLAS/LAPACK.\n");
}
#endif
if (famname[0]) {
if ((calculation_type & (CALC_SEXCHECK | CALC_MISSING_REPORT | CALC_GENOME | CALC_HOMOZYG | CALC_SCORE | CALC_MENDEL | CALC_HET)) || cluster_ptr->mds_dim_ct) {
calc_plink_maxfid(unfiltered_sample_ct, sample_exclude, sample_ct, sample_ids, max_sample_id_len, &plink_maxfid, &plink_maxiid);
}
if (sample_sort & (SAMPLE_SORT_NATURAL | SAMPLE_SORT_ASCII)) {
retval = sort_item_ids(unfiltered_sample_ct, sample_exclude, sample_exclude_ct, sample_ids, max_sample_id_len, 0, 0, (sample_sort & SAMPLE_SORT_NATURAL)? strcmp_natural_deref : strcmp_deref, &cptr, &uiptr);
if (retval) {
goto plink_ret_1;
}
sample_sort_map = uiptr;
bigstack_reset(cptr);
} else if (sample_sort == SAMPLE_SORT_FILE) {
retval = sample_sort_file_map(sample_sort_fname, unfiltered_sample_ct, sample_exclude, unfiltered_sample_ct - sample_exclude_ct, sample_ids, max_sample_id_len, &sample_sort_map);
if (retval) {
goto plink_ret_1;
}
}
if ((filter_flags & FILTER_MAKE_FOUNDERS) && (!(misc_flags & MISC_MAKE_FOUNDERS_FIRST))) {
if (make_founders(unfiltered_sample_ct, sample_ct, sample_ids, max_sample_id_len, paternal_ids, max_paternal_id_len, maternal_ids, max_maternal_id_len, (misc_flags / MISC_MAKE_FOUNDERS_REQUIRE_2_MISSING) & 1, sample_exclude, founder_info)) {
goto plink_ret_NOMEM;
}
}
if (calculation_type & CALC_WRITE_CLUSTER) {
retval = write_clusters(outname, outname_end, unfiltered_sample_ct, sample_exclude, sample_ct, sample_ids, max_sample_id_len, (misc_flags / MISC_WRITE_CLUSTER_OMIT_UNASSIGNED) & 1, cluster_ct, cluster_map, cluster_starts, cluster_ids, max_cluster_id_len);
if (retval || (!(calculation_type & (~(CALC_MERGE | CALC_WRITE_CLUSTER))))) {
goto plink_ret_1;
}
}
// this currently has to come last since covar data structures refer to
// filtered sample indices.
if (covar_fname) {
// update this as more covariate-referencing commands are added
if (!(calculation_type & (CALC_MAKE_BED | CALC_MAKE_FAM | CALC_RECODE | CALC_WRITE_COVAR | CALC_GXE | CALC_GLM | CALC_LASSO | CALC_RPLUGIN))) {
logerrprint("Warning: Ignoring --covar since no commands reference the covariates.\n");
} else {
// if only --gxe, ignore --covar-name/--covar-number
uii = (calculation_type & (CALC_MAKE_BED | CALC_MAKE_FAM | CALC_RECODE | CALC_WRITE_COVAR | CALC_GLM | CALC_LASSO | CALC_RPLUGIN))? 1 : 0;
retval = load_covars(covar_fname, unfiltered_sample_ct, sample_exclude, sample_ct, nullptr, nullptr, sample_ids, max_sample_id_len, missing_phenod, uii? covar_modifier : (covar_modifier & COVAR_KEEP_PHENO_ON_MISSING_COV), uii? covar_range_list_ptr : nullptr, gxe_mcovar, &covar_ct, &covar_names, &max_covar_name_len, pheno_nm, &covar_nm, &covar_d, &gxe_covar_nm, &gxe_covar_c);
if (retval) {
goto plink_ret_1;
}
}
}
bitvec_andnot(sample_exclude, unfiltered_sample_ctl, pheno_nm);
if (pheno_c) {
bitvec_and(pheno_nm, unfiltered_sample_ctl, pheno_c);
}
bitvec_andnot(sample_exclude, unfiltered_sample_ctl, founder_info);
bitvec_andnot(sample_exclude, unfiltered_sample_ctl, sex_nm);
if (gender_unk_ct) {
gender_unk_ct = sample_ct - popcount_longs(sex_nm, unfiltered_sample_ctl);
}
bitvec_and(sex_nm, unfiltered_sample_ctl, sex_male);
pheno_nm_ct = popcount_longs(pheno_nm, unfiltered_sample_ctl);
if (!pheno_nm_ct) {
hwe_modifier |= HWE_THRESH_ALL;
} else if (pheno_c) {
pheno_ctrl_ct = pheno_nm_ct - popcount_longs(pheno_c, unfiltered_sample_ctl);
if (!pheno_ctrl_ct) {
hwe_modifier |= HWE_THRESH_ALL;
}
} else {
hwe_modifier |= HWE_THRESH_ALL;
}
ulii = popcount_longs(founder_info, unfiltered_sample_ctl);
LOGPRINTFWW("Before main variant filters, %" PRIuPTR " founder%s and %" PRIuPTR " nonfounder%s present.\n", ulii, (ulii == 1)? "" : "s", sample_ct - ulii, (sample_ct - ulii == 1)? "" : "s");
}
if (bimname[0] && (unfiltered_marker_ct != marker_exclude_ct)) {
plink_maxsnp = calc_plink_maxsnp(unfiltered_marker_ct, marker_exclude, unfiltered_marker_ct - marker_exclude_ct, marker_ids, max_marker_id_blen);
uii = BITCT_TO_WORDCT(unfiltered_marker_ct);
if (bigstack_calloc_ul(uii, &marker_reverse)) {
goto plink_ret_NOMEM;
}
if (bedfile && sample_ct) {
retval = calc_freqs_and_hwe(bedfile, outname, outname_end, unfiltered_marker_ct, marker_exclude, unfiltered_marker_ct - marker_exclude_ct, marker_ids, max_marker_id_blen, unfiltered_sample_ct, sample_exclude, sample_exclude_ct, sample_ids, max_sample_id_len, founder_info, nonfounders, (misc_flags / MISC_MAF_SUCC) & 1, set_allele_freqs, bed_offset, (hwe_thresh > 0.0) || (calculation_type & CALC_HARDY), hwe_modifier & HWE_THRESH_ALL, (pheno_nm_ct && pheno_c)? ((calculation_type / CALC_HARDY) & 1) : 0, min_ac, max_ac, geno_thresh, pheno_nm, pheno_nm_ct? pheno_c : nullptr, &hwe_lls, &hwe_lhs, &hwe_hhs, &hwe_ll_cases, &hwe_lh_cases, &hwe_hh_cases, &hwe_ll_allfs, &hwe_lh_allfs, &hwe_hh_allfs, &hwe_hapl_allfs, &hwe_haph_allfs, &geno_excl_bitfield, &ac_excl_bitfield, &sample_male_ct, &sample_f_ct, &sample_f_male_ct, chrom_info_ptr, om_ip, sex_nm, sex_male, map_is_unsorted & UNSORTED_SPLIT_CHROM, &hh_exists);
if (retval) {
goto plink_ret_1;
}
} else {
for (marker_uidx = 0; marker_uidx < unfiltered_marker_ct; marker_uidx++) {
set_allele_freqs[marker_uidx] = 1.0;
}
}
if (freqname) {
retval = read_external_freqs(freqname, unfiltered_marker_ct, marker_exclude, marker_exclude_ct, marker_ids, max_marker_id_blen, chrom_info_ptr, marker_allele_ptrs, set_allele_freqs, nchrobs, (misc_flags / MISC_MAF_SUCC) & 1);
if (retval) {
goto plink_ret_1;
}
}
if (!(misc_flags & MISC_KEEP_ALLELE_ORDER)) {
// after this, set_allele_freqs[] has A2 freqs
calc_marker_reverse_bin(marker_reverse, marker_exclude, unfiltered_marker_ct, unfiltered_marker_ct - marker_exclude_ct, set_allele_freqs);
}
if (a1alleles || a2alleles) {
retval = load_ax_alleles(a1alleles? a1alleles : a2alleles, unfiltered_marker_ct, marker_exclude, marker_exclude_ct, marker_allele_ptrs, &max_marker_allele_blen, marker_reverse, marker_ids, max_marker_id_blen, set_allele_freqs, a2alleles? 1 : 0);
if (retval) {
goto plink_ret_1;
}
}
if (marker_allele_ptrs) {
swap_reversed_marker_alleles(unfiltered_marker_ct, marker_reverse, marker_allele_ptrs);
}
// contrary to the PLINK 1.07 flowchart, --freq effectively resolves before
// --geno.
if (sample_ct) {
if (calculation_type & CALC_FREQ) {
if (cluster_ct && (!(misc_flags & MISC_FREQX))) {
if (misc_flags & MISC_FREQ_COUNTS) {
logprint("Note: --freq 'counts' modifier has no effect on cluster-stratified report.\n");
}
retval = write_stratified_freqs(bedfile, bed_offset, outname, outname_end, (misc_flags / MISC_FREQ_GZ) & 1, plink_maxsnp, unfiltered_marker_ct, marker_exclude, chrom_info_ptr, marker_ids, max_marker_id_blen, marker_allele_ptrs, max_marker_allele_blen, unfiltered_sample_ct, sample_ct, sample_f_ct, founder_info, nonfounders, sex_male, sample_f_male_ct, marker_reverse, cluster_ct, cluster_map, cluster_starts, cluster_ids, max_cluster_id_len);
} else if (misc_flags & MISC_FREQ_CC) {
retval = write_cc_freqs(bedfile, bed_offset, outname, outname_end, (misc_flags / MISC_FREQ_GZ) & 1, plink_maxsnp, unfiltered_marker_ct, marker_exclude, chrom_info_ptr, marker_ids, max_marker_id_blen, marker_allele_ptrs, max_marker_allele_blen, unfiltered_sample_ct, founder_info, nonfounders, sex_male, marker_reverse, pheno_nm, pheno_c);
} else {
retval = write_freqs(outname, outname_end, plink_maxsnp, unfiltered_marker_ct, marker_exclude, set_allele_freqs, chrom_info_ptr, marker_ids, max_marker_id_blen, marker_allele_ptrs, max_marker_allele_blen, hwe_ll_allfs, hwe_lh_allfs, hwe_hh_allfs, hwe_hapl_allfs, hwe_haph_allfs, sample_f_ct, sample_f_male_ct, nonfounders, misc_flags, marker_reverse);
}
if (retval || (!(calculation_type & (~(CALC_MERGE | CALC_WRITE_CLUSTER | CALC_FREQ))))) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_MISSING_REPORT) {
retval = write_missingness_reports(bedfile, bed_offset, outname, outname_end, (misc_flags / MISC_MISSING_GZ) & 1, plink_maxfid, plink_maxiid, plink_maxsnp, unfiltered_marker_ct, marker_exclude, unfiltered_marker_ct - marker_exclude_ct, chrom_info_ptr, om_ip, marker_ids, max_marker_id_blen, unfiltered_sample_ct, sample_ct, sample_exclude, pheno_nm, sex_male, sample_male_ct, sample_ids, max_sample_id_len, cluster_ct, cluster_map, cluster_starts, cluster_ids, max_cluster_id_len, hh_exists);
if (retval || (!(calculation_type & (~(CALC_MERGE | CALC_WRITE_CLUSTER | CALC_FREQ | CALC_MISSING_REPORT))))) {
goto plink_ret_1;
}
}
if (geno_excl_bitfield) {
ulii = marker_exclude_ct;
uljj = BITCT_TO_WORDCT(unfiltered_marker_ct);
bitvec_or(geno_excl_bitfield, uljj, marker_exclude);
marker_exclude_ct = popcount_longs(marker_exclude, uljj);
if ((marker_exclude_ct == unfiltered_marker_ct) && (!allow_no_variants)) {
logerrprint("Error: All variants excluded due to missing genotype data (--geno).\n");
goto plink_ret_ALL_MARKERS_EXCLUDED;
}
ulii = marker_exclude_ct - ulii;
LOGPRINTF("%" PRIuPTR " variant%s removed due to missing genotype data (--geno).\n", ulii, (ulii == 1)? "" : "s");
}
}
oblig_missing_cleanup(om_ip);
if (sample_ct) {
if (calculation_type & CALC_HARDY) {
retval = hardy_report(outname, outname_end, output_min_p, unfiltered_marker_ct, marker_exclude, marker_exclude_ct, marker_ids, max_marker_id_blen, plink_maxsnp, marker_allele_ptrs, max_marker_allele_blen, marker_reverse, hwe_lls, hwe_lhs, hwe_hhs, hwe_modifier, nonfounders, hwe_ll_cases, hwe_lh_cases, hwe_hh_cases, hwe_ll_allfs, hwe_lh_allfs, hwe_hh_allfs, pheno_nm_ct, pheno_c, chrom_info_ptr);
if (retval || (!(calculation_type & (~(CALC_MERGE | CALC_WRITE_CLUSTER | CALC_FREQ | CALC_HARDY))))) {
goto plink_ret_1;
}
}
if (hwe_thresh > 0.0) {
if (enforce_hwe_threshold(hwe_thresh, unfiltered_marker_ct, marker_exclude, &marker_exclude_ct, hwe_lls, hwe_lhs, hwe_hhs, hwe_modifier, allow_no_variants, hwe_ll_allfs, hwe_lh_allfs, hwe_hh_allfs, chrom_info_ptr)) {
goto plink_ret_ALL_MARKERS_EXCLUDED;
}
}
}
if ((min_maf != 0.0) || (max_maf != 0.5) || ac_excl_bitfield) {
if (enforce_minor_allele_thresholds(min_maf, max_maf, unfiltered_marker_ct, marker_exclude, ac_excl_bitfield, &marker_exclude_ct, set_allele_freqs, allow_no_variants)) {
goto plink_ret_ALL_MARKERS_EXCLUDED;
}
}
if (min_bp_space && (unfiltered_marker_ct > marker_exclude_ct)) {
if (map_is_unsorted & UNSORTED_BP) {
logerrprint("Error: --bp-space requires a sorted .bim file. Retry this command after using\n--make-bed to sort your data.\n");
goto plink_ret_INVALID_FORMAT;
}
enforce_min_bp_space(min_bp_space, unfiltered_marker_ct, marker_exclude, marker_pos, &marker_exclude_ct, chrom_info_ptr);
}
if (bedfile && sample_ct && (unfiltered_marker_ct > marker_exclude_ct)) {
if ((calculation_type & CALC_MENDEL) || (fam_ip->mendel_modifier & MENDEL_FILTER)) {
retval = mendel_error_scan(fam_ip, bedfile, bed_offset, outname, outname_end, plink_maxfid, plink_maxiid, plink_maxsnp, allow_no_variants, unfiltered_marker_ct, marker_exclude, &marker_exclude_ct, marker_reverse, marker_ids, max_marker_id_blen, marker_allele_ptrs, max_marker_allele_blen, unfiltered_sample_ct, sample_exclude, &sample_exclude_ct, founder_info, sex_nm, sex_male, sample_ids, max_sample_id_len, paternal_ids, max_paternal_id_len, maternal_ids, max_maternal_id_len, hh_exists, chrom_info_ptr, (calculation_type / CALC_MENDEL) & 1);
if (retval || (!(calculation_type & (~(CALC_MERGE | CALC_WRITE_CLUSTER | CALC_FREQ | CALC_MISSING_REPORT | CALC_MENDEL))))) {
goto plink_ret_1;
}
if (fam_ip->mendel_modifier & MENDEL_FILTER) {
// gah
sample_ct = unfiltered_sample_ct - sample_exclude_ct;
bitvec_andnot(sample_exclude, unfiltered_sample_ctl, founder_info);
bitvec_andnot(sample_exclude, unfiltered_sample_ctl, sex_nm);
bitvec_and(sex_nm, unfiltered_sample_ctl, sex_male);
if (pheno_nm_ct) {
bitvec_andnot(sample_exclude, unfiltered_sample_ctl, pheno_nm);
pheno_nm_ct = popcount_longs(pheno_nm, unfiltered_sample_ctl);
if (pheno_c) {
bitvec_and(pheno_nm, unfiltered_sample_ctl, pheno_c);
pheno_ctrl_ct = pheno_nm_ct - popcount_longs(pheno_c, unfiltered_sample_ctl);
}
}
}
}
bigstack_reset(hwe_lls);
}
if (sip->fname) {
if (map_is_unsorted & UNSORTED_BP) {
logerrprint("Error: --set/--make-set requires a sorted .bim file. Retry this command after\nusing --make-bed to sort your data.\n");
goto plink_ret_INVALID_FORMAT;
}
retval = define_sets(sip, unfiltered_marker_ct, marker_exclude, marker_pos, &marker_exclude_ct, marker_ids, max_marker_id_blen, chrom_info_ptr, allow_no_variants, (misc_flags / MISC_ALLOW_EXTRA_CHROMS) & 1);
if (retval) {
goto plink_ret_1;
}
}
marker_ct = unfiltered_marker_ct - marker_exclude_ct;
if ((!marker_ct) && (!allow_no_variants)) {
// defensive
logerrprint("Error: All variants fail QC.\n");
goto plink_ret_ALL_MARKERS_EXCLUDED;
}
// could add --parallel + --r/--r2/--{fast-}epistasis check here. (this
// currently happens downstream)
if (bedfile) {
LOGPRINTFWW("%" PRIuPTR " variant%s and %" PRIuPTR " %s pass filters and QC%s.\n", marker_ct, (marker_ct == 1)? "" : "s", sample_ct, species_str(sample_ct), (calculation_type & CALC_REL_CUTOFF)? " (before --rel-cutoff)": "");
} else {
LOGPRINTFWW("%" PRIuPTR " variant%s filters and QC.\n", marker_ct, (marker_ct == 1)? " passes" : "s pass");
}
} else if ((!allow_no_variants) && ((calculation_type & (~CALC_ONLY_FAM)) || (filter_flags & FILTER_BIM_REQ))) {
// defensive
logerrprint("Error: No variants remaining.\n");
goto plink_ret_ALL_MARKERS_EXCLUDED;
}
if (famname[0] && sample_ct) {
if (!pheno_nm_ct) {
logprint("Note: No phenotypes present.\n");
} else if (pheno_c) {
if (pheno_nm_ct != sample_ct) {
snprintf(g_logbuf, LOGBUFLEN, "Among remaining phenotypes, %u %s and %u %s. (%" PRIuPTR " phenotype%s missing.)\n", pheno_nm_ct - pheno_ctrl_ct, (pheno_nm_ct - pheno_ctrl_ct == 1)? "is a case" : "are cases", pheno_ctrl_ct, (pheno_ctrl_ct == 1)? "is a control" : "are controls", sample_ct - pheno_nm_ct, (sample_ct - pheno_nm_ct == 1)? " is" : "s are");
} else {
snprintf(g_logbuf, LOGBUFLEN, "Among remaining phenotypes, %u %s and %u %s.\n", pheno_nm_ct - pheno_ctrl_ct, (pheno_nm_ct - pheno_ctrl_ct == 1)? "is a case" : "are cases", pheno_ctrl_ct, (pheno_ctrl_ct == 1)? "is a control" : "are controls");
}
wordwrapb(0);
logprintb();
} else {
logprint("Phenotype data is quantitative.\n");
}
}
if (sample_ct) {
if (marker_ct) {
if (relationship_or_ibc_req(calculation_type)) {
if (relip->pca_cluster_names_flattened || relip->pca_clusters_fname) {
retval = extract_clusters(unfiltered_sample_ct, sample_exclude, sample_ct, cluster_ct, cluster_map, cluster_starts, cluster_ids, max_cluster_id_len, relip->pca_cluster_names_flattened, relip->pca_clusters_fname, &pca_sample_exclude, &pca_sample_ct);
if (retval) {
goto plink_ret_1;
}
if (pca_sample_ct < 2) {
logerrprint("Error: Too few samples specified by --pca-cluster-names/--pca-clusters.\n");
goto plink_ret_1;
}
if (pca_sample_ct == sample_ct) {
logerrprint("Warning: --pca-cluster-names/--pca-clusters has no effect since all samples are\nin the named clusters.\n");
pca_sample_exclude = nullptr;
} else {
LOGPRINTF("--pca-cluster-names/--pca-clusters: %" PRIuPTR " samples specified.\n", pca_sample_ct);
ulii = unfiltered_sample_ct - pca_sample_ct;
}
}
retval = calc_rel(threads, parallel_idx, parallel_tot, calculation_type, relip, bedfile, bed_offset, outname, outname_end, distance_wts_fname, (dist_calc_type & DISTANCE_WTS_NOHEADER), unfiltered_marker_ct, marker_exclude, marker_reverse, marker_ct, marker_ids, max_marker_id_blen, unfiltered_sample_ct, pca_sample_exclude? pca_sample_exclude : sample_exclude, pca_sample_exclude? (&ulii) : (&sample_exclude_ct), sample_ids, max_sample_id_len, set_allele_freqs, &rel_ibc, chrom_info_ptr);
if (retval) {
goto plink_ret_1;
}
if ((!pca_sample_exclude) && (sample_ct != unfiltered_sample_ct + sample_exclude_ct)) {
sample_ct = unfiltered_sample_ct - sample_exclude_ct;
if ((sample_ct < 2) && (distance_req(read_dists_fname, calculation_type) || (calculation_type & (CALC_REGRESS_REL | CALC_PCA | CALC_GENOME | CALC_CLUSTER | CALC_NEIGHBOR)))) {
// pathological case
snprintf(g_logbuf, LOGBUFLEN, "Error: Too many %s pruned for additional pairwise analysis steps.\n", g_species_plural);
goto plink_ret_INVALID_CMDLINE_2;
}
}
if (calculation_type & CALC_REL_CUTOFF) {
// ugh, probably better to just stop supporting this
bitvec_andnot(sample_exclude, unfiltered_sample_ctl, founder_info);
bitvec_andnot(sample_exclude, unfiltered_sample_ctl, sex_nm);
bitvec_and(sex_nm, unfiltered_sample_ctl, sex_male);
if (pheno_nm_ct) {
bitvec_andnot(sample_exclude, unfiltered_sample_ctl, pheno_nm);
pheno_nm_ct = popcount_longs(pheno_nm, unfiltered_sample_ctl);
if (pheno_c) {
bitvec_and(pheno_nm, unfiltered_sample_ctl, pheno_c);
pheno_ctrl_ct = pheno_nm_ct - popcount_longs(pheno_c, unfiltered_sample_ctl);
}
}
}
if (calculation_type & CALC_REGRESS_REL) {
retval = regress_rel_main(unfiltered_sample_ct, sample_exclude, sample_ct, relip, threads, pheno_d);
if (retval) {
goto plink_ret_1;
}
}
#ifndef NOLAPACK
if (calculation_type & CALC_PCA) {
retval = calc_pca(bedfile, bed_offset, outname, outname_end, calculation_type, relip, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, marker_allele_ptrs, marker_reverse, unfiltered_sample_ct, sample_exclude, sample_ct, pca_sample_exclude? pca_sample_exclude : sample_exclude, pca_sample_exclude? pca_sample_ct : sample_ct, sample_ids, max_sample_id_len, set_allele_freqs, chrom_info_ptr, rel_ibc);
} else if (calculation_type & CALC_UNRELATED_HERITABILITY) {
if (sample_ct != pheno_nm_ct) {
logerrprint("Error: --unrelated-heritability requires phenotype data for all samples.\n(--prune should help.)\n");
goto plink_ret_INVALID_CMDLINE;
}
retval = calc_unrelated_herit(calculation_type, relip, unfiltered_sample_ct, sample_exclude, sample_ct, pheno_d, rel_ibc);
}
#endif
bigstack_reset(g_sample_missing_unwt);
if (retval) {
goto plink_ret_1;
}
g_sample_missing_unwt = nullptr;
g_missing_dbl_excluded = nullptr;
}
if (calculation_type & CALC_SEXCHECK) {
retval = sexcheck(bedfile, bed_offset, outname, outname_end, unfiltered_marker_ct, marker_exclude, unfiltered_sample_ct, sample_exclude, sample_ct, sample_ids, plink_maxfid, plink_maxiid, max_sample_id_len, sex_nm, sex_male, misc_flags, check_sex_fthresh, check_sex_mthresh, check_sex_f_yobs, check_sex_m_yobs, chrom_info_ptr, set_allele_freqs, &gender_unk_ct);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_TUCC) {
retval = make_pseudocontrols(bedfile, bed_offset, outname, outname_end, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, marker_cms, marker_pos, marker_allele_ptrs, max_marker_allele_blen, marker_reverse, unfiltered_sample_ct, sample_exclude, sample_ct, founder_info, sex_nm, sex_male, sample_ids, max_sample_id_len, paternal_ids, max_paternal_id_len, maternal_ids, max_maternal_id_len, chrom_info_ptr, fam_ip);
if (retval) {
goto plink_ret_1;
}
}
}
if (calculation_type & CALC_MAKE_PERM_PHENO) {
retval = make_perm_pheno(threads, outname, outname_end, unfiltered_sample_ct, sample_exclude, sample_ct, sample_ids, max_sample_id_len, cluster_ct, cluster_map, cluster_starts, pheno_nm_ct, pheno_nm, pheno_c, pheno_d, output_missing_pheno, permphe_ct);
if (retval) {
goto plink_ret_1;
}
}
if ((calculation_type & CALC_GENOME) || genome_skip_write) {
// er, this probably should be moved inside calc_genome(), since we're
// using get_trios_and_families() instead of pri elsewhere
retval = populate_pedigree_rel_info(&pri, unfiltered_sample_ct, sample_ids, max_sample_id_len, paternal_ids, max_paternal_id_len, maternal_ids, max_maternal_id_len, founder_info);
if (retval) {
goto plink_ret_1;
}
}
}
if (marker_ct) {
if (calculation_type & CALC_WRITE_SET) {
retval = write_set(sip, outname, outname_end, marker_ct, unfiltered_marker_ct, marker_exclude, marker_ids, max_marker_id_blen, marker_pos, chrom_info_ptr);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_WRITE_SNPLIST) {
retval = write_snplist(outname, outname_end, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, nullptr, 0);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_WRITE_VAR_RANGES) {
retval = write_var_ranges(outname, outname_end, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, write_var_range_ct);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_LIST_23_INDELS) {
retval = write_snplist(outname, outname_end, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, marker_allele_ptrs, 1);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_DUPVAR) {
if (map_is_unsorted & UNSORTED_BP) {
logerrprint("Error: --list-duplicate-vars requires a sorted .bim file. Retry this command\nafter using --make-bed to sort your data.\n");
goto plink_ret_INVALID_FORMAT;
}
retval = list_duplicate_vars(outname, outname_end, dupvar_modifier, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, marker_pos, chrom_info_ptr, marker_allele_ptrs);
if (retval) {
goto plink_ret_1;
}
}
}
if (calculation_type & (CALC_WRITE_COVAR | CALC_MAKE_BED | CALC_MAKE_BIM | CALC_MAKE_FAM | CALC_RECODE)) {
if (gender_unk_ct && (sex_missing_pheno & MUST_HAVE_SEX)) {
if (aligned_malloc(unfiltered_sample_ctl * sizeof(intptr_t), &pheno_nm_datagen)) {
goto plink_ret_NOMEM;
}
memcpy(pheno_nm_datagen, pheno_nm, unfiltered_sample_ctl * sizeof(intptr_t));
bitvec_and(sex_nm, unfiltered_sample_ctl, pheno_nm_datagen);
}
if (covar_ct && (calculation_type & (CALC_WRITE_COVAR | CALC_MAKE_BED | CALC_MAKE_FAM | CALC_RECODE)) && sample_ct) {
retval = write_covars(outname, outname_end, write_covar_modifier, write_covar_dummy_max_categories, unfiltered_sample_ct, sample_exclude, sample_ct, sample_ids, max_sample_id_len, paternal_ids, max_paternal_id_len, maternal_ids, max_maternal_id_len, sex_nm, sex_male, pheno_nm_datagen? pheno_nm_datagen : pheno_nm, pheno_c, pheno_d, missing_phenod, output_missing_pheno, covar_ct, covar_names, max_covar_name_len, covar_nm, covar_d);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & (CALC_MAKE_BED | CALC_MAKE_BIM | CALC_MAKE_FAM)) {
retval = make_bed(bedfile, bed_offset, bimname, outname, outname_end, calculation_type, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, marker_cms, marker_pos, marker_allele_ptrs, marker_reverse, unfiltered_sample_ct, sample_exclude, sample_ct, sample_ids, max_sample_id_len, paternal_ids, max_paternal_id_len, maternal_ids, max_maternal_id_len, founder_info, sex_nm, sex_male, pheno_nm_datagen? pheno_nm_datagen : pheno_nm, pheno_c, pheno_d, output_missing_pheno, map_is_unsorted & (UNSORTED_CHROM | UNSORTED_BP | UNSORTED_SPLIT_CHROM), sample_sort_map, misc_flags, splitx_bound1, splitx_bound2, update_chr, flip_fname, flip_subset_fname, cluster_ptr->zerofname, cluster_ct, cluster_map, cluster_starts, cluster_ids, max_cluster_id_len, hh_exists, chrom_info_ptr, fam_ip->mendel_modifier, max_bim_linelen);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_RECODE) {
retval = recode(recode_modifier, bedfile, bed_offset, outname, outname_end, recode_allele_name, unfiltered_marker_ct, marker_exclude, marker_ct, unfiltered_sample_ct, sample_exclude, sample_ct, marker_ids, max_marker_id_blen, marker_cms, marker_allele_ptrs, max_marker_allele_blen, marker_pos, marker_reverse, sample_ids, max_sample_id_len, paternal_ids, max_paternal_id_len, maternal_ids, max_maternal_id_len, sex_nm, sex_male, pheno_nm_datagen? pheno_nm_datagen : pheno_nm, pheno_c, pheno_d, output_missing_pheno, map_is_unsorted & (UNSORTED_CHROM | UNSORTED_BP | UNSORTED_SPLIT_CHROM), misc_flags, hh_exists, chrom_info_ptr);
if (retval) {
goto plink_ret_1;
}
}
aligned_free_cond_null(&pheno_nm_datagen);
}
if ((!marker_ct) || (!sample_ct)) {
goto plink_ret_1;
}
if ((calculation_type & CALC_EPI) && epi_ip->twolocus_mkr1) {
retval = twolocus(epi_ip, bedfile, bed_offset, marker_ct, unfiltered_marker_ct, marker_exclude, marker_reverse, marker_ids, max_marker_id_blen, plink_maxsnp, marker_allele_ptrs, chrom_info_ptr, unfiltered_sample_ct, sample_exclude, sample_ct, pheno_nm, pheno_nm_ct, pheno_ctrl_ct, pheno_c, sex_male, outname, outname_end, hh_exists);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_SHOW_TAGS) {
if (map_is_unsorted & UNSORTED_BP) {
logerrprint("Error: --show-tags requires a sorted .bim file. Retry this command after using\n--make-bed to sort your data.\n");
goto plink_ret_INVALID_CMDLINE;
}
retval = show_tags(ldip, bedfile, bed_offset, marker_ct, unfiltered_marker_ct, marker_exclude, marker_reverse, marker_ids, max_marker_id_blen, plink_maxsnp, marker_pos, chrom_info_ptr, unfiltered_sample_ct, founder_info, sex_male, outname, outname_end, hh_exists);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_BLOCKS) {
if (map_is_unsorted & UNSORTED_BP) {
logerrprint("Error: --blocks requires a sorted .bim file. Retry this command after using\n--make-bed to sort your data.\n");
goto plink_ret_INVALID_CMDLINE;
}
retval = haploview_blocks(ldip, bedfile, bed_offset, marker_ct, unfiltered_marker_ct, marker_exclude, marker_ids, max_marker_id_blen, marker_pos, chrom_info_ptr, set_allele_freqs, unfiltered_sample_ct, founder_info, pheno_nm, sex_male, outname, outname_end, hh_exists);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_HOMOZYG) {
if (map_is_unsorted & UNSORTED_BP) {
logerrprint("Error: Run-of-homozygosity scanning requires a sorted .bim. Retry this command\nafter using --make-bed to sort your data.\n");
goto plink_ret_INVALID_CMDLINE;
}
retval = calc_homozyg(homozyg_ptr, bedfile, bed_offset, marker_ct, unfiltered_marker_ct, marker_exclude, marker_ids, max_marker_id_blen, plink_maxsnp, marker_allele_ptrs, max_marker_allele_blen, marker_reverse, chrom_info_ptr, marker_pos, sample_ct, unfiltered_sample_ct, sample_exclude, sample_ids, plink_maxfid, plink_maxiid, max_sample_id_len, outname, outname_end, pheno_nm, pheno_c, pheno_d, output_missing_pheno, sex_male);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_LD_PRUNE) {
if (map_is_unsorted & UNSORTED_BP) {
logerrprint("Error: LD-based pruning requires a sorted .bim. Retry this command after using\n--make-bed to sort your data.\n");
goto plink_ret_INVALID_CMDLINE;
}
if (!(ldip->modifier & LD_PRUNE_PAIRPHASE)) {
retval = ld_prune(ldip, bedfile, bed_offset, marker_ct, unfiltered_marker_ct, marker_exclude, marker_reverse, marker_ids, max_marker_id_blen, chrom_info_ptr, set_allele_freqs, marker_pos, unfiltered_sample_ct, founder_info, sex_male, outname, outname_end, hh_exists);
} else {
retval = indep_pairphase(ldip, bedfile, bed_offset, marker_ct, unfiltered_marker_ct, marker_exclude, marker_reverse, marker_ids, max_marker_id_blen, chrom_info_ptr, set_allele_freqs, marker_pos, unfiltered_sample_ct, founder_info, sex_male, outname, outname_end, hh_exists);
}
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_FLIPSCAN) {
if (map_is_unsorted & UNSORTED_BP) {
logerrprint("Error: LD-based strand flip scanning requires a sorted .bim. Retry this\ncommand after using --make-bed to sort your data.\n");
goto plink_ret_INVALID_CMDLINE;
}
retval = flipscan(ldip, bedfile, bed_offset, marker_ct, unfiltered_marker_ct, marker_exclude, marker_reverse, marker_ids, max_marker_id_blen, plink_maxsnp, marker_allele_ptrs, max_marker_allele_blen, chrom_info_ptr, set_allele_freqs, marker_pos, unfiltered_sample_ct, pheno_nm, pheno_c, founder_info, sex_male, outname, outname_end, hh_exists);
if (retval) {
goto plink_ret_1;
}
}
if ((calculation_type & CALC_EPI) && epi_ip->ld_mkr1) {
retval = twolocus(epi_ip, bedfile, bed_offset, marker_ct, unfiltered_marker_ct, marker_exclude, marker_reverse, marker_ids, max_marker_id_blen, plink_maxsnp, marker_allele_ptrs, chrom_info_ptr, unfiltered_sample_ct, founder_info, 0, nullptr, 0, 0, nullptr, sex_male, nullptr, nullptr, hh_exists);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_LD) {
if (!(ldip->modifier & (LD_MATRIX_SHAPEMASK | LD_INTER_CHR))) {
if (map_is_unsorted & UNSORTED_BP) {
logerrprint("Error: Windowed --r/--r2 runs require a sorted .bim. Retry this command after\nusing --make-bed to sort your data.\n");
goto plink_ret_INVALID_CMDLINE;
}
if ((map_is_unsorted & UNSORTED_CM) && (ldip->window_cm != -1)) {
logerrprint("Error: --ld-window-cm requires nondecreasing CM values on each chromosome.\nRetry this command after regenerating your CM coordinates.\n");
goto plink_ret_INVALID_CMDLINE;
}
}
retval = ld_report(threads, ldip, bedfile, bed_offset, marker_ct, unfiltered_marker_ct, marker_exclude, marker_reverse, marker_ids, max_marker_id_blen, plink_maxsnp, marker_allele_ptrs, max_marker_allele_blen, set_allele_freqs, chrom_info_ptr, marker_pos, marker_cms, unfiltered_sample_ct, founder_info, parallel_idx, parallel_tot, sex_male, outname, outname_end, hh_exists);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_TESTMISHAP) {
if (map_is_unsorted & UNSORTED_BP) {
logerrprint("Error: --test-mishap requires a sorted .bim. Retry this command after using\n--make-bed to sort your data.\n");
goto plink_ret_INVALID_CMDLINE;
}
retval = test_mishap(bedfile, bed_offset, outname, outname_end, output_min_p, unfiltered_marker_ct, marker_exclude, marker_reverse, marker_ct, marker_ids, max_marker_id_blen, plink_maxsnp, marker_allele_ptrs, min_maf, chrom_info_ptr, unfiltered_sample_ct, sample_exclude, sample_ct);
if (retval) {
goto plink_ret_1;
}
}
// sometimes no more need for marker_ids/marker_allele_ptrs, conditional
// unload to clear space for IBS matrix, etc.? (probably want to initially
// load at far end of stack to make this workable...)
if (calculation_type & (CALC_CLUSTER | CALC_NEIGHBOR)) {
bigstack_mark_postcluster = g_bigstack_base;
ulii = (sample_ct * (sample_ct - 1)) >> 1;
if (cluster_ptr->mds_dim_ct) {
#ifndef __LP64__
// catch 32-bit intptr_t overflow
if (sample_ct > 23169) {
goto plink_ret_NOMEM;
}
#endif
if (((!read_dists_fname) && (!read_genome_fname)) || (cluster_ptr->modifier & CLUSTER_MISSING)) {
if ((!(cluster_ptr->modifier & CLUSTER_MDS)) || (!cluster_ct)) {
if (bigstack_alloc_d(ulii, &mds_plot_dmatrix_copy)) {
goto plink_ret_NOMEM;
}
} else {
ulii = cluster_ct + sample_ct - cluster_starts[cluster_ct];
if (bigstack_alloc_d((ulii * (ulii - 1)) / 2, &mds_plot_dmatrix_copy)) {
goto plink_ret_NOMEM;
}
}
}
}
if (cluster_ct) {
ulii = cluster_ct + sample_ct - cluster_starts[cluster_ct];
#ifndef __LP64__
if (ulii > 23169) {
goto plink_ret_NOMEM;
}
#endif
ulii = (ulii * (ulii - 1)) >> 1;
#ifndef __LP64__
} else if (sample_ct > 23169) {
goto plink_ret_NOMEM;
#endif
}
if (bigstack_alloc_ul(BITCT_TO_WORDCT(ulii), &cluster_merge_prevented)) {
goto plink_ret_NOMEM;
}
if (cluster_ct || (calculation_type & CALC_GENOME) || genome_skip_write) {
if (bigstack_alloc_d(ulii, &cluster_sorted_ibs)) {
goto plink_ret_NOMEM;
}
if (cluster_ptr->modifier & CLUSTER_GROUP_AVG) {
fill_double_zero(ulii, cluster_sorted_ibs);
} else {
for (uljj = 0; uljj < ulii; uljj++) {
cluster_sorted_ibs[uljj] = 1.0;
}
}
}
bigstack_mark_precluster = g_bigstack_base;
}
bigstack_mark2 = g_bigstack_base;
if (distance_req(read_dists_fname, calculation_type)) {
retval = calc_distance(threads, parallel_idx, parallel_tot, bedfile, bed_offset, outname, outname_end, read_dists_fname, distance_wts_fname, distance_exp, calculation_type, dist_calc_type, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, set_allele_freqs, unfiltered_sample_ct, sample_exclude, sample_ct, sample_ids, max_sample_id_len, chrom_info_ptr);
if (retval) {
goto plink_ret_1;
}
}
if (read_dists_fname && (calculation_type & (CALC_IBS_TEST | CALC_GROUPDIST | CALC_REGRESS_DISTANCE))) {
// use delayed and specialized load for --cluster/--neighbour, since PPC
// values may be needed, and user may want to process a distance matrix too
// large to be loaded in memory by doing some pre-clustering
if (bigstack_alloc_d((sample_ct * (sample_ct - 1)) / 2, &g_dists)) {
goto plink_ret_NOMEM;
}
retval = read_dists(read_dists_fname, read_dists_id_fname, unfiltered_sample_ct, sample_exclude, sample_ct, sample_ids, max_sample_id_len, 0, nullptr, nullptr, 0, 0, g_dists, 0, nullptr, nullptr);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_IBS_TEST) {
if (cluster_starts) {
logerrprint("Error: --ibs-test does not currently support within-cluster permutation.\nContact the developers if you need this.\n");
retval = RET_CALC_NOT_YET_SUPPORTED;
goto plink_ret_1;
}
retval = ibs_test_calc(threads, read_dists_fname, unfiltered_sample_ct, sample_exclude, sample_ct, ibs_test_perms, pheno_nm_ct, pheno_ctrl_ct, pheno_nm, pheno_c);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_GROUPDIST) {
retval = groupdist_calc(threads, unfiltered_sample_ct, sample_exclude, sample_ct, groupdist_iters, groupdist_d, pheno_nm_ct, pheno_ctrl_ct, pheno_nm, pheno_c);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_REGRESS_DISTANCE) {
if (sample_ct != pheno_nm_ct) {
logerrprint("Error: --regress-distance requires phenotype data for all samples. (--prune\nshould help.)\n");
goto plink_ret_INVALID_CMDLINE;
}
retval = regress_distance(threads, calculation_type, pheno_d, unfiltered_sample_ct, sample_exclude, sample_ct, g_thread_ct, regress_iters, regress_d);
if (retval) {
goto plink_ret_1;
}
}
if (read_dists_fname && (calculation_type & (CALC_IBS_TEST | CALC_GROUPDIST | CALC_REGRESS_DISTANCE))) {
bigstack_reset(g_dists);
g_dists = nullptr;
}
if ((calculation_type & CALC_GENOME) || genome_skip_write) {
bigstack_reset(bigstack_mark2);
g_dists = nullptr;
retval = calc_genome(threads, bedfile, bed_offset, marker_ct, unfiltered_marker_ct, marker_exclude, chrom_info_ptr, marker_pos, set_allele_freqs, nchrobs, unfiltered_sample_ct, sample_exclude, sample_ct, sample_ids, plink_maxfid, plink_maxiid, max_sample_id_len, paternal_ids, max_paternal_id_len, maternal_ids, max_maternal_id_len, founder_info, parallel_idx, parallel_tot, outname, outname_end, nonfounders, calculation_type, genome_modifier, ppc_gap, genome_min_pi_hat, genome_max_pi_hat, pheno_nm, pheno_c, pri, genome_skip_write);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_HET) {
retval = het_report(bedfile, bed_offset, outname, outname_end, (misc_flags / MISC_HET_GZ) & 1, unfiltered_marker_ct, marker_exclude, marker_ct, unfiltered_sample_ct, sample_exclude, sample_ct, sample_ids, plink_maxfid, plink_maxiid, max_sample_id_len, (misc_flags & MISC_HET_SMALL_SAMPLE)? founder_info : nullptr, chrom_info_ptr, set_allele_freqs);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_FST) {
retval = fst_report(bedfile, bed_offset, outname, outname_end, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, marker_pos, chrom_info_ptr, unfiltered_sample_ct, sample_exclude, pheno_nm, (misc_flags & MISC_FST_CC)? pheno_c : nullptr, cluster_ct, cluster_map, cluster_starts);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & (CALC_CLUSTER | CALC_NEIGHBOR)) {
retval = calc_cluster_neighbor(threads, bedfile, bed_offset, marker_ct, unfiltered_marker_ct, marker_exclude, chrom_info_ptr, set_allele_freqs, unfiltered_sample_ct, sample_exclude, sample_ct, sample_ids, plink_maxfid, plink_maxiid, max_sample_id_len, read_dists_fname, read_dists_id_fname, read_genome_fname, outname, outname_end, calculation_type, cluster_ct, cluster_map, cluster_starts, cluster_ptr, missing_pheno, neighbor_n1, neighbor_n2, ppc_gap, pheno_c, mds_plot_dmatrix_copy, cluster_merge_prevented, cluster_sorted_ibs, bigstack_mark_precluster, bigstack_mark_postcluster);
if (retval) {
goto plink_ret_1;
}
}
if ((calculation_type & CALC_EPI) && (epi_ip->modifier & (EPI_FAST | EPI_REG))) {
if ((map_is_unsorted & UNSORTED_BP) && (epi_ip->modifier & EPI_FAST_CASE_ONLY)) {
logerrprint("Error: --fast-epistasis case-only requires a sorted .bim. Retry this command\nafter using --make-bed to sort your data.\n");
goto plink_ret_INVALID_CMDLINE;
}
retval = epistasis_report(threads, epi_ip, bedfile, bed_offset, marker_ct, unfiltered_marker_ct, marker_exclude, marker_reverse, marker_ids, max_marker_id_blen, marker_pos, plink_maxsnp, chrom_info_ptr, unfiltered_sample_ct, pheno_nm, pheno_nm_ct, pheno_ctrl_ct, pheno_c, pheno_d, parallel_idx, parallel_tot, outname, outname_end, output_min_p, glm_vif_thresh, sip);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_SCORE) {
retval = score_report(sc_ip, bedfile, bed_offset, marker_ct, unfiltered_marker_ct, marker_exclude, marker_reverse, marker_ids, max_marker_id_blen, marker_allele_ptrs, set_allele_freqs, sample_ct, unfiltered_sample_ct, sample_exclude, sample_ids, plink_maxfid, plink_maxiid, max_sample_id_len, sex_male, pheno_nm, pheno_c, pheno_d, output_missing_pheno, hh_exists, chrom_info_ptr, outname, outname_end);
if (retval) {
goto plink_ret_1;
}
}
#if defined __cplusplus && !defined _WIN32
if (calculation_type & CALC_RPLUGIN) {
retval = rserve_call(rplugin_fname, rplugin_host_or_socket, rplugin_port, (misc_flags / MISC_RPLUGIN_DEBUG) & 1, bedfile, bed_offset, marker_ct, unfiltered_marker_ct, marker_exclude, marker_reverse, marker_ids, max_marker_id_blen, marker_allele_ptrs, marker_pos, plink_maxsnp, chrom_info_ptr, unfiltered_sample_ct, pheno_nm, pheno_nm_ct, pheno_c, pheno_d, cluster_ct, cluster_map, cluster_starts, covar_ct, covar_d, outname, outname_end);
if (retval) {
goto plink_ret_1;
}
}
#endif
if (calculation_type & CALC_LASSO_LAMBDA) {
retval = lasso_lambda(marker_exclude, marker_reverse, chrom_info_ptr, sample_exclude, sex_male, pheno_nm, covar_nm, bed_offset, unfiltered_marker_ct, marker_ct, unfiltered_sample_ct, sample_ct, pheno_nm_ct, hh_exists, lasso_lambda_iters, lasso_h2, bedfile, outname, outname_end, &lasso_minlambda);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & (CALC_MODEL | CALC_GXE | CALC_GLM | CALC_LASSO | CALC_CMH | CALC_HOMOG | CALC_TESTMISS | CALC_TDT | CALC_DFAM | CALC_QFAM)) {
// can't use pheno_ctrl_ct in here since new phenotypes may be loaded, and
// we don't bother updating it...
if ((!pheno_all) && (!loop_assoc_fname)) {
outname_end2 = outname_end;
goto plink_skip_all_pheno;
}
uii = 0; // phenotype/cluster number
*outname_end = '.';
if (loop_assoc_fname) {
retval = load_clusters(loop_assoc_fname, unfiltered_sample_ct, sample_exclude, &sample_exclude_ct, sample_ids, max_sample_id_len, mwithin_col, (misc_flags / MISC_LOAD_CLUSTER_KEEP_NA) & 1, &cluster_ct, &cluster_map, &cluster_starts, &cluster_ids, &max_cluster_id_len, nullptr, nullptr, nullptr, nullptr, 0);
if (retval) {
goto plink_ret_1;
}
// bugfix (17 Jun 2019): need to reset pheno_nm, otherwise missing values
// in original phenotype remain missing in the --loop-assoc analysis
bitarr_invert_copy(sample_exclude, unfiltered_sample_ct, pheno_nm);
pheno_nm_ct = unfiltered_sample_ct - sample_exclude_ct;
if (pheno_d) {
free(pheno_d);
pheno_d = nullptr;
}
if (!pheno_c) {
if (aligned_malloc(unfiltered_sample_ctl * sizeof(intptr_t), &pheno_c)) {
goto plink_ret_NOMEM;
}
}
} else {
bigstack_mark = g_bigstack_base;
retval = sort_item_ids(unfiltered_sample_ct, sample_exclude, sample_exclude_ct, sample_ids, max_sample_id_len, 0, 0, strcmp_deref, &cptr, &uiptr);
if (retval) {
goto plink_ret_1;
}
}
do {
if (loop_assoc_fname) {
if (uii == cluster_ct) {
break;
}
outname_end2 = strcpya(&(outname_end[1]), &(cluster_ids[uii * max_cluster_id_len]));
fill_ulong_zero(unfiltered_sample_ctl, pheno_c);
ukk = cluster_starts[uii + 1];
for (ujj = cluster_starts[uii]; ujj < ukk; ujj++) {
SET_BIT(cluster_map[ujj], pheno_c);
}
uii++;
} else {
// --all-pheno
if (pheno_modifier & PHENO_MERGE) {
memcpy(pheno_nm, orig_pheno_nm, unfiltered_sample_ctl * sizeof(intptr_t));
if (orig_pheno_c) {
if (!pheno_c) {
free(pheno_d);
pheno_d = nullptr;
if (aligned_malloc(unfiltered_sample_ctl * sizeof(intptr_t), &pheno_c)) {
goto plink_ret_NOMEM;
}
}
memcpy(pheno_c, orig_pheno_c, unfiltered_sample_ctl * sizeof(intptr_t));
} else {
memcpy(pheno_d, orig_pheno_d, unfiltered_sample_ct * sizeof(double));
}
} else {
fill_ulong_zero(unfiltered_sample_ctl, pheno_nm);
aligned_free_cond_null(&pheno_c);
if (pheno_d) {
free(pheno_d);
pheno_d = nullptr;
}
}
// bugfix (9 Jan 2018): forgot to increment phenotype index when
// skipping empty pheno
plink_skip_empty_pheno:
uii++;
rewind(phenofile);
outname_end[1] = '\0';
retval = load_pheno(phenofile, unfiltered_sample_ct, sample_exclude_ct, cptr, max_sample_id_len, uiptr, missing_pheno, (misc_flags / MISC_AFFECTION_01) & 1, uii, nullptr, pheno_nm, &pheno_c, &pheno_d, &(outname_end[1]), (uintptr_t)((&(outname[FNAMESIZE - 32])) - outname_end));
if (retval == LOAD_PHENO_LAST_COL) {
bigstack_reset(bigstack_mark);
retval = 0; // exit code bugfix
break;
} else if (retval) {
goto plink_ret_1;
}
bitvec_andnot(sample_exclude, unfiltered_sample_ctl, pheno_nm);
if (gender_unk_ct && (!(sex_missing_pheno & ALLOW_NO_SEX))) {
bitvec_and(sex_nm, unfiltered_sample_ctl, pheno_nm);
}
pheno_nm_ct = popcount_longs(pheno_nm, unfiltered_sample_ctl);
if (!pheno_nm_ct) {
goto plink_skip_empty_pheno;
}
if (!outname_end[1]) {
outname_end[1] = 'P';
outname_end2 = uint32toa(uii, &(outname_end[2]));
} else {
outname_end2 = (char*)memchr(&(outname_end[1]), '\0', FNAMESIZE);
}
}
*outname_end2 = '\0';
if (pheno_c) {
bitvec_and(pheno_nm, unfiltered_sample_ctl, pheno_c);
ujj = popcount_longs(pheno_c, unfiltered_sample_ctl);
ukk = pheno_nm_ct - ujj;
ulii = unfiltered_sample_ct - sample_exclude_ct - pheno_nm_ct;
if (ulii) {
LOGPRINTF("%s has %u case%s, %u control%s, and %" PRIuPTR " missing phenotype%s.\n", &(outname_end[1]), ujj, (ujj == 1)? "" : "s", ukk, (ukk == 1)? "" : "s", ulii, (ulii == 1)? "" : "s");
} else {
LOGPRINTF("%s has %u case%s and %u control%s.\n", &(outname_end[1]), ujj, (ujj == 1)? "" : "s", ukk, (ukk == 1)? "" : "s");
}
}
plink_skip_all_pheno:
if (calculation_type & CALC_MODEL) {
if (pheno_d) {
if (model_modifier & MODEL_ASSOC) {
retval = qassoc(threads, bedfile, bed_offset, outname, outname_end2, model_modifier, model_mperm_val, pfilter, output_min_p, mtest_adjust, adjust_lambda, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, plink_maxsnp, marker_pos, marker_allele_ptrs, marker_reverse, chrom_info_ptr, unfiltered_sample_ct, cluster_ct, cluster_map, cluster_starts, apip, mperm_save, pheno_nm_ct, pheno_nm, pheno_d, founder_info, sex_male, hh_exists, ldip->modifier & LD_IGNORE_X, perm_batch_size, sip);
}
} else {
retval = model_assoc(threads, bedfile, bed_offset, outname, outname_end2, model_modifier, model_cell_ct, model_mperm_val, ci_size, ci_zt, pfilter, output_min_p, mtest_adjust, adjust_lambda, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, plink_maxsnp, marker_pos, marker_allele_ptrs, max_marker_allele_blen, marker_reverse, chrom_info_ptr, unfiltered_sample_ct, cluster_ct, cluster_map, loop_assoc_fname? nullptr : cluster_starts, apip, mperm_save, pheno_nm_ct, pheno_nm, pheno_c, founder_info, sex_male, hh_exists, ldip->modifier & LD_IGNORE_X, perm_batch_size, sip);
}
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_GLM) {
if (!(glm_modifier & GLM_NO_SNP)) {
if (pheno_d) {
#ifndef NOLAPACK
retval = glm_linear_assoc(threads, bedfile, bed_offset, outname, outname_end2, glm_modifier, glm_vif_thresh, glm_xchr_model, glm_mperm_val, parameters_range_list_ptr, tests_range_list_ptr, ci_size, ci_zt, pfilter, output_min_p, mtest_adjust, adjust_lambda, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, plink_maxsnp, marker_pos, marker_allele_ptrs, max_marker_allele_blen, marker_reverse, condition_mname, condition_fname, chrom_info_ptr, unfiltered_sample_ct, sample_ct, sample_exclude, cluster_ct, cluster_map, cluster_starts, apip, mperm_save, pheno_nm_ct, pheno_nm, pheno_d, covar_ct, covar_names, max_covar_name_len, covar_nm, covar_d, founder_info, sex_nm, sex_male, ldip->modifier & LD_IGNORE_X, hh_exists, perm_batch_size, sip);
#else
logerrprint("Warning: Skipping --logistic on --all-pheno QT since this is a no-LAPACK " PROG_NAME_CAPS"\nbuild.\n");
#endif
} else {
retval = glm_logistic_assoc(threads, bedfile, bed_offset, outname, outname_end2, glm_modifier, glm_vif_thresh, glm_xchr_model, glm_mperm_val, parameters_range_list_ptr, tests_range_list_ptr, ci_size, ci_zt, pfilter, output_min_p, mtest_adjust, adjust_lambda, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, plink_maxsnp, marker_pos, marker_allele_ptrs, max_marker_allele_blen, marker_reverse, condition_mname, condition_fname, chrom_info_ptr, unfiltered_sample_ct, sample_ct, sample_exclude, cluster_ct, cluster_map, cluster_starts, apip, mperm_save, pheno_nm_ct, pheno_nm, pheno_c, covar_ct, covar_names, max_covar_name_len, covar_nm, covar_d, founder_info, sex_nm, sex_male, ldip->modifier & LD_IGNORE_X, hh_exists, perm_batch_size, sip);
}
} else {
if (pheno_d) {
#ifndef NOLAPACK
retval = glm_linear_nosnp(threads, bedfile, bed_offset, outname, outname_end2, glm_modifier, glm_vif_thresh, glm_xchr_model, glm_mperm_val, parameters_range_list_ptr, tests_range_list_ptr, ci_size, ci_zt, pfilter, output_min_p, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, marker_reverse, condition_mname, condition_fname, chrom_info_ptr, unfiltered_sample_ct, sample_ct, sample_exclude, cluster_ct, cluster_map, cluster_starts, mperm_save, pheno_nm_ct, pheno_nm, pheno_d, covar_ct, covar_names, max_covar_name_len, covar_nm, covar_d, sex_nm, sex_male, hh_exists, perm_batch_size, sip);
#else
logerrprint("Warning: Skipping --logistic on --all-pheno QT since this is a no-LAPACK " PROG_NAME_CAPS"\nbuild.\n");
#endif
} else {
retval = glm_logistic_nosnp(threads, bedfile, bed_offset, outname, outname_end2, glm_modifier, glm_vif_thresh, glm_xchr_model, glm_mperm_val, parameters_range_list_ptr, tests_range_list_ptr, ci_size, ci_zt, pfilter, output_min_p, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, marker_reverse, condition_mname, condition_fname, chrom_info_ptr, unfiltered_sample_ct, sample_ct, sample_exclude, cluster_ct, cluster_map, cluster_starts, mperm_save, pheno_nm_ct, pheno_nm, pheno_c, covar_ct, covar_names, max_covar_name_len, covar_nm, covar_d, sex_nm, sex_male, hh_exists, perm_batch_size, sip);
}
}
if (retval) {
goto plink_ret_1;
}
}
// if case/control phenotype loaded with --all-pheno, skip --gxe
if ((calculation_type & CALC_GXE) && pheno_d) {
retval = gxe_assoc(bedfile, bed_offset, outname, outname_end2, output_min_p, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, plink_maxsnp, marker_reverse, chrom_info_ptr, unfiltered_sample_ct, sample_ct, sample_exclude, pheno_nm, pheno_d, gxe_covar_nm, gxe_covar_c, sex_male, hh_exists);
if (retval) {
goto plink_ret_1;
}
}
if (calculation_type & CALC_LASSO) {
retval = lasso(threads, bedfile, bed_offset, outname, outname_end2, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, marker_allele_ptrs, marker_reverse, chrom_info_ptr, unfiltered_sample_ct, sample_ct, pheno_nm_ct, lasso_h2, lasso_minlambda, lasso_select_covars_range_list_ptr, misc_flags, sample_exclude, pheno_nm, pheno_c, pheno_d, covar_ct, covar_names, max_covar_name_len, covar_nm, covar_d, sex_male, hh_exists);
if (retval) {
goto plink_ret_1;
}
}
if ((calculation_type & CALC_CMH) && pheno_c) {
if (!(cluster_ptr->modifier & CLUSTER_CMH2)) {
retval = cmh_assoc(threads, bedfile, bed_offset, outname, outname_end2, cluster_ptr->cmh_mperm_val, cluster_ptr->modifier, ci_size, pfilter, output_min_p, mtest_adjust, adjust_lambda, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, plink_maxsnp, marker_pos, marker_allele_ptrs, marker_reverse, chrom_info_ptr, set_allele_freqs, unfiltered_sample_ct, cluster_ct, cluster_map, cluster_starts, apip, mperm_save, pheno_nm_ct, pheno_nm, pheno_c, sex_male, hh_exists, sip);
} else {
retval = cmh2_assoc(bedfile, bed_offset, outname, outname_end, output_min_p, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, marker_reverse, chrom_info_ptr, unfiltered_sample_ct, cluster_ct, cluster_map, cluster_starts, pheno_nm_ct, pheno_nm, pheno_c, sex_male, hh_exists);
}
if (retval) {
goto plink_ret_1;
}
}
if ((calculation_type & CALC_HOMOG) && pheno_c) {
retval = homog_assoc(bedfile, bed_offset, outname, outname_end, output_min_p, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, plink_maxsnp, marker_allele_ptrs, max_marker_allele_blen, marker_reverse, chrom_info_ptr, set_allele_freqs, unfiltered_sample_ct, cluster_ct, cluster_map, cluster_starts, cluster_ids, max_cluster_id_len, pheno_nm_ct, pheno_nm, pheno_c, sex_male, hh_exists);
if (retval) {
goto plink_ret_1;
}
}
if ((calculation_type & CALC_TESTMISS) && pheno_c) {
retval = testmiss(threads, bedfile, bed_offset, outname, outname_end2, testmiss_mperm_val, testmiss_modifier, pfilter, output_min_p, mtest_adjust, adjust_lambda, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, plink_maxsnp, chrom_info_ptr, unfiltered_sample_ct, cluster_ct, cluster_map, loop_assoc_fname? nullptr : cluster_starts, apip, mperm_save, pheno_nm_ct, pheno_nm, pheno_c, sex_male, hh_exists);
if (retval) {
goto plink_ret_1;
}
}
if ((calculation_type & CALC_TDT) && pheno_c) {
retval = tdt(threads, bedfile, bed_offset, outname, outname_end2, ci_size, ci_zt, pfilter, output_min_p, mtest_adjust, adjust_lambda, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, plink_maxsnp, marker_pos, marker_allele_ptrs, max_marker_allele_blen, marker_reverse, unfiltered_sample_ct, sample_exclude, sample_ct, apip, mperm_save, pheno_nm, pheno_c, founder_info, sex_nm, sex_male, sample_ids, max_sample_id_len, paternal_ids, max_paternal_id_len, maternal_ids, max_maternal_id_len, chrom_info_ptr, hh_exists, fam_ip);
if (retval) {
goto plink_ret_1;
}
}
if ((calculation_type & CALC_DFAM) && pheno_c) {
retval = dfam(threads, bedfile, bed_offset, outname, outname_end2, pfilter, output_min_p, mtest_adjust, adjust_lambda, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, plink_maxsnp, marker_allele_ptrs, max_marker_allele_blen, marker_reverse, unfiltered_sample_ct, sample_exclude, sample_ct, cluster_ct, cluster_map, loop_assoc_fname? nullptr : cluster_starts, apip, mperm_save, pheno_c, founder_info, sex_nm, sex_male, sample_ids, max_sample_id_len, paternal_ids, max_paternal_id_len, maternal_ids, max_maternal_id_len, chrom_info_ptr, hh_exists, (cluster_ptr->fname != nullptr), perm_batch_size, fam_ip, sip);
if (retval) {
goto plink_ret_1;
}
}
#ifndef NOLAPACK
if ((calculation_type & CALC_QFAM) && pheno_d) {
if (covar_ct) {
logerrprint("Warning: The QFAM test ignores covariates.\n");
}
if (cluster_ct) {
logerrprint("Warning: Clusters have no effect on the QFAM permutation test.\n");
}
if (mtest_adjust && (fam_ip->qfam_modifier & QFAM_PERM)) {
logerrprint("Warning: The QFAM test does not support --adjust. Use max(T) permutation to\nobtain multiple-testing corrected p-values.\n");
}
retval = qfam(threads, bedfile, bed_offset, outname, outname_end2, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, plink_maxsnp, marker_pos, marker_allele_ptrs, marker_reverse, unfiltered_sample_ct, sample_exclude, sample_ct, apip, pheno_nm, pheno_d, founder_info, sex_nm, sex_male, sample_ids, max_sample_id_len, paternal_ids, max_paternal_id_len, maternal_ids, max_maternal_id_len, chrom_info_ptr, hh_exists, perm_batch_size, fam_ip);
if (retval) {
goto plink_ret_1;
}
}
#endif
} while (pheno_all || loop_assoc_fname);
}
if (calculation_type & CALC_CLUMP) {
if (map_is_unsorted & UNSORTED_BP) {
logerrprint("Error: --clump requires a sorted .bim. Retry this command after using\n--make-bed to sort your data.\n");
goto plink_ret_INVALID_CMDLINE;
}
retval = clump_reports(bedfile, bed_offset, outname, outname_end, unfiltered_marker_ct, marker_exclude, marker_ct, marker_ids, max_marker_id_blen, plink_maxsnp, marker_pos, marker_allele_ptrs, marker_reverse, chrom_info_ptr, unfiltered_sample_ct, founder_info, clump_ip, sex_male, hh_exists, (misc_flags / MISC_ALLOW_EXTRA_CHROMS) & 1);
if (retval) {
goto plink_ret_1;
}
}
while (0) {
plink_ret_NOMEM:
retval = RET_NOMEM;
break;
plink_ret_OPEN_FAIL:
retval = RET_OPEN_FAIL;
break;
plink_ret_INVALID_FORMAT_2:
logerrprintb();
plink_ret_INVALID_FORMAT:
retval = RET_INVALID_FORMAT;
break;
plink_ret_INVALID_CMDLINE_2:
logerrprintb();
plink_ret_INVALID_CMDLINE:
retval = RET_INVALID_CMDLINE;
break;
plink_ret_READ_FAIL:
retval = RET_READ_FAIL;
break;
plink_ret_ALL_SAMPLES_EXCLUDED:
retval = RET_ALL_SAMPLES_EXCLUDED;
break;
plink_ret_ALL_MARKERS_EXCLUDED:
retval = RET_ALL_MARKERS_EXCLUDED;
break;
}
plink_ret_1:
aligned_free_cond(pheno_nm_datagen);
free_cond(orig_pheno_d);
aligned_free_cond(orig_pheno_c);
aligned_free_cond(orig_pheno_nm);
free_cond(pheno_d);
aligned_free_cond(pheno_c);
fclose_cond(phenofile);
fclose_cond(bedfile);
cleanup_allele_storage(max_marker_allele_blen - 1, 2 * unfiltered_marker_ct, marker_allele_ptrs);
return retval;
}
// meta-analysis-report-dups + terminating null, or 'recode 01 fastphase-1chr'
#define MAX_FLAG_LEN 26
static inline int32_t is_flag(char* param) {
unsigned char ucc = param[1];
return ((*param == '-') && ((ucc > '9') || ((ucc < '0') && (ucc != '.') && (ucc != '\0'))));
}
static inline char* is_flag_start(char* param) {
unsigned char ucc = param[1];
if ((*param == '-') && ((ucc > '9') || ((ucc < '0') && (ucc != '.') && (ucc != '\0')))) {
return (ucc == '-')? (&(param[2])) : (&(param[1]));
}
return nullptr;
}
uint32_t param_count(int32_t argc, char** argv, int32_t flag_idx) {
// Counts the number of optional parameters given to the flag at position
// flag_idx, treating any parameter not beginning with "--" as optional.
int32_t opt_params = 0;
int32_t cur_idx = flag_idx + 1;
while (cur_idx < argc) {
if (is_flag(argv[cur_idx])) {
break;
}
opt_params++;
cur_idx++;
}
return opt_params;
}
int32_t enforce_param_ct_range(uint32_t param_ct, char* flag_name, uint32_t min_ct, uint32_t max_ct) {
if (param_ct > max_ct) {
if (max_ct > min_ct) {
snprintf(g_logbuf, LOGBUFLEN, "Error: %s accepts at most %u parameter%s.\n", flag_name, max_ct, (max_ct == 1)? "" : "s");
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: %s only accepts %u parameter%s.\n", flag_name, max_ct, (max_ct == 1)? "" : "s");
}
return -1;
} else if (param_ct < min_ct) {
if (min_ct == 1) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Missing %s parameter.\n", flag_name);
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: %s requires %s%u parameters.\n", flag_name, (min_ct < max_ct)? "at least " : "", min_ct);
}
return -1;
}
return 0;
}
int32_t parse_next_range(uint32_t param_ct, char range_delim, char** argv, uint32_t* cur_param_idx_ptr, char** cur_arg_pptr, char** range_start_ptr, uint32_t* rs_len_ptr, char** range_end_ptr, uint32_t* re_len_ptr) {
// Starts reading from argv[cur_param_idx][cur_pos]. If a valid range is
// next, range_start + rs_len + range_end + re_len are updated. If only a
// single item is next, range_end is set to nullptr and range_start + rs_len
// are updated. If there are no items left, range_start is set to nullptr.
// If the input is not well-formed, -1 is returned instead of 0.
uint32_t cur_param_idx = *cur_param_idx_ptr;
char* cur_arg_ptr = *cur_arg_pptr;
char cc;
if (cur_param_idx > param_ct) {
*cur_arg_pptr = nullptr;
return 0;
}
while (1) {
cc = *cur_arg_ptr;
if (!cc) {
*cur_param_idx_ptr = ++cur_param_idx;
if (cur_param_idx > param_ct) {
*range_start_ptr = nullptr;
return 0;
}
cur_arg_ptr = argv[cur_param_idx];
cc = *cur_arg_ptr;
}
if (cc == range_delim) {
return -1;
}
if (cc != ',') {
break;
}
cur_arg_ptr++;
}
*range_start_ptr = cur_arg_ptr;
do {
cc = *(++cur_arg_ptr);
if ((!cc) || (cc == ',')) {
*rs_len_ptr = (uintptr_t)(cur_arg_ptr - (*range_start_ptr));
*cur_arg_pptr = cur_arg_ptr;
*range_end_ptr = nullptr;
return 0;
}
} while (cc != range_delim);
*rs_len_ptr = (uintptr_t)(cur_arg_ptr - (*range_start_ptr));
cc = *(++cur_arg_ptr);
if ((!cc) || (cc == ',') || (cc == range_delim)) {
return -1;
}
*range_end_ptr = cur_arg_ptr;
do {
cc = *(++cur_arg_ptr);
if (cc == range_delim) {
return -1;
}
} while (cc && (cc != ','));
*re_len_ptr = (uintptr_t)(cur_arg_ptr - (*range_end_ptr));
*cur_arg_pptr = cur_arg_ptr;
return 0;
}
int32_t parse_chrom_ranges(uint32_t param_ct, char range_delim, char** argv, uintptr_t* chrom_mask, Chrom_info* chrom_info_ptr, uint32_t allow_extra_chroms, char* cur_flag_str) {
uint32_t argct = 0;
uint32_t cur_param_idx = 1;
int32_t retval = 0;
char* cur_arg_ptr;
char* range_start;
uint32_t rs_len;
char* range_end;
uint32_t re_len;
int32_t chrom_code_start;
int32_t chrom_code_end;
if (param_ct) {
cur_arg_ptr = argv[1];
while (1) {
if (parse_next_range(param_ct, range_delim, argv, &cur_param_idx, &cur_arg_ptr, &range_start, &rs_len, &range_end, &re_len)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --%s parameter '%s'.\n", cur_flag_str, argv[cur_param_idx]);
goto parse_chrom_ranges_ret_INVALID_CMDLINE_WWA;
}
if (!range_start) {
break;
}
chrom_code_start = get_chrom_code_counted(chrom_info_ptr, rs_len, range_start);
if (chrom_code_start < 0) {
range_start[rs_len] = '\0';
if (!allow_extra_chroms) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --%s chromosome code '%s'.\n", cur_flag_str, range_start);
goto parse_chrom_ranges_ret_INVALID_CMDLINE_WWA;
} else if (range_end) {
goto parse_chrom_ranges_ret_INVALID_CMDLINE_NONSTD;
}
if (push_ll_str(range_start, &(chrom_info_ptr->incl_excl_name_stack))) {
goto parse_chrom_ranges_ret_NOMEM;
}
} else if (range_end) {
chrom_code_end = get_chrom_code_counted(chrom_info_ptr, re_len, range_end);
if (chrom_code_end < 0) {
if (!allow_extra_chroms) {
range_end[re_len] = '\0';
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --%s chromosome code '%s'.\n", cur_flag_str, range_end);
goto parse_chrom_ranges_ret_INVALID_CMDLINE_WWA;
} else {
goto parse_chrom_ranges_ret_INVALID_CMDLINE_NONSTD;
}
}
if (chrom_code_end <= chrom_code_start) {
range_start[rs_len] = '\0';
range_end[re_len] = '\0';
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s chromosome code '%s' is not greater than '%s'.\n", cur_flag_str, range_end, range_start);
goto parse_chrom_ranges_ret_INVALID_CMDLINE_WWA;
}
fill_bits(chrom_code_start, chrom_code_end + 1 - chrom_code_start, chrom_mask);
} else {
set_bit(chrom_code_start, chrom_mask);
}
argct++;
}
}
if (!argct) {
LOGERRPRINTF("Error: --%s requires at least one value.\n%s", cur_flag_str, errstr_append);
return RET_INVALID_CMDLINE;
}
while (0) {
parse_chrom_ranges_ret_NOMEM:
retval = RET_NOMEM;
break;
parse_chrom_ranges_ret_INVALID_CMDLINE_NONSTD:
logerrprint("Error: Chromosome ranges cannot include nonstandard names.\n");
retval = RET_INVALID_CMDLINE;
break;
parse_chrom_ranges_ret_INVALID_CMDLINE_WWA:
wordwrapb(0);
logerrprintb();
logerrprint(errstr_append);
retval = RET_INVALID_CMDLINE;
break;
}
return retval;
}
int32_t parse_name_ranges(uint32_t param_ct, char range_delim, char** argv, Range_list* range_list_ptr, uint32_t require_posint) {
uint32_t name_ct = 0;
uint32_t cur_param_idx = 1;
uint32_t name_max_len = 0;
char* cur_arg_ptr;
char* range_start;
uint32_t rs_len;
char* range_end;
uint32_t re_len;
char* cur_name_str;
char* dup_check;
unsigned char* cur_name_starts_range;
uint32_t last_val;
uint32_t cur_val;
// two passes. first pass: count parameters, determine name_max_len;
// then allocate memory; then fill it.
if (param_ct) {
cur_arg_ptr = argv[1];
while (1) {
if (parse_next_range(param_ct, range_delim, argv, &cur_param_idx, &cur_arg_ptr, &range_start, &rs_len, &range_end, &re_len)) {
LOGERRPRINTFWW("Error: Invalid %s parameter '%s'.\n", argv[0], argv[cur_param_idx]);
logerrprint(errstr_append);
return RET_INVALID_CMDLINE;
}
if (!range_start) {
break;
}
name_ct++;
if (rs_len > name_max_len) {
name_max_len = rs_len; // does NOT include trailing null yet
}
if (range_end) {
name_ct++;
if (re_len > name_max_len) {
name_max_len = re_len;
}
}
}
}
if (!name_ct) {
LOGERRPRINTF("Error: %s requires at least one value.\n%s", argv[0], errstr_append);
return RET_INVALID_CMDLINE;
}
range_list_ptr->name_max_len = ++name_max_len;
range_list_ptr->name_ct = name_ct;
range_list_ptr->names = (char*)malloc(name_ct * ((uintptr_t)name_max_len));
if (!range_list_ptr->names) {
return RET_NOMEM;
}
range_list_ptr->starts_range = (unsigned char*)malloc(name_ct * sizeof(char));
if (!range_list_ptr->starts_range) {
return RET_NOMEM;
}
cur_name_str = range_list_ptr->names;
cur_name_starts_range = range_list_ptr->starts_range;
cur_param_idx = 1;
cur_arg_ptr = argv[1];
while (1) {
parse_next_range(param_ct, range_delim, argv, &cur_param_idx, &cur_arg_ptr, &range_start, &rs_len, &range_end, &re_len);
if (!range_start) {
if (require_posint) {
last_val = 0;
for (cur_param_idx = 0; cur_param_idx < name_ct; cur_param_idx++) {
cur_name_str = &(range_list_ptr->names[cur_param_idx * ((uintptr_t)name_max_len)]);
dup_check = cur_name_str; // actually a numeric check
do {
if (is_not_digit(*dup_check)) {
LOGERRPRINTFWW("Error: Invalid %s parameter '%s'.\n", argv[0], cur_name_str);
return RET_INVALID_CMDLINE;
}
} while (*(++dup_check));
if (scan_posint_defcapx(cur_name_str, &cur_val)) {
LOGERRPRINTFWW("Error: Invalid %s parameter '%s'.\n", argv[0], cur_name_str);
return RET_INVALID_CMDLINE;
}
if (range_list_ptr->starts_range[cur_param_idx]) {
last_val = cur_val;
} else {
if (cur_val <= last_val) {
LOGERRPRINTFWW("Error: Invalid %s range '%s-%s'.\n", argv[0], &(range_list_ptr->names[(cur_param_idx - 1) * name_max_len]), cur_name_str);
return RET_INVALID_CMDLINE;
}
last_val = 0;
}
}
}
return 0;
}
memcpyx(cur_name_str, range_start, rs_len, 0);
dup_check = range_list_ptr->names;
while (dup_check < cur_name_str) {
if (!memcmp(dup_check, cur_name_str, rs_len + 1)) {
LOGERRPRINTFWW("Error: Duplicate %s parameter '%s'.\n", argv[0], cur_name_str);
return RET_INVALID_CMDLINE;
}
dup_check = &(dup_check[name_max_len]);
}
cur_name_str = &(cur_name_str[name_max_len]);
if (range_end) {
*cur_name_starts_range++ = 1;
memcpyx(cur_name_str, range_end, re_len, 0);
dup_check = range_list_ptr->names;
while (dup_check < cur_name_str) {
if (!memcmp(dup_check, cur_name_str, rs_len + 1)) {
LOGERRPRINTFWW("Error: Duplicate %s parameter '%s'.\n", argv[0], cur_name_str);
return RET_INVALID_CMDLINE;
}
dup_check = &(dup_check[name_max_len]);
}
cur_name_str = &(cur_name_str[name_max_len]);
*cur_name_starts_range++ = 0;
} else {
*cur_name_starts_range++ = 0;
}
}
}
void invalid_arg(char* argv) {
LOGPREPRINTFWW("Error: Unrecognized flag ('%s').\n", argv);
}
void print_ver() {
fputs(ver_str, stdout);
fputs(ver_str2, stdout);
}
int32_t rerun(uint32_t rerun_argv_pos, uint32_t rerun_parameter_present, int32_t* argc_ptr, uint32_t* cur_arg_ptr, char*** argv_ptr, char*** subst_argv_ptr, char** rerun_buf_ptr) {
// caller is responsible for freeing rerun_buf
char** argv = *argv_ptr;
FILE* rerunfile = fopen(rerun_parameter_present? argv[rerun_argv_pos + 1] : (PROG_NAME_STR ".log"), "r");
uintptr_t line_idx = 1;
char** subst_argv2 = nullptr;
uint32_t argc = (uint32_t)(*argc_ptr);
uint32_t cur_arg = *cur_arg_ptr;
int32_t retval = 0;
char* rerun_buf;
char* rerun_start_ptr;
char* sptr;
char* argptr;
char* argptr2;
char* load_ptr;
uint32_t line_byte_ct;
uint32_t loaded_arg_ct;
uint32_t duplicate_ct;
uint32_t loaded_arg_idx;
uint32_t cmdline_arg_idx;
uint32_t new_arg_idx;
uint32_t slen;
uint32_t slen2;
if (!rerunfile) {
goto rerun_ret_OPEN_FAIL;
}
g_textbuf[MAXLINELEN - 1] = ' ';
if (!fgets(g_textbuf, MAXLINELEN, rerunfile)) {
print_ver();
fputs("Error: Empty log file for --rerun.\n", stderr);
goto rerun_ret_INVALID_FORMAT;
}
if (!g_textbuf[MAXLINELEN - 1]) {
goto rerun_ret_LONG_LINE;
}
if (!fgets(g_textbuf, MAXLINELEN, rerunfile)) {
print_ver();
fputs("Error: Only one line in --rerun log file.\n", stderr);
goto rerun_ret_INVALID_FORMAT;
}
line_idx++;
if (!g_textbuf[MAXLINELEN - 1]) {
goto rerun_ret_LONG_LINE;
}
if ((g_textbuf[0] >= '0') && (g_textbuf[0] <= '9')) {
// Old "xx arguments: --aa bb --cc --dd" format
fclose_null(&rerunfile);
if (scan_posint_cappedx(g_textbuf, (MAXLINELEN / 2), &loaded_arg_ct)) {
print_ver();
fputs("Error: Invalid argument count on line 2 of --rerun log file.\n", stderr);
goto rerun_ret_INVALID_FORMAT;
}
line_byte_ct = strlen(g_textbuf) + 1;
rerun_buf = (char*)malloc(line_byte_ct);
if (!rerun_buf) {
goto rerun_ret_NOMEM;
}
*rerun_buf_ptr = rerun_buf;
memcpy(rerun_buf, g_textbuf, line_byte_ct);
// skip "xx arguments: ", to get to the first flag
rerun_start_ptr = next_token_mult(rerun_buf, 2);
} else {
// Current, and also PLINK 1.07, "Options in effect:"
while (memcmp(g_textbuf, "Options in effect:", 18) || (g_textbuf[18] >= ' ')) {
line_idx++;
if (!fgets(g_textbuf, MAXLINELEN, rerunfile)) {
print_ver();
fputs("Error: Invalid log file for --rerun.\n", stderr);
goto rerun_ret_INVALID_FORMAT;
}
}
load_ptr = g_textbuf;
loaded_arg_ct = 0;
// We load each of the option lines in sequence into g_textbuf, always
// overwriting the previous line's newline. (Note that g_textbuf[] has
// size > 2 * MAXLINELEN; this lets us avoid additional dynamic memory
// allocation as long as we impose the constraint that all lines combined
// add up to less than MAXLINELEN bytes.)
while (1) {
load_ptr[MAXLINELEN - 1] = ' ';
if (!fgets(load_ptr, MAXLINELEN, rerunfile)) {
break;
}
line_idx++;
if (!load_ptr[MAXLINELEN - 1]) {
goto rerun_ret_LONG_LINE;
}
sptr = skip_initial_spaces(load_ptr);
if (is_eoln_kns(*sptr)) {
*load_ptr = '\0';
break;
}
do {
argptr = token_endnn(sptr);
loaded_arg_ct++;
sptr = skip_initial_spaces(argptr);
} while (!is_eoln_kns(*sptr));
load_ptr = argptr;
if (load_ptr >= &(g_textbuf[MAXLINELEN])) {
print_ver();
fputs("Error: --rerun argument sequence too long.\n", stderr);
goto rerun_ret_INVALID_FORMAT;
}
}
fclose_null(&rerunfile);
line_byte_ct = 1 + (uintptr_t)(load_ptr - g_textbuf);
rerun_buf = (char*)malloc(line_byte_ct);
if (!rerun_buf) {
goto rerun_ret_NOMEM;
}
memcpy(rerun_buf, g_textbuf, line_byte_ct);
rerun_start_ptr = skip_initial_spaces(rerun_buf);
}
sptr = rerun_start_ptr;
// now use g_textbuf as a lame bitfield
memset(g_textbuf, 1, loaded_arg_ct);
loaded_arg_idx = 0;
duplicate_ct = 0;
do {
if (no_more_tokens_kns(sptr)) {
print_ver();
fputs("Error: Line 2 of --rerun log file has fewer tokens than expected.\n", stderr);
goto rerun_ret_INVALID_FORMAT;
}
argptr = is_flag_start(sptr);
if (argptr) {
slen = strlen_se(argptr);
for (cmdline_arg_idx = cur_arg; cmdline_arg_idx < argc; cmdline_arg_idx++) {
argptr2 = is_flag_start(argv[cmdline_arg_idx]);
if (argptr2) {
slen2 = strlen(argptr2);
if ((slen == slen2) && (!memcmp(argptr, argptr2, slen))) {
cmdline_arg_idx = 0xffffffffU;
break;
}
}
}
if (cmdline_arg_idx == 0xffffffffU) {
// matching flag, override --rerun
do {
duplicate_ct++;
g_textbuf[loaded_arg_idx++] = 0;
if (loaded_arg_idx == loaded_arg_ct) {
break;
}
sptr = next_token(sptr);
} while (!is_flag(sptr));
} else {
loaded_arg_idx++;
sptr = next_token(sptr);
}
} else {
loaded_arg_idx++;
sptr = next_token(sptr);
}
} while (loaded_arg_idx < loaded_arg_ct);
subst_argv2 = (char**)malloc((argc + loaded_arg_ct - duplicate_ct - rerun_parameter_present - 1 - cur_arg) * sizeof(char*));
if (!subst_argv2) {
goto rerun_ret_NOMEM;
}
new_arg_idx = 0;
for (cmdline_arg_idx = cur_arg; cmdline_arg_idx < rerun_argv_pos; cmdline_arg_idx++) {
subst_argv2[new_arg_idx++] = argv[cmdline_arg_idx];
}
sptr = rerun_start_ptr;
for (loaded_arg_idx = 0; loaded_arg_idx < loaded_arg_ct; loaded_arg_idx++) {
if (g_textbuf[loaded_arg_idx]) {
slen = strlen_se(sptr);
subst_argv2[new_arg_idx++] = sptr;
sptr[slen] = '\0';
if (loaded_arg_idx != loaded_arg_ct - 1) {
sptr = skip_initial_spaces(&(sptr[slen + 1]));
}
} else {
sptr = next_token(sptr);
}
}
for (cmdline_arg_idx = rerun_argv_pos + rerun_parameter_present + 1; cmdline_arg_idx < argc; cmdline_arg_idx++) {
subst_argv2[new_arg_idx++] = argv[cmdline_arg_idx];
}
*cur_arg_ptr = 0;
*argc_ptr = new_arg_idx;
if (*subst_argv_ptr) {
free(*subst_argv_ptr);
}
*subst_argv_ptr = subst_argv2;
*argv_ptr = subst_argv2;
subst_argv2 = nullptr;
while (0) {
rerun_ret_NOMEM:
print_ver();
fputs(errstr_nomem, stderr);
retval = RET_NOMEM;
break;
rerun_ret_OPEN_FAIL:
print_ver();
fputs("Error: Failed to open --rerun file.\n", stderr);
retval = RET_OPEN_FAIL;
break;
rerun_ret_LONG_LINE:
print_ver();
fprintf(stderr, "Error: Line %" PRIuPTR " of --rerun log file is pathologically long.\n", line_idx);
rerun_ret_INVALID_FORMAT:
retval = RET_INVALID_FORMAT;
break;
}
free_cond(subst_argv2);
fclose_cond(rerunfile);
return retval;
}
char extract_char_param(char* ss) {
// maps c, 'c', and "c" to c, and anything else to the null char. This is
// intended to support e.g. always using '#' to designate a # parameter
// without worrying about differences between shells.
char cc = ss[0];
if (((cc == '\'') || (cc == '"')) && (ss[1]) && (ss[2] == cc) && (!ss[3])) {
return ss[1];
} else if (cc && (!ss[1])) {
return cc;
} else {
return '\0';
}
}
int32_t alloc_string(char** sbuf, const char* source) {
uint32_t slen = strlen(source) + 1;
*sbuf = (char*)malloc(slen * sizeof(char));
if (!(*sbuf)) {
return -1;
}
memcpy(*sbuf, source, slen);
return 0;
}
int32_t alloc_fname(char** fnbuf, char* source, char* argptr, uint32_t extra_size) {
uint32_t slen = strlen(source) + 1;
if (slen > (FNAMESIZE - extra_size)) {
LOGERRPRINTF("Error: --%s filename too long.\n", argptr);
return RET_OPEN_FAIL;
}
*fnbuf = (char*)malloc((slen + extra_size) * sizeof(char));
if (!(*fnbuf)) {
return RET_NOMEM;
}
memcpy(*fnbuf, source, slen);
return 0;
}
int32_t alloc_and_flatten(char** flattened_buf_ptr, char** sources, uint32_t param_ct) {
uint32_t totlen = 1;
char* bufptr;
uint32_t param_idx;
for (param_idx = 0; param_idx < param_ct; param_idx++) {
totlen += 1 + strlen(sources[param_idx]);
}
bufptr = (char*)malloc(totlen);
if (!bufptr) {
return RET_NOMEM;
}
*flattened_buf_ptr = bufptr;
for (param_idx = 0; param_idx < param_ct; param_idx++) {
bufptr = strcpyax(bufptr, sources[param_idx], '\0');
}
*bufptr = '\0';
return 0;
}
int32_t alloc_and_flatten_comma_delim(char** flattened_buf_ptr, char** sources, uint32_t param_ct) {
uint32_t totlen = 1;
char* bufptr;
char* bufptr2;
char* bufptr3;
uint32_t param_idx;
for (param_idx = 0; param_idx < param_ct; param_idx++) {
bufptr = sources[param_idx];
while (1) {
while (*bufptr == ',') {
bufptr++;
}
bufptr2 = strchr(bufptr, ',');
if (!bufptr2) {
break;
}
totlen += 1 + (uintptr_t)(bufptr2 - bufptr);
bufptr = &(bufptr2[1]);
}
totlen += 1 + strlen(bufptr);
}
bufptr = (char*)malloc(totlen);
if (!bufptr) {
return RET_NOMEM;
}
*flattened_buf_ptr = bufptr;
for (param_idx = 0; param_idx < param_ct; param_idx++) {
bufptr2 = sources[param_idx];
while (1) {
while (*bufptr2 == ',') {
bufptr2++;
}
bufptr3 = strchr(bufptr2, ',');
if (!bufptr3) {
break;
}
bufptr = memcpyax(bufptr, bufptr2, (uintptr_t)(bufptr3 - bufptr2), '\0');
bufptr2 = &(bufptr3[1]);
}
bufptr = strcpyax(bufptr, bufptr2, '\0');
}
*bufptr = '\0';
return 0;
}
int32_t alloc_2col(Two_col_params** tcbuf, char** params_ptr, char* argptr, uint32_t param_ct) {
uint32_t slen = strlen(*params_ptr) + 1;
char cc;
if (slen > FNAMESIZE) {
LOGERRPRINTF("Error: --%s filename too long.\n", argptr);
return RET_OPEN_FAIL;
}
*tcbuf = (Two_col_params*)malloc(sizeof(Two_col_params) + slen);
if (!(*tcbuf)) {
return RET_NOMEM;
}
memcpy((*tcbuf)->fname, params_ptr[0], slen);
(*tcbuf)->skip = 0;
(*tcbuf)->skipchar = '\0';
if (param_ct > 1) {
if (scan_posint_defcapx(params_ptr[1], &((*tcbuf)->colx))) {
LOGERRPRINTF("Error: Invalid --%s column number.\n", argptr);
return RET_INVALID_FORMAT;
}
if (param_ct > 2) {
if (scan_posint_defcapx(params_ptr[2], &((*tcbuf)->colid))) {
LOGERRPRINTF("Error: Invalid --%s variant ID column number.\n", argptr);
return RET_INVALID_FORMAT;
}
if (param_ct == 4) {
cc = params_ptr[3][0];
if ((cc < '0') || (cc > '9')) {
cc = extract_char_param(params_ptr[3]);
if (!cc) {
goto alloc_2col_invalid_skip;
}
(*tcbuf)->skipchar = cc;
} else {
if (scan_uint_defcapx(params_ptr[3], &((*tcbuf)->skip))) {
alloc_2col_invalid_skip:
LOGERRPRINTF("Error: Invalid --%s skip parameter. This needs to either be a\nsingle character (usually '#') which, when present at the start of a line,\nindicates it should be skipped; or the number of initial lines to skip. (Note\nthat in shells such as bash, '#' is a special character that must be\nsurrounded by single- or double-quotes to be parsed correctly.)\n", argptr);
return RET_INVALID_FORMAT;
}
}
}
} else {
(*tcbuf)->colid = 1;
}
if ((*tcbuf)->colx == (*tcbuf)->colid) {
LOGERRPRINTF("Error: Column numbers for --%s cannot be equal.\n%s", argptr, errstr_append);
return RET_INVALID_FORMAT;
}
} else {
(*tcbuf)->colx = 2;
(*tcbuf)->colid = 1;
}
return 0;
}
int32_t flag_match(const char* to_match, uint32_t* cur_flag_ptr, uint32_t flag_ct, char* flag_buf) {
int32_t ii;
while (*cur_flag_ptr < flag_ct) {
ii = strcmp(to_match, &(flag_buf[(*cur_flag_ptr) * MAX_FLAG_LEN]));
if (ii < 0) {
return 0;
}
*cur_flag_ptr += 1;
if (!ii) {
flag_buf[((*cur_flag_ptr) - 1) * MAX_FLAG_LEN] = '\0';
return 1;
}
}
return 0;
}
uint32_t species_flag(uint32_t* species_code_ptr, uint32_t new_code) {
if (*species_code_ptr) {
logerrprint("Error: Multiple chromosome set flags.\n");
return 1;
}
*species_code_ptr = new_code;
return 0;
}
uint32_t valid_varid_template_string(char* varid_str, const char* flag_name) {
char* sptr = strchr(varid_str, '@');
char* sptr2 = strchr(varid_str, '#');
if ((!sptr) || (!sptr2) || strchr(&(sptr[1]), '@') || strchr(&(sptr2[1]), '#')) {
LOGERRPRINTFWW("Error: The %s template string requires exactly one '@' and one '#'.\n", flag_name);
return 0;
}
// snp/nonsnp is not sufficient for assigning unique IDs to unnamed 1000
// Genomes phase 3 variants (see e.g. chr22:18078898). So we now allow the
// template string to include allele names, where '$1' = first allele in
// ASCII-sort order, and '$2' = second allele.
// Use of sorted order, instead of ref/alt or major/minor, is necessary to
// minimize the chance of assigning different names to the same variant in
// different datasets. (Triallelic variants are still a problem, but no
// solution is possible there until the file format is extended.)
// For now, either '$' must be entirely absent from the template string, or
// it appears exactly twice, once in '$1' and once in '$2'.
sptr = strchr(varid_str, '$');
if (sptr) {
sptr2 = strchr(&(sptr[1]), '$');
if ((!sptr2) || strchr(&(sptr2[1]), '$') || (!(((sptr[1] == '1') && (sptr2[1] == '2')) || ((sptr[1] == '2') && (sptr2[1] == '1'))))) {
LOGERRPRINTFWW("Error: The %s template string requires either no instances of '$', or exactly one '$1' and one '$2'.\n", flag_name);
return 0;
}
}
return 1;
}
int32_t init_delim_and_species(uint32_t flag_ct, char* flag_buf, uint32_t* flag_map, int32_t argc, char** argv, char* range_delim_ptr, Chrom_info* chrom_info_ptr) {
uint32_t species_code = SPECIES_DEFAULT;
uint32_t flag_idx = 0;
uint32_t retval = 0;
int32_t cur_arg;
uint32_t param_ct;
int32_t ii;
uint32_t param_idx;
if (flag_match("autosome-num", &flag_idx, flag_ct, flag_buf)) {
species_code = SPECIES_UNKNOWN;
cur_arg = flag_map[flag_idx - 1];
param_ct = param_count(argc, argv, cur_arg);
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto init_delim_and_species_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_cappedx(argv[cur_arg + 1], MAX_CHROM_TEXTNUM, (uint32_t*)(&ii))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --autosome-num parameter '%s'.\n", argv[cur_arg + 1]);
goto init_delim_and_species_ret_INVALID_CMDLINE_WWA;
}
chrom_info_ptr->xymt_codes[X_OFFSET] = ii + 1;
// bugfix (28 Apr 2020): We were segfaulting instead of printing an
// appropriate error message when e.g. --autosome-num was specified yet
// chrY was encountered.
// plink 2.0 fixed this issue by using -2 instead of -1 to indicate a null
// xymt_code (-1 signals that there's nothing to worry about when
// --allow-extra-chr is specified). It touches more code than I'd like,
// but I haven't gotten any related plink 2.0 bug reports for a long time,
// so we backport that fix.
chrom_info_ptr->xymt_codes[Y_OFFSET] = -2;
chrom_info_ptr->xymt_codes[XY_OFFSET] = -2;
chrom_info_ptr->xymt_codes[MT_OFFSET] = -2;
chrom_info_ptr->max_code = ii + 1;
chrom_info_ptr->autosome_ct = ii;
set_bit(ii + 1, chrom_info_ptr->haploid_mask);
}
if (flag_match("chr-set", &flag_idx, flag_ct, flag_buf)) {
if (species_flag(&species_code, SPECIES_UNKNOWN)) {
goto init_delim_and_species_ret_INVALID_CMDLINE;
}
cur_arg = flag_map[flag_idx - 1];
param_ct = param_count(argc, argv, cur_arg);
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 5)) {
goto init_delim_and_species_ret_INVALID_CMDLINE_2A;
}
if (scan_int_abs_boundedx(argv[cur_arg + 1], MAX_CHROM_TEXTNUM, &ii) || (!ii)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --chr-set parameter '%s'.\n", argv[cur_arg + 1]);
goto init_delim_and_species_ret_INVALID_CMDLINE_WWA;
}
if (ii < 0) {
if (param_ct > 1) {
logerrprint("Error: --chr-set does not accept multiple parameters in haploid mode.\n");
goto init_delim_and_species_ret_INVALID_CMDLINE_A;
}
ii = -ii;
chrom_info_ptr->autosome_ct = ii;
chrom_info_ptr->xymt_codes[X_OFFSET] = -2;
chrom_info_ptr->xymt_codes[Y_OFFSET] = -2;
chrom_info_ptr->xymt_codes[XY_OFFSET] = -2;
chrom_info_ptr->xymt_codes[MT_OFFSET] = -2;
chrom_info_ptr->max_code = ii;
fill_all_bits(((uint32_t)ii) + 1, chrom_info_ptr->haploid_mask);
} else {
chrom_info_ptr->autosome_ct = ii;
chrom_info_ptr->xymt_codes[X_OFFSET] = ii + 1;
chrom_info_ptr->xymt_codes[Y_OFFSET] = ii + 2;
chrom_info_ptr->xymt_codes[XY_OFFSET] = ii + 3;
chrom_info_ptr->xymt_codes[MT_OFFSET] = ii + 4;
set_bit(ii + 1, chrom_info_ptr->haploid_mask);
set_bit(ii + 2, chrom_info_ptr->haploid_mask);
for (param_idx = 2; param_idx <= param_ct; param_idx++) {
if (!strcmp(argv[cur_arg + param_idx], "no-x")) {
chrom_info_ptr->xymt_codes[X_OFFSET] = -2;
clear_bit(ii + 1, chrom_info_ptr->haploid_mask);
} else if (!strcmp(argv[cur_arg + param_idx], "no-y")) {
chrom_info_ptr->xymt_codes[Y_OFFSET] = -2;
clear_bit(ii + 2, chrom_info_ptr->haploid_mask);
} else if (!strcmp(argv[cur_arg + param_idx], "no-xy")) {
chrom_info_ptr->xymt_codes[XY_OFFSET] = -2;
} else if (!strcmp(argv[cur_arg + param_idx], "no-mt")) {
chrom_info_ptr->xymt_codes[MT_OFFSET] = -2;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --chr-set parameter '%s'.\n", argv[cur_arg + param_idx]);
goto init_delim_and_species_ret_INVALID_CMDLINE_WWA;
}
}
if (chrom_info_ptr->xymt_codes[MT_OFFSET] != -2) {
chrom_info_ptr->max_code = ii + 4;
} else if (chrom_info_ptr->xymt_codes[XY_OFFSET] != -2) {
chrom_info_ptr->max_code = ii + 3;
} else if (chrom_info_ptr->xymt_codes[Y_OFFSET] != -2) {
chrom_info_ptr->max_code = ii + 2;
} else if (chrom_info_ptr->xymt_codes[X_OFFSET] != -2) {
chrom_info_ptr->max_code = ii + 1;
} else {
chrom_info_ptr->max_code = ii;
}
}
}
if (flag_match("cow", &flag_idx, flag_ct, flag_buf)) {
if (species_flag(&species_code, SPECIES_COW)) {
goto init_delim_and_species_ret_INVALID_CMDLINE;
}
if (param_count(argc, argv, flag_map[flag_idx - 1])) {
logerrprint("Error: --cow doesn't accept parameters.\n");
goto init_delim_and_species_ret_INVALID_CMDLINE;
}
}
if (flag_match("d", &flag_idx, flag_ct, flag_buf)) {
// moved here to support --covar-name + --d
cur_arg = flag_map[flag_idx - 1];
param_ct = param_count(argc, argv, cur_arg);
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto init_delim_and_species_ret_INVALID_CMDLINE_2A;
}
*range_delim_ptr = extract_char_param(argv[cur_arg + 1]);
if (!(*range_delim_ptr)) {
logerrprint("Error: --d parameter too long (must be a single character).\n");
goto init_delim_and_species_ret_INVALID_CMDLINE_A;
} else if ((*range_delim_ptr == '-') || (*range_delim_ptr == ',')) {
logerrprint("Error: --d parameter cannot be '-' or ','.\n");
goto init_delim_and_species_ret_INVALID_CMDLINE_A;
}
}
if (flag_match("dog", &flag_idx, flag_ct, flag_buf)) {
if (species_flag(&species_code, SPECIES_DOG)) {
goto init_delim_and_species_ret_INVALID_CMDLINE;
}
if (param_count(argc, argv, flag_map[flag_idx - 1])) {
logerrprint("Error: --dog doesn't accept parameters.\n");
goto init_delim_and_species_ret_INVALID_CMDLINE;
}
}
if (flag_match("horse", &flag_idx, flag_ct, flag_buf)) {
if (species_flag(&species_code, SPECIES_HORSE)) {
goto init_delim_and_species_ret_INVALID_CMDLINE;
}
if (param_count(argc, argv, flag_map[flag_idx - 1])) {
logerrprint("Error: --horse doesn't accept parameters.\n");
goto init_delim_and_species_ret_INVALID_CMDLINE;
}
}
if (flag_match("mouse", &flag_idx, flag_ct, flag_buf)) {
if (species_flag(&species_code, SPECIES_MOUSE)) {
goto init_delim_and_species_ret_INVALID_CMDLINE;
}
if (param_count(argc, argv, flag_map[flag_idx - 1])) {
logerrprint("Error: --mouse doesn't accept parameters.\n");
goto init_delim_and_species_ret_INVALID_CMDLINE;
}
}
if (flag_match("rice", &flag_idx, flag_ct, flag_buf)) {
if (species_flag(&species_code, SPECIES_RICE)) {
goto init_delim_and_species_ret_INVALID_CMDLINE;
}
if (param_count(argc, argv, flag_map[flag_idx - 1])) {
logerrprint("Error: --rice doesn't accept parameters.\n");
goto init_delim_and_species_ret_INVALID_CMDLINE;
}
}
if (flag_match("sheep", &flag_idx, flag_ct, flag_buf)) {
if (species_flag(&species_code, SPECIES_SHEEP)) {
goto init_delim_and_species_ret_INVALID_CMDLINE;
}
if (param_count(argc, argv, flag_map[flag_idx - 1])) {
logerrprint("Error: --sheep doesn't accept parameters.\n");
goto init_delim_and_species_ret_INVALID_CMDLINE;
}
}
init_species(species_code, chrom_info_ptr);
while (0) {
init_delim_and_species_ret_INVALID_CMDLINE_WWA:
wordwrapb(0);
init_delim_and_species_ret_INVALID_CMDLINE_2A:
logerrprintb();
init_delim_and_species_ret_INVALID_CMDLINE_A:
logerrprint(errstr_append);
retval = RET_INVALID_CMDLINE;
break;
init_delim_and_species_ret_INVALID_CMDLINE:
retval = RET_INVALID_CMDLINE;
break;
}
return retval;
}
int32_t recode_type_set(uint32_t* recode_modifier_ptr, uint32_t cur_code) {
if (*recode_modifier_ptr & (RECODE_TYPEMASK - cur_code)) {
logerrprint("Error: Multiple --recode output formats.\n");
return -1;
}
*recode_modifier_ptr |= cur_code;
return 0;
}
int32_t main(int32_t argc, char** argv) {
char* outname_end = nullptr;
char** subst_argv = nullptr;
char* script_buf = nullptr;
char* rerun_buf = nullptr;
char* flag_buf = nullptr;
uint32_t* flag_map = nullptr;
char* makepheno_str = nullptr;
char* phenoname_str = nullptr;
Two_col_params* a1alleles = nullptr;
Two_col_params* a2alleles = nullptr;
char* sample_sort_fname = nullptr;
char* filtervals_flattened = nullptr;
char* evecname = nullptr;
char* filtername = nullptr;
char* distance_wts_fname = nullptr;
char* read_dists_fname = nullptr;
char* read_dists_id_fname = nullptr;
char* freqname = nullptr;
char* extractname = nullptr;
char* excludename = nullptr;
char* keepname = nullptr;
char* removename = nullptr;
char* keepfamname = nullptr;
char* removefamname = nullptr;
char* cm_map_fname = nullptr;
char* cm_map_chrname = nullptr;
char* phenoname = nullptr;
char* recode_allele_name = nullptr;
char* lgen_reference_fname = nullptr;
char* covar_fname = nullptr;
char* update_alleles_fname = nullptr;
Two_col_params* qual_filter = nullptr;
Two_col_params* update_chr = nullptr;
Two_col_params* update_cm = nullptr;
Two_col_params* update_map = nullptr;
Two_col_params* update_name = nullptr;
char* oxford_single_chr = nullptr;
char* oxford_pheno_name = nullptr;
char* update_ids_fname = nullptr;
char* update_parents_fname = nullptr;
char* update_sex_fname = nullptr;
char* loop_assoc_fname = nullptr;
char* flip_fname = nullptr;
char* flip_subset_fname = nullptr;
char* read_genome_fname = nullptr;
char* condition_mname = nullptr;
char* condition_fname = nullptr;
char* missing_marker_id_match = nullptr;
char* filter_attrib_fname = nullptr;
char* filter_attrib_liststr = nullptr;
char* filter_attrib_sample_fname = nullptr;
char* filter_attrib_sample_liststr = nullptr;
char* const_fid = nullptr;
char* vcf_filter_exceptions_flattened = nullptr;
char* gene_report_fname = nullptr;
char* gene_report_glist = nullptr;
char* gene_report_subset = nullptr;
char* gene_report_snp_field = nullptr;
char* metaanal_fnames = nullptr;
char* metaanal_chrfield_search_order = nullptr;
char* metaanal_snpfield_search_order = nullptr;
char* metaanal_bpfield_search_order = nullptr;
char* metaanal_a1field_search_order = nullptr;
char* metaanal_a2field_search_order = nullptr;
char* metaanal_pfield_search_order = nullptr;
char* metaanal_sefield_search_order = nullptr;
char* metaanal_essfield_search_order = nullptr;
char* rplugin_fname = nullptr;
char* rplugin_host_or_socket = nullptr;
uint32_t gene_report_border = 0;
uint32_t metaanal_flags = 0;
int32_t rplugin_port = -2; // now interpreted by rserve_call() as default
double vcf_min_qual = -1;
double vcf_min_gq = -1;
double vcf_min_gp = -1;
double qual_min_thresh = 0.0;
double qual_max_thresh = DBL_MAX;
char id_delim = '\0';
char vcf_idspace_to = '\0';
unsigned char vcf_half_call = 0;
int32_t retval = 0;
uint32_t load_params = 0; // describes what file params have been provided
uint32_t load_rare = 0;
uint32_t fam_cols = FAM_COL_13456;
uint32_t mpheno_col = 0;
uint32_t mwithin_col = 0;
uint64_t misc_flags = 0;
uint64_t filter_flags = 0;
double thin_keep_prob = 1.0;
double thin_keep_sample_prob = 1.0;
uint32_t thin_keep_ct = 0xffffffffU;
uint32_t thin_keep_sample_ct = 0xffffffffU;
uint32_t min_bp_space = 0;
uint32_t check_sex_f_yobs = 0;
uint32_t check_sex_m_yobs = 0;
double check_sex_fthresh = 0.2;
double check_sex_mthresh = 0.8;
double distance_exp = 0.0;
double min_maf = 0.0;
double max_maf = 0.5;
double geno_thresh = 1.0;
double mind_thresh = 1.0;
double hwe_thresh = 0.0;
uint32_t cur_arg = 1;
uint64_t calculation_type = 0;
uint32_t dist_calc_type = 0;
uint32_t mfilter_col = 0;
uint32_t pheno_modifier = 0;
int32_t missing_pheno = -9;
intptr_t malloc_size_mb = 0;
uintptr_t groupdist_iters = ITERS_DEFAULT;
uint32_t groupdist_d = 0;
uintptr_t regress_iters = ITERS_DEFAULT;
uint32_t regress_d = 0;
uint32_t parallel_idx = 0;
uint32_t parallel_tot = 1;
uint32_t splitx_bound1 = 0;
uint32_t splitx_bound2 = 0;
uint32_t sex_missing_pheno = 0;
uint32_t update_sex_col = 1;
uint32_t hwe_modifier = 0;
uint32_t min_ac = 0;
uint32_t max_ac = 0x7fffffff;
uint32_t write_covar_modifier = 0;
uint32_t write_covar_dummy_max_categories = 49;
uint32_t dupvar_modifier = 0;
uint32_t model_modifier = 0;
int32_t model_cell_ct = -1;
uint32_t gxe_mcovar = 0;
uint32_t glm_modifier = 0;
double glm_vif_thresh = 50.0;
uint32_t glm_xchr_model = 1;
uint32_t ppc_gap = DEFAULT_PPC_GAP;
uint32_t* rseeds = nullptr;
uint32_t rseed_ct = 0;
uint32_t genome_modifier = 0;
double genome_min_pi_hat = -1.0;
double genome_max_pi_hat = 1.0;
FILE* scriptfile = nullptr;
uint32_t recode_modifier = 0;
uint32_t recode_require_format = 0;
uint32_t allelexxxx = 0;
uint32_t merge_type = 0;
uint32_t sample_sort = 0;
uint32_t cur_flag = 0;
uint32_t flag_ct = 0;
uint32_t dummy_marker_ct = 0;
uint32_t dummy_sample_ct = 0;
uint32_t dummy_flags = 0;
double dummy_missing_geno = 0.0;
double dummy_missing_pheno = 0.0;
char* simulate_fname = nullptr;
uint32_t simulate_flags = 0;
uint32_t simulate_cases = 1000;
uint32_t simulate_controls = 1000;
double simulate_prevalence = 0.01;
char* simulate_label = nullptr;
double simulate_missing = 0.0;
uint32_t simulate_qt_samples = 1000;
char* markername_from = nullptr;
char* markername_to = nullptr;
char* markername_snp = nullptr;
// minor bugfix: --snp and '--window 0 --snp' should actually behave
// differently when there are other variants at the same bp coordinate
int32_t snp_window_size = -1;
int32_t marker_pos_start = -1;
int32_t marker_pos_end = -1;
uint32_t write_var_range_ct = 0;
uint32_t lgen_modifier = 0;
uint32_t covar_modifier = 0;
uint32_t update_map_modifier = 0;
uint32_t model_mperm_val = 0;
uint32_t glm_mperm_val = 0;
uint32_t mperm_save = 0;
uint32_t mperm_val = 0;
double ci_size = 0.0;
double pfilter = 2.0; // make --pfilter 1 still filter out NAs
double output_min_p = 0.0;
uint32_t perm_batch_size = DEFAULT_PERM_BATCH_SIZE;
uint32_t mtest_adjust = 0;
double adjust_lambda = 0.0;
uintptr_t ibs_test_perms = DEFAULT_IBS_TEST_PERMS;
uint32_t neighbor_n1 = 0;
uint32_t neighbor_n2 = 0;
uint32_t cnv_calc_type = 0;
uint32_t cnv_sample_mperms = 0;
uint32_t cnv_test_mperms = 0;
uint32_t cnv_test_region_mperms = 0;
uint32_t cnv_enrichment_test_mperms = 0;
uint32_t cnv_min_seglen = 0;
uint32_t cnv_max_seglen = 0xffffffffU;
double cnv_min_score = -DBL_MAX;
double cnv_max_score = DBL_MAX;
uint32_t cnv_min_sites = 0;
uint32_t cnv_max_sites = 0xffffffffU;
uint32_t cnv_intersect_filter_type = 0;
char* cnv_intersect_filter_fname = nullptr;
char* cnv_subset_fname = nullptr;
uint32_t cnv_overlap_type = 0;
double cnv_overlap_val = 0.0;
uint32_t cnv_freq_type = 0;
uint32_t cnv_freq_val = 0;
double cnv_freq_val2 = 0.0;
uint32_t cnv_test_window = 0;
uint32_t segment_modifier = 0;
uint32_t permphe_ct = 0;
uint32_t matrix_flag_state = 0; // 1 = present and unclaimed, 2 = claimed
double hard_call_threshold = 0.1;
double tail_bottom = 0.0;
double tail_top = 0.0;
double lasso_h2 = 0.0;
double lasso_minlambda = -1;
uint32_t lasso_lambda_iters = 0;
uint32_t testmiss_modifier = 0;
uint32_t testmiss_mperm_val = 0;
#ifdef USE_MKL
uint32_t mkl_native = 0;
#endif
// this default limit plays well with e.g. fbstring small-string optimization
uint32_t new_id_max_allele_len = 23;
uint32_t aperm_present = 0;
char* segment_spanning_fname = nullptr;
char* oxford_missing_code = nullptr;
char range_delim = '-';
uint32_t modifier_23 = 0;
double pheno_23 = DBL_MAX;
char* fid_23 = nullptr;
char* iid_23 = nullptr;
char* paternal_id_23 = nullptr;
char* maternal_id_23 = nullptr;
Ll_str* file_delete_list = nullptr;
uint32_t chrom_flag_present = 0;
uintptr_t chrom_exclude[CHROM_MASK_INITIAL_WORDS];
// er, except for first four, these should not be preallocated...
char outname[FNAMESIZE];
char mapname[FNAMESIZE];
char pedname[FNAMESIZE];
char famname[FNAMESIZE];
char mergename1[FNAMESIZE];
char mergename2[FNAMESIZE];
char mergename3[FNAMESIZE];
char output_missing_pheno[32];
char* missing_mid_template;
#ifdef __APPLE__
int32_t mib[2];
size_t sztmp;
#endif
unsigned char* bigstack_ua = nullptr; // ua = unaligned
char* bubble = nullptr;
unsigned char* bigstack_initial_base;
uint32_t param_ct;
time_t rawtime;
char* argptr;
char* sptr;
const char* csptr;
int32_t ii;
int32_t jj;
int32_t kk;
int32_t num_params;
int32_t in_param;
Chrom_info chrom_info;
Family_info family_info;
Oblig_missing_info oblig_missing_info;
Aperm_info aperm;
Cluster_info cluster;
Set_info set_info;
Homozyg_info homozyg;
Ld_info ld_info;
Epi_info epi_info;
Annot_info annot_info;
Clump_info clump_info;
Rel_info rel_info;
Score_info score_info;
Dosage_info dosage_info;
Range_list snps_range_list;
Range_list covar_range_list;
Range_list lasso_select_covars_range_list;
Range_list parameters_range_list;
Range_list tests_range_list;
char* argptr2;
char* flagptr;
double dxx;
char cc;
int32_t known_procs;
uint32_t uii;
uint32_t ujj;
uint32_t ukk;
intptr_t default_alloc_mb;
int64_t llxx;
Ll_str* ll_str_ptr;
#ifdef _WIN32
SYSTEM_INFO sysinfo;
MEMORYSTATUSEX memstatus;
DWORD windows_dw; // why the f*** does uint32_t not work?
#endif
family_init(&family_info);
oblig_missing_init(&oblig_missing_info);
aperm_init(&aperm);
cluster_init(&cluster);
set_init(&set_info, &annot_info);
homozyg_init(&homozyg);
ld_epi_init(&ld_info, &epi_info, &clump_info);
rel_init(&rel_info);
misc_init(&score_info);
dosage_init(&dosage_info);
range_list_init(&snps_range_list);
range_list_init(&covar_range_list);
range_list_init(&lasso_select_covars_range_list);
range_list_init(¶meters_range_list);
range_list_init(&tests_range_list);
missing_mid_template = nullptr;
// standardize strtod() behavior
setlocale(LC_NUMERIC, "C");
if (init_chrom_info(&chrom_info)) {
goto main_ret_NOMEM_NOLOG;
}
for (uii = 1; uii < (uint32_t)argc; uii++) {
if ((!strcmp("-script", argv[uii])) || (!strcmp("--script", argv[uii]))) {
ujj = param_count(argc, argv, uii);
if (enforce_param_ct_range(ujj, argv[uii], 1, 1)) {
print_ver();
fputs(g_logbuf, stderr);
fputs(errstr_append, stderr);
goto main_ret_INVALID_CMDLINE;
}
for (ujj = uii + 2; ujj < (uint32_t)argc; ujj++) {
if ((!strcmp("-script", argv[ujj])) || (!strcmp("--script", argv[ujj]))) {
print_ver();
fputs("Error: Multiple --script flags. Merge the files into one.\n", stderr);
fputs(errstr_append, stderr);
goto main_ret_INVALID_CMDLINE;
}
}
// logging not yet active, so don't use fopen_checked()
scriptfile = fopen(argv[uii + 1], FOPEN_RB);
if (!scriptfile) {
print_ver();
fprintf(stderr, g_errstr_fopen, argv[uii + 1]);
goto main_ret_OPEN_FAIL;
}
if (fseeko(scriptfile, 0, SEEK_END)) {
goto main_ret_READ_FAIL_NOLOG;
}
llxx = ftello(scriptfile);
if (llxx == -1) {
goto main_ret_READ_FAIL_NOLOG;
} else if (llxx > 0x7fffffff) {
// could actually happen if user enters parameters in the wrong order,
// so may as well catch it and print a somewhat informative error msg
print_ver();
fputs("Error: --script file too large.\n", stderr);
goto main_ret_INVALID_CMDLINE;
}
rewind(scriptfile);
ujj = (uint32_t)((uint64_t)llxx);
script_buf = (char*)malloc(ujj);
if (!script_buf) {
goto main_ret_NOMEM_NOLOG;
}
ukk = fread(script_buf, 1, ujj, scriptfile);
if (ukk < ujj) {
goto main_ret_READ_FAIL_NOLOG;
}
fclose_null(&scriptfile);
num_params = 0;
in_param = 0;
for (ukk = 0; ukk < ujj; ukk++) {
if (is_space_or_eoln(script_buf[ukk])) {
in_param = 0;
} else if (!in_param) {
num_params++;
in_param = 1;
}
}
subst_argv = (char**)malloc((num_params + argc - 3) * sizeof(char*));
if (!subst_argv) {
goto main_ret_NOMEM_NOLOG;
}
num_params = 0;
in_param = 0;
for (ukk = 1; ukk < uii; ukk++) {
subst_argv[num_params++] = argv[ukk];
}
for (ukk = 0; ukk < ujj; ukk++) {
if (is_space_or_eoln(script_buf[ukk])) {
if (in_param) {
script_buf[ukk] = '\0';
in_param = 0;
}
} else if (!in_param) {
subst_argv[num_params++] = &(script_buf[ukk]);
in_param = 1;
}
}
for (ujj = uii + 2; ujj < (uint32_t)argc; ujj++) {
subst_argv[num_params++] = argv[ujj];
}
argc = num_params;
cur_arg = 0;
argv = subst_argv;
break;
}
}
for (uii = cur_arg; uii < (uint32_t)argc; uii++) {
if ((!strcmp("-rerun", argv[uii])) || (!strcmp("--rerun", argv[uii]))) {
ujj = param_count(argc, argv, uii);
if (enforce_param_ct_range(ujj, argv[uii], 0, 1)) {
print_ver();
fputs(g_logbuf, stderr);
fputs(errstr_append, stderr);
goto main_ret_INVALID_CMDLINE;
}
for (ukk = uii + ujj + 1; ukk < (uint32_t)argc; ukk++) {
if ((!strcmp("-rerun", argv[ukk])) || (!strcmp("--rerun", argv[ukk]))) {
print_ver();
fputs("Error: Duplicate --rerun flag.\n", stderr);
goto main_ret_INVALID_CMDLINE;
}
}
retval = rerun(uii, ujj, &argc, &cur_arg, &argv, &subst_argv, &rerun_buf);
if (retval) {
goto main_ret_NOLOG;
}
break;
}
}
if ((cur_arg < (uint32_t)argc) && (!is_flag(argv[cur_arg]))) {
print_ver();
fputs("Error: First parameter must be a flag.\n", stderr);
fputs(errstr_append, stderr);
goto main_ret_INVALID_CMDLINE;
}
flag_ct = 0;
// (these aren't resolved immediately since we want --help to take
// precedence)
ujj = 0; // --version?
ukk = 0; // silence?
for (uii = cur_arg; uii < (uint32_t)argc; uii++) {
argptr = is_flag_start(argv[uii]);
if (argptr) {
if (!strcmp("help", argptr)) {
print_ver();
if ((cur_arg != 1) || (uii != 1) || subst_argv) {
fputs("--help present, ignoring other flags.\n", stdout);
}
if ((uii == ((uint32_t)argc) - 1) && flag_ct) {
// make "plink --help" work, and skip the
// parameters
char** help_argv = (char**)malloc(flag_ct * sizeof(intptr_t));
if (!help_argv) {
goto main_ret_NOMEM_NOLOG2;
}
uint32_t arg_idx2 = 0;
for (uint32_t flag_idx = 0; flag_idx < flag_ct; ++flag_idx) {
while (!is_flag_start(argv[++arg_idx2]));
help_argv[flag_idx] = argv[arg_idx2];
}
retval = disp_help(flag_ct, help_argv);
free(help_argv);
} else {
retval = disp_help(argc - uii - 1, &(argv[uii + 1]));
}
goto main_ret_1;
}
if ((!strcmp("h", argptr)) || (!strcmp("?", argptr))) {
// these just act like the no-parameter case
print_ver();
if ((cur_arg != 1) || (uii != 1) || subst_argv) {
printf("-%s present, ignoring other flags.\n", argptr);
}
fputs(g_cmdline_format_str, stdout);
fputs(notestr_null_calc2, stdout);
goto main_ret_1;
}
if (!strcmp("version", argptr)) {
ujj = 1;
} else if ((!strcmp("silent", argptr)) || (!strcmp("gplink", argptr))) {
ukk = 1;
}
if (strlen(argptr) >= MAX_FLAG_LEN) {
print_ver();
// shouldn't be possible for this to overflow the buffer...
snprintf(g_logbuf, LOGBUFLEN, "Error: Unrecognized flag ('%s').\n", argv[uii]);
wordwrapb(0);
fputs(g_logbuf, stderr);
fputs(errstr_append, stderr);
goto main_ret_INVALID_CMDLINE;
}
flag_ct++;
}
}
if (!flag_ct) {
print_ver();
fputs(g_cmdline_format_str, stdout);
fputs(notestr_null_calc2, stdout);
retval = RET_NULL_CALC;
goto main_ret_1;
}
if (ujj) {
fputs(ver_str, stdout);
putc_unlocked('\n', stdout);
goto main_ret_1;
}
if (ukk) {
// bugfix: redirection to /dev/null doesn't work on Windows
if (!freopen(
#ifdef _WIN32
"nul"
#else
"/dev/null"
#endif
, "w", stdout)) {
fputs("Warning: --silent failed.\n", stderr);
}
}
print_ver();
flag_buf = (char*)malloc(flag_ct * MAX_FLAG_LEN * sizeof(char));
flag_map = (uint32_t*)malloc(flag_ct * sizeof(int32_t));
if ((!flag_buf) || (!flag_map)) {
goto main_ret_NOMEM_NOLOG2;
}
flagptr = flag_buf;
for (uii = cur_arg; uii < (uint32_t)argc; uii++) {
argptr = is_flag_start(argv[uii]);
if (argptr) {
ukk = strlen(argptr) + 1;
// handle aliases now, so sorting will have the desired effects
switch (*argptr) {
case '\0':
// special case, since we reserve empty names for preprocessed flags
fputs("Error: Unrecognized flag ('--').\n", stderr);
goto main_ret_INVALID_CMDLINE;
case 'F':
if (!strcmp(argptr, "Fst")) {
memcpy(flagptr, "fst", 4);
break;
}
goto main_flag_copy;
case 'a':
if ((ukk == 11) && (!memcmp(argptr, "allele", 6))) {
if (match_upper(&(argptr[6]), "ACGT")) {
memcpy(flagptr, "alleleACGT", 11);
break;
}
} else if ((ukk == 12) && (!memcmp(argptr, "allele-", 7))) {
if (!memcmp(&(argptr[7]), "1234", 4)) {
memcpy(flagptr, "allele1234", 11);
break;
} else if (match_upper(&(argptr[7]), "ACGT")) {
memcpy(flagptr, "alleleACGT", 11);
break;
}
} else if (!strcmp(argptr, "aec")) {
memcpy(flagptr, "allow-extra-chr", 16);
break;
}
goto main_flag_copy;
case 'c':
if (!strcmp(argptr, "chr-excl")) {
fputs("Note: --chr-excl flag has been renamed to --not-chr.\n", stdout);
memcpy(flagptr, "not-chr", 8);
break;
} else if (!strcmp(argptr, "cmh")) {
memcpy(flagptr, "mh", 3);
break;
} else if (!strcmp(argptr, "chr-output")) {
fputs("Note: --chr-output flag has been renamed to --output-chr, for consistency with\n--output-missing-{genotype/phenotype}.\n", stdout);
memcpy(flagptr, "output-chr", 11);
break;
}
goto main_flag_copy;
case 'e':
if (!strcmp(argptr, "extract-snp")) {
memcpy(flagptr, "snp", 4);
break;
} else if (!strcmp(argptr, "exponent")) {
memcpy(flagptr, "distance-exp", 13);
break;
} else if (!strcmp(argptr, "export")) {
memcpy(flagptr, "recode", 7);
recode_require_format = 1;
break;
}
goto main_flag_copy;
case 'f':
if (!strcmp(argptr, "frqx")) {
memcpy(flagptr, "freqx", 6);
break;
} else if (!strcmp(argptr, "flipscan")) {
memcpy(flagptr, "flip-scan", 10);
break;
} else if (!strcmp(argptr, "flipscan-window")) {
memcpy(flagptr, "flip-scan-window", 17);
break;
} else if (!strcmp(argptr, "flipscan-window-kb")) {
memcpy(flagptr, "flip-scan-window-kb", 20);
break;
} else if (!strcmp(argptr, "flipscan-threshold")) {
memcpy(flagptr, "flip-scan-threshold", 20);
break;
}
goto main_flag_copy;
case 'g':
if (!strcmp(argptr, "grm-cutoff")) {
memcpy(flagptr, "rel-cutoff", 11);
break;
}
goto main_flag_copy;
case 'h':
if (!strcmp(argptr, "hwe2")) {
fputs("Warning: --hwe2 flag is obsolete, and now treated as an alias for \"--hwe midp\".\n", stderr);
memcpy(flagptr, "hwe midp", 9);
break;
} else if (!strcmp(argptr, "hardy2")) {
fputs("Warning: --hardy2 flag is obsolete, and now treated as an alias for\n\"--hardy midp\".\n", stderr);
memcpy(flagptr, "hardy midp", 11);
break;
}
goto main_flag_copy;
case 'k':
if (!memcmp(argptr, "k", 2)) {
memcpy(flagptr, "K", 2);
break;
}
goto main_flag_copy;
case 'l':
if (!strcmp(argptr, "list")) {
memcpy(flagptr, "recode list", 12);
fputs("Note: --list flag deprecated. Use \"--recode list\" instead.\n", stdout);
recode_modifier |= RECODE_LIST;
misc_flags |= MISC_SET_HH_MISSING;
break;
} else if (!strcmp(argptr, "load-dists")) {
memcpy(flagptr, "read-dists", 11);
fputs("Note: --load-dists flag has been renamed to --read-dists.\n", stdout);
break;
}
goto main_flag_copy;
case 'm':
if (!strcmp(argptr, "missing_code")) {
memcpy(flagptr, "missing-code", 13);
break;
} else if (!strcmp(argptr, "mh1")) {
memcpy(flagptr, "mh", 3);
break;
} else if (!strcmp(argptr, "make-set-collapse-all")) {
memcpy(flagptr, "set-collapse-all", 17);
break;
} else if (!strcmp(argptr, "min-ac")) {
memcpy(flagptr, "mac", 4);
break;
} else if (!strcmp(argptr, "max-ac")) {
memcpy(flagptr, "max-mac", 8);
break;
} else if (!strcmp(argptr, "max-indv")) {
memcpy(flagptr, "thin-indiv-count", 17);
break;
}
goto main_flag_copy;
case 'n':
if (!strcmp(argptr, "neighbor")) {
memcpy(flagptr, "neighbour", 10);
break;
} else if (!strcmp(argptr, "num_threads")) {
memcpy(flagptr, "threads", 8);
break;
}
goto main_flag_copy;
case 'p':
if (!strcmp(argptr, "pedmap")) {
memcpy(flagptr, "file", 5);
break;
}
goto main_flag_copy;
case 'r':
if ((ukk >= 8) && (!memcmp(argptr, "recode", 6))) {
ujj = 0; // alias match?
argptr2 = &(argptr[6]);
switch (ukk) {
case 8:
if (tolower(*argptr2) == 'a') {
memcpy(flagptr, "recode A", 9);
recode_modifier |= RECODE_A;
ujj = 1;
}
break;
case 9:
if (!memcmp(argptr2, "12", 2)) {
memcpy(flagptr, "recode 12", 10);
recode_modifier |= RECODE_12;
// technically, this should also affect --tucc, but whatever
ujj = 1;
} else if (match_upper(argptr2, "AD")) {
memcpy(flagptr, "recode AD", 10);
recode_modifier |= RECODE_AD;
ujj = 1;
} else if (match_upper(argptr2, "HV")) {
memcpy(flagptr, "recode HV-1chr", 15);
recode_modifier |= RECODE_HV_1CHR;
fputs("Note: --recodeHV flag deprecated. Use \"--recode HV\" or \"--recode HV-1chr\".\n", stdout);
ujj = 2;
}
break;
case 11:
if (!memcmp(argptr2, "-vcf", 4)) {
memcpy(flagptr, "recode vcf", 11);
recode_modifier |= RECODE_VCF;
ujj = 1;
}
break;
case 12:
if (!memcmp(argptr2, "-lgen", 5)) {
memcpy(flagptr, "recode lgen", 12);
recode_modifier |= RECODE_LGEN;
// backwards compatibility
misc_flags |= MISC_SET_HH_MISSING;
ujj = 1;
}
break;
case 13:
if (!memcmp(argptr2, "-rlist", 6)) {
memcpy(flagptr, "recode rlist", 13);
recode_modifier |= RECODE_RLIST;
misc_flags |= MISC_SET_HH_MISSING;
ujj = 1;
}
break;
case 14:
if (!memcmp(argptr2, "-beagle", 7)) {
memcpy(flagptr, "recode beagle", 14);
recode_modifier |= RECODE_BEAGLE;
ujj = 1;
} else if (!memcmp(argptr2, "-bimbam", 7)) {
memcpy(flagptr, "recode bimbam-1chr", 19);
recode_modifier |= RECODE_BIMBAM_1CHR;
misc_flags |= MISC_SET_HH_MISSING;
fputs("Note: --recode-bimbam flag deprecated. Use \"--recode bimbam\" or\n\"--recode bimbam-1chr\".\n", stdout);
ujj = 2;
}
break;
case 17:
if (!memcmp(argptr2, "-fastphase", 10)) {
memcpy(flagptr, "recode 01 fastphase-1chr", 25);
recode_modifier |= RECODE_01 | RECODE_FASTPHASE_1CHR;
misc_flags |= MISC_SET_HH_MISSING;
fputs("Note: --recode-fastphase flag deprecated. Use e.g. \"--recode 01 fastphase-1chr\".\n", stdout);
ujj = 2;
} else if (!memcmp(argptr2, "-structure", 10)) {
memcpy(flagptr, "recode structure", 17);
recode_modifier |= RECODE_STRUCTURE;
misc_flags |= MISC_SET_HH_MISSING;
ujj = 1;
}
break;
}
if (ujj) {
if (ujj == 1) {
printf("Note: --%s flag deprecated. Use \"--%s ...\".\n", argptr, flagptr);
}
break;
}
} else if (!strcmp(argptr, "reference-allele")) {
memcpy(flagptr, "a1-allele", 10);
break;
}
goto main_flag_copy;
case 's':
if (!strcmp(argptr, "set-invalid-haploid-missing")) {
memcpy(flagptr, "set-hh-missing", 15);
break;
}
goto main_flag_copy;
case 't':
if (!strcmp(argptr, "thread-num")) {
memcpy(flagptr, "threads", 8);
break;
}
goto main_flag_copy;
case 'u':
if (!strcmp(argptr, "update-freq")) {
memcpy(flagptr, "read-freq", 10);
break;
} else if (!strcmp(argptr, "update-ref-allele")) {
// GCTA alias
memcpy(flagptr, "a1-allele", 10);
break;
}
goto main_flag_copy;
default:
main_flag_copy:
memcpy(flagptr, argptr, ukk);
}
flagptr = &(flagptr[MAX_FLAG_LEN]);
flag_map[cur_flag++] = uii;
}
}
// requires MAX_FLAG_LEN to be at least sizeof(void*) + sizeof(int32_t)
sptr = (char*)malloc(flag_ct * MAX_FLAG_LEN);
if (!sptr) {
goto main_ret_NOMEM_NOLOG2;
}
qsort_ext2(flag_buf, flag_ct, MAX_FLAG_LEN, strcmp_deref, (char*)flag_map, sizeof(int32_t), sptr, MAX_FLAG_LEN);
free(sptr);
ujj = strlen_se(flag_buf);
for (cur_flag = 1; cur_flag < flag_ct; cur_flag++) {
ukk = strlen_se(&(flag_buf[cur_flag * MAX_FLAG_LEN]));
if ((ujj == ukk) && (!memcmp(&(flag_buf[(cur_flag - 1) * MAX_FLAG_LEN]), &(flag_buf[cur_flag * MAX_FLAG_LEN]), ukk))) {
flag_buf[cur_flag * MAX_FLAG_LEN + ukk] = '\0'; // just in case of aliases
fprintf(stderr, "Error: Duplicate --%s flag.\n", &(flag_buf[cur_flag * MAX_FLAG_LEN]));
goto main_ret_INVALID_CMDLINE;
}
ujj = ukk;
}
uii = 5;
memcpy(outname, PROG_NAME_STR, 6);
for (cur_flag = 0; cur_flag < flag_ct; cur_flag++) {
ii = memcmp("out", &(flag_buf[cur_flag * MAX_FLAG_LEN]), 4);
if (!ii) {
ujj = flag_map[cur_flag];
ukk = param_count(argc, argv, ujj);
if (enforce_param_ct_range(ukk, argv[ujj], 1, 1)) {
fputs(g_logbuf, stderr);
fputs(errstr_append, stderr);
goto main_ret_INVALID_CMDLINE;
}
if (strlen(argv[ujj + 1]) > (FNAMESIZE - MAX_POST_EXT)) {
fputs("Error: --out parameter too long.\n", stderr);
goto main_ret_OPEN_FAIL;
}
uii = strlen(argv[ujj + 1]);
memcpy(outname, argv[ujj + 1], uii + 1);
outname_end = &(outname[uii]);
}
if (ii <= 0) {
break;
}
}
memcpy(&(outname[uii]), ".log", 5);
g_logfile = fopen(outname, "w");
if (!g_logfile) {
fprintf(stderr, "Error: Failed to open %s. Try ", outname);
if (!memcmp(outname, PROG_NAME_STR, 6)) {
fputs("using --out.\n", stderr);
} else {
fputs("changing the --out parameter.\n", stderr);
}
goto main_ret_OPEN_FAIL;
}
printf("Logging to %s.\n", outname);
outname[uii] = '\0';
logstr(ver_str);
logstr("\n");
logprint("Options in effect:\n");
for (cur_flag = 0; cur_flag < flag_ct; cur_flag++) {
logprint(" --");
logprint(&(flag_buf[cur_flag * MAX_FLAG_LEN]));
ii = flag_map[cur_flag] + 1;
while ((ii < argc) && (!is_flag(argv[ii]))) {
logprint(" ");
logprint(argv[ii++]);
}
logprint("\n");
}
logprint("\n");
#ifdef _WIN32
windows_dw = TEXTBUF_SIZE;
if (GetComputerName(g_textbuf, &windows_dw))
#else
if (gethostname(g_textbuf, TEXTBUF_SIZE) != -1)
#endif
{
logstr("Hostname: ");
logstr(g_textbuf);
}
logstr("\nWorking directory: ");
if (!getcwd(g_textbuf, FNAMESIZE)) {
goto main_ret_READ_FAIL;
}
logstr(g_textbuf);
logstr("\nStart time: ");
time(&rawtime);
logstr(ctime(&rawtime));
logstr("\n");
#ifdef _WIN32
GetSystemInfo(&sysinfo);
g_thread_ct = sysinfo.dwNumberOfProcessors;
known_procs = g_thread_ct;
#else
# ifdef __APPLE__
known_procs = sysconf(_SC_NPROCESSORS_ONLN);
# else
known_procs = -1;
{
cpu_set_t cpu_set;
if (sched_getaffinity(0, sizeof(cpu_set), &cpu_set) == 0) {
known_procs = CPU_COUNT(&cpu_set);
}
}
# endif
g_thread_ct = (known_procs == -1)? 1 : known_procs;
#endif
if (g_thread_ct > 8) {
if (g_thread_ct > MAX_THREADS) {
g_thread_ct = MAX_THREADS;
} else {
g_thread_ct--;
}
}
mapname[0] = '\0';
pedname[0] = '\0';
famname[0] = '\0';
memcpyl3(output_missing_pheno, "-9\0");
// stuff that must be processed before regular alphabetical loop
retval = init_delim_and_species(flag_ct, flag_buf, flag_map, argc, argv, &range_delim, &chrom_info);
if (retval) {
goto main_ret_1;
}
fill_ulong_zero(CHROM_MASK_INITIAL_WORDS, chrom_exclude);
cur_flag = 0;
do {
argptr = &(flag_buf[cur_flag * MAX_FLAG_LEN]);
if (!(*argptr)) {
// preprocessed
continue;
}
argptr2 = &(argptr[1]);
cur_arg = flag_map[cur_flag];
param_ct = param_count(argc, argv, cur_arg);
switch (*argptr) {
case '1':
if (*argptr2 == '\0') {
misc_flags |= MISC_AFFECTION_01;
goto main_param_zero;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case '2':
if (!memcmp(argptr2, "3file", 6)) {
if (chrom_info.species != SPECIES_HUMAN) {
logerrprint("Error: --23file cannot be used with a nonhuman species flag.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 7)) {
goto main_ret_INVALID_CMDLINE_2A;
}
ii = strlen(argv[cur_arg + 1]);
if (ii > FNAMESIZE - 1) {
logerrprint("Error: --23file filename too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(pedname, argv[cur_arg + 1], ii + 1);
if (param_ct > 1) {
if (strchr(argv[cur_arg + 2], ' ')) {
logerrprint("Error: Space present in --23file family ID.\n");
goto main_ret_INVALID_CMDLINE;
}
if (alloc_string(&fid_23, argv[cur_arg + 2])) {
goto main_ret_NOMEM;
}
if (param_ct > 2) {
if (strchr(argv[cur_arg + 3], ' ')) {
logerrprint("Error: Space present in --23file sample ID.\n");
goto main_ret_INVALID_CMDLINE;
}
if (alloc_string(&iid_23, argv[cur_arg + 3])) {
goto main_ret_NOMEM;
}
if (param_ct > 3) {
cc = extract_char_param(argv[cur_arg + 4]);
if ((cc == 'M') || (cc == 'm') || (cc == '1')) {
modifier_23 |= M23_MALE;
} else if ((cc == 'F') || (cc == 'f') || (cc == '2')) {
modifier_23 |= M23_FEMALE;
} else if (cc == '0') {
modifier_23 |= M23_FORCE_MISSING_SEX;
} else if ((cc != 'I') && (cc != 'i')) {
logerrprint("Error: Invalid --23file sex parameter (M or 1 = male, F or 2 = female,\nI = infer from data, 0 = force missing).\n");
goto main_ret_INVALID_CMDLINE;
}
if (param_ct > 4) {
if (scan_doublex(argv[cur_arg + 5], &pheno_23)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --23file phenotype '%s'.\n", argv[cur_arg + 5]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (param_ct > 5) {
if (strchr(argv[cur_arg + 6], ' ')) {
logerrprint("Error: Space present in --23file paternal ID.\n");
goto main_ret_INVALID_CMDLINE;
}
if (alloc_string(&paternal_id_23, argv[cur_arg + 6])) {
goto main_ret_NOMEM;
}
if (param_ct > 6) {
if (strchr(argv[cur_arg + 7], ' ')) {
logerrprint("Error: Space present in --23file maternal ID.\n");
goto main_ret_INVALID_CMDLINE;
}
if (alloc_string(&maternal_id_23, argv[cur_arg + 7])) {
goto main_ret_NOMEM;
}
}
}
}
}
}
}
load_rare = LOAD_RARE_23;
} else if ((!memcmp(argptr2, "3file-convert-xy", 17)) || (!memcmp(argptr2, "3file-make-xylist", 18))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s has been retired due to brain-damaged design. Use\n--split-x instead.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'D':
if (*argptr2 == '\0') {
logprint("Note: --D flag deprecated. Use e.g. \"--r2 dprime\".\n");
ld_info.modifier |= LD_DPRIME;
goto main_param_zero;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'K':
if (*argptr2 == '\0') {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &cluster.min_ct)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --K cluster count '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'R':
if (*argptr2 == '\0') {
#if defined __cplusplus && !defined _WIN32
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
uii = 1;
if (param_ct == 2) {
if (!strcmp(argv[cur_arg + 1], "debug")) {
uii = 2;
} else if (strcmp(argv[cur_arg + 2], "debug")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --R modifier '%s'.\n", argv[cur_arg + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
misc_flags |= MISC_RPLUGIN_DEBUG;
}
retval = alloc_fname(&rplugin_fname, argv[cur_arg + uii], argptr, 0);
if (retval) {
goto main_ret_1;
}
calculation_type |= CALC_RPLUGIN;
#else
#ifdef _WIN32
logerrprint("Error: --R does not currently support Windows.\n");
#else
logerrprint("Error: --R requires " PROG_NAME_CAPS " to be built with a C++, not a pure C, compiler.\n");
#endif
goto main_ret_INVALID_CMDLINE;
#endif
} else if (!memcmp(argptr2, "-port", 6)) {
if (!rplugin_fname) {
logerrprint("Error: --R-port must be used with --R.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_cappedx(argv[cur_arg + 1], 65535, (uint32_t*)(&rplugin_port))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --R-port parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "-debug", 7)) {
if (!rplugin_fname) {
logerrprint("Error: --R-debug must be used with --R.\n");
goto main_ret_INVALID_CMDLINE;
}
logprint("Note: --R-debug flag deprecated. Use e.g. \"--R debug\".\n");
misc_flags |= MISC_RPLUGIN_DEBUG;
goto main_param_zero;
} else if (!memcmp(argptr2, "-host", 6)) {
if (!rplugin_fname) {
logerrprint("Error: --R-host must be used with --R.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_string(&rplugin_host_or_socket, argv[cur_arg + 1]);
if (retval) {
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "-socket", 8)) {
if (!rplugin_fname) {
logerrprint("Error: --R-socket must be used with --R.\n");
goto main_ret_INVALID_CMDLINE;
}
if (rplugin_port != -2) {
logerrprint("Error: --R-socket cannot be used with --R-port.\n");
goto main_ret_INVALID_CMDLINE;
}
if (rplugin_host_or_socket) {
logerrprint("Error: --R-socket cannot be used with --R-host.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_string(&rplugin_host_or_socket, argv[cur_arg + 1]);
if (retval) {
goto main_ret_INVALID_CMDLINE_WWA;
}
rplugin_port = -1;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'Z':
if (!memcmp(argptr2, "-genome", 8)) {
kk = 1;
genome_modifier |= GENOME_OUTPUT_GZ;
goto main_genome_flag;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
case 'a':
if (!memcmp(argptr2, "utosome", 8)) {
fill_bits(1, chrom_info.autosome_ct, chrom_info.chrom_mask);
chrom_info.is_include_stack = 1;
chrom_flag_present = 1;
goto main_param_zero;
} else if (!memcmp(argptr2, "utosome-xy", 11)) {
if (chrom_flag_present) {
logerrprint("Error: --autosome-xy cannot be used with --autosome.\n");
goto main_ret_INVALID_CMDLINE;
}
if (chrom_info.xymt_codes[XY_OFFSET] == -2) {
logerrprint("Error: --autosome-xy used with a species lacking an XY region.\n");
goto main_ret_INVALID_CMDLINE_A;
}
fill_bits(1, chrom_info.autosome_ct, chrom_info.chrom_mask);
set_bit(chrom_info.xymt_codes[XY_OFFSET], chrom_info.chrom_mask);
chrom_info.is_include_stack = 1;
goto main_param_zero;
} else if (!memcmp(argptr2, "llow-extra-chr", 15)) {
if (load_rare == LOAD_RARE_23) {
logerrprint("Error: --allow-extra-chr cannot currently be used with --23file.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (memcmp("0", argv[cur_arg + 1], 2)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --allow-extra-chr parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
chrom_info.zero_extra_chroms = 1;
}
misc_flags |= MISC_ALLOW_EXTRA_CHROMS;
} else if (!memcmp(argptr2, "llow-no-sex", 12)) {
sex_missing_pheno |= ALLOW_NO_SEX;
goto main_param_zero;
} else if (!memcmp(argptr2, "llow-no-samples", 16)) {
misc_flags |= MISC_ALLOW_NO_SAMPLES;
goto main_param_zero;
} else if (!memcmp(argptr2, "llow-no-vars", 13)) {
misc_flags |= MISC_ALLOW_NO_VARS;
goto main_param_zero;
} else if (!memcmp(argptr2, "llow-no-covars", 15)) {
covar_modifier |= COVAR_ALLOW_NONE;
goto main_param_zero;
} else if (!memcmp(argptr2, "ll", 3)) {
logprint("Note: --all flag has no effect.\n");
goto main_param_zero;
} else if (!memcmp(argptr2, "llele1234", 10)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct == 1) {
if (strcmp("multichar", argv[cur_arg + 1])) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --allele1234 parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
allelexxxx = ALLELE_RECODE_MULTICHAR;
} else {
allelexxxx = ALLELE_RECODE;
}
filter_flags |= FILTER_BIM_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "lleleACGT", 9)) {
if (allelexxxx) {
logerrprint("Error: --allele1234 and --alleleACGT cannot be used together.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct == 1) {
if (strcmp("multichar", argv[cur_arg + 1])) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --alleleACGT parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
allelexxxx = ALLELE_RECODE_ACGT | ALLELE_RECODE_MULTICHAR;
} else {
allelexxxx = ALLELE_RECODE_ACGT;
}
filter_flags |= FILTER_BIM_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "llele-count", 12)) {
lgen_modifier |= LGEN_ALLELE_COUNT;
goto main_param_zero;
} else if (!memcmp(argptr2, "ll-pheno", 9)) {
pheno_modifier |= PHENO_ALL;
goto main_param_zero;
} else if (!memcmp(argptr2, "ssoc", 5)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 6)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "counts")) {
if (model_modifier & MODEL_QMASK) {
logerrprint("Error: --assoc 'qt-means' modifier does not make sense with 'counts'.\n");
goto main_ret_INVALID_CMDLINE_A;
}
model_modifier |= MODEL_ASSOC_COUNTS;
} else if (!strcmp(argv[cur_arg + uii], "fisher")) {
if (model_modifier & MODEL_QMASK) {
logerrprint("Error: --assoc 'qt-means'/'lin' does not make sense with 'fisher'.\n");
goto main_ret_INVALID_CMDLINE_A;
}
model_modifier |= MODEL_FISHER;
} else if (!strcmp(argv[cur_arg + uii], "fisher-midp")) {
if (model_modifier & MODEL_QMASK) {
logerrprint("Error: --assoc 'qt-means'/'lin' does not make sense with 'fisher-midp'.\n");
goto main_ret_INVALID_CMDLINE_A;
}
model_modifier |= MODEL_FISHER | MODEL_FISHER_MIDP;
} else if (!strcmp(argv[cur_arg + uii], "perm")) {
if (model_modifier & MODEL_MPERM) {
logerrprint("Error: --assoc 'mperm' and 'perm' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
model_modifier |= MODEL_PERM;
} else if (!strcmp(argv[cur_arg + uii], "genedrop")) {
if (model_modifier & MODEL_QMASK) {
logerrprint("Error: --assoc 'qt-means'/'lin' does not make sense with 'genedrop'.\n");
goto main_ret_INVALID_CMDLINE_A;
}
model_modifier |= MODEL_GENEDROP;
} else if (!strcmp(argv[cur_arg + uii], "perm-count")) {
model_modifier |= MODEL_PERM_COUNT;
} else if ((strlen(argv[cur_arg + uii]) > 6) && (!memcmp(argv[cur_arg + uii], "mperm=", 6))) {
if (model_modifier & MODEL_PERM) {
logerrprint("Error: --assoc 'mperm' and 'perm' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (model_modifier & MODEL_MPERM) {
logerrprint("Error: Duplicate --assoc 'mperm' modifier.\n");
goto main_ret_INVALID_CMDLINE;
}
if (scan_posint_defcapx(&(argv[cur_arg + uii][6]), &model_mperm_val)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --assoc mperm parameter '%s'.\n", &(argv[cur_arg + uii][6]));
goto main_ret_INVALID_CMDLINE_WWA;
}
model_modifier |= MODEL_MPERM;
} else if (!strcmp(argv[cur_arg + uii], "qt-means")) {
if (model_modifier & MODEL_DMASK) {
logerrprint("Error: --assoc 'qt-means' does not make sense with a case/control-specific\nmodifier.\n");
goto main_ret_INVALID_CMDLINE_A;
}
model_modifier |= MODEL_QT_MEANS;
} else if (!strcmp(argv[cur_arg + uii], "lin")) {
if (model_modifier & MODEL_DMASK) {
logerrprint("Error: --assoc 'lin' does not make sense with a case/control-specific modifier.\n");
goto main_ret_INVALID_CMDLINE_A;
}
model_modifier |= MODEL_LIN;
} else if (!strcmp(argv[cur_arg + uii], "mperm")) {
logerrprint("Error: Improper --assoc mperm syntax. (Use \"--assoc mperm=\".)\n");
goto main_ret_INVALID_CMDLINE;
} else if (!strcmp(argv[cur_arg + uii], "set-test")) {
model_modifier |= MODEL_SET_TEST;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --assoc parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
model_modifier |= MODEL_ASSOC;
calculation_type |= CALC_MODEL;
} else if (!memcmp(argptr2, "djust", 6)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 3)) {
goto main_ret_INVALID_CMDLINE_2A;
}
mtest_adjust = 1;
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "gc")) {
mtest_adjust |= ADJUST_GC;
} else if (!strcmp(argv[cur_arg + uii], "log10")) {
mtest_adjust |= ADJUST_LOG10;
} else if (!strcmp(argv[cur_arg + uii], "qq-plot")) {
mtest_adjust |= ADJUST_QQ;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --adjust parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
} else if (!memcmp(argptr2, "perm", 5)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 6)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &aperm.min)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --aperm min permutation count '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
aperm.min++;
if (param_ct > 1) {
if (scan_posint_cappedx(argv[cur_arg + 2], APERM_MAX, &aperm.max)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --aperm max permutation count '%s'.\n", argv[cur_arg + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
// may as well disallow equality since there's no reason not to use
// max(T) then...
if (aperm.min >= aperm.max) {
logerrprint("Error: --aperm min permutation count must be smaller than max.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (param_ct > 2) {
if (scan_doublex(argv[cur_arg + 3], &aperm.alpha)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --aperm alpha threshold '%s'.\n", argv[cur_arg + 3]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (param_ct > 3) {
if (scan_doublex(argv[cur_arg + 4], &aperm.beta) || (aperm.beta <= 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --aperm beta '%s'.\n", argv[cur_arg + 4]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (param_ct > 4) {
if (scan_doublex(argv[cur_arg + 5], &aperm.init_interval)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --aperm initial pruning interval '%s'.\n", argv[cur_arg + 5]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((aperm.init_interval < 1) || (aperm.init_interval > 1000000)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --aperm initial pruning interval '%s'.\n", argv[cur_arg + 5]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (param_ct == 6) {
if (scan_doublex(argv[cur_arg + 6], &aperm.interval_slope)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --aperm pruning interval slope '%s'.\n", argv[cur_arg + 6]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((aperm.interval_slope < 0) || (aperm.interval_slope > 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --aperm pruning interval slope '%s'.\n", argv[cur_arg + 6]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
}
}
}
aperm_present = 1;
} else if (!memcmp(argptr2, "1-allele", 9)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_2col(&a1alleles, &(argv[cur_arg + 1]), argptr, param_ct);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_BIM_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "2-allele", 9)) {
if (a1alleles) {
logerrprint("Error: --a2-allele cannot be used with --a1-allele.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_2col(&a2alleles, &(argv[cur_arg + 1]), argptr, param_ct);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_BIM_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "nnotate", 8)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 2, 10)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&annot_info.fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
for (uii = 2; uii <= param_ct; uii++) {
ujj = strlen(argv[cur_arg + uii]);
if ((ujj > 7) && (!memcmp(argv[cur_arg + uii], "attrib=", 7))) {
retval = alloc_fname(&annot_info.attrib_fname, &(argv[cur_arg + uii][7]), argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if ((ujj > 7) && (!memcmp(argv[cur_arg + uii], "ranges=", 7))) {
retval = alloc_fname(&annot_info.ranges_fname, &(argv[cur_arg + uii][7]), argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if ((ujj > 7) && (!memcmp(argv[cur_arg + uii], "filter=", 7))) {
retval = alloc_fname(&annot_info.filter_fname, &(argv[cur_arg + uii][7]), argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if ((ujj > 7) && (!memcmp(argv[cur_arg + uii], "subset=", 7))) {
retval = alloc_fname(&annot_info.subset_fname, &(argv[cur_arg + uii][7]), argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if ((ujj > 5) && (!memcmp(argv[cur_arg + uii], "snps=", 5))) {
retval = alloc_fname(&annot_info.snps_fname, &(argv[cur_arg + uii][5]), argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if ((ujj == 2) && (!memcmp(argv[cur_arg + uii], "NA", 2))) {
if (annot_info.modifier & ANNOT_PRUNE) {
logerrprint("Error: --annotate 'NA' and 'prune' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
annot_info.modifier |= ANNOT_NA;
} else if ((ujj == 5) && (!memcmp(argv[cur_arg + uii], "prune", 5))) {
if (annot_info.modifier & ANNOT_NA) {
logerrprint("Error: --annotate 'NA' and 'prune' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
annot_info.modifier |= ANNOT_PRUNE;
} else if ((ujj == 5) && (!memcmp(argv[cur_arg + uii], "block", 5))) {
annot_info.modifier |= ANNOT_BLOCK;
} else if ((ujj == 7) && (!memcmp(argv[cur_arg + uii], "minimal", 7))) {
annot_info.modifier |= ANNOT_MINIMAL;
} else if ((ujj == 8) && (!memcmp(argv[cur_arg + uii], "distance", 8))) {
annot_info.modifier |= ANNOT_DISTANCE;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --annotate parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
if ((annot_info.modifier & ANNOT_BLOCK) && (annot_info.modifier & (ANNOT_NA | ANNOT_MINIMAL))) {
logerrprint("Error: --annotate 'block' cannot be used with 'NA' or 'minimal'.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (!annot_info.attrib_fname) {
if (!annot_info.ranges_fname) {
logerrprint("Error: --annotate must be used with 'attrib' and/or 'ranges'.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!annot_info.ranges_fname) {
if (annot_info.subset_fname) {
logerrprint("Error: --annotate 'subset' modifier must be used with 'ranges'.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (annot_info.modifier & (ANNOT_MINIMAL | ANNOT_DISTANCE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --annotate '%s' modifier must be used with 'ranges'.\n", (annot_info.modifier & ANNOT_MINIMAL)? "minimal" : "distance");
goto main_ret_INVALID_CMDLINE_2A;
}
}
} else if (!memcmp(argptr2, "nnotate-snp-field", 18)) {
if (!annot_info.attrib_fname) {
logerrprint("Error: --annotate-snp-field must be used with --annotate + 'attrib'.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&annot_info.snpfield, argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "ttrib", 6)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&filter_attrib_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
if (param_ct == 2) {
// force comma-terminated string to simplify parsing
uii = strlen(argv[cur_arg + 2]);
filter_attrib_liststr = (char*)malloc(uii + 2);
if (!filter_attrib_liststr) {
goto main_ret_NOMEM;
}
memcpy(filter_attrib_liststr, argv[cur_arg + 2], uii);
memcpy(&(filter_attrib_liststr[uii]), ",", 2);
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP | FILTER_NOCNV;
} else if (!memcmp(argptr2, "ttrib-indiv", 12)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&filter_attrib_sample_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
if (param_ct == 2) {
uii = strlen(argv[cur_arg + 2]);
filter_attrib_sample_liststr = (char*)malloc(uii + 2);
if (!filter_attrib_sample_liststr) {
goto main_ret_NOMEM;
}
memcpy(filter_attrib_sample_liststr, argv[cur_arg + 2], uii);
memcpy(&(filter_attrib_sample_liststr[uii]), ",", 2);
}
filter_flags |= FILTER_FAM_REQ;
} else if (!memcmp(argptr2, "c-founders", 11)) {
// Accept this flag even though it isn't enforced, since we want to
// encourage its use with --mac/"--freq counts" in plink 2.0.
misc_flags |= MISC_AC_FOUNDERS;
goto main_param_zero;
} else if ((!memcmp(argptr2, "lt-group", 9)) ||
(!memcmp(argptr2, "lt-snp", 7))) {
goto main_hap_disabled_message;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'b':
if (!memcmp(argptr2, "file", 5)) {
if (load_rare) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
csptr = argv[cur_arg + 1];
if (strlen(csptr) > (FNAMESIZE - 5)) {
logerrprint("Error: --bfile parameter too long.\n");
goto main_ret_OPEN_FAIL;
}
} else {
csptr = PROG_NAME_STR;
}
if (!(load_params & LOAD_PARAMS_BED)) {
memcpy(strcpya(pedname, csptr), ".bed", 5);
load_params |= LOAD_PARAMS_BED;
}
memcpy(strcpya(mapname, csptr), ".bim", 5);
memcpy(strcpya(famname, csptr), ".fam", 5);
load_params |= LOAD_PARAMS_BIM | LOAD_PARAMS_FAM;
} else if (!memcmp(argptr2, "ed", 3)) {
if (load_rare) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
load_params |= LOAD_PARAMS_BED;
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (strlen(argv[cur_arg + 1]) > (FNAMESIZE - 1)) {
logerrprint("Error: --bed parameter too long.\n");
goto main_ret_OPEN_FAIL;
}
strcpy(pedname, argv[cur_arg + 1]);
} else if (!memcmp(argptr2, "im", 3)) {
if (load_rare) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
load_params |= LOAD_PARAMS_BIM;
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (strlen(argv[cur_arg + 1]) > (FNAMESIZE - 1)) {
logerrprint("Error: --bim parameter too long.\n");
goto main_ret_OPEN_FAIL;
}
strcpy(mapname, argv[cur_arg + 1]);
} else if (!memcmp(argptr2, "merge", 6)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 3)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct == 2) {
logerrprint("Error: --bmerge must have exactly 1 or 3 parameters.\n");
goto main_ret_INVALID_CMDLINE_A;
}
jj = strlen(argv[cur_arg + 1]);
if (param_ct == 3) {
if (++jj > FNAMESIZE) {
logerrprint("Error: --bmerge .bed filename too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(mergename1, argv[cur_arg + 1], jj);
jj = strlen(argv[cur_arg + 2]) + 1;
if (jj > FNAMESIZE) {
logerrprint("Error: --bmerge .bim filename too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(mergename2, argv[cur_arg + 2], jj);
jj = strlen(argv[cur_arg + 3]) + 1;
if (jj > FNAMESIZE) {
logerrprint("Error: --bmerge .fam filename too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(mergename3, argv[cur_arg + 3], jj);
} else {
if (jj > (FNAMESIZE - 5)) {
logerrprint("Error: --bmerge filename prefix too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(memcpya(mergename1, argv[cur_arg + 1], jj), ".bed", 5);
memcpy(memcpya(mergename2, argv[cur_arg + 1], jj), ".bim", 5);
memcpy(memcpya(mergename3, argv[cur_arg + 1], jj), ".fam", 5);
}
calculation_type |= CALC_MERGE;
merge_type |= MERGE_BINARY;
} else if (!memcmp(argptr2, "p-space", 8)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &min_bp_space)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --bp-space minimum bp distance '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP | FILTER_NOCNV;
} else if (!memcmp(argptr2, "eta", 4)) {
logprint("Note: --beta flag deprecated. Use e.g. \"--logistic beta\".\n");
glm_modifier |= GLM_BETA;
goto main_param_zero;
} else if (!memcmp(argptr2, "d", 2)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 3)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "perm")) {
if (cluster.modifier & CLUSTER_CMH_MPERM) {
logerrprint("Error: --bd 'mperm' and 'perm[-bd]' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (cluster.modifier & CLUSTER_CMH_PERM_BD) {
logerrprint("Error: --bd 'perm' and 'perm-bd' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
cluster.modifier |= CLUSTER_CMH_PERM;
} else if (!strcmp(argv[cur_arg + uii], "perm-bd")) {
if (cluster.modifier & CLUSTER_CMH_MPERM) {
logerrprint("Error: --bd 'mperm' and 'perm[-bd]' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((cluster.modifier & (CLUSTER_CMH_PERM | CLUSTER_CMH_PERM_BD)) == CLUSTER_CMH_PERM) {
logerrprint("Error: --bd 'perm' and 'perm-bd' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (mtest_adjust) {
logerrprint("Error: --bd 'perm-bd' mode cannot currently be used with --adjust.\n");
goto main_ret_INVALID_CMDLINE_A;
}
cluster.modifier |= CLUSTER_CMH_PERM_BD;
} else if ((strlen(argv[cur_arg + uii]) > 6) && (!memcmp(argv[cur_arg + uii], "mperm=", 6))) {
if (cluster.modifier & CLUSTER_CMH_PERM) {
logerrprint("Error: --bd 'mperm' and 'perm[-bd]' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (cluster.modifier & CLUSTER_CMH_MPERM) {
logerrprint("Error: Duplicate --bd 'mperm' modifier.\n");
goto main_ret_INVALID_CMDLINE;
}
if (scan_posint_defcapx(&(argv[cur_arg + uii][6]), &(cluster.cmh_mperm_val))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --bd mperm parameter '%s'.\n", &(argv[cur_arg + uii][6]));
goto main_ret_INVALID_CMDLINE_WWA;
}
cluster.modifier |= CLUSTER_CMH_MPERM;
} else if (!strcmp(argv[cur_arg + uii], "perm-count")) {
cluster.modifier |= CLUSTER_CMH_PERM_COUNT;
} else if (!strcmp(argv[cur_arg + uii], "set-test")) {
cluster.modifier |= CLUSTER_CMH_SET_TEST;
} else if (!strcmp(argv[cur_arg + uii], "mperm")) {
logerrprint("Error: Improper --bd mperm syntax. (Use \"--bd mperm=\".)\n");
goto main_ret_INVALID_CMDLINE_A;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --bd parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_CMH;
cluster.modifier |= CLUSTER_CMH_BD;
} else if (!memcmp(argptr2, "iallelic-only", 14)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "strict")) {
misc_flags |= MISC_BIALLELIC_ONLY_STRICT;
} else if (!strcmp(argv[cur_arg + uii], "list")) {
misc_flags |= MISC_BIALLELIC_ONLY_LIST;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --biallelic-only modifier '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
misc_flags |= MISC_BIALLELIC_ONLY;
} else if (!memcmp(argptr2, "cf", 3)) {
if (load_rare || load_params) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
uii = strlen(argv[cur_arg + 1]);
if (uii > FNAMESIZE - 1) {
logerrprint("Error: --bcf filename too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(pedname, argv[cur_arg + 1], uii + 1);
load_rare = LOAD_RARE_BCF;
} else if (!memcmp(argptr2, "gen", 4)) {
if (load_rare || (load_params & LOAD_PARAMS_BFILE_ALL)) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
load_params |= LOAD_PARAMS_OXBGEN;
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (strlen(argv[cur_arg + 1]) > (FNAMESIZE - 1)) {
logerrprint("Error: --bgen parameter too long.\n");
goto main_ret_OPEN_FAIL;
}
strcpy(pedname, argv[cur_arg + 1]);
if (param_ct == 2) {
if (strcmp(argv[cur_arg + 2], "snpid-chr")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --bgen modifier '%s'.\n", argv[cur_arg + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
misc_flags |= MISC_OXFORD_SNPID_CHR;
}
} else if (!memcmp(argptr2, "locks", 6)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "no-pheno-req")) {
ld_info.modifier |= LD_BLOCKS_NO_PHENO_REQ;
} else if (!strcmp(argv[cur_arg + uii], "no-small-max-span")) {
ld_info.modifier |= LD_BLOCKS_NO_SMALL_MAX_SPAN;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --blocks parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_BLOCKS;
} else if (!memcmp(argptr2,"locks-inform-frac", 17)) {
if (!(calculation_type & CALC_BLOCKS)) {
logerrprint("Error: --blocks-inform-frac must be used with --blocks.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0) || (dxx > 1.0 - SMALL_EPSILON)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --blocks-inform-frac parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
ld_info.blocks_inform_frac = dxx;
} else if (!memcmp(argptr2, "locks-max-kb", 13)) {
if (!(calculation_type & CALC_BLOCKS)) {
logerrprint("Error: --blocks-max-kb must be used with --blocks.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --blocks-max-kb parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (dxx > 2147483.646) {
ld_info.blocks_max_bp = 2147483646;
} else {
ld_info.blocks_max_bp = ((int32_t)(dxx * 1000 * (1 + SMALL_EPSILON)));
}
} else if (!memcmp(argptr2, "locks-min-maf", 14)) {
if (!(calculation_type & CALC_BLOCKS)) {
logerrprint("Error: --blocks-min-maf must be used with --blocks.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0) || (dxx > 0.5)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --blocks-min-maf parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
ld_info.blocks_min_maf = dxx;
} else if (!memcmp(argptr2, "locks-recomb-highci", 20)) {
if (!(calculation_type & CALC_BLOCKS)) {
logerrprint("Error: --blocks-recomb-highci must be used with --blocks.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0) || (dxx > 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --blocks-recomb-highci parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
ld_info.blocks_recomb_highci = ((int32_t)((dxx + SMALL_EPSILON) * 100));
if (ld_info.blocks_recomb_highci < 2) {
logerrprint("Error: --blocks-recomb-highci parameter must be at least 0.02.\n");
goto main_ret_INVALID_CMDLINE_A;
}
ld_info.blocks_recomb_highci--;
} else if (!memcmp(argptr2, "locks-strong-highci", 20)) {
if (!(calculation_type & CALC_BLOCKS)) {
logerrprint("Error: --blocks-strong-highci must be used with --blocks.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < SMALL_EPSILON) || (dxx > 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --blocks-strong-highci parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
ld_info.blocks_strong_highci = (int32_t)((dxx - SMALL_EPSILON) * 100);
// 0.83 lower bound is needed for now for sane handling of size-2
// special case
if (ld_info.blocks_strong_highci < 83) {
logerrprint("Error: --blocks-strong-highci parameter currently must be larger than 0.83.\nContact the developers if this is problematic.\n");
goto main_ret_INVALID_CMDLINE;
}
} else if (!memcmp(argptr2, "locks-strong-lowci", 19)) {
if (!(calculation_type & CALC_BLOCKS)) {
logerrprint("Error: --blocks-strong-lowci must be used with --blocks.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < SMALL_EPSILON) || (dxx >= 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --blocks-strong-lowci parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
ld_info.blocks_strong_lowci_outer = 2 + (int32_t)((dxx - SMALL_EPSILON) * 100);
ld_info.blocks_strong_lowci = 2 + (int32_t)((dxx + SMALL_EPSILON) * 100);
if ((ld_info.blocks_strong_lowci_outer < 52) || (ld_info.blocks_strong_lowci > 82)) {
logerrprint("Error: --blocks-strong-lowci parameter currently must be in (0.5, 0.81).\nContact the developers if this is problematic.\n");
goto main_ret_INVALID_CMDLINE;
}
} else if (!memcmp(argptr2, "order", 6)) {
if (!annot_info.ranges_fname) {
logerrprint("Error: --border now must be used with --annotate + 'ranges'.\n");
if (!annot_info.fname) {
logerrprint("Use --make-set-border with --make-set, etc.)\n");
}
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --border parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WW;
}
if (dxx > 2147483.646) {
annot_info.border = 0x7ffffffe;
} else {
annot_info.border = (int32_t)(dxx * 1000 * (1 + SMALL_EPSILON));
}
} else if (!memcmp(argptr2, "pfile", 6)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Unrecognized flag (%s). (This is PLINK 1.9, not 2.x.)\n", argv[cur_arg]);
goto main_ret_INVALID_CMDLINE_2;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'c':
if (!memcmp(argptr2, "hr", 3)) {
if (chrom_flag_present) {
logerrprint("Error: --chr cannot be used with --autosome[-xy].\n");
goto main_ret_INVALID_CMDLINE_A;
}
retval = parse_chrom_ranges(param_ct, '-', &(argv[cur_arg]), chrom_info.chrom_mask, &chrom_info, (misc_flags / MISC_ALLOW_EXTRA_CHROMS) & 1, argptr);
if (retval) {
goto main_ret_1;
}
chrom_info.is_include_stack = 1;
chrom_flag_present = 1;
} else if (!memcmp(argptr2, "ompound-genotypes", 18)) {
logprint("Note: --compound-genotypes flag unnecessary (spaces between alleles in .ped\nand .lgen files are optional if all alleles are single-character).\n");
goto main_param_zero;
} else if (!memcmp(argptr2, "ompress", 8)) {
logerrprint("Error: --compress flag retired. Use e.g. \"gzip \".\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "ounts", 6)) {
if (model_modifier & MODEL_ASSOC) {
if (model_modifier & MODEL_QMASK) {
logerrprint("Error: --assoc 'qt-means'/'lin' does not make sense with --counts.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --counts flag deprecated. Use \"--assoc counts\" instead.\n");
model_modifier |= MODEL_ASSOC_COUNTS;
} else {
logprint("Note: --counts flag deprecated. Use \"--freq counts\" or --freqx instead.\n");
}
misc_flags |= MISC_FREQ_COUNTS;
goto main_param_zero;
} else if (!memcmp(argptr2, "ovar", 5)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
uii = 1;
if (param_ct == 2) {
if (!strcmp(argv[cur_arg + 1], "keep-pheno-on-missing-cov")) {
uii = 2;
} else if (strcmp(argv[cur_arg + 2], "keep-pheno-on-missing-cov")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --covar parameter '%s'.\n", argv[cur_arg + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (rplugin_fname) {
logerrprint("Error: --covar 'keep-pheno-on-missing-cov' modifier cannot be used with --R.\n");
goto main_ret_INVALID_CMDLINE_A;
}
covar_modifier |= COVAR_KEEP_PHENO_ON_MISSING_COV;
}
retval = alloc_fname(&covar_fname, argv[cur_arg + uii], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "ovar-name", 10)) {
if (!covar_fname) {
logerrprint("Error: --covar-name must be used with --covar.\n");
goto main_ret_INVALID_CMDLINE;
}
retval = parse_name_ranges(param_ct, range_delim, &(argv[cur_arg]), &covar_range_list, 0);
if (retval) {
goto main_ret_1;
}
covar_modifier |= COVAR_NAME;
} else if (!memcmp(argptr2, "ovar-number", 12)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (covar_modifier & COVAR_NAME) {
logerrprint("Error: --covar-number cannot be used with --covar-name.\n");
goto main_ret_INVALID_CMDLINE;
}
if (!covar_fname) {
logerrprint("Error: --covar-number must be used with --covar.\n");
goto main_ret_INVALID_CMDLINE;
}
retval = parse_name_ranges(param_ct, '-', &(argv[cur_arg]), &covar_range_list, 1);
if (retval) {
goto main_ret_1;
}
covar_modifier |= COVAR_NUMBER;
} else if (!memcmp(argptr2, "ell", 4)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_uint_defcapx(argv[cur_arg + 1], (uint32_t*)&model_cell_ct)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cell parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "i", 2)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --ci parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((dxx < 0.01) || (dxx >= 1.0)) {
logerrprint("Error: --ci confidence interval size s must satisfy 0.01 <= s < 1.\n");
goto main_ret_INVALID_CMDLINE_A;
}
ci_size = dxx;
} else if (!memcmp(argptr2, "luster", 7)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "cc")) {
cluster.modifier |= CLUSTER_CC;
} else if (!strcmp(argv[cur_arg + uii], "group-avg")) {
if (cluster.modifier & CLUSTER_OLD_TIEBREAKS) {
logerrprint("Error: --cluster 'group-avg' and 'old-tiebreaks' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
cluster.modifier |= CLUSTER_GROUP_AVG;
} else if (!strcmp(argv[cur_arg + uii], "missing")) {
cluster.modifier |= CLUSTER_MISSING;
} else if (!strcmp(argv[cur_arg + uii], "only2")) {
cluster.modifier |= CLUSTER_ONLY2;
} else if (!strcmp(argv[cur_arg + uii], "old-tiebreaks")) {
if (cluster.modifier & CLUSTER_GROUP_AVG) {
logerrprint("Error: --cluster 'group-avg' and 'old-tiebreaks' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
cluster.modifier |= CLUSTER_OLD_TIEBREAKS;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cluster parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_CLUSTER;
} else if (!memcmp(argptr2, "c", 2)) {
logprint("Note: --cc flag deprecated. Use \"--cluster cc\".\n");
cluster.modifier |= CLUSTER_CC;
goto main_param_zero;
} else if (!memcmp(argptr2, "luster-missing", 15)) {
if (calculation_type & CALC_CLUSTER) {
logerrprint("Error: --cluster-missing cannot be used with --cluster.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --cluster-missing flag deprecated. Use \"--cluster missing\".\n");
calculation_type |= CALC_CLUSTER;
cluster.modifier |= CLUSTER_MISSING;
goto main_param_zero;
} else if (!memcmp(argptr2, "file", 5)) {
UNSTABLE("cfile");
if (load_rare || load_params) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (calculation_type & CALC_MERGE) {
logerrprint("Error: --cfile cannot be used with --bmerge.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
sptr = argv[cur_arg + 1];
uii = strlen(sptr);
if (uii > (FNAMESIZE - 9)) {
logerrprint("Error: --cfile parameter too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(memcpya(pedname, sptr, uii), ".cnv", 5);
memcpy(memcpya(famname, sptr, uii), ".fam", 5);
memcpy(memcpya(mapname, sptr, uii), ".cnv.map", 9);
load_rare = LOAD_RARE_CNV;
} else if (!memcmp(argptr2, "nv-count", 9)) {
UNSTABLE("cnv-count");
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&cnv_intersect_filter_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
cnv_intersect_filter_type = CNV_COUNT;
} else if (!memcmp(argptr2, "nv-del", 7)) {
UNSTABLE("cnv-del");
cnv_calc_type |= CNV_DEL;
goto main_param_zero;
} else if (!memcmp(argptr2, "nv-disrupt", 11)) {
UNSTABLE("cnv-disrupt");
cnv_overlap_type = CNV_DISRUPT;
goto main_param_zero;
} else if (!memcmp(argptr2, "nv-dup", 7)) {
UNSTABLE("cnv-dup");
if (cnv_calc_type & CNV_DEL) {
logerrprint("Error: --cnv-dup cannot be used with --cnv-del.\n");
goto main_ret_INVALID_CMDLINE_A;
}
cnv_calc_type |= CNV_DUP;
goto main_param_zero;
} else if (!memcmp(argptr2, "nv-enrichment-test", 19)) {
UNSTABLE("cnv-enrichment-test");
if (!cnv_intersect_filter_type) {
logerrprint("Error: --cnv-enrichment-test must be used with --cnv-count.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (scan_posint_defcapx(argv[cur_arg + 1], &cnv_enrichment_test_mperms)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-enrichment-test permutation count '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
cnv_calc_type |= CNV_ENRICHMENT_TEST;
} else if (!memcmp(argptr2, "nv-exclude", 11)) {
UNSTABLE("cnv-exclude");
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (cnv_intersect_filter_type) {
logerrprint("Error: --cnv-exclude cannot be used with --cnv-count.\n");
goto main_ret_INVALID_CMDLINE_A;
}
retval = alloc_fname(&cnv_intersect_filter_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
cnv_intersect_filter_type = CNV_EXCLUDE;
} else if (!memcmp(argptr2, "nv-exclude-off-by-1", 20)) {
UNSTABLE("cnv-exclude-off-by-1");
cnv_calc_type |= CNV_EXCLUDE_OFF_BY_1;
goto main_param_zero;
} else if (!memcmp(argptr2, "nv-freq-exclude-above", 22)) {
UNSTABLE("cnv-freq-exclude-above");
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &cnv_freq_val)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-freq-exclude-above parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
cnv_freq_type = CNV_FREQ_EXCLUDE_ABOVE;
} else if (!memcmp(argptr2, "nv-freq-exclude-below", 22)) {
UNSTABLE("cnv-freq-exclude-below");
if (cnv_freq_type) {
logerrprint("Error: --cnv-freq-exclude-below cannot be used with --cnv-freq-exclude-above.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &cnv_freq_val) || (cnv_freq_val == 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-freq-exclude-below parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
cnv_freq_type = CNV_FREQ_EXCLUDE_BELOW;
} else if (!memcmp(argptr2, "nv-freq-exclude-exact", 22)) {
UNSTABLE("cnv-freq-exclude-exact");
if (cnv_freq_type) {
logerrprint("Error: --cnv-freq-exclude-exact cannot be used with\n--cnv-freq-exclude-above/-below.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &cnv_freq_val)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-freq-exclude-exact parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
cnv_freq_type = CNV_FREQ_EXCLUDE_EXACT;
} else if (!memcmp(argptr2, "nv-freq-include-exact", 22)) {
UNSTABLE("cnv-freq-include-exact");
if (cnv_freq_type) {
logerrprint("Error: --cnv-freq-include-exact cannot be used with\n--cnv-freq-exclude-above/-below/-exact.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &cnv_freq_val)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-freq-include-exact parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
cnv_freq_type = CNV_FREQ_INCLUDE_EXACT;
} else if (!memcmp(argptr2, "nv-freq-method2", 16)) {
UNSTABLE("cnv-freq-method2");
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (scan_doublex(argv[cur_arg + 1], &cnv_freq_val2) || (cnv_freq_val2 < 0) || (cnv_freq_val2 > 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-freq-method2 parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
cnv_freq_type |= CNV_FREQ_METHOD2;
if (cnv_freq_val2 == 0) {
// allow >= comparison to be used
cnv_freq_val2 = SMALLISH_EPSILON;
}
} else if (!memcmp(argptr2, "nv-freq-overlap", 16)) {
UNSTABLE("cnv-freq-overlap");
if (!(cnv_freq_type & CNV_FREQ_FILTER)) {
logerrprint("Error: --cnv-freq-overlap must be used with --cnv-freq-include-exact or\n--cnv-freq-exclude-above/-below/-exact.\n");
goto main_ret_INVALID_CMDLINE;
} else if (cnv_freq_type & CNV_FREQ_METHOD2) {
logerrprint("Error: --cnv-freq-overlap cannot be used with --cnv-freq-method2.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (scan_doublex(argv[cur_arg + 1], &cnv_freq_val2) || (cnv_freq_val2 < 0) || (cnv_freq_val2 > 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-freq-overlap parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
if (cnv_freq_val2 == 0) {
cnv_freq_val2 = SMALLISH_EPSILON;
}
cnv_freq_type |= CNV_FREQ_OVERLAP;
} else if (!memcmp(argptr2, "nv-indiv-perm", 14)) {
UNSTABLE("cnv-indiv-perm");
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (scan_posint_defcapx(argv[cur_arg + 1], &cnv_sample_mperms)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-indiv-perm permutation count '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
cnv_calc_type |= CNV_SAMPLE_PERM;
} else if (!memcmp(argptr2, "nv-intersect", 13)) {
UNSTABLE("cnv-intersect");
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (cnv_intersect_filter_type) {
logerrprint("Error: --cnv-intersect cannot be used with --cnv-count/--cnv-exclude.\n");
goto main_ret_INVALID_CMDLINE_A;
}
retval = alloc_fname(&cnv_intersect_filter_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
cnv_intersect_filter_type = CNV_INTERSECT;
} else if (!memcmp(argptr2, "nv-kb", 6)) {
UNSTABLE("cnv-kb");
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0.001) || (dxx > 2147483.646)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-kb size '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
cnv_min_seglen = (int32_t)(dxx * 1000 * (1 + SMALL_EPSILON));
} else if (!memcmp(argptr2, "nv-list", 8)) {
UNSTABLE("cnv-list");
if ((load_rare & (~LOAD_RARE_CNV)) || load_params) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (calculation_type & CALC_MERGE) {
logerrprint("Error: --cnv-list cannot be used with --bmerge.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
strcpya(pedname, argv[cur_arg + 1]);
load_rare = LOAD_RARE_CNV;
} else if (!memcmp(argptr2, "nv-make-map", 12)) {
UNSTABLE("cnv-make-map");
if (!(load_rare & LOAD_RARE_CNV)) {
logerrprint("Error: --cnv-make-map cannot be used without a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (strcmp(argv[cur_arg + 1], "short")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-make-map parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
cnv_calc_type |= CNV_MAKE_MAP;
} else {
cnv_calc_type |= CNV_MAKE_MAP | CNV_MAKE_MAP_LONG;
}
} else if (!memcmp(argptr2, "nv-max-kb", 10)) {
UNSTABLE("cnv-max-kb");
if (!(load_rare & LOAD_RARE_CNV)) {
logerrprint("Error: --cnv-max-kb cannot be used without a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0.001) || (dxx > 2147483.646)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-max-kb size '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
cnv_max_seglen = (int32_t)(dxx * 1000 * (1 + SMALL_EPSILON));
if (cnv_min_seglen > cnv_max_seglen) {
logerrprint("Error: --cnv-max-kb value cannot be smaller than --cnv-kb value.\n");
goto main_ret_INVALID_CMDLINE;
}
} else if (!memcmp(argptr2, "nv-max-score", 13)) {
UNSTABLE("cnv-max-score");
if (!(load_rare & LOAD_RARE_CNV)) {
logerrprint("Error: --cnv-max-score cannot be used without a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &cnv_max_score)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-max-score value '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "nv-max-sites", 13)) {
UNSTABLE("cnv-max-sites");
if (!(load_rare & LOAD_RARE_CNV)) {
logerrprint("Error: --cnv-max-sites cannot be used without a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_uint_defcapx(argv[cur_arg + 1], &cnv_max_sites)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-max-sites parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "nv-overlap", 11)) {
UNSTABLE("cnv-overlap");
if (!(load_rare & LOAD_RARE_CNV)) {
logerrprint("Error: --cnv-overlap cannot be used without a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE;
} else if (cnv_overlap_type == CNV_DISRUPT) {
logerrprint("Error: --cnv-overlap cannot be used with --cnv-disrupt.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &cnv_overlap_val) || (cnv_overlap_val < 0) || (cnv_overlap_val > 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-overlap value '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (cnv_overlap_val != 0) {
// ignore --cnv-overlap 0
cnv_overlap_type = CNV_OVERLAP;
}
if ((cnv_freq_type & CNV_FREQ_FILTER) && (!(cnv_freq_type & (CNV_FREQ_OVERLAP | CNV_FREQ_METHOD2)))) {
logprint("Note: --cnv-overlap + --cnv-freq-... deprecated. Use --cnv-freq-overlap.\n");
if (cnv_overlap_val != 0) {
cnv_freq_type |= CNV_FREQ_OVERLAP;
cnv_freq_val2 = cnv_overlap_val;
}
}
} else if (!memcmp(argptr2, "nv-region-overlap", 18)) {
UNSTABLE("cnv-region-overlap");
if (!(load_rare & LOAD_RARE_CNV)) {
logerrprint("Error: --cnv-region-overlap cannot be used without a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE;
} else if (cnv_overlap_type) {
logerrprint("Error: --cnv-region-overlap cannot be used with --cnv-overlap/-disrupt.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &cnv_overlap_val) || (cnv_overlap_val <= 0) || (cnv_overlap_val > 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-region-overlap value '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
cnv_overlap_type = CNV_OVERLAP_REGION;
} else if (!memcmp(argptr2, "nv-score", 9)) {
UNSTABLE("cnv-score");
if (!(load_rare & LOAD_RARE_CNV)) {
logerrprint("Error: --cnv-score cannot be used without a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &cnv_min_score)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-score value '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (cnv_min_score > cnv_max_score) {
logerrprint("Error: --cnv-score value cannot be greater than --cnv-max-score value.\n");
goto main_ret_INVALID_CMDLINE;
}
} else if (!memcmp(argptr2, "nv-sites", 9)) {
UNSTABLE("cnv-sites");
if (!(load_rare & LOAD_RARE_CNV)) {
logerrprint("Error: --cnv-sites cannot be used without a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_uint_defcapx(argv[cur_arg + 1], &cnv_min_sites)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-sites parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (cnv_min_sites > cnv_max_sites) {
logerrprint("Error: --cnv-sites value cannot be greater than --cnv-max-sites value.\n");
goto main_ret_INVALID_CMDLINE;
}
} else if (!memcmp(argptr2, "nv-subset", 10)) {
UNSTABLE("cnv-subset");
if (!(load_rare & LOAD_RARE_CNV)) {
logerrprint("Error: --cnv-subset cannot be used without a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!cnv_intersect_filter_type) {
logerrprint("Error: --cnv-subset must be used with --cnv-intersect/-exclude/-count.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&cnv_subset_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "nv-test", 8)) {
UNSTABLE("cnv-test");
if (!(load_rare & LOAD_RARE_CNV)) {
logerrprint("Error: --cnv-test cannot be used without a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct == 2) {
if (!strcmp(argv[cur_arg + 1], "1sided")) {
uii = 2;
cnv_calc_type |= CNV_TEST_FORCE_1SIDED;
} else if (!strcmp(argv[cur_arg + 1], "2sided")) {
uii = 2;
cnv_calc_type |= CNV_TEST_FORCE_2SIDED;
} else {
uii = 1;
if (!strcmp(argv[cur_arg + 2], "1sided")) {
cnv_calc_type |= CNV_TEST_FORCE_1SIDED;
} else if (!strcmp(argv[cur_arg + 2], "2sided")) {
cnv_calc_type |= CNV_TEST_FORCE_2SIDED;
} else {
logerrprint("Error: Invalid --cnv-test parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
} else {
uii = 1;
}
if (scan_posint_defcapx(argv[cur_arg + uii], &cnv_test_mperms)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-test permutation count '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
cnv_calc_type |= CNV_TEST;
} else if (!memcmp(argptr2, "nv-test-1sided", 15)) {
UNSTABLE("cnv-test-1sided");
if (cnv_calc_type & CNV_TEST_FORCE_2SIDED) {
logerrprint("Error: --cnv-test cannot be both 1-sided and 2-sided at the same time.\n");
goto main_ret_INVALID_CMDLINE;
}
logprint("Note: --cnv-test-1sided flag deprecated. Use \"--cnv-test 1sided\".\n");
cnv_calc_type |= CNV_TEST_FORCE_1SIDED;
} else if (!memcmp(argptr2, "nv-test-2sided", 15)) {
UNSTABLE("cnv-test-2sided");
if (cnv_calc_type & CNV_TEST_FORCE_1SIDED) {
logerrprint("Error: --cnv-test cannot be both 1-sided and 2-sided at the same time.\n");
goto main_ret_INVALID_CMDLINE;
}
logprint("Note: --cnv-test-2sided flag deprecated. Use \"--cnv-test 2sided\".\n");
cnv_calc_type |= CNV_TEST_FORCE_2SIDED;
} else if (!memcmp(argptr2, "nv-test-region", 15)) {
UNSTABLE("cnv-test-region");
if (!(load_rare & LOAD_RARE_CNV)) {
logerrprint("Error: --cnv-test-region cannot be used without a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (scan_posint_defcapx(argv[cur_arg + 1], &cnv_test_region_mperms)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-test-region permutation count '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
cnv_calc_type |= CNV_TEST_REGION;
} else if (!memcmp(argptr2, "nv-test-window", 15)) {
UNSTABLE("cnv-test-window");
if (!(load_rare & LOAD_RARE_CNV)) {
logerrprint("Error: --cnv-test-window cannot be used without a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0.001)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-test-window size '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
dxx *= 1000;
if (dxx > 2147483646) {
cnv_test_window = 0x7ffffffe;
} else {
cnv_test_window = (int32_t)(dxx * (1 + SMALL_EPSILON));
}
} else if (!memcmp(argptr2, "nv-union-overlap", 17)) {
UNSTABLE("cnv-union-overlap");
if (!(load_rare & LOAD_RARE_CNV)) {
logerrprint("Error: --cnv-union-overlap cannot be used without a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE;
} else if (cnv_overlap_type) {
logerrprint("Error: --cnv-union-overlap cannot be used with --cnv-{region-}overlap/-disrupt.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &cnv_overlap_val) || (cnv_overlap_val <= 0) || (cnv_overlap_val > 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-union-overlap value '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
cnv_overlap_type = CNV_OVERLAP_UNION;
} else if (!memcmp(argptr2, "nv-write", 9)) {
UNSTABLE("cnv-write");
if (!(load_rare & LOAD_RARE_CNV)) {
logerrprint("Error: --cnv-write cannot be used without a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (strcmp(argv[cur_arg + 1], "freq")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --cnv-write parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (!(cnv_freq_val & CNV_FREQ_METHOD2)) {
logerrprint("Error: --cnv-write 'freq' modifier must be used with --cnv-freq-method2.\n");
goto main_ret_INVALID_CMDLINE_A;
}
cnv_calc_type |= CNV_WRITE_FREQ;
}
cnv_calc_type |= CNV_WRITE;
} else if (!memcmp(argptr2, "nv-write-freq", 14)) {
UNSTABLE("cnv-write-freq");
if (!(load_rare & LOAD_RARE_CNV)) {
logerrprint("Error: --cnv-write freq cannot be used without a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!(cnv_freq_val & CNV_FREQ_METHOD2)) {
logerrprint("Error: --cnv-write 'freq' modifier must be used with --cnv-freq-method2.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (!(cnv_calc_type & CNV_WRITE)) {
logerrprint("Error: --cnv-write-freq must be used with --cnv-write.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --cnv-write-freq flag deprecated. Use \"--cnv-write freq\".\n");
cnv_calc_type |= CNV_WRITE_FREQ;
} else if (!memcmp(argptr2, "onsensus-match", 15)) {
logprint("Note: --consensus-match flag deprecated. Use \"--homozyg consensus-match\".\n");
homozyg.modifier |= HOMOZYG_CONSENSUS_MATCH;
goto main_param_zero;
} else if (!memcmp(argptr2, "ondition", 9)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
uii = 1;
if (param_ct == 2) {
if (!strcmp("dominant", argv[cur_arg + 2])) {
glm_modifier |= GLM_CONDITION_DOMINANT;
} else if (!strcmp("recessive", argv[cur_arg + 2])) {
glm_modifier |= GLM_CONDITION_RECESSIVE;
} else {
uii = 2;
if (!strcmp("dominant", argv[cur_arg + 1])) {
glm_modifier |= GLM_CONDITION_DOMINANT;
} else if (!strcmp("recessive", argv[cur_arg + 1])) {
glm_modifier |= GLM_CONDITION_RECESSIVE;
} else {
logerrprint("Error: Invalid --condition parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
}
if (alloc_string(&condition_mname, argv[cur_arg + uii])) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "ondition-list", 14)) {
if (condition_mname) {
logerrprint("Error: --condition-list cannot be used with --condition.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
uii = 1;
if (param_ct == 2) {
if (!strcmp("dominant", argv[cur_arg + 2])) {
glm_modifier |= GLM_CONDITION_DOMINANT;
} else if (!strcmp("recessive", argv[cur_arg + 2])) {
glm_modifier |= GLM_CONDITION_RECESSIVE;
} else {
uii = 2;
if (!strcmp("dominant", argv[cur_arg + 1])) {
glm_modifier |= GLM_CONDITION_DOMINANT;
} else if (!strcmp("recessive", argv[cur_arg + 1])) {
glm_modifier |= GLM_CONDITION_RECESSIVE;
} else {
logerrprint("Error: Invalid --condition-list parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
}
retval = alloc_fname(&condition_fname, argv[cur_arg + uii], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "omplement-sets", 15)) {
set_info.modifier |= SET_COMPLEMENTS | SET_C_PREFIX;
goto main_param_zero;
} else if (!memcmp(argptr2, "onst-fid", 9)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&const_fid, param_ct? argv[cur_arg + 1] : "0")) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "ase-only", 9)) {
logprint("Note: --case-only flag deprecated. Use \"--fast-epistasis case-only\".\n");
epi_info.modifier |= EPI_FAST_CASE_ONLY;
goto main_param_zero;
} else if (!memcmp(argptr2, "m-map", 6)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct == 1) {
// cannot contain more than one '@'
sptr = strchr(argv[cur_arg + 1], '@');
if (sptr) {
if (strchr(&(sptr[1]), '@')) {
logerrprint("Error: Multiple '@'s in --cm-map filename pattern.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
if (alloc_string(&cm_map_fname, argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
} else {
retval = alloc_fname(&cm_map_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
if (alloc_string(&cm_map_chrname, argv[cur_arg + 2])) {
goto main_ret_NOMEM;
}
}
filter_flags |= FILTER_BIM_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "heck-sex", 9)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 5)) {
goto main_ret_INVALID_CMDLINE_2A;
}
// pre-scan for 'y-only', since that changes interpretation of the
// first two numeric parameters
ujj = 0;
if (param_ct) {
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "y-only")) {
ujj = uii;
break;
}
}
}
if (!ujj) {
// now ujj is number of numeric parameters read
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "ycount")) {
misc_flags |= MISC_SEXCHECK_YCOUNT;
} else {
if (!ujj) {
if (scan_doublex(argv[cur_arg + uii], &check_sex_fthresh) || (check_sex_fthresh <= 0.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --check-sex female F-statistic estimate ceiling '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (ujj == 1) {
if (scan_doublex(argv[cur_arg + uii], &check_sex_mthresh) || (check_sex_mthresh >= 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --check-sex male F-statistic estimate floor '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (ujj == 2) {
if (scan_uint_defcapx(argv[cur_arg + uii], &check_sex_f_yobs)) {
logerrprint("Error: Invalid --check-sex female Ychr maximum nonmissing genotype count.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else if (ujj == 3) {
if (scan_uint_defcapx(argv[cur_arg + uii], &check_sex_m_yobs)) {
logerrprint("Error: Invalid --check-sex male Ychr minimum nonmissing genotype count.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else {
logerrprint("Error: Invalid --check-sex parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
ujj++;
}
}
if ((ujj > 2) && (!(misc_flags & MISC_SEXCHECK_YCOUNT))) {
logerrprint("Error: --check-sex only accepts >2 numeric parameters in 'ycount' mode.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (check_sex_fthresh > check_sex_mthresh) {
logerrprint("Error: --check-sex female F estimate ceiling cannot be larger than male floor.\n");
goto main_ret_INVALID_CMDLINE_A;
}
// actually fine if check_sex_f_yobs > check_sex_m_yobs
} else {
check_sex_m_yobs = 1;
ukk = 0; // number of numeric parameters
// in practice, second numeric parameter is not really optional if
// first is provided...
for (uii = 1; uii <= param_ct; uii++) {
if (uii == ujj) {
continue;
}
// may as well print a more informative error message in this case
if (!strcmp(argv[cur_arg + uii], "ycount")) {
logerrprint("Error: Conflicting --check-sex modes.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (!ukk) {
if (scan_uint_defcapx(argv[cur_arg + uii], &check_sex_f_yobs)) {
logerrprint("Error: Invalid --check-sex y-only female Ychr maximum nonmissing genotype\ncount.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else if (ukk == 1) {
if (scan_uint_defcapx(argv[cur_arg + uii], &check_sex_m_yobs)) {
logerrprint("Error: Invalid --check-sex y-only male Ychr minimum nonmissing genotype count.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else {
logerrprint("Error: Invalid --check-sex y-only parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
ukk++;
}
if (check_sex_f_yobs >= check_sex_m_yobs) {
logerrprint("Error: In y-only mode, --check-sex female Y observation threshold must be\nsmaller than male threshold.\n");
goto main_ret_INVALID_CMDLINE_A;
}
misc_flags |= MISC_SEXCHECK_YCOUNT | MISC_SEXCHECK_YONLY;
}
calculation_type |= CALC_SEXCHECK;
} else if (!memcmp(argptr2, "lump", 5)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x7fffffff)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten_comma_delim(&clump_info.fnames_flattened, &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_1;
}
calculation_type |= CALC_CLUMP;
// only needs to distinguish between one and two
if ((param_ct > 1) || strchr(argv[cur_arg + 1], ',')) {
clump_info.fname_ct = 2;
} else {
clump_info.fname_ct = 1;
}
} else if (!memcmp(argptr2, "lump-allow-overlap", 19)) {
if (!clump_info.fname_ct) {
logerrprint("Error: --clump-allow-overlap must be used with --clump.\n");
goto main_ret_INVALID_CMDLINE;
}
clump_info.modifier |= CLUMP_ALLOW_OVERLAP;
goto main_param_zero;
} else if (!memcmp(argptr2, "lump-annotate", 14)) {
if (!clump_info.fname_ct) {
logerrprint("Error: --clump-annotate must be used with --clump.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x7fffffff)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten_comma_delim(&clump_info.annotate_flattened, &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "lump-best", 10)) {
if (!clump_info.fname_ct) {
logerrprint("Error: --clump-best must be used with --clump.\n");
goto main_ret_INVALID_CMDLINE;
}
clump_info.modifier |= CLUMP_BEST;
goto main_param_zero;
} else if (!memcmp(argptr2, "lump-field", 11)) {
if (!clump_info.fname_ct) {
logerrprint("Error: --clump-field must be used with --clump.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x7fffffff)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten(&clump_info.pfield_search_order, &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "lump-index-first", 17)) {
if (!clump_info.fname_ct) {
logerrprint("Error: --clump-index-first must be used with --clump.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (clump_info.fname_ct == 1) {
logerrprint("Warning: --clump-index-first has no effect when there is only one --clump file.\n");
} else {
clump_info.modifier |= CLUMP_INDEX_FIRST;
}
goto main_param_zero;
} else if (!memcmp(argptr2, "lump-kb", 8)) {
if (!clump_info.fname_ct) {
logerrprint("Error: --clump-kb must be used with --clump.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0.001)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --clump-kb parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WW;
}
dxx *= 1000;
if (dxx > 2147483647.0) {
clump_info.bp_radius = 0x7ffffffe;
} else {
clump_info.bp_radius = ((int32_t)(dxx * (1 + SMALL_EPSILON) - 1));
}
} else if (!memcmp(argptr2, "lump-p1", 8)) {
if (!clump_info.fname_ct) {
logerrprint("Error: --clump-p1 must be used with --clump.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx <= 0) || (dxx > 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --clump-p1 parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WW;
}
clump_info.p1 = dxx;
} else if (!memcmp(argptr2, "lump-p2", 8)) {
if (!clump_info.fname_ct) {
logerrprint("Error: --clump-p2 must be used with --clump.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < clump_info.p1) || (dxx > 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --clump-p2 parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WW;
}
clump_info.p2 = dxx;
} else if (!memcmp(argptr2, "lump-r2", 8)) {
if (!clump_info.fname_ct) {
logerrprint("Error: --clump-r2 must be used with --clump.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx >= 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --clump-r2 parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WW;
}
clump_info.r2 = dxx;
} else if (!memcmp(argptr2, "lump-range", 11)) {
if (!clump_info.fname_ct) {
logerrprint("Error: --clump-range must be used with --clump.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&clump_info.range_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "lump-range-border", 18)) {
if (!clump_info.range_fname) {
logerrprint("Error: --clump-range-border must be used with --clump-range.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --clump-range-border parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WW;
}
if (dxx > 2147483.646) {
clump_info.range_border = 0x7ffffffe;
} else {
clump_info.range_border = (int32_t)(dxx * 1000 * (1 + SMALL_EPSILON));
}
} else if (!memcmp(argptr2, "lump-replicate", 15)) {
if (clump_info.fname_ct < 2) {
logerrprint("Error: --clump-replicate requires multiple --clump files.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (clump_info.modifier & CLUMP_BEST) {
logprint("Note: --clump-replicate no longer has any effect when used with --clump-best.\n");
} else {
clump_info.modifier |= CLUMP_REPLICATE;
}
goto main_param_zero;
} else if (!memcmp(argptr2, "lump-snp-field", 15)) {
if (!clump_info.fname_ct) {
logerrprint("Error: --clump-snp-field must be used with --clump.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x7fffffff)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten(&clump_info.snpfield_search_order, &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "lump-verbose", 13)) {
if (!clump_info.fname_ct) {
logerrprint("Error: --clump-verbose must be used with --clump.\n");
goto main_ret_INVALID_CMDLINE;
}
clump_info.modifier |= CLUMP_VERBOSE;
goto main_param_zero;
} else if (!memcmp(argptr2, "hap", 4)) {
goto main_hap_disabled_message;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'd':
if (!memcmp(argptr2, "ebug", 5)) {
g_debug_on = 1;
goto main_param_zero;
} else if (!memcmp(argptr2, "ata", 4)) {
if (load_rare || load_params) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
csptr = argv[cur_arg + 1];
if (strlen(csptr) > (FNAMESIZE - 8)) {
logerrprint("Error: --data parameter too long.\n");
goto main_ret_OPEN_FAIL;
}
} else {
csptr = PROG_NAME_STR;
}
if (!(load_params & LOAD_PARAMS_OXBGEN)) {
memcpy(strcpya(pedname, csptr), ".gen", 5);
load_params |= LOAD_PARAMS_OXGEN;
}
// cheating: this is of course more like a .fam file
memcpy(strcpya(mapname, csptr), ".sample", 8);
load_params |= LOAD_PARAMS_OXSAMPLE;
} else if (!memcmp(argptr2, "ecompress", 10)) {
logerrprint("Error: --decompress flag retired. Use e.g. \"gunzip \".\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "istance", 8)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 6)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "square")) {
if ((dist_calc_type & DISTANCE_SHAPEMASK) == DISTANCE_SQ0) {
logerrprint("Error: --distance 'square' and 'square0' modifiers cannot coexist.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((dist_calc_type & DISTANCE_SHAPEMASK) == DISTANCE_TRI) {
logerrprint("Error: --distance 'square' and 'triangle' modifiers cannot coexist.\n");
goto main_ret_INVALID_CMDLINE_A;
}
dist_calc_type |= DISTANCE_SQ;
} else if (!strcmp(argv[cur_arg + uii], "square0")) {
if ((dist_calc_type & DISTANCE_SHAPEMASK) == DISTANCE_SQ) {
logerrprint("Error: --distance 'square' and 'square0' modifiers cannot coexist.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((dist_calc_type & DISTANCE_SHAPEMASK) == DISTANCE_TRI) {
logerrprint("Error: --distance 'square0' and 'triangle' modifiers cannot coexist.\n");
goto main_ret_INVALID_CMDLINE_A;
}
dist_calc_type |= DISTANCE_SQ0;
} else if (!strcmp(argv[cur_arg + uii], "triangle")) {
if ((dist_calc_type & DISTANCE_SHAPEMASK) == DISTANCE_SQ) {
logerrprint("Error: --distance 'square' and 'triangle' modifiers cannot coexist.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((dist_calc_type & DISTANCE_SHAPEMASK) == DISTANCE_SQ0) {
logerrprint("Error: --distance 'square0' and 'triangle' modifiers cannot coexist.\n");
goto main_ret_INVALID_CMDLINE_A;
}
dist_calc_type |= DISTANCE_TRI;
} else if (!strcmp(argv[cur_arg + uii], "gz")) {
if (dist_calc_type & (DISTANCE_BIN | DISTANCE_BIN4)) {
logerrprint("Error: Conflicting --distance modifiers.\n");
goto main_ret_INVALID_CMDLINE_A;
}
dist_calc_type |= DISTANCE_GZ;
} else if (!strcmp(argv[cur_arg + uii], "bin")) {
if (dist_calc_type & (DISTANCE_GZ | DISTANCE_BIN4)) {
logerrprint("Error: Conflicting --distance modifiers.\n");
goto main_ret_INVALID_CMDLINE_A;
}
dist_calc_type |= DISTANCE_BIN;
} else if (!strcmp(argv[cur_arg + uii], "bin4")) {
if (dist_calc_type & (DISTANCE_GZ | DISTANCE_BIN)) {
logerrprint("Error: Conflicting --distance modifiers.\n");
goto main_ret_INVALID_CMDLINE_A;
}
dist_calc_type |= DISTANCE_BIN4;
} else if (!strcmp(argv[cur_arg + uii], "ibs")) {
if (dist_calc_type & DISTANCE_IBS) {
logerrprint("Error: Duplicate --distance 'ibs' modifier.\n");
goto main_ret_INVALID_CMDLINE;
}
dist_calc_type |= DISTANCE_IBS;
} else if (!strcmp(argv[cur_arg + uii], "1-ibs")) {
if (dist_calc_type & DISTANCE_1_MINUS_IBS) {
logerrprint("Error: Duplicate --distance '1-ibs' modifier.\n");
goto main_ret_INVALID_CMDLINE;
}
dist_calc_type |= DISTANCE_1_MINUS_IBS;
} else if (!strcmp(argv[cur_arg + uii], "allele-ct")) {
if (dist_calc_type & DISTANCE_ALCT) {
logerrprint("Error: Duplicate --distance 'allele-ct' modifier.\n");
goto main_ret_INVALID_CMDLINE;
}
dist_calc_type |= DISTANCE_ALCT;
} else if (!strcmp(argv[cur_arg + uii], "flat-missing")) {
dist_calc_type |= DISTANCE_FLAT_MISSING;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --distance parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
if (!(dist_calc_type & DISTANCE_TYPEMASK)) {
dist_calc_type |= DISTANCE_ALCT;
}
calculation_type |= CALC_DISTANCE;
} else if (!memcmp(argptr2, "istance-exp", 12)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &distance_exp)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --distance-exp parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WW;
}
fputs("Note: \"--distance-exp \" deprecated. Use \"--distance-wts exp=\" instead.\n", stdout);
} else if (!memcmp(argptr2, "istance-wts", 12)) {
if (distance_exp != 0.0) {
logerrprint("Error: --distance-wts cannot be used with --distance-exp.\n");
goto main_ret_INVALID_CMDLINE;
} else if (calculation_type & CALC_PLINK1_DISTANCE_MATRIX) {
logerrprint("Error: --distance-wts cannot be used with --distance-matrix.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if ((strlen(argv[cur_arg + 1]) > 4) && (!memcmp(argv[cur_arg + 1], "exp=", 4))) {
if (scan_doublex(&(argv[cur_arg + 1][4]), &distance_exp)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --distance-wts exponent '%s'.\n", &(argv[cur_arg + 1][4]));
goto main_ret_INVALID_CMDLINE_WW;
}
} else {
UNSTABLE("distance-wts");
uii = 1;
if (param_ct == 2) {
if (!strcmp(argv[cur_arg + 1], "noheader")) {
uii = 2;
} else if (strcmp(argv[cur_arg + 2], "noheader")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --distance-wts parameter '%s'.\n", argv[cur_arg + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
dist_calc_type |= DISTANCE_WTS_NOHEADER;
}
retval = alloc_fname(&distance_wts_fname, argv[cur_arg + uii], argptr, 0);
if (retval) {
goto main_ret_1;
}
}
} else if (!memcmp(argptr2, "istance-matrix", 15)) {
if (calculation_type & CALC_DISTANCE) {
// not worth the maintenance burden of making a few of these subcases
// work
logerrprint("Error: --distance-matrix cannot be used with --distance.\n");
goto main_ret_INVALID_CMDLINE;
}
calculation_type |= CALC_PLINK1_DISTANCE_MATRIX;
goto main_param_zero;
} else if (!memcmp(argptr2, "ummy", 5)) {
if (load_params) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 2, 6)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_uint_defcapx(argv[cur_arg + 1], &dummy_sample_ct) || ((!dummy_sample_ct) && (!(misc_flags & MISC_ALLOW_NO_SAMPLES)))) {
logerrprint("Error: Invalid --dummy sample count.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (scan_uint_defcapx(argv[cur_arg + 2], &dummy_marker_ct) || ((!dummy_marker_ct) && (!(misc_flags & MISC_ALLOW_NO_VARS)))) {
logerrprint("Error: Invalid --dummy variant count.\n");
goto main_ret_INVALID_CMDLINE_A;
}
for (uii = 3; uii <= param_ct; uii++) {
if (match_upper(argv[cur_arg + uii], "ACGT")) {
if (dummy_flags & (DUMMY_1234 | DUMMY_12)) {
logerrprint("Error: --dummy 'acgt' modifier cannot be used with '1234' or '12'.\n");
goto main_ret_INVALID_CMDLINE_A;
}
dummy_flags |= DUMMY_ACGT;
} else if (!strcmp(argv[cur_arg + uii], "1234")) {
if (dummy_flags & (DUMMY_ACGT | DUMMY_12)) {
logerrprint("Error: --dummy '1234' modifier cannot be used with 'acgt' or '12'.\n");
goto main_ret_INVALID_CMDLINE_A;
}
dummy_flags |= DUMMY_1234;
} else if (!strcmp(argv[cur_arg + uii], "12")) {
if (dummy_flags & (DUMMY_ACGT | DUMMY_1234)) {
logerrprint("Error: --dummy '12' modifier cannot be used with 'acgt' or '1234'.\n");
goto main_ret_INVALID_CMDLINE_A;
}
dummy_flags |= DUMMY_12;
} else if (!strcmp(argv[cur_arg + uii], "scalar-pheno")) {
dummy_flags |= DUMMY_SCALAR_PHENO;
} else {
if ((dummy_flags & DUMMY_MISSING_PHENO) || scan_doublex(argv[cur_arg + uii], &dxx) || (dxx < 0.0) || (dxx > 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --dummy parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
} else if (dummy_flags & DUMMY_MISSING_GENO) {
dummy_missing_pheno = dxx;
dummy_flags |= DUMMY_MISSING_PHENO;
} else {
dummy_missing_geno = dxx;
dummy_flags |= DUMMY_MISSING_GENO;
}
}
}
load_rare = LOAD_RARE_DUMMY;
} else if (!memcmp(argptr2, "ummy-coding", 12)) {
if (!covar_fname) {
logerrprint("Error: --dummy-coding cannot be used without --covar.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (!strcmp(argv[cur_arg + 1], "no-round")) {
uii = 2;
write_covar_modifier |= WRITE_COVAR_DUMMY_NO_ROUND;
} else {
if (param_ct == 2) {
if (strcmp(argv[cur_arg + 2], "no-round")) {
logerrprint("Error: Invalid --dummy-coding parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
write_covar_modifier |= WRITE_COVAR_DUMMY_NO_ROUND;
}
uii = 1;
}
if (uii <= param_ct) {
if (scan_posint_defcapx(argv[cur_arg + uii], &write_covar_dummy_max_categories) || (write_covar_dummy_max_categories < 3)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --dummy-coding max categories parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
}
write_covar_modifier |= WRITE_COVAR_DUMMY;
} else if (!memcmp(argptr2, "ominant", 8)) {
logprint("Note: --dominant flag deprecated. Use e.g. \"--linear dominant\" (and\n\"--condition-list dominant\" to change covariate coding).\n");
glm_modifier |= GLM_DOMINANT | GLM_CONDITION_DOMINANT;
glm_xchr_model = 0;
goto main_param_zero;
} else if (!memcmp(argptr2, "ouble-id", 9)) {
if (const_fid) {
logerrprint("Error: --double-id cannot be used with --const-fid.\n");
goto main_ret_INVALID_CMDLINE_A;
}
misc_flags |= MISC_DOUBLE_ID;
goto main_param_zero;
} else if (!memcmp(argptr2, "osage", 6)) {
if (load_rare || load_params) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
} else if (pheno_modifier & PHENO_ALL) {
logerrprint("Error: --dosage cannot be used with --all-pheno.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (mtest_adjust) {
logerrprint("Error: --dosage cannot be used with --adjust.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (covar_modifier & COVAR_KEEP_PHENO_ON_MISSING_COV) {
logerrprint("Error: --dosage cannot be used with --covar 'keep-pheno-on-missing-cov'\nmodifier.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (condition_mname || condition_fname) {
logerrprint("Error: --dosage does not support --condition/--condition-list.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (misc_flags & (MISC_ALLOW_NO_SAMPLES | MISC_ALLOW_NO_VARS)) {
logerrprint("Error: --dosage does not support --allow-no-samples/--allow-no-vars.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 13)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&dosage_info.fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
for (uii = 2; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "list")) {
dosage_info.modifier |= DOSAGE_LIST;
} else if (!strcmp(argv[cur_arg + uii], "dose1")) {
dosage_info.modifier |= DOSAGE_DOSE1;
} else if (!strcmp(argv[cur_arg + uii], "Z")) {
logprint("Note: --dosage 'Z' modifier is now equivalent to 'Zout', since gzipped input is\nautomatically supported.\n");
dosage_info.modifier |= DOSAGE_ZOUT;
} else if (!strcmp(argv[cur_arg + uii], "Zin")) {
logprint("Note: --dosage 'Zin' modifier now has no effect, since gzipped input is\nautomatically supported.\n");
} else if (!strcmp(argv[cur_arg + uii], "Zout")) {
dosage_info.modifier |= DOSAGE_ZOUT;
} else if (!strcmp(argv[cur_arg + uii], "occur")) {
dosage_info.modifier |= DOSAGE_OCCUR;
} else if (!strcmp(argv[cur_arg + uii], "sex")) {
dosage_info.modifier |= DOSAGE_SEX;
} else if (!strcmp(argv[cur_arg + uii], "case-control-freqs")) {
dosage_info.modifier |= DOSAGE_FREQ_CC;
} else if (!strcmp(argv[cur_arg + uii], "frq2")) {
// turn this into an error before official 1.9 release
logerrprint("Warning: The --dosage 'frq2' modifier has been renamed to 'case-control-freqs'.\n");
dosage_info.modifier |= DOSAGE_FREQ_CC;
} else if (strlen(argv[cur_arg + uii]) <= 6) {
goto main_dosage_invalid_param;
} else if (!strcmp(argv[cur_arg + uii], "sepheader")) {
if (dosage_info.modifier & DOSAGE_NOHEADER) {
logerrprint("Error: --dosage 'sepheader' and 'noheader' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
dosage_info.modifier |= DOSAGE_SEPHEADER;
} else if (!strcmp(argv[cur_arg + uii], "noheader")) {
if (dosage_info.modifier & DOSAGE_SEPHEADER) {
logerrprint("Error: --dosage 'sepheader' and 'noheader' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
dosage_info.modifier |= DOSAGE_NOHEADER;
} else if (!memcmp(argv[cur_arg + uii], "skip0=", 6)) {
if (scan_uint_defcapx(&(argv[cur_arg + uii][6]), &(dosage_info.skip0))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --dosage skip0 parameter '%s'.\n", &(argv[cur_arg + uii][6]));
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argv[cur_arg + uii], "skip1=", 6)) {
if (scan_uint_defcapx(&(argv[cur_arg + uii][6]), &(dosage_info.skip1))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --dosage skip1 parameter '%s'.\n", &(argv[cur_arg + uii][6]));
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argv[cur_arg + uii], "skip2=", 6)) {
if (scan_uint_defcapx(&(argv[cur_arg + uii][6]), &(dosage_info.skip2))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --dosage skip2 parameter '%s'.\n", &(argv[cur_arg + uii][6]));
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argv[cur_arg + uii], "format=", 7)) {
ujj = ((unsigned char)argv[cur_arg + uii][7]) - '1';
if ((ujj > 2) || argv[cur_arg + uii][8]) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --dosage format parameter '%s'.\n", &(argv[cur_arg + uii][7]));
goto main_ret_INVALID_CMDLINE_WWA;
}
dosage_info.format = ujj + 1;
} else if (!strcmp(argv[cur_arg + uii], "standard-beta")) {
glm_modifier |= GLM_STANDARD_BETA;
} else {
main_dosage_invalid_param:
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --dosage modifier '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
if (dosage_info.modifier & DOSAGE_OCCUR) {
if ((glm_modifier & GLM_STANDARD_BETA) || (dosage_info.modifier & DOSAGE_SEX)) {
logerrprint("Error: --dosage 'occur' mode cannot be used with association analysis\nmodifiers/flags.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else {
dosage_info.modifier |= DOSAGE_GLM;
}
if ((dosage_info.modifier & (DOSAGE_LIST | DOSAGE_SEPHEADER)) == DOSAGE_SEPHEADER) {
logerrprint("Error: --dosage 'sepheader' modifier must be used with 'list'.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((dosage_info.modifier & DOSAGE_DOSE1) && (dosage_info.format != 1)) {
logerrprint("Error: --dosage 'dose1' modifier must be used with 'format=1'.\n");
goto main_ret_INVALID_CMDLINE_A;
}
load_rare = LOAD_RARE_DOSAGE;
} else if (!memcmp(argptr2, "fam", 4)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "no-unrelateds")) {
family_info.dfam_modifier |= DFAM_NO_UNRELATEDS;
} else if (!strcmp(argv[cur_arg + uii], "perm")) {
if (family_info.dfam_modifier & DFAM_MPERM) {
logerrprint("Error: --dfam 'mperm' and 'perm' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
family_info.dfam_modifier |= DFAM_PERM;
} else if (!strcmp(argv[cur_arg + uii], "perm-count")) {
family_info.dfam_modifier |= DFAM_PERM_COUNT;
} else if ((strlen(argv[cur_arg + uii]) > 6) && (!memcmp(argv[cur_arg + uii], "mperm=", 6))) {
if (family_info.dfam_modifier & DFAM_PERM) {
logerrprint("Error: --dfam 'mperm' and 'perm' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (family_info.dfam_modifier & DFAM_MPERM) {
logerrprint("Error: Duplicate --dfam 'mperm' modifier.\n");
goto main_ret_INVALID_CMDLINE;
}
if (scan_posint_defcapx(&(argv[cur_arg + uii][6]), &family_info.dfam_mperm_val)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --dfam mperm parameter '%s'.\n", &(argv[cur_arg + uii][6]));
goto main_ret_INVALID_CMDLINE_WWA;
}
family_info.dfam_modifier |= DFAM_MPERM;
} else if (!strcmp(argv[cur_arg + uii], "set-test")) {
family_info.dfam_modifier |= DFAM_SET_TEST;
} else if (!strcmp(argv[cur_arg + uii], "mperm")) {
logerrprint("Error: Improper --dfam mperm syntax. (Use \"--dfam mperm=\".)\n");
goto main_ret_INVALID_CMDLINE;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --dfam parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_DFAM;
} else if (!memcmp(argptr2, "fam-no-unrelateds", 18)) {
// keep this undocumented flag since it makes DFAM correspond to the
// original sib-TDT.
if (!(calculation_type & CALC_DFAM)) {
logerrprint("Error: --dfam-no-unrelateds must be used with --dfam.\n");
goto main_ret_INVALID_CMDLINE;
}
family_info.dfam_modifier |= DFAM_NO_UNRELATEDS;
logprint("Note: --dfam-no-unrelateds flag deprecated. Use \"--dfam no-unrelateds\".\n");
goto main_param_zero;
} else if (!memcmp(argptr2, "prime", 6)) {
logprint("Note: --dprime flag deprecated. Use e.g. \"--r2 dprime\".\n");
ld_info.modifier |= LD_DPRIME;
goto main_param_zero;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'e':
if (!memcmp(argptr2, "xtract", 7)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
uii = 1;
if (param_ct == 2) {
if (!strcmp(argv[cur_arg + 1], "range")) {
uii = 2;
} else if (strcmp(argv[cur_arg + 2], "range")) {
logerrprint("Error: Invalid --extract parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
misc_flags |= MISC_EXTRACT_RANGE;
}
retval = alloc_fname(&extractname, argv[cur_arg + uii], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP | FILTER_NOCNV;
} else if (!memcmp(argptr2, "xclude", 7)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
uii = 1;
if (param_ct == 2) {
if (!strcmp(argv[cur_arg + 1], "range")) {
uii = 2;
} else if (strcmp(argv[cur_arg + 2], "range")) {
logerrprint("Error: Invalid --exclude parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
misc_flags |= MISC_EXCLUDE_RANGE;
}
retval = alloc_fname(&excludename, argv[cur_arg + uii], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP | FILTER_NOCNV;
} else if (!memcmp(argptr2, "xclude-snp", 11)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&markername_snp, argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP | FILTER_NOCNV | FILTER_EXCLUDE_MARKERNAME_SNP;
} else if (!memcmp(argptr2, "xclude-snps", 12)) {
if (markername_snp) {
logerrprint("Error: --exclude-snps cannot be used with --exclude-snp.\n");
goto main_ret_INVALID_CMDLINE_A;
}
retval = parse_name_ranges(param_ct, range_delim, &(argv[cur_arg]), &snps_range_list, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP | FILTER_NOCNV | FILTER_EXCLUDE_MARKERNAME_SNP;
} else if (!memcmp(argptr2, "pistasis", 9)) {
if (epi_info.modifier & EPI_FAST_CASE_ONLY) {
logerrprint("Error: --epistasis cannot be used with --case-only.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (!strcmp(argv[cur_arg + 1], "set-by-set")) {
epi_info.modifier |= EPI_SET_BY_SET;
} else if (!strcmp(argv[cur_arg + 1], "set-by-all")) {
epi_info.modifier |= EPI_SET_BY_ALL;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --epistasis modifier '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
epi_info.modifier |= EPI_REG;
calculation_type |= CALC_EPI;
} else if (!memcmp(argptr2, "pistasis-summary-merge", 23)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 2, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
// .summary.32767 = 14 chars
retval = alloc_fname(&epi_info.summary_merge_prefix, argv[cur_arg + 1], argptr, 14);
if (retval) {
goto main_ret_1;
}
if (scan_posint_cappedx(argv[cur_arg + 2], PARALLEL_MAX, &epi_info.summary_merge_ct) || (epi_info.summary_merge_ct == 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --epistasis-summary-merge job count '%s'.\n", argv[cur_arg + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "pi1", 4)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx <= 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --epi1 parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
epi_info.epi1 = dxx;
} else if (!memcmp(argptr2, "pi2", 4)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx <= 0) || (dxx >= 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --epi2 parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
epi_info.epi2 = dxx;
} else if (!memcmp(argptr2, "xclude-before-extract", 22)) {
logprint("Note: --exclude-before-extract has no effect.\n");
goto main_param_zero;
} else if ((!memcmp(argptr2, "m-follow", 9)) ||
(!memcmp(argptr2, "m-meta-iter", 12)) ||
// may as well print an appropriate error message when an
// unsupported undocumented flag is used, but I'll draw a line
// at *misspelled* undocumented flags--if anyone was using
// --em-meta-likilood, the misspelling should have been
// caught...
(!memcmp(argptr2, "m-meta-prune-haplotype", 23)) ||
(!memcmp(argptr2, "m-meta-prune-phase", 19)) ||
(!memcmp(argptr2, "m-meta-tol", 11)) ||
(!memcmp(argptr2, "m-meta-window", 14)) ||
(!memcmp(argptr2, "m-overlap", 10)) ||
(!memcmp(argptr2, "m-verbose", 10)) ||
(!memcmp(argptr2, "m-window", 9)) ||
(!memcmp(argptr2, "m-window-iter", 14)) ||
(!memcmp(argptr2, "m-window-likelihood", 20)) ||
(!memcmp(argptr2, "m-window-prune-haplotype", 25)) ||
(!memcmp(argptr2, "m-window-prune-phase", 21)) ||
(!memcmp(argptr2, "m-window-tol", 13))) {
goto main_hap_disabled_message;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'f':
if (!memcmp(argptr2, "ile", 4)) {
if (load_params & (LOAD_PARAMS_BFILE_ALL | LOAD_PARAMS_OX_ALL)) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
load_params |= LOAD_PARAMS_TEXT_ALL;
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
csptr = argv[cur_arg + 1];
if (strlen(csptr) > (FNAMESIZE - 5)) {
logerrprint("Error: --file parameter too long.\n");
goto main_ret_OPEN_FAIL;
}
} else {
csptr = PROG_NAME_STR;
}
memcpy(strcpya(pedname, csptr), ".ped", 5);
memcpy(strcpya(mapname, csptr), ".map", 5);
} else if (!memcmp(argptr2, "am", 3)) {
if (load_params & (LOAD_PARAMS_TEXT_ALL | LOAD_PARAMS_OX_ALL)) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
load_params |= LOAD_PARAMS_FAM;
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (strlen(argv[cur_arg + 1]) > (FNAMESIZE - 1)) {
logerrprint("Error: --fam parameter too long.\n");
goto main_ret_OPEN_FAIL;
}
strcpy(famname, argv[cur_arg + 1]);
} else if (!memcmp(argptr2, "ilter", 6)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 2, 0x7fffffff)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&filtername, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
retval = alloc_and_flatten(&filtervals_flattened, &(argv[cur_arg + 2]), param_ct - 1);
if (retval) {
goto main_ret_NOMEM;
}
filter_flags |= FILTER_FAM_REQ;
} else if (!memcmp(argptr2, "ilter-cases", 12)) {
filter_flags |= FILTER_FAM_REQ | FILTER_BINARY_CASES;
goto main_param_zero;
} else if (!memcmp(argptr2, "ilter-controls", 15)) {
if (filter_flags & FILTER_BINARY_CASES) {
logerrprint("Error: --filter-cases and --filter-controls cannot be used together.\n");
goto main_ret_INVALID_CMDLINE;
}
filter_flags |= FILTER_FAM_REQ | FILTER_BINARY_CONTROLS;
goto main_param_zero;
} else if (!memcmp(argptr2, "ilter-females", 14)) {
filter_flags |= FILTER_FAM_REQ | FILTER_BINARY_FEMALES;
goto main_param_zero;
} else if (!memcmp(argptr2, "ilter-males", 12)) {
if (filter_flags & FILTER_BINARY_FEMALES) {
logerrprint("Error: --filter-males and --filter-females cannot be used together.\n");
goto main_ret_INVALID_CMDLINE;
}
filter_flags |= FILTER_FAM_REQ | FILTER_BINARY_MALES;
goto main_param_zero;
} else if (!memcmp(argptr2, "ilter-founders", 15)) {
filter_flags |= FILTER_FAM_REQ | FILTER_BINARY_FOUNDERS;
goto main_param_zero;
} else if (!memcmp(argptr2, "ilter-nonfounders", 18)) {
if (filter_flags & FILTER_BINARY_FOUNDERS) {
logerrprint("Error: --filter-founders and --filter-nonfounders cannot be used together.\n");
goto main_ret_INVALID_CMDLINE;
}
filter_flags |= FILTER_FAM_REQ | FILTER_BINARY_NONFOUNDERS;
goto main_param_zero;
} else if (!memcmp(argptr2, "req", 4)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "counts")) {
if (misc_flags & MISC_FREQ_CC) {
logerrprint("Error: --freq 'counts' and 'case-control' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE;
}
misc_flags |= MISC_FREQ_COUNTS;
} else if (!strcmp(argv[cur_arg + uii], "case-control")) {
if (misc_flags & MISC_FREQ_COUNTS) {
logerrprint("Error: --freq 'counts' and 'case-control' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE;
}
misc_flags |= MISC_FREQ_CC;
} else if (!strcmp(argv[cur_arg + uii], "gz")) {
misc_flags |= MISC_FREQ_GZ;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --freq parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_FREQ;
if (misc_flags & MISC_FREQ_COUNTS) {
// --keep-allele-order also set for backward compatibility
// placed here instead of a few lines up because "--freq --counts" is
// permitted
misc_flags |= MISC_KEEP_ALLELE_ORDER;
}
} else if (!memcmp(argptr2, "reqx", 5)) {
if (calculation_type & CALC_FREQ) {
logerrprint("Error: --freqx cannot be used with --freq.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (strcmp(argv[cur_arg + 1], "gz")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --freqx parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
misc_flags |= MISC_FREQ_GZ;
}
calculation_type |= CALC_FREQ;
misc_flags |= MISC_FREQX;
} else if (!memcmp(argptr2, "rom", 4)) {
if (chrom_flag_present) {
logerrprint("Error: --from cannot be used with --autosome[-xy] or --[not-]chr.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&markername_from, argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP | FILTER_NOCNV;
} else if ((!memcmp(argptr2, "rom-bp", 7)) || (!memcmp(argptr2, "rom-kb", 7)) || (!memcmp(argptr2, "rom-mb", 7))) {
if (markername_from) {
logerrprint("Error: --from-bp/-kb/-mb cannot be used with --from.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
cc = argptr2[4];
if (cc == 'b') {
if (scan_uint_defcapx(argv[cur_arg + 1], (uint32_t*)&marker_pos_start)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --from-bp parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else {
if (marker_pos_start != -1) {
logerrprint("Error: Multiple --from-bp/-kb/-mb values.\n");
goto main_ret_INVALID_CMDLINE;
}
if (scan_doublex(argv[cur_arg + 1], &dxx)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --from-kb/-mb parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
dxx *= (cc == 'k')? 1000 : 1000000;
if (dxx < 0) {
marker_pos_start = 0;
} else if (dxx > 2147483646) {
marker_pos_start = 0x7ffffffe;
} else {
marker_pos_start = (int32_t)(dxx * (1 + SMALL_EPSILON));
}
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP;
} else if (!memcmp(argptr2, "isher", 6)) {
if (model_modifier & MODEL_ASSOC) {
logerrprint("Error: --fisher cannot be used with --assoc.\n");
goto main_ret_INVALID_CMDLINE;
}
logprint("Note: --fisher flag deprecated. Use \"--assoc fisher\" or \"--model fisher\".\n");
model_modifier |= MODEL_ASSOC | MODEL_FISHER | MODEL_ASSOC_FDEPR;
calculation_type |= CALC_MODEL;
goto main_param_zero;
} else if (!memcmp(argptr2, "id", 3)) {
logprint("Note: --fid flag deprecated. Use \"--recode vcf-fid\".\n");
recode_modifier |= RECODE_FID;
goto main_param_zero;
} else if (!memcmp(argptr2, "lip", 4)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&flip_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_BIM_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "lip-subset", 11)) {
if (!flip_fname) {
logerrprint("Error: --flip-subset must be used with --flip.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (allelexxxx) {
// fix for this is too messy to be worthwhile
logerrprint("Error: --flip-subset cannot be used with --allele1234/ACGT.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&flip_subset_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "ast-epistasis", 14)) {
if (epi_info.modifier & EPI_REG) {
logerrprint("Error: --fast-epistasis cannot be used with --epistasis.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "no-ueki")) {
if (epi_info.modifier & (EPI_FAST_BOOST | EPI_FAST_JOINT_EFFECTS)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --fast-epistasis 'no-ueki' modifier cannot be used with '%s'.\n", (epi_info.modifier & EPI_FAST_BOOST)? "boost" : "joint-effects");
goto main_ret_INVALID_CMDLINE_2A;
}
epi_info.modifier |= EPI_FAST_NO_UEKI;
} else if (!strcmp(argv[cur_arg + uii], "boost")) {
if (epi_info.modifier & (EPI_FAST_NO_UEKI | EPI_FAST_JOINT_EFFECTS)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --fast-epistasis 'boost' modifier cannot be used with '%s'.\n", (epi_info.modifier & EPI_FAST_NO_UEKI)? "no-ueki" : "joint-effects");
goto main_ret_INVALID_CMDLINE_2A;
}
if (epi_info.modifier & EPI_FAST_CASE_ONLY) {
logerrprint("Error: --fast-epistasis boost does not have a case-only mode.\n");
goto main_ret_INVALID_CMDLINE;
}
epi_info.modifier |= EPI_FAST_BOOST;
} else if (!strcmp(argv[cur_arg + uii], "joint-effects")) {
if (epi_info.modifier & (EPI_FAST_NO_UEKI | EPI_FAST_BOOST)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --fast-epistasis 'joint-effects' modifier cannot be used with '%s'.\n", (epi_info.modifier & EPI_FAST_NO_UEKI)? "no-ueki" : "boost");
goto main_ret_INVALID_CMDLINE_2A;
}
epi_info.modifier |= EPI_FAST_JOINT_EFFECTS;
} else if (!strcmp(argv[cur_arg + uii], "case-only")) {
if (epi_info.modifier & EPI_FAST_BOOST) {
logerrprint("Error: --fast-epistasis boost does not have a case-only mode.\n");
goto main_ret_INVALID_CMDLINE;
}
epi_info.modifier |= EPI_FAST_CASE_ONLY;
} else if (!strcmp(argv[cur_arg + uii], "set-by-set")) {
if (!(epi_info.modifier & EPI_SET_BY_ALL)) {
epi_info.modifier |= EPI_SET_BY_SET;
}
} else if (!strcmp(argv[cur_arg + uii], "set-by-all")) {
if (epi_info.modifier & EPI_SET_BY_SET) {
epi_info.modifier -= EPI_SET_BY_SET;
}
epi_info.modifier |= EPI_SET_BY_ALL;
} else if (!strcmp(argv[cur_arg + uii], "nop")) {
epi_info.modifier |= EPI_FAST_NO_P_VALUE;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --fast-epistasis modifier '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
epi_info.modifier |= EPI_FAST;
calculation_type |= CALC_EPI;
} else if (!memcmp(argptr2, "lip-scan", 9)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (strcmp(argv[cur_arg + 1], "verbose")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --flip-scan parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
ld_info.modifier |= LD_FLIPSCAN_VERBOSE;
}
calculation_type |= CALC_FLIPSCAN;
} else if (!memcmp(argptr2, "lip-scan-window", 16)) {
if (!(calculation_type & CALC_FLIPSCAN)) {
logerrprint("Error: --flip-scan-window must be used with --flip-scan.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &ld_info.flipscan_window_size) || (ld_info.flipscan_window_size == 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --flip-scan-window size '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "lip-scan-window-kb", 19)) {
if (!(calculation_type & CALC_FLIPSCAN)) {
logerrprint("Error: --flip-scan-window-kb must be used with --flip-scan.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --flip-scan-window-kb parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (dxx > 2147483.646) {
ld_info.flipscan_window_bp = 2147483646;
} else {
ld_info.flipscan_window_bp = ((int32_t)(dxx * 1000 * (1 + SMALL_EPSILON)));
}
} else if (!memcmp(argptr2, "lip-scan-threshold", 19)) {
if (!(calculation_type & CALC_FLIPSCAN)) {
logerrprint("Error: --flip-scan-threshold must be used with --flip-scan.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx <= 0.0) || (dxx > 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --flip-scan-threshold parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
ld_info.flipscan_thresh = dxx;
} else if (!memcmp(argptr2, "lip-scan-verbose", 17)) {
if (!(calculation_type & CALC_FLIPSCAN)) {
logerrprint("Error: --flip-scan-verbose must be used with --flip-scan.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --flip-scan-verbose flag deprecated. Use \"--flip-scan verbose\".\n");
ld_info.modifier |= LD_FLIPSCAN_VERBOSE;
} else if (!memcmp(argptr2, "amily", 6)) {
if (calculation_type & CALC_DFAM) {
logerrprint("Error: --family cannot be used with --dfam.\n");
goto main_ret_INVALID_CMDLINE_A;
}
misc_flags |= MISC_FAMILY_CLUSTERS;
filter_flags |= FILTER_FAM_REQ;
goto main_param_zero;
} else if (!memcmp(argptr2, "ill-missing-a2", 15)) {
if (load_rare & LOAD_RARE_CNV) {
logerrprint("Error: --fill-missing-a2 cannot be used with a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (flip_subset_fname) {
logerrprint("Error: --fill-missing-a2 cannot be used with --flip-subset.\n");
goto main_ret_INVALID_CMDLINE_A;
}
misc_flags |= MISC_FILL_MISSING_A2;
goto main_param_zero;
} else if (!memcmp(argptr2, "st", 3)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
// allow case/control status to represent just two subpopulations,
// but force user to be explicit about this nonstandard usage
if (strcmp(argv[cur_arg + 1], "case-control")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --fst parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
misc_flags |= MISC_FST_CC;
}
calculation_type |= CALC_FST;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'g':
if (!memcmp(argptr2, "eno", 4)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (scan_doublex(argv[cur_arg + 1], &geno_thresh)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --geno parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((geno_thresh < 0.0) || (geno_thresh > 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --geno parameter '%s' (must be between 0 and 1).\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else {
geno_thresh = 0.1;
}
filter_flags |= FILTER_ALL_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "en", 3)) {
if (load_rare || (load_params & (LOAD_PARAMS_TEXT_ALL | LOAD_PARAMS_BFILE_ALL | LOAD_PARAMS_OXBGEN))) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
load_params |= LOAD_PARAMS_OXGEN;
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (strlen(argv[cur_arg + 1]) > (FNAMESIZE - 1)) {
logerrprint("Error: --gen parameter too long.\n");
goto main_ret_OPEN_FAIL;
}
strcpy(pedname, argv[cur_arg + 1]);
} else if (!memcmp(argptr2, "enome", 6)) {
if (genome_modifier & GENOME_OUTPUT_GZ) {
logerrprint("Warning: Duplicate --genome flag. (--Z-genome is treated as \"--genome gz\".)\n");
}
kk = 0;
main_genome_flag:
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 5 - kk)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "gz")) {
genome_modifier |= GENOME_OUTPUT_GZ;
} else if (!strcmp(argv[cur_arg + uii], "rel-check")) {
genome_modifier |= GENOME_REL_CHECK;
} else if (!strcmp(argv[cur_arg + uii], "full")) {
genome_modifier |= GENOME_OUTPUT_FULL;
} else if (!strcmp(argv[cur_arg + uii], "unbounded")) {
genome_modifier |= GENOME_IBD_UNBOUNDED;
} else if (!strcmp(argv[cur_arg + uii], "nudge")) {
genome_modifier |= GENOME_NUDGE;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --genome parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_GENOME;
} else if (!memcmp(argptr2, "enome-full", 11)) {
if (!(calculation_type & CALC_GENOME)) {
logerrprint("Error: --genome-full must be used with --genome.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --genome-full flag deprecated. Use \"--genome full\".\n");
genome_modifier |= GENOME_OUTPUT_FULL;
goto main_param_zero;
} else if (!memcmp(argptr2, "roupdist", 9)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (scan_posintptrx(argv[cur_arg + 1], &groupdist_iters) || (groupdist_iters < 2) || (groupdist_iters > ((~ZEROLU) - MAX_THREADS))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --groupdist jackknife iteration count '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (param_ct == 2) {
if (scan_posint_defcapx(argv[cur_arg + 2], &groupdist_d)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --groupdist jackknife delete parameter '%s'.\n", argv[cur_arg + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
}
calculation_type |= CALC_GROUPDIST;
} else if (!memcmp(argptr2, "rm", 3)) {
logerrprint("Error: --grm has been retired due to inconsistent meaning across GCTA versions.\nUse --grm-gz or --grm-bin.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "rm-gz", 6)) {
if (load_params || load_rare) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
sptr = argv[cur_arg + 1];
if (strlen(sptr) > (FNAMESIZE - 8)) {
logerrprint("Error: --grm-gz parameter too long.\n");
goto main_ret_OPEN_FAIL;
}
strcpy(pedname, sptr);
} else {
memcpy(pedname, PROG_NAME_STR, 6);
}
load_rare = LOAD_RARE_GRM;
} else if (!memcmp(argptr2, "rm-bin", 7)) {
if (load_params || load_rare) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
sptr = argv[cur_arg + 1];
if (strlen(sptr) > (FNAMESIZE - 11)) {
logerrprint("Error: --grm-bin parameter too long.\n");
goto main_ret_OPEN_FAIL;
}
strcpy(pedname, sptr);
} else {
memcpy(pedname, PROG_NAME_STR, 6);
}
load_rare = LOAD_RARE_GRM_BIN;
} else if (!memcmp(argptr2, "xe", 3)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (!covar_fname) {
logerrprint("Error: --gxe must be used with --covar.\n");
goto main_ret_INVALID_CMDLINE;
}
if (param_ct) {
if (scan_posint_defcapx(argv[cur_arg + 1], &gxe_mcovar)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --gxe parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else {
gxe_mcovar = 1;
}
calculation_type |= CALC_GXE;
} else if (!memcmp(argptr2, "enedrop", 8)) {
if (model_modifier & MODEL_QMASK) {
logerrprint("Error: --assoc 'qt-means'/'lin' does not make sense with --genedrop.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --genedrop flag deprecated. Use e.g. \"--model genedrop\".\n");
model_modifier |= MODEL_GENEDROP;
glm_modifier |= GLM_GENEDROP;
goto main_param_zero;
} else if (!memcmp(argptr2, "c", 2)) {
if (!mtest_adjust) {
logerrprint("Error: --gc must be used with --adjust.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --gc flag deprecated. Use \"--adjust gc\".\n");
mtest_adjust |= ADJUST_GC;
goto main_param_zero;
} else if (!memcmp(argptr2, "file", 5)) {
UNSTABLE("gfile");
if (load_rare || (load_params & (~LOAD_PARAMS_FAM))) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
sptr = argv[cur_arg + 1];
uii = strlen(sptr);
if (uii > (FNAMESIZE - 6)) {
logerrprint("Error: --gfile parameter too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(memcpya(pedname, sptr, uii), ".gvar", 6);
if (!(load_params & LOAD_PARAMS_FAM)) {
memcpy(memcpya(famname, sptr, uii), ".fam", 5);
}
memcpy(memcpya(mapname, sptr, uii), ".map", 5);
load_rare = LOAD_RARE_GVAR;
} else if (!memcmp(argptr2, "enome-lists", 12)) {
logerrprint("Error: --genome-lists flag retired. Use --parallel.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "enome-minimal", 14)) {
logerrprint("Error: --genome-minimal flag retired. Use \"--genome gz\".\n");
goto main_ret_INVALID_CMDLINE;
} else if ((!memcmp(argptr2, "roup-avg", 9)) || (!memcmp(argptr2, "roup-average", 13))) {
if (!(calculation_type & CALC_CLUSTER)) {
logerrprint("Error: --group-avg must be used with --cluster.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (cluster.modifier & CLUSTER_OLD_TIEBREAKS) {
logerrprint("Error: --cluster 'group-avg' and 'old-tiebreaks' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
LOGPRINTF("Note: --%s flag deprecated. Use \"--cluster group-avg\".\n", argptr);
cluster.modifier |= CLUSTER_GROUP_AVG;
goto main_param_zero;
} else if (!memcmp(argptr2, "enotypic", 9)) {
if (glm_modifier & GLM_DOMINANT) {
logerrprint("Error: --genotypic cannot be used with --dominant.\n");
goto main_ret_INVALID_CMDLINE;
}
logprint("Note: --genotypic flag deprecated. Use e.g. \"--linear genotypic\".\n");
glm_modifier |= GLM_GENOTYPIC;
glm_xchr_model = 0;
goto main_param_zero;
} else if (!memcmp(argptr2, "ene", 4)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x7fffffff)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten(&set_info.genekeep_flattened, &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_BIM_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "ene-all", 8)) {
if (set_info.genekeep_flattened) {
logerrprint("Error: --gene-all cannot be used with --gene.\n");
goto main_ret_INVALID_CMDLINE_A;
}
set_info.modifier |= SET_GENE_ALL;
filter_flags |= FILTER_BIM_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
goto main_param_zero;
} else if (!memcmp(argptr2, "ap", 3)) {
if ((epi_info.modifier & (EPI_FAST | EPI_FAST_CASE_ONLY)) != (EPI_FAST | EPI_FAST_CASE_ONLY)) {
logerrprint("Error: --gap must be used with \"--fast-epistasis case-only\".\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --gap parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (dxx > 2147483.646) {
epi_info.case_only_gap = 2147483646;
} else {
epi_info.case_only_gap = (int32_t)(dxx * 1000 * (1 + SMALL_EPSILON));
}
} else if (!memcmp(argptr2, "ene-report", 11)) {
uii = gene_report_glist? 1 : 2;
if (enforce_param_ct_range(param_ct, argv[cur_arg], uii, uii)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&gene_report_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
if (uii == 2) {
retval = alloc_fname(&gene_report_glist, argv[cur_arg + 2], argptr, 0);
if (retval) {
goto main_ret_1;
}
}
} else if (!memcmp(argptr2, "ene-list", 9)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&gene_report_glist, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
logprint("Note: --gene-list flag deprecated. Pass two parameters to --gene-report\ninstead.\n");
} else if (!memcmp(argptr2, "ene-list-border", 16)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --gene-list-border parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WW;
}
if (dxx > 2147483.646) {
gene_report_border = 0x7ffffffe;
} else {
gene_report_border = (int32_t)(dxx * 1000 * (1 + SMALL_EPSILON));
}
} else if (!memcmp(argptr2, "ene-subset", 11)) {
if (!gene_report_fname) {
logerrprint("Error: --gene-subset must be used with --gene-report.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&gene_report_subset, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "ene-report-snp-field", 21)) {
if (!extractname) {
logerrprint("Error: --gene-report-snp-field must be used with --extract.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (misc_flags & MISC_EXTRACT_RANGE) {
logerrprint("Error: --gene-report-snp-field cannot be used with \"--extract range\".\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&gene_report_snp_field, argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "plink", 6)) {
misc_flags |= MISC_GPLINK;
} else if (!memcmp(argptr2, "ates", 5)) {
logerrprint("Error: --gates is not implemented yet.\n");
retval = RET_CALC_NOT_YET_SUPPORTED;
goto main_ret_1;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'h':
if ((!memcmp(argptr2, "we", 3)) || (!memcmp(argptr2, "we midp", 8))) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 3)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (argptr2[2]) {
hwe_modifier |= HWE_THRESH_MIDP;
}
ujj = 0;
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "midp")) {
hwe_modifier |= HWE_THRESH_MIDP;
} else if (!strcmp(argv[cur_arg + uii], "include-nonctrl")) {
hwe_modifier |= HWE_THRESH_ALL;
} else {
if (scan_doublex(argv[cur_arg + uii], &hwe_thresh) || ujj) {
logerrprint("Error: Invalid --hwe parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
ujj = 1;
if ((hwe_thresh < 0.0) || (hwe_thresh >= 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --hwe threshold '%s' (must be between 0 and 1).\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
}
if (!ujj) {
logerrprint("Error: --hwe now requires a p-value threshold.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((hwe_modifier & HWE_THRESH_MIDP) && (hwe_thresh >= 0.5)) {
logerrprint("Error: --hwe threshold must be smaller than 0.5 when using mid-p adjustment.\n");
goto main_ret_INVALID_CMDLINE_A;
}
filter_flags |= FILTER_ALL_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "we-all", 7)) {
logprint("Note: --hwe-all flag deprecated. Use \"--hwe include-nonctrl\".\n");
hwe_modifier |= HWE_THRESH_ALL;
goto main_param_zero;
} else if (!memcmp(argptr2, "et", 3)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "small-sample")) {
misc_flags |= MISC_HET_SMALL_SAMPLE;
} else if (!strcmp(argv[cur_arg + uii], "gz")) {
misc_flags |= MISC_HET_GZ;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --het parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_HET;
} else if ((!memcmp(argptr2, "ardy", 5)) || (!memcmp(argptr2, "ardy midp", 10))) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (argptr2[4]) {
hwe_modifier |= HWE_MIDP;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "midp")) {
hwe_modifier |= HWE_MIDP;
} else if (!strcmp(argv[cur_arg + uii], "gz")) {
hwe_modifier |= HWE_GZ;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --hardy parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_HARDY;
} else if (!memcmp(argptr2, "omozyg", 7)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "group")) {
if (homozyg.modifier & HOMOZYG_GROUP_VERBOSE) {
logerrprint("Error: --homozyg 'group' and 'group-verbose' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE;
}
homozyg.modifier |= HOMOZYG_GROUP;
} else if (!strcmp(argv[cur_arg + uii], "group-verbose")) {
if (homozyg.modifier & HOMOZYG_GROUP) {
logerrprint("Error: --homozyg 'group' and 'group-verbose' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE;
}
homozyg.modifier |= HOMOZYG_GROUP_VERBOSE;
} else if (!strcmp(argv[cur_arg + uii], "consensus-match")) {
homozyg.modifier |= HOMOZYG_CONSENSUS_MATCH;
} else if (!strcmp(argv[cur_arg + uii], "extend")) {
homozyg.modifier |= HOMOZYG_EXTEND;
} else if (!strcmp(argv[cur_arg + uii], "subtract-1-from-lengths")) {
homozyg.modifier |= HOMOZYG_OLD_LENGTHS;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --homozyg parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_HOMOZYG;
} else if (!memcmp(argptr2, "omozyg-snp", 11)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &homozyg.min_snp) || (homozyg.min_snp == 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --homozyg-snp parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
calculation_type |= CALC_HOMOZYG;
} else if (!memcmp(argptr2, "omozyg-kb", 10)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < SMALL_EPSILON) || (dxx >= (2147483.646 * (1 + SMALL_EPSILON)))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --homozyg-kb parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
calculation_type |= CALC_HOMOZYG;
// round up
homozyg.min_bases = 1 + (uint32_t)((int32_t)(dxx * 1000 * (1 - SMALL_EPSILON)));
} else if (!memcmp(argptr2, "omozyg-density", 15)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx <= 0.0) || (dxx >= 2147483.646)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --homozyg-density parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
calculation_type |= CALC_HOMOZYG;
homozyg.max_bases_per_snp = ((int32_t)(dxx * 1000 * (1 + SMALL_EPSILON)));
} else if (!memcmp(argptr2, "omozyg-gap", 11)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0.001) || (dxx >= 2147483.646)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --homozyg-gap parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
calculation_type |= CALC_HOMOZYG;
homozyg.max_gap = ((int32_t)(dxx * 1000 * (1 + SMALL_EPSILON)));
} else if (!memcmp(argptr2, "omozyg-het", 11)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_uint_defcapx(argv[cur_arg + 1], &homozyg.max_hets)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --homozyg-het parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (homozyg.max_hets && (homozyg.modifier & HOMOZYG_EXTEND)) {
logerrprint("Error: --homozyg-het with a nonzero parameter cannot be used with --homozyg\nextend. For fine-grained control over heterozygote frequency, use\n--homozyg-window-snp and --homozyg-window-het instead.\n");
goto main_ret_INVALID_CMDLINE_A;
}
calculation_type |= CALC_HOMOZYG;
} else if (!memcmp(argptr2, "omozyg-window-snp", 18)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &homozyg.window_size) || (homozyg.window_size == 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --homozyg-window-snp parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
calculation_type |= CALC_HOMOZYG;
} else if (!memcmp(argptr2, "omozyg-window-kb", 17)) {
logerrprint("Error: --homozyg-window-kb flag provisionally retired, since it had no effect\nin PLINK 1.07.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "omozyg-window-het", 18)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_uint_defcapx(argv[cur_arg + 1], &homozyg.window_max_hets)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --homozyg-window-het parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
calculation_type |= CALC_HOMOZYG;
} else if (!memcmp(argptr2, "omozyg-window-missing", 22)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_uint_defcapx(argv[cur_arg + 1], &homozyg.window_max_missing)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --homozyg-window-missing parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
calculation_type |= CALC_HOMOZYG;
} else if (!memcmp(argptr2, "omozyg-window-threshold", 24)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx <= 0.0) || (dxx > 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --homozyg-window-threshold parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
calculation_type |= CALC_HOMOZYG;
homozyg.hit_threshold = dxx;
} else if (!memcmp(argptr2, "omozyg-match", 13)) {
if (!(homozyg.modifier & (HOMOZYG_GROUP | HOMOZYG_GROUP_VERBOSE))) {
homozyg.modifier |= HOMOZYG_GROUP;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx <= 0.0) || (dxx > 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --homozyg-match parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
homozyg.overlap_min = dxx;
} else if (!memcmp(argptr2, "omozyg-group", 13)) {
if (homozyg.modifier & HOMOZYG_GROUP_VERBOSE) {
logprint("Note: --homozyg-group deprecated, and superseded by --homozyg group-verbose.\n");
} else {
logprint("Note: --homozyg-group flag deprecated. Use \"--homozyg group\".\n");
homozyg.modifier |= HOMOZYG_GROUP;
}
goto main_param_zero;
} else if (!memcmp(argptr2, "omozyg-verbose", 15)) {
if (!(homozyg.modifier & HOMOZYG_GROUP)) {
logerrprint("Error: --homozyg-verbose must be used with --homozyg group.\n");
goto main_ret_INVALID_CMDLINE;
}
logprint("Note: --homozyg-verbose flag deprecated. Use \"--homozyg group-verbose\".\n");
homozyg.modifier = (homozyg.modifier & (~HOMOZYG_GROUP)) | HOMOZYG_GROUP_VERBOSE;
goto main_param_zero;
} else if (!memcmp(argptr2, "omozyg-include-missing", 23)) {
logerrprint("Error: --homozyg-include-missing flag provisionally retired, since it had no\neffect in PLINK 1.07.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "ethom", 6)) {
if (!(glm_modifier & GLM_GENOTYPIC)) {
logerrprint("Error: --hethom must be used with --genotypic.\n");
goto main_ret_INVALID_CMDLINE;
}
logprint("Note: --hethom flag deprecated. Use e.g. \"--linear hethom\" (and\n\"--condition-list recessive\" to change covariate coding).\n");
glm_modifier |= GLM_HETHOM | GLM_CONDITION_RECESSIVE;
glm_modifier -= GLM_GENOTYPIC;
glm_xchr_model = 0;
goto main_param_zero;
} else if (!memcmp(argptr2, "ide-covar", 10)) {
logprint("Note: --hide-covar flag deprecated. Use e.g. \"--linear hide-covar\".\n");
glm_modifier |= GLM_HIDE_COVAR;
goto main_param_zero;
} else if (!memcmp(argptr2, "ard-call-threshold", 19)) {
if (!(load_params & (LOAD_PARAMS_OX_ALL))) {
logerrprint("Error: --hard-call-threshold must be used with --data, --gen, or --bgen.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (!strcmp(argv[cur_arg + 1], "random")) {
hard_call_threshold = -1;
} else {
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0.0) || (dxx > 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --hard-call-threshold parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
} else if (dxx > (0.5 + SMALLISH_EPSILON)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: The --hard-call-threshold parameter must be smaller than 0.5. (Did you\nmean \"--hard-call-threshold %g\"?)\n", 1.0 - dxx);
goto main_ret_INVALID_CMDLINE_2A;
} else if (dxx > (0.5 - SMALLISH_EPSILON)) {
logerrprint("Error: The --hard-call-threshold parameter must be smaller than 0.5, to prevent\nties.\n");
goto main_ret_INVALID_CMDLINE_A;
}
hard_call_threshold = dxx * (1 + SMALL_EPSILON);
}
} else if (!memcmp(argptr2, "omog", 5)) {
calculation_type |= CALC_HOMOG;
goto main_param_zero;
} else if ((!memcmp(argptr2, "ap", 3)) ||
(!memcmp(argptr2, "ap-all", 7)) ||
(!memcmp(argptr2, "ap-assoc", 9)) ||
(!memcmp(argptr2, "ap-freq", 8)) ||
(!memcmp(argptr2, "ap-impute", 10)) ||
(!memcmp(argptr2, "ap-impute-verbose", 18)) ||
(!memcmp(argptr2, "ap-linear", 10)) ||
(!memcmp(argptr2, "ap-logistic", 12)) ||
(!memcmp(argptr2, "ap-max-phase", 13)) ||
(!memcmp(argptr2, "ap-min-phase-prob", 18)) ||
(!memcmp(argptr2, "ap-miss", 8)) ||
(!memcmp(argptr2, "ap-omnibus", 11)) ||
(!memcmp(argptr2, "ap-only", 8)) ||
(!memcmp(argptr2, "ap-phase", 9)) ||
(!memcmp(argptr2, "ap-phase-wide", 14)) ||
(!memcmp(argptr2, "ap-pp", 6)) ||
(!memcmp(argptr2, "ap-snps", 8)) ||
(!memcmp(argptr2, "ap-tdt", 7)) ||
(!memcmp(argptr2, "ap-window", 10)) ||
(!memcmp(argptr2, "omozyg-haplo-track", 19))) {
main_hap_disabled_message:
logerrprint("Error: The --hap... family of flags has not been reimplemented in PLINK 1.9 due\nto poor phasing accuracy (and, consequently, inferior haplotype\nlikelihood/frequency estimates) relative to other software; for now, we\nrecommend using BEAGLE instead of PLINK for case/control haplotype association\nanalysis. (You can use \"--recode beagle\" to export data.) We apologize for\nthe inconvenience, and plan to develop variants of the --hap... flags which\nhandle pre-phased data effectively.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "ard-call", 9)) {
logerrprint("Error: The undocumented --hard-call flag has been retired. (The\n--hard-call-threshold flag, supported by both PLINK and PLINK/SEQ, has similar\nfunctionality.)\n");
goto main_ret_INVALID_CMDLINE;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'i':
if (!memcmp(argptr2, "bc", 3)) {
calculation_type |= CALC_IBC;
goto main_param_zero;
} else if ((!memcmp(argptr2, "ndep-pairwise", 14)) || (!memcmp(argptr2, "ndep-pairphase", 15))) {
if (calculation_type & CALC_LD_PRUNE) {
logerrprint("Error: Conflicting --indep... commands.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 3, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
// may want to permit decimal here
if (scan_posint_defcap(argv[cur_arg + 1], &ld_info.prune_window_size) || ((ld_info.prune_window_size == 1) && (param_ct == 3))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --%s window size '%s'.\n", argptr, argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (param_ct == 4) {
if (!match_upper(argv[cur_arg + 2], "KB")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --%s parameter sequence.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
}
ld_info.modifier |= LD_PRUNE_KB_WINDOW;
} else {
uii = strlen(argv[cur_arg + 1]);
if ((uii > 2) && match_upper(&(argv[cur_arg + 1][uii - 2]), "KB")) {
ld_info.modifier |= LD_PRUNE_KB_WINDOW;
}
}
if (scan_posint_defcapx(argv[cur_arg + param_ct - 1], &ld_info.prune_window_incr)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid increment '%s' for --%s.\n", argv[cur_arg + param_ct - 1], argptr);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((ld_info.modifier & LD_PRUNE_KB_WINDOW) && (ld_info.prune_window_incr > 1)) {
LOGERRPRINTFWW("Warning: --%s step size should be 1 when window size is in kb units.\n", argptr);
}
if (scan_doublex(argv[cur_arg + param_ct], &ld_info.prune_last_param) || (ld_info.prune_last_param < 0.0) || (ld_info.prune_last_param >= 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --%s r^2 threshold '%s'.\n", argptr, argv[cur_arg + param_ct]);
goto main_ret_INVALID_CMDLINE_WWA;
}
calculation_type |= CALC_LD_PRUNE;
if (argptr2[9] == 'w') {
ld_info.modifier |= LD_PRUNE_PAIRWISE;
} else {
ld_info.modifier |= LD_PRUNE_PAIRPHASE;
}
} else if (!memcmp(argptr2, "ndep", 5)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 3, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &ld_info.prune_window_size) || ((ld_info.prune_window_size == 1) && (param_ct == 3))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --indep window size '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (param_ct == 4) {
if (!match_upper(argv[cur_arg + 2], "KB")) {
logerrprint("Error: Invalid --indep parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
ld_info.modifier |= LD_PRUNE_KB_WINDOW;
} else {
uii = strlen(argv[cur_arg + 1]);
if ((uii > 2) && match_upper(&(argv[cur_arg + 1][uii - 2]), "KB")) {
ld_info.modifier |= LD_PRUNE_KB_WINDOW;
}
}
if (scan_posint_defcapx(argv[cur_arg + param_ct - 1], &ld_info.prune_window_incr)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid increment '%s' for --indep.\n", argv[cur_arg + param_ct - 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (scan_doublex(argv[cur_arg + param_ct], &ld_info.prune_last_param)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --indep VIF threshold '%s'.\n", argv[cur_arg + param_ct]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (ld_info.prune_last_param < 1.0) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --indep VIF threshold '%s' too small (must be >= 1).\n", argv[cur_arg + param_ct]);
goto main_ret_INVALID_CMDLINE_WWA;
}
calculation_type |= CALC_LD_PRUNE;
} else if (!memcmp(argptr2, "ndiv-sort", 10)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
jj = (argv[cur_arg + 1][1] == '\0');
if ((!strcmp(argv[cur_arg + 1], "none")) || ((argv[cur_arg + 1][0] == '0') && jj)) {
sample_sort = SAMPLE_SORT_NONE;
} else if ((!strcmp(argv[cur_arg + 1], "natural")) || ((tolower(argv[cur_arg + 1][0]) == 'n') && jj)) {
sample_sort = SAMPLE_SORT_NATURAL;
} else if ((!strcmp(argv[cur_arg + 1], "ascii")) || ((tolower(argv[cur_arg + 1][0]) == 'a') && jj)) {
sample_sort = SAMPLE_SORT_ASCII;
} else if ((!strcmp(argv[cur_arg + 1], "file")) || ((tolower(argv[cur_arg + 1][0]) == 'f') && jj)) {
if (param_ct == 1) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Missing \"--indiv-sort %s\" filename.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_2A;
}
sample_sort = SAMPLE_SORT_FILE;
retval = alloc_fname(&sample_sort_fname, argv[cur_arg + 2], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: '%s' is not a valid mode for --indiv-sort.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((param_ct == 2) && (sample_sort != SAMPLE_SORT_FILE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: \"--indiv-sort %s\" does not accept a second parameter.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_2A;
}
} else if (!memcmp(argptr2, "bs-test", 8)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (scan_posintptrx(argv[cur_arg + 1], &ibs_test_perms)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --ibs-test permutation count '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (ibs_test_perms < MAX_THREADS * 2) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --ibs-test permutation count '%s' too small (min %u).\n", argv[cur_arg + 1], MAX_THREADS * 2);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_IBS_TEST;
} else if (!memcmp(argptr2, "id", 3)) {
logprint("Note: --iid flag deprecated. Use \"--recode vcf-iid\".\n");
recode_modifier |= RECODE_IID;
goto main_param_zero;
} else if (!memcmp(argptr2, "bm", 3)) {
if (!(calculation_type & CALC_CLUSTER)) {
logerrprint("Error: --ibm must be used with --cluster.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --ibm parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((dxx <= 0.0) || (dxx > 1.0)) {
logerrprint("Error: --ibm threshold must be in (0, 1].\n");
goto main_ret_INVALID_CMDLINE_A;
}
cluster.min_ibm = dxx;
} else if (!memcmp(argptr2, "mpossible", 10)) {
logerrprint("Error: --impossible flag retired. Use \"--genome nudge\", or explicitly validate\nZ0/Z1/Z2/PI_HAT in your script.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "nteraction", 11)) {
logprint("Note: --interaction flag deprecated. Use e.g. \"--linear interaction\".\n");
glm_modifier |= GLM_INTERACTION;
goto main_param_zero;
} else if (!memcmp(argptr2, "bs-matrix", 10)) {
if (calculation_type & CALC_DISTANCE) {
logerrprint("Error: --ibs-matrix cannot be used with --distance.\n");
goto main_ret_INVALID_CMDLINE;
}
calculation_type |= CALC_PLINK1_IBS_MATRIX;
goto main_param_zero;
} else if (!memcmp(argptr2, "d-delim", 8)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
id_delim = extract_char_param(argv[cur_arg + 1]);
if (!id_delim) {
logerrprint("Error: --id-delim parameter must be a single character.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (((unsigned char)id_delim) < ' ') {
logerrprint("Error: --id-delim parameter cannot be tab, newline, or a nonprinting character.\n");
goto main_ret_INVALID_CMDLINE;
}
} else {
id_delim = '_';
}
} else if (!memcmp(argptr2, "nter-chr", 9)) {
logprint("Note: --inter-chr flag deprecated. Use e.g. \"--r2 inter-chr\".\n");
ld_info.modifier |= LD_INTER_CHR;
} else if (!memcmp(argptr2, "nd-major", 9)) {
logerrprint("Error: --ind-major is retired, to discourage creation of .bed files that\nconstantly have to be transposed back. \"--recode ped\" exports sample-major\nfiles which are good enough for smaller jobs; we suggest transposing small data\nwindows on the fly when tackling large jobs.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "mpute-sex", 10)) {
if (calculation_type & CALC_SEXCHECK) {
logerrprint("Error: --check-sex is redundant with --impute-sex.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 5)) {
goto main_ret_INVALID_CMDLINE_2A;
}
ujj = 0;
if (param_ct) {
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "y-only")) {
ujj = uii;
break;
}
}
}
if (!ujj) {
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "ycount")) {
misc_flags |= MISC_SEXCHECK_YCOUNT;
} else {
if (!ujj) {
if (scan_doublex(argv[cur_arg + uii], &check_sex_fthresh) || (check_sex_fthresh <= 0.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --impute-sex female F-statistic estimate ceiling '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (ujj == 1) {
if (scan_doublex(argv[cur_arg + uii], &check_sex_mthresh) || (check_sex_mthresh >= 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --impute-sex male F-statistic estimate floor '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (ujj == 2) {
if (scan_uint_defcapx(argv[cur_arg + uii], &check_sex_f_yobs)) {
logerrprint("Error: Invalid --impute-sex female Ychr maximum nonmissing genotype count.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else if (ujj == 3) {
if (scan_uint_defcapx(argv[cur_arg + uii], &check_sex_m_yobs)) {
logerrprint("Error: Invalid --impute-sex male Ychr minimum nonmissing genotype count.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else {
logerrprint("Error: Invalid --impute-sex parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
ujj++;
}
}
if ((ujj > 2) && (!(misc_flags & MISC_SEXCHECK_YCOUNT))) {
logerrprint("Error: --impute-sex only accepts >2 numeric parameters in 'ycount' mode.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (check_sex_fthresh > check_sex_mthresh) {
logerrprint("Error: --impute-sex female F estimate ceiling cannot be larger than male floor.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else {
check_sex_m_yobs = 1;
ukk = 0;
for (uii = 1; uii <= param_ct; uii++) {
if (uii == ujj) {
continue;
}
if (!strcmp(argv[cur_arg + uii], "ycount")) {
logerrprint("Error: Conflicting --impute-sex modes.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (!ukk) {
if (scan_uint_defcapx(argv[cur_arg + uii], &check_sex_f_yobs)) {
logerrprint("Error: Invalid --impute-sex y-only female Ychr maximum nonmissing genotype\ncount.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else if (ukk == 1) {
if (scan_uint_defcapx(argv[cur_arg + uii], &check_sex_m_yobs)) {
logerrprint("Error: Invalid --impute-sex y-only male Ychr minimum nonmissing genotype count.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else {
logerrprint("Error: Invalid --impute-sex y-only parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
ukk++;
}
if (check_sex_f_yobs >= check_sex_m_yobs) {
logerrprint("Error: In y-only mode, --impute-sex female Y observation threshold must be\nsmaller than male threshold.\n");
goto main_ret_INVALID_CMDLINE_A;
}
misc_flags |= MISC_SEXCHECK_YCOUNT | MISC_SEXCHECK_YONLY;
}
calculation_type |= CALC_SEXCHECK;
misc_flags |= MISC_IMPUTE_SEX;
sex_missing_pheno |= ALLOW_NO_SEX;
} else if ((!memcmp(argptr2, "d-dict", 7)) || (!memcmp(argptr2, "d-dump", 7)) || (!memcmp(argptr2, "d-lookup", 9)) || (!memcmp(argptr2, "d-match", 8)) || (!memcmp(argptr2, "d-replace", 10)) || (!memcmp(argptr2, "d-table", 8))) {
logerrprint("Error: --id-dict and --id-match are provisionally retired, since free database\nsoftware handles these operations in a more flexible and powerful manner.\nContact the developers if you still need them.\n");
goto main_ret_INVALID_CMDLINE;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'j':
if (!memcmp(argptr2, "e-cellmin", 10)) {
if (!(epi_info.modifier & EPI_FAST_JOINT_EFFECTS)) {
logerrprint("Error: --je-cellmin must be used with \"--fast-epistasis joint-effects\".\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
// may as well enforce 2^29 / 18 limit...
if (scan_uint_cappedx(argv[cur_arg + 1], 29826161, &epi_info.je_cellmin)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --je-cellmin parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'k':
if (!memcmp(argptr2, "eep", 4)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&keepname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_FAM_REQ;
} else if (!memcmp(argptr2, "eep-fam", 8)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&keepfamname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_FAM_REQ;
} else if (!memcmp(argptr2, "eep-allele-order", 17)) {
if (load_rare & (LOAD_RARE_CNV | LOAD_RARE_DOSAGE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --keep-allele-order has no effect with %s.\n", (load_rare == LOAD_RARE_CNV)? "a .cnv fileset" : "--dosage");
goto main_ret_INVALID_CMDLINE_2A;
}
misc_flags |= MISC_KEEP_ALLELE_ORDER;
goto main_param_zero;
} else if (!memcmp(argptr2, "eep-before-remove", 18)) {
logprint("Note: --keep-before-remove has no effect.\n");
goto main_param_zero;
} else if (!memcmp(argptr2, "eep-autoconv", 13)) {
if (load_rare & (LOAD_RARE_CNV | LOAD_RARE_DOSAGE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --keep-autoconv has no effect with %s.\n", (load_rare == LOAD_RARE_CNV)? "--cfile/--cnv-list" : "--dosage");
goto main_ret_INVALID_CMDLINE_2A;
}
misc_flags |= MISC_KEEP_AUTOCONV;
goto main_param_zero;
} else if (!memcmp(argptr2, "eep-cluster-names", 18)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x7fffffff)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten(&(cluster.keep_flattened), &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_FAM_REQ;
} else if (!memcmp(argptr2, "eep-clusters", 13)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&(cluster.keep_fname), argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_FAM_REQ;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'l':
if (!memcmp(argptr2, "file", 5)) {
if (load_rare || (load_params & (~LOAD_PARAMS_FAM))) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
csptr = argv[cur_arg + 1];
if (strlen(csptr) > FNAMESIZE - 6) {
logerrprint("Error: --lfile filename prefix too long.\n");
goto main_ret_OPEN_FAIL;
}
} else {
csptr = PROG_NAME_STR;
}
memcpy(strcpya(pedname, csptr), ".lgen", 6);
memcpy(strcpya(mapname, csptr), ".map", 5);
if (!famname[0]) {
memcpy(strcpya(famname, csptr), ".fam", 5);
}
load_rare = LOAD_RARE_LGEN;
} else if (!memcmp(argptr2, "gen", 4)) {
if ((load_rare & (~LOAD_RARE_LGEN)) || (load_params & (~LOAD_PARAMS_FAM))) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if ((load_params != LOAD_PARAMS_FAM) && (!load_rare)) {
logerrprint("Error: --lgen must be used with --fam or --lfile.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (strlen(argv[cur_arg + 1]) > (FNAMESIZE - 1)) {
logerrprint("Error: --lgen parameter too long.\n");
goto main_ret_OPEN_FAIL;
}
strcpy(pedname, argv[cur_arg + 1]);
load_rare = LOAD_RARE_LGEN;
} else if (!memcmp(argptr2, "oop-assoc", 10)) {
if (pheno_modifier & PHENO_ALL) {
logerrprint("Error: --loop-assoc cannot be used with --all-pheno.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (misc_flags & MISC_FAMILY_CLUSTERS) {
logerrprint("Error: --loop-assoc cannot be used with --family.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (load_rare == LOAD_RARE_DOSAGE) {
logerrprint("Error: --loop-assoc cannot be used with --dosage.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
uii = 1;
if (param_ct == 2) {
if ((strlen(argv[cur_arg + 1]) == 7) && (!memcmp(argv[cur_arg + 1], "keep-", 5)) && match_upper(&(argv[cur_arg + 1][5]), "NA")) {
uii = 2;
} else if ((strlen(argv[cur_arg + 2]) != 7) || memcmp(argv[cur_arg + 2], "keep-", 5) || (!match_upper(&(argv[cur_arg + 2][5]), "NA"))) {
logerrprint("Error: Invalid --loop-assoc parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
misc_flags |= MISC_LOAD_CLUSTER_KEEP_NA;
}
retval = alloc_fname(&loop_assoc_fname, argv[cur_arg + uii], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "og10", 5)) {
if (!mtest_adjust) {
logerrprint("Error: --log10 must be used with --adjust.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --log10 flag deprecated. Use \"--adjust log10\".\n");
mtest_adjust |= ADJUST_LOG10;
goto main_param_zero;
} else if (!memcmp(argptr2, "ambda", 6)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &adjust_lambda)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --lambda parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (adjust_lambda < 1) {
logprint("Note: --lambda parameter set to 1.\n");
adjust_lambda = 1;
}
mtest_adjust |= ADJUST_LAMBDA;
} else if (!memcmp(argptr2, "ist-23-indels", 14)) {
calculation_type |= CALC_LIST_23_INDELS;
goto main_param_zero;
} else if ((!memcmp(argptr2, "inear", 6)) || (!memcmp(argptr2, "ogistic", 8))) {
#ifndef NOLAPACK
if (calculation_type & CALC_GLM) {
logerrprint("Error: --logistic cannot be used with --linear.\n");
goto main_ret_INVALID_CMDLINE;
}
#endif
if (*argptr2 == 'o') {
glm_modifier |= GLM_LOGISTIC;
#ifdef NOLAPACK
} else {
logerrprint("Error: --linear requires " PROG_NAME_CAPS " to be built with LAPACK.\n");
goto main_ret_INVALID_CMDLINE;
#endif
}
if (load_rare & LOAD_RARE_DOSAGE) {
// make --dosage + modifier-free --linear/--logistic only issue a
// warning
if (param_ct) {
logerrprint("Error: --dosage cannot be used with --linear/--logistic modifiers.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --dosage automatically performs a regression; --linear/--logistic has no\nadditional effect.\n");
} else {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 11)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "perm")) {
if (glm_modifier & GLM_MPERM) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s 'mperm' and 'perm' cannot be used together.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
}
glm_modifier |= GLM_PERM;
} else if ((strlen(argv[cur_arg + uii]) > 6) && (!memcmp(argv[cur_arg + uii], "mperm=", 6))) {
if (glm_modifier & GLM_PERM) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s 'mperm' and 'perm' cannot be used together.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
} else if (glm_modifier & GLM_MPERM) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Duplicate --%s 'mperm' modifier.\n", argptr);
goto main_ret_INVALID_CMDLINE_2;
}
if (scan_posint_defcapx(&(argv[cur_arg + uii][6]), &glm_mperm_val)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --%s mperm parameter '%s'.\n", argptr, &(argv[cur_arg + uii][6]));
goto main_ret_INVALID_CMDLINE_WWA;
}
glm_modifier |= GLM_MPERM;
} else if (!strcmp(argv[cur_arg + uii], "genedrop")) {
glm_modifier |= GLM_GENEDROP;
} else if (!strcmp(argv[cur_arg + uii], "perm-count")) {
glm_modifier |= GLM_PERM_COUNT;
} else if (!strcmp(argv[cur_arg + uii], "genotypic")) {
if (glm_modifier & (GLM_HETHOM | GLM_DOMINANT | GLM_RECESSIVE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Conflicting --%s parameters.\n", argptr);
goto main_ret_INVALID_CMDLINE_2;
}
glm_modifier |= GLM_GENOTYPIC;
glm_xchr_model = 0;
} else if (!strcmp(argv[cur_arg + uii], "hethom")) {
if (glm_modifier & (GLM_GENOTYPIC | GLM_DOMINANT | GLM_RECESSIVE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Conflicting --%s parameters.\n", argptr);
goto main_ret_INVALID_CMDLINE_2;
}
glm_modifier |= GLM_HETHOM;
glm_xchr_model = 0;
} else if (!strcmp(argv[cur_arg + uii], "dominant")) {
if (glm_modifier & (GLM_GENOTYPIC | GLM_HETHOM | GLM_RECESSIVE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Conflicting --%s parameters.\n", argptr);
goto main_ret_INVALID_CMDLINE_2;
}
glm_modifier |= GLM_DOMINANT;
glm_xchr_model = 0;
} else if (!strcmp(argv[cur_arg + uii], "recessive")) {
if (glm_modifier & (GLM_GENOTYPIC | GLM_HETHOM | GLM_DOMINANT)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Conflicting --%s parameters.\n", argptr);
goto main_ret_INVALID_CMDLINE_2;
}
glm_modifier |= GLM_RECESSIVE;
glm_xchr_model = 0;
} else if (!strcmp(argv[cur_arg + uii], "no-snp")) {
if (mtest_adjust) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s no-snp cannot be used with --adjust.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
}
// defer the rest of the check
glm_modifier |= GLM_NO_SNP;
} else if (!strcmp(argv[cur_arg + uii], "hide-covar")) {
glm_modifier |= GLM_HIDE_COVAR;
} else if (!strcmp(argv[cur_arg + uii], "sex")) {
if (glm_modifier & GLM_NO_X_SEX) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s 'sex' and 'no-x-sex' cannot be used together.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
}
glm_modifier |= GLM_SEX;
} else if (!strcmp(argv[cur_arg + uii], "no-x-sex")) {
if (glm_modifier & GLM_SEX) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s 'sex' and 'no-x-sex' cannot be used together.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
}
glm_modifier |= GLM_NO_X_SEX;
} else if (!strcmp(argv[cur_arg + uii], "interaction")) {
glm_modifier |= GLM_INTERACTION;
} else if (!strcmp(argv[cur_arg + uii], "standard-beta")) {
if (glm_modifier & GLM_LOGISTIC) {
logerrprint("Error: --logistic does not have a 'standard-beta' modifier. (Did you mean\n--linear or 'beta'?)\n");
goto main_ret_INVALID_CMDLINE_A;
}
glm_modifier |= GLM_STANDARD_BETA;
} else if (!strcmp(argv[cur_arg + uii], "intercept")) {
glm_modifier |= GLM_INTERCEPT;
} else if (!strcmp(argv[cur_arg + uii], "beta")) {
glm_modifier |= GLM_BETA;
} else if (!strcmp(argv[cur_arg + uii], "set-test")) {
glm_modifier |= GLM_SET_TEST;
} else if (!strcmp(argv[cur_arg + uii], "mperm")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Improper --%s mperm syntax. (Use \"--%s mperm=\".)\n", argptr, argptr);
goto main_ret_INVALID_CMDLINE_2;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --%s parameter '%s'.\n", argptr, argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
if ((glm_modifier & GLM_NO_SNP) && (glm_modifier & GLM_NO_SNP_EXCL)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s 'no-snp' modifier conflicts with another modifier.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
}
calculation_type |= CALC_GLM;
}
} else if (!memcmp(argptr2, "d-xchr", 7)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
cc = argv[cur_arg + 1][0];
if ((cc < '1') || (cc > '3') || (argv[cur_arg + 1][1] != '\0')) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --ld-xchr parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (cc == '2') {
ld_info.modifier |= LD_IGNORE_X;
} else if (cc == '3') {
ld_info.modifier |= LD_WEIGHTED_X;
}
} else if (!memcmp(argptr2, "asso", 5)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &lasso_h2) || (lasso_h2 > 1) || (lasso_h2 <= 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --lasso heritability estimate '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
for (uii = 2; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "report-zeroes")) {
misc_flags |= MISC_LASSO_REPORT_ZEROES;
} else if (lasso_minlambda > 0) {
logerrprint("Error: Invalid --lasso parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (scan_doublex(argv[cur_arg + uii], &lasso_minlambda) || (lasso_minlambda <= 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --lasso minimum lambda '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_LASSO;
} else if (!memcmp(argptr2, "asso-select-covars", 19)) {
if (!(calculation_type & CALC_LASSO)) {
logerrprint("Error: --lasso-select-covars must be used with --lasso.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!covar_fname) {
logerrprint("Error: --lasso-select-covars must be used with --covar.\n");
goto main_ret_INVALID_CMDLINE;
}
misc_flags |= MISC_LASSO_SELECT_COVARS;
if (param_ct) {
retval = parse_name_ranges(param_ct, range_delim, &(argv[cur_arg]), &lasso_select_covars_range_list, 0);
if (retval) {
goto main_ret_1;
}
}
} else if (!memcmp(argptr2, "asso-lambda", 12)) {
UNSTABLE("lasso-lambda");
if (lasso_minlambda != -1) {
logerrprint("Error: --lasso-lambda cannot be used with a --lasso minimum lambda setting.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &lasso_lambda_iters)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --lasso-lambda parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (param_ct == 2) {
if (scan_doublex(argv[cur_arg + 2], &dxx) || (dxx > 1) || (dxx <= 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --lasso-lambda heritability estimate '%s'.\n", argv[cur_arg + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((calculation_type & CALC_LASSO) && (dxx != lasso_h2)) {
logerrprint("Error: --lasso and --lasso-lambda heritability estimates are different.\n");
goto main_ret_INVALID_CMDLINE;
} else {
lasso_h2 = dxx;
}
} else if (!(calculation_type & CALC_LASSO)) {
logerrprint("Error: --lasso-lambda requires a heritability estimate.\n");
goto main_ret_INVALID_CMDLINE;
}
calculation_type |= CALC_LASSO_LAMBDA;
} else if (!memcmp(argptr2, "d-window", 9)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &ld_info.window_size) || (ld_info.window_size == 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --ld-window window size '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "d-window-kb", 12)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --ld-window-kb parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (dxx > 2147483.646) {
ld_info.window_bp = 2147483646;
} else {
ld_info.window_bp = ((int32_t)(dxx * 1000 * (1 + SMALL_EPSILON)));
}
} else if (!memcmp(argptr2, "d-window-cm", 12)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --ld-window-cm parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
ld_info.window_cm = dxx * (1 + SMALL_EPSILON);
} else if (!memcmp(argptr2, "d-window-r2", 12)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0) || (dxx > 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --ld-window-r2 parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
ld_info.window_r2 = dxx;
} else if (!memcmp(argptr2, "d-snp", 6)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&(ld_info.snpstr), argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "d-snps", 7)) {
if (ld_info.snpstr) {
logerrprint("Error: --ld-snps cannot be used with --ld-snp or --ld-snp-list.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x7fffffff)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = parse_name_ranges(param_ct, range_delim, &(argv[cur_arg]), &(ld_info.snps_rl), 0);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "d-snp-list", 11)) {
if (ld_info.snpstr) {
logerrprint("Error: --ld-snp cannot be used with --ld-snp-list.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&(ld_info.snpstr), argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
ld_info.modifier |= LD_SNP_LIST_FILE;
} else if (!memcmp(argptr2, "d", 2)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 2, 3)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&(epi_info.ld_mkr1), argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
if (alloc_string(&(epi_info.ld_mkr2), argv[cur_arg + 2])) {
goto main_ret_NOMEM;
}
if (param_ct == 3) {
if (strcmp(argv[cur_arg + 3], "hwe-midp")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --ld parameter '%s'.\n", argv[cur_arg + 3]);
goto main_ret_INVALID_CMDLINE_WWA;
}
epi_info.modifier |= EPI_HWE_MIDP;
}
calculation_type |= CALC_EPI;
} else if (!memcmp(argptr2, "ist-all", 8)) {
ld_info.modifier |= LD_SHOW_TAGS_LIST_ALL;
goto main_param_zero;
} else if (!memcmp(argptr2, "ist-duplicate-vars", 19)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 3)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "require-same-ref")) {
dupvar_modifier |= DUPVAR_REF;
} else if (!strcmp(argv[cur_arg + uii], "ids-only")) {
dupvar_modifier |= DUPVAR_IDS_ONLY;
} else if (!strcmp(argv[cur_arg + uii], "suppress-first")) {
dupvar_modifier |= DUPVAR_SUPPRESS_FIRST;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --list-duplicate-vars parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_DUPVAR;
} else if (!memcmp(argptr2, "d-pred", 7)) {
logerrprint("Error: --ld-pred is currently under development.\n");
retval = RET_CALC_NOT_YET_SUPPORTED;
goto main_ret_1;
} else if ((!memcmp(argptr2, "ookup", 6)) ||
(!memcmp(argptr2, "ookup-list", 11)) ||
(!memcmp(argptr2, "ookup-gene", 11)) ||
(!memcmp(argptr2, "ookup-gene-kb", 14)) ||
(!memcmp(argptr2, "ookup-gene-list", 16))) {
logerrprint("Error: --lookup commands have been retired since the Sullivan Lab web database\nis no longer operational. Use e.g. PLINK/SEQ's lookup command instead.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "iability", 9)) {
logerrprint("Error: --liability is provisionally retired. Contact the developers if you\nneed this option.\n");
goto main_ret_INVALID_CMDLINE;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'm':
if (!memcmp(argptr2, "ap", 3)) {
if (((load_params & (LOAD_PARAMS_BFILE_ALL | LOAD_PARAMS_OX_ALL)) || (load_rare & (~(LOAD_RARE_CNV | LOAD_RARE_GVAR)))) && ((load_rare != LOAD_RARE_DOSAGE) || (load_params != LOAD_PARAMS_FAM)) && (load_rare != LOAD_RARE_LGEN)) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
load_params |= LOAD_PARAMS_MAP;
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (strlen(argv[cur_arg + 1]) > (FNAMESIZE - 1)) {
logerrprint("Error: --map parameter too long.\n");
goto main_ret_OPEN_FAIL;
}
strcpy(mapname, argv[cur_arg + 1]);
} else if (!memcmp(argptr2, "issing-genotype", 16)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
cc = extract_char_param(argv[cur_arg + 1]);
if (((unsigned char)cc <= ' ') || ((cc > '0') && (cc <= '4')) || (cc == 'A') || (cc == 'C') || (cc == 'G') || (cc == 'T')) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --missing-genotype parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
g_missing_geno_ptr = &(g_one_char_strs[((unsigned char)cc) * 2]);
g_output_missing_geno_ptr = g_missing_geno_ptr;
} else if (!memcmp(argptr2, "issing-genotype2", 17)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
cc = extract_char_param(argv[cur_arg + 1]);
if (((unsigned char)cc <= ' ') || ((cc > '0') && (cc <= '4')) || (cc == 'A') || (cc == 'C') || (cc == 'G') || (cc == 'T')) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --missing-genotype2 parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
g_missing_geno_char2 = cc;
} else if (!memcmp(argptr2, "issing-phenotype", 17)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
jj = strlen(argv[cur_arg + 1]);
// if anyone is using a missing pheno value of -2^31, they should be
// flogged with wet noodles
if (scan_int32x(argv[cur_arg + 1], &missing_pheno) || (!missing_pheno) || (missing_pheno == 1) || (jj > 31) || scan_doublex(argv[cur_arg + 1], &dxx) || (dxx != (double)missing_pheno)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --missing-phenotype parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
memcpy(output_missing_pheno, argv[cur_arg + 1], jj + 1);
} else if (!memcmp(argptr2, "issing-code", 12)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&oxford_missing_code, param_ct? argv[cur_arg + 1] : "")) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "ake-pheno", 10)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 2, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&phenoname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
if (alloc_string(&makepheno_str, argv[cur_arg + 2])) {
goto main_ret_NOMEM;
}
if (((argv[cur_arg + 2][0] == '\'') || (argv[cur_arg + 2][0] == '"')) && (argv[cur_arg + 2][1] == '*') && (argv[cur_arg + 2][2] == argv[cur_arg + 2][0]) && (!argv[cur_arg + 2][3])) {
memcpy(makepheno_str, "*", 2);
}
filter_flags |= FILTER_FAM_REQ;
} else if (!memcmp(argptr2, "pheno", 6)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &mpheno_col)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --mpheno parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "filter", 7)) {
if (!filtername) {
logerrprint("Error: --mfilter must be used with --filter.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &mfilter_col)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --mfilter parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "emory", 6)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
// may as well support systems with >2 PB RAM...
if (scan_posintptrx(argv[cur_arg + 1], (uintptr_t*)&malloc_size_mb)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --memory parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (malloc_size_mb < BIGSTACK_MIN_MB) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --memory parameter '%s' (minimum %u).\n", argv[cur_arg + 1], BIGSTACK_MIN_MB);
goto main_ret_INVALID_CMDLINE_WWA;
}
#ifndef __LP64__
if (malloc_size_mb > 2047) {
logerrprint("Error: --memory parameter too large for 32-bit version (max 2047).\n");
goto main_ret_INVALID_CMDLINE;
}
#endif
} else if (!memcmp(argptr2, "af", 3)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (scan_doublex(argv[cur_arg + 1], &min_maf)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --maf parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (min_maf <= 0.0) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --maf parameter '%s' too small (must be > 0).\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
} else if (min_maf > max_maf) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --maf parameter '%s' too large (must be <= %g).\n", argv[cur_arg + 1], max_maf);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else {
min_maf = 0.01;
}
filter_flags |= FILTER_ALL_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "ax-maf", 7)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &max_maf)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --max-maf parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (max_maf < min_maf) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --max-maf parameter '%s' too small (must be >= %g).\n", argv[cur_arg + 1], min_maf);
goto main_ret_INVALID_CMDLINE_WWA;
} else if (max_maf >= 0.5) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --max-maf parameter '%s' too large (must be < 0.5).\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
filter_flags |= FILTER_ALL_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "ind", 4)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (scan_doublex(argv[cur_arg + 1], &mind_thresh)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --mind parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((mind_thresh < 0.0) || (mind_thresh > 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --mind parameter '%s' (must be between 0 and 1).\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else {
mind_thresh = 0.1;
}
filter_flags |= FILTER_ALL_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "ake-grm", 8)) {
logerrprint("Error: --make-grm has been retired due to inconsistent meaning across GCTA\nversions. Use --make-grm-gz or --make-grm-bin.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "ake-grm-gz", 11)) {
if (calculation_type & CALC_RELATIONSHIP) {
logerrprint("Error: --make-grm-bin cannot be used with --make-grm-gz.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (distance_exp != 0.0) {
logerrprint("Error: \"--distance-wts exp=\" cannot be used with --make-grm-gz.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
rel_info.modifier |= REL_CALC_GZ | REL_CALC_GRM;
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "cov")) {
if (calculation_type & CALC_IBC) {
logerrprint("Error: --make-grm-gz 'cov' modifier cannot coexist with --ibc flag.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (rel_info.ibc_type) {
logerrprint("Error: --make-grm-gz 'cov' modifier cannot coexist with an IBC modifier.\n");
goto main_ret_INVALID_CMDLINE_A;
}
rel_info.modifier |= REL_CALC_COV;
} else if (!strcmp(argv[cur_arg + uii], "no-gz")) {
rel_info.modifier &= ~REL_CALC_GZ;
} else if ((!strcmp(argv[cur_arg + uii], "ibc2")) || (!strcmp(argv[cur_arg + uii], "ibc3"))) {
if (rel_info.modifier & REL_CALC_COV) {
logerrprint("Error: --make-grm-gz 'cov' modifier cannot coexist with an IBC modifier.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (rel_info.ibc_type) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --make-grm-gz '%s' modifier cannot coexist with another IBC modifier.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_2A;
}
rel_info.ibc_type = argv[cur_arg + uii][3] - '0';
} else if (!strcmp(argv[cur_arg + uii], "single-prec")) {
logerrprint("Error: --make-grm-gz 'single-prec' modifier has been retired.\n");
goto main_ret_INVALID_CMDLINE;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --make-grm-gz parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_RELATIONSHIP;
} else if (!memcmp(argptr2, "ake-grm-bin", 12)) {
if (distance_exp != 0.0) {
logerrprint("Error: \"--distance-wts exp=\" cannot be used with --make-grm-bin.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
rel_info.modifier |= REL_CALC_GRM_BIN | REL_CALC_BIN4;
if (param_ct) {
if (!strcmp(argv[cur_arg + 1], "cov")) {
if (calculation_type & CALC_IBC) {
logerrprint("Error: --make-grm-bin 'cov' modifier cannot coexist with --ibc flag.\n");
goto main_ret_INVALID_CMDLINE_A;
}
rel_info.modifier |= REL_CALC_COV;
} else if ((!strcmp(argv[cur_arg + 1], "ibc2")) || (!strcmp(argv[cur_arg + 1], "ibc3"))) {
rel_info.ibc_type = argv[cur_arg + 1][3] - '0';
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --make-grm-bin parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_RELATIONSHIP;
} else if (!memcmp(argptr2, "ake-rel", 8)) {
if (calculation_type & CALC_RELATIONSHIP) {
logerrprint("Error: --make-rel cannot be used with --make-grm-gz/--make-grm-bin.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (distance_exp != 0.0) {
logerrprint("Error: \"--distance-wts exp=\" cannot be used with --make-rel.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 3)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "cov")) {
if (calculation_type & CALC_IBC) {
logerrprint("Error: --make-rel 'cov' modifier cannot coexist with --ibc flag.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (rel_info.ibc_type) {
logerrprint("Error: --make-rel 'cov' modifier cannot coexist with an IBC modifier.\n");
goto main_ret_INVALID_CMDLINE_A;
}
rel_info.modifier |= REL_CALC_COV;
} else if (!strcmp(argv[cur_arg + uii], "gz")) {
if (rel_info.modifier & (REL_CALC_BIN | REL_CALC_BIN4)) {
logerrprint("Error: Conflicting --make-rel modifiers.\n");
goto main_ret_INVALID_CMDLINE_A;
}
rel_info.modifier |= REL_CALC_GZ;
} else if (!strcmp(argv[cur_arg + uii], "bin")) {
if (rel_info.modifier & (REL_CALC_GZ | REL_CALC_BIN4)) {
logerrprint("Error: Conflicting --make-rel modifiers.\n");
goto main_ret_INVALID_CMDLINE_A;
}
rel_info.modifier |= REL_CALC_BIN;
} else if (!strcmp(argv[cur_arg + uii], "bin4")) {
if (rel_info.modifier & (REL_CALC_GZ | REL_CALC_BIN)) {
logerrprint("Error: Conflicting --make-rel modifiers.\n");
goto main_ret_INVALID_CMDLINE_A;
}
rel_info.modifier |= REL_CALC_BIN4;
} else if (!strcmp(argv[cur_arg + uii], "square")) {
if ((rel_info.modifier & REL_CALC_SHAPEMASK) == REL_CALC_SQ0) {
logerrprint("Error: --make-rel 'square' and 'square0' modifiers cannot coexist.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((rel_info.modifier & REL_CALC_SHAPEMASK) == REL_CALC_TRI) {
logerrprint("Error: --make-rel 'square' and 'triangle' modifiers cannot coexist.\n");
goto main_ret_INVALID_CMDLINE_A;
}
rel_info.modifier |= REL_CALC_SQ;
} else if (!strcmp(argv[cur_arg + uii], "square0")) {
if ((rel_info.modifier & REL_CALC_SHAPEMASK) == REL_CALC_SQ) {
logerrprint("Error: --make-rel 'square' and 'square0' modifiers cannot coexist.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((rel_info.modifier & REL_CALC_SHAPEMASK) == REL_CALC_TRI) {
logerrprint("Error: --make-rel 'square0' and 'triangle' modifiers cannot coexist.\n");
goto main_ret_INVALID_CMDLINE_A;
}
rel_info.modifier |= REL_CALC_SQ0;
} else if (!strcmp(argv[cur_arg + uii], "triangle")) {
if ((rel_info.modifier & REL_CALC_SHAPEMASK) == REL_CALC_SQ) {
logerrprint("Error: --make-rel 'square' and 'triangle' modifiers cannot coexist.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((rel_info.modifier & REL_CALC_SHAPEMASK) == REL_CALC_SQ0) {
logerrprint("Error: --make-rel 'square0' and 'triangle' modifiers cannot coexist.\n");
goto main_ret_INVALID_CMDLINE_A;
}
rel_info.modifier |= REL_CALC_TRI;
} else if ((!strcmp(argv[cur_arg + uii], "ibc2")) || (!strcmp(argv[cur_arg + uii], "ibc3"))) {
if (rel_info.modifier & REL_CALC_COV) {
logerrprint("Error: --make-rel 'cov' modifier cannot coexist with an IBC modifier.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (rel_info.ibc_type) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --make-rel '%s' modifier cannot coexist with another IBC modifier.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_2A;
}
rel_info.ibc_type = argv[cur_arg + uii][3] - '0';
} else if (!strcmp(argv[cur_arg + uii], "single-prec")) {
logerrprint("Error: --make-rel 'single-prec' modifier has been retired. Use 'bin4'.\n");
goto main_ret_INVALID_CMDLINE;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --make-rel parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
if (!(rel_info.modifier & REL_CALC_SHAPEMASK)) {
rel_info.modifier |= (rel_info.modifier & (REL_CALC_BIN | REL_CALC_BIN4))? REL_CALC_SQ : REL_CALC_TRI;
}
calculation_type |= CALC_RELATIONSHIP;
} else if (!memcmp(argptr2, "atrix", 6)) {
logprint("Note: --matrix flag deprecated. Migrate to \"--distance ibs flat-missing\",\n\"--r2 square\", etc.\n");
matrix_flag_state = 1;
if (calculation_type & CALC_CLUSTER) {
calculation_type |= CALC_PLINK1_IBS_MATRIX;
}
goto main_param_zero;
} else if (!memcmp(argptr2, "af-succ", 8)) {
if (misc_flags & MISC_HET_SMALL_SAMPLE) {
logerrprint("Error: \"--het small-sample\" cannot be used with --maf-succ.\n");
goto main_ret_INVALID_CMDLINE_A;
}
misc_flags |= MISC_MAF_SUCC;
goto main_param_zero;
} else if (!memcmp(argptr2, "ap3", 4)) {
logprint("Note: --map3 flag unnecessary (.map file format is autodetected).\n");
goto main_param_zero;
} else if (!memcmp(argptr2, "ake-bed", 8)) {
if (misc_flags & MISC_KEEP_AUTOCONV) {
logerrprint("Error: --make-bed cannot be used with --keep-autoconv.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (load_rare & (LOAD_RARE_CNV | LOAD_RARE_DOSAGE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --make-bed cannot be used with %s.\n", (load_rare == LOAD_RARE_CNV)? "a .cnv fileset" : "--dosage");
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
// the missing --out mistake is so common--I must have made it over a
// hundred times by now--that a custom error message is worthwhile.
snprintf(g_logbuf, LOGBUFLEN, "Error: --make-bed doesn't accept parameters.%s\n", ((param_ct == 1) && (!outname_end))? " (Did you forget '--out'?)" : "");
goto main_ret_INVALID_CMDLINE_2A;
}
calculation_type |= CALC_MAKE_BED;
} else if (!memcmp(argptr2, "ake-just-bim", 13)) {
if (calculation_type & CALC_MAKE_BED) {
logerrprint("Error: --make-just-bim cannot be used with --make-bed.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (load_rare & (LOAD_RARE_CNV | LOAD_RARE_DOSAGE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --make-just-bim cannot be used with %s.\n", (load_rare == LOAD_RARE_CNV)? "a .cnv fileset" : "--dosage");
goto main_ret_INVALID_CMDLINE_2A;
}
calculation_type |= CALC_MAKE_BIM;
goto main_param_zero;
} else if (!memcmp(argptr2, "ake-just-fam", 13)) {
if (calculation_type & CALC_MAKE_BED) {
logerrprint("Error: --make-just-fam cannot be used with --make-bed.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (load_rare & (LOAD_RARE_CNV | LOAD_RARE_DOSAGE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --make-just-fam cannot be used with %s.\n", (load_rare == LOAD_RARE_CNV)? "a .cnv fileset" : "--dosage");
goto main_ret_INVALID_CMDLINE_2A;
}
calculation_type |= CALC_MAKE_FAM;
goto main_param_zero;
} else if (!memcmp(argptr2, "erge", 5)) {
if (calculation_type & CALC_MERGE) {
logerrprint("Error: --merge cannot be used with --bmerge.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (load_rare & (LOAD_RARE_CNV | LOAD_RARE_DOSAGE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --merge cannot be used with %s.\n", (load_rare == LOAD_RARE_CNV)? ".cnv filesets" : "--dosage");
goto main_ret_INVALID_CMDLINE_2A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
jj = strlen(argv[cur_arg + 1]);
if (param_ct == 2) {
if (++jj > FNAMESIZE) {
logerrprint("Error: --merge .ped filename too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(mergename1, argv[cur_arg + 1], jj);
jj = strlen(argv[cur_arg + 2]) + 1;
if (jj > FNAMESIZE) {
logerrprint("Error: --merge .map filename too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(mergename2, argv[cur_arg + 2], jj);
} else {
if (jj > (FNAMESIZE - 5)) {
logerrprint("Error: --merge filename prefix too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(memcpya(mergename1, argv[cur_arg + 1], jj), ".ped", 5);
memcpy(memcpya(mergename2, argv[cur_arg + 1], jj), ".map", 5);
}
calculation_type |= CALC_MERGE;
} else if (!memcmp(argptr2, "erge-list", 10)) {
if (calculation_type & CALC_MERGE) {
logerrprint("Error: --merge-list cannot be used with --merge or --bmerge.\n");
goto main_ret_INVALID_CMDLINE;
} else if (load_rare & (LOAD_RARE_CNV | LOAD_RARE_DOSAGE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --merge-list cannot be used with %s.\n", (load_rare == LOAD_RARE_CNV)? ".cnv filesets" : "--dosage");
goto main_ret_INVALID_CMDLINE_2A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
jj = strlen(argv[cur_arg + 1]) + 1;
if (jj > FNAMESIZE) {
logerrprint("Error: --merge-list filename too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(mergename1, argv[cur_arg + 1], jj);
merge_type |= MERGE_LIST;
calculation_type |= CALC_MERGE;
} else if (!memcmp(argptr2, "erge-mode", 10)) {
if (!(calculation_type & CALC_MERGE)) {
logerrprint("Error: --merge-mode must be used with --{b}merge/--merge-list.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
cc = argv[cur_arg + 1][0];
if ((cc < '1') || (cc > '7') || (argv[cur_arg + 1][1] != '\0')) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --merge-mode parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((merge_type & MERGE_LIST) && (cc > '5')) {
logerrprint("Error: --merge-mode 6-7 cannot be used with --merge-list.\n");
goto main_ret_INVALID_CMDLINE_A;
}
merge_type |= cc - '0';
} else if (!memcmp(argptr2, "erge-equal-pos", 15)) {
merge_type |= MERGE_EQUAL_POS;
goto main_param_zero;
} else if (!memcmp(argptr2, "ust-have-sex", 13)) {
sex_missing_pheno |= MUST_HAVE_SEX;
goto main_param_zero;
} else if (!memcmp(argptr2, "covar", 6)) {
if (!(calculation_type & CALC_GXE)) {
logerrprint("Error: --mcovar must be used with --covar and --gxe.\n");
goto main_ret_INVALID_CMDLINE;
} else if (gxe_mcovar > 1) {
logerrprint("Error: --mcovar cannot be used with a --gxe parameter.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &gxe_mcovar)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --mcovar parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
logprint("Note: --mcovar flag deprecated. Use \"--gxe \".\n");
} else if (!memcmp(argptr2, "odel", 5)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 6)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (model_modifier & MODEL_ASSOC_FDEPR) {
model_modifier &= ~(MODEL_ASSOC | MODEL_ASSOC_FDEPR);
} else if (model_modifier & MODEL_ASSOC) {
logerrprint("Error: --model cannot be used with --assoc.\n");
goto main_ret_INVALID_CMDLINE;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "fisher")) {
if (model_modifier & MODEL_TRENDONLY) {
logerrprint("Error: --model 'fisher' and 'trend-only' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
model_modifier |= MODEL_FISHER;
} else if (!strcmp(argv[cur_arg + uii], "fisher-midp")) {
if (model_modifier & MODEL_TRENDONLY) {
logerrprint("Error: --model 'fisher-midp' and 'trend-only' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
model_modifier |= MODEL_FISHER | MODEL_FISHER_MIDP;
} else if (!strcmp(argv[cur_arg + uii], "perm")) {
if (model_modifier & MODEL_MPERM) {
logerrprint("Error: --model 'mperm' and 'perm' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
model_modifier |= MODEL_PERM;
} else if (!strcmp(argv[cur_arg + uii], "genedrop")) {
model_modifier |= MODEL_GENEDROP;
} else if (!strcmp(argv[cur_arg + uii], "perm-count")) {
model_modifier |= MODEL_PERM_COUNT;
} else if (!strcmp(argv[cur_arg + uii], "dom")) {
if (model_modifier & (MODEL_PREC | MODEL_PGEN | MODEL_PTREND | MODEL_TRENDONLY)) {
logerrprint("Error: Conflicting --model parameters.\n");
goto main_ret_INVALID_CMDLINE_A;
}
model_modifier |= MODEL_PDOM;
} else if (!strcmp(argv[cur_arg + uii], "rec")) {
if (model_modifier & (MODEL_PDOM | MODEL_PGEN | MODEL_PTREND | MODEL_TRENDONLY)) {
logerrprint("Error: Conflicting --model parameters.\n");
goto main_ret_INVALID_CMDLINE_A;
}
model_modifier |= MODEL_PREC;
} else if (!strcmp(argv[cur_arg + uii], "gen")) {
if (model_modifier & (MODEL_PDOM | MODEL_PREC | MODEL_PTREND | MODEL_TRENDONLY)) {
logerrprint("Error: Conflicting --model parameters.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (mtest_adjust) {
logerrprint("Error: --model perm-gen cannot be used with --adjust.\n");
goto main_ret_INVALID_CMDLINE_A;
}
model_modifier |= MODEL_PGEN;
} else if (!strcmp(argv[cur_arg + uii], "trend")) {
if (model_modifier & (MODEL_PDOM | MODEL_PREC | MODEL_PGEN)) {
logerrprint("Error: Conflicting --model parameters.\n");
goto main_ret_INVALID_CMDLINE_A;
}
model_modifier |= MODEL_PTREND;
} else if (!strcmp(argv[cur_arg + uii], "trend-only")) {
if (model_modifier & (MODEL_FISHER | MODEL_PDOM | MODEL_PREC | MODEL_PGEN)) {
logerrprint("Error: Conflicting --model parameters.\n");
goto main_ret_INVALID_CMDLINE_A;
}
model_modifier |= MODEL_PTREND | MODEL_TRENDONLY;
} else if ((strlen(argv[cur_arg + uii]) > 6) && (!memcmp(argv[cur_arg + uii], "mperm=", 6))) {
if (model_modifier & MODEL_PERM) {
logerrprint("Error: --model 'mperm' and 'perm' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (model_modifier & MODEL_MPERM) {
logerrprint("Error: Duplicate --model 'mperm' modifier.\n");
goto main_ret_INVALID_CMDLINE;
}
if (scan_posint_defcapx(&(argv[cur_arg + uii][6]), &model_mperm_val)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --model mperm parameter '%s'.\n", &(argv[cur_arg + uii][6]));
goto main_ret_INVALID_CMDLINE_WWA;
}
model_modifier |= MODEL_MPERM;
} else if (!strcmp(argv[cur_arg + uii], "mperm")) {
logerrprint("Error: Improper --model mperm syntax. (Use \"--model mperm=\".)\n");
goto main_ret_INVALID_CMDLINE;
} else if (!strcmp(argv[cur_arg + uii], "set-test")) {
model_modifier |= MODEL_SET_TEST;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --model parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_MODEL;
} else if (!memcmp(argptr2, "odel-dom", 9)) {
if (model_modifier & MODEL_ASSOC) {
logerrprint("Error: --model-dom cannot be used with --assoc.\n");
goto main_ret_INVALID_CMDLINE;
}
if (model_modifier & (MODEL_PREC | MODEL_PGEN | MODEL_PTREND)) {
logerrprint("Error: Conflicting --model parameters.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --model-dom flag deprecated. Use \"--model dom\".\n");
model_modifier |= MODEL_PDOM;
calculation_type |= CALC_MODEL;
goto main_param_zero;
} else if (!memcmp(argptr2, "odel-gen", 9)) {
if (model_modifier & MODEL_ASSOC) {
logerrprint("Error: --model-gen cannot be used with --assoc.\n");
goto main_ret_INVALID_CMDLINE;
}
if (model_modifier & (MODEL_PDOM | MODEL_PREC | MODEL_PTREND)) {
logerrprint("Error: Conflicting --model parameters.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --model-gen flag deprecated. Use \"--model gen\".\n");
model_modifier |= MODEL_PGEN;
calculation_type |= CALC_MODEL;
goto main_param_zero;
} else if (!memcmp(argptr2, "odel-rec", 9)) {
if (model_modifier & MODEL_ASSOC) {
logerrprint("Error: --model-rec cannot be used with --assoc.\n");
goto main_ret_INVALID_CMDLINE;
}
if (model_modifier & (MODEL_PDOM | MODEL_PGEN | MODEL_PTREND)) {
logerrprint("Error: Conflicting --model parameters.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --model-rec flag deprecated. Use \"--model rec\".\n");
model_modifier |= MODEL_PREC;
calculation_type |= CALC_MODEL;
goto main_param_zero;
} else if (!memcmp(argptr2, "odel-trend", 11)) {
if (model_modifier & MODEL_ASSOC) {
logerrprint("Error: --model-trend cannot be used with --assoc.\n");
goto main_ret_INVALID_CMDLINE;
}
if (model_modifier & (MODEL_PDOM | MODEL_PGEN | MODEL_PREC)) {
logerrprint("Error: Conflicting --model parameters.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --model-trend flag deprecated. Use \"--model trend\".\n");
model_modifier |= MODEL_PTREND;
calculation_type |= CALC_MODEL;
goto main_param_zero;
} else if (!memcmp(argptr2, "perm", 5)) {
if (model_modifier & (MODEL_PERM | MODEL_MPERM)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --mperm cannot be used with --%s %sperm.\n", (model_modifier & MODEL_ASSOC)? "assoc" : "model", (model_modifier & MODEL_PERM)? "" : "m");
goto main_ret_INVALID_CMDLINE_2A;
} else if (glm_modifier & (GLM_PERM | GLM_MPERM)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --mperm cannot be used with --%s %sperm.\n", (glm_modifier & GLM_LOGISTIC)? "logistic" : "linear", (glm_modifier & GLM_PERM)? "" : "m");
goto main_ret_INVALID_CMDLINE_2A;
} else if (family_info.dfam_modifier & (DFAM_PERM | DFAM_MPERM)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --mperm cannot be used with --dfam %sperm.\n", (family_info.dfam_modifier & DFAM_PERM)? "" : "m");
goto main_ret_INVALID_CMDLINE_2A;
} else if (cluster.modifier & (CLUSTER_CMH_PERM | CLUSTER_CMH_MPERM)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --mperm cannot be used with --%s %sperm.\n", (cluster.modifier & CLUSTER_CMH_BD)? "bd" : "mh", (cluster.modifier & CLUSTER_CMH_PERM)? "" : "m");
goto main_ret_INVALID_CMDLINE_2A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &mperm_val)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --mperm parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (load_rare & LOAD_RARE_CNV) {
if ((cnv_calc_type & CNV_SAMPLE_PERM) && (!cnv_sample_mperms)) {
logprint("Note: --mperm flag deprecated. Use e.g. \"--cnv-indiv-perm \".\n");
cnv_sample_mperms = mperm_val;
} else if ((cnv_calc_type & CNV_TEST_REGION) && (!cnv_test_region_mperms)) {
logprint("Note: --mperm flag deprecated. Use e.g. \"--cnv-test-region \".\n");
} else if ((cnv_calc_type & CNV_ENRICHMENT_TEST) && (!cnv_enrichment_test_mperms)) {
logprint("Note: --mperm flag deprecated. Use e.g. \"--cnv-enrichment-test \".\n");
} else {
logprint("Note: --mperm flag deprecated. Use e.g. \"--cnv-test \".\n");
if (!(cnv_calc_type & (CNV_SAMPLE_PERM | CNV_ENRICHMENT_TEST | CNV_TEST | CNV_TEST_REGION))) {
cnv_calc_type |= CNV_TEST;
}
cnv_test_mperms = mperm_val;
}
// if e.g. --cnv-test-region had a valid parameter, don't clobber it
if (!cnv_test_region_mperms) {
cnv_test_region_mperms = mperm_val;
}
if (!cnv_enrichment_test_mperms) {
cnv_enrichment_test_mperms = mperm_val;
}
} else {
logprint("Note: --mperm flag deprecated. Use e.g. \"--model mperm=\".\n");
model_mperm_val = mperm_val;
model_modifier |= MODEL_MPERM;
glm_mperm_val = mperm_val;
glm_modifier |= GLM_MPERM;
testmiss_mperm_val = mperm_val;
testmiss_modifier |= TESTMISS_MPERM;
family_info.tdt_mperm_val = mperm_val;
family_info.tdt_modifier |= TDT_MPERM;
family_info.dfam_mperm_val = mperm_val;
family_info.dfam_modifier |= DFAM_MPERM;
family_info.qfam_mperm_val = mperm_val;
family_info.qfam_modifier |= QFAM_MPERM;
cluster.cmh_mperm_val = mperm_val;
cluster.modifier |= CLUSTER_CMH_MPERM;
}
} else if (!memcmp(argptr2, "perm-save", 10)) {
if (glm_modifier & GLM_NO_SNP) {
logerrprint("Error: --mperm-save cannot be used with --linear/--logistic no-snp.\n");
goto main_ret_INVALID_CMDLINE_A;
}
mperm_save |= MPERM_DUMP_BEST;
goto main_param_zero;
} else if (!memcmp(argptr2, "perm-save-all", 14)) {
mperm_save |= MPERM_DUMP_ALL;
goto main_param_zero;
} else if (!memcmp(argptr2, "c", 2)) {
if (!(calculation_type & CALC_CLUSTER)) {
logerrprint("Error: --mc must be used with --cluster.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &cluster.max_size) || (cluster.max_size == 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --mc parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "cc", 2)) {
if (!(calculation_type & CALC_CLUSTER)) {
logerrprint("Error: --mcc must be used with --cluster.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 2, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &cluster.max_cases)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --mcc parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (cluster.max_cases > cluster.max_size) {
logerrprint("Error: --mcc parameter exceeds --mc parameter.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (scan_posint_defcapx(argv[cur_arg + 2], &cluster.max_ctrls)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --mcc parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (cluster.max_ctrls > cluster.max_size) {
logerrprint("Error: --mcc parameter exceeds --mc parameter.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!memcmp(argptr2, "atch", 5)) {
if (!(calculation_type & CALC_CLUSTER)) {
logerrprint("Error: --match must be used with --cluster.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&cluster.match_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
if (param_ct == 2) {
if (alloc_string(&cluster.match_missing_str, argv[cur_arg + 2])) {
goto main_ret_NOMEM;
}
}
} else if (!memcmp(argptr2, "atch-type", 10)) {
if (!cluster.match_fname) {
logerrprint("Error: --match-type must be used with --match.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&cluster.match_type_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "ds-plot", 8)) {
#ifdef NOLAPACK
// may want to support this again, now that we've switched the default
// algorithm back to PLINK 1.07-style SVD
logerrprint("Error: --mds-plot requires " PROG_NAME_CAPS " to be built with LAPACK.\n");
goto main_ret_INVALID_CMDLINE;
#else
if (!(calculation_type & CALC_CLUSTER)) {
logerrprint("Error: --mds-plot must be used with --cluster.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
cluster.mds_dim_ct = 0;
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "by-cluster")) {
cluster.modifier |= CLUSTER_MDS;
} else if (!strcmp(argv[cur_arg + uii], "eigendecomp")) {
cluster.modifier |= CLUSTER_MDS_EIGENDECOMP;
} else if (!strcmp(argv[cur_arg + uii], "eigvals")) {
cluster.modifier |= CLUSTER_MDS_EIGVALS;
} else {
if (cluster.mds_dim_ct) {
logerrprint("Error: Invalid --mds-plot parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (scan_posint_defcapx(argv[cur_arg + uii], &cluster.mds_dim_ct)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --mds-plot parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
}
if (!cluster.mds_dim_ct) {
logerrprint("Error: Missing --mds-plot dimension count.\n");
goto main_ret_INVALID_CMDLINE_A;
}
#endif
} else if (!memcmp(argptr2, "ds-cluster", 11)) {
if (!(calculation_type & CALC_CLUSTER)) {
logerrprint("Error: --mds-cluster must be used with --cluster.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --mds-cluster flag deprecated. Use \"--mds-plot by-cluster\".\n");
cluster.modifier |= CLUSTER_MDS;
} else if (!memcmp(argptr2, "within", 7)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &mwithin_col)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --mwithin parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "in", 3)) {
if (!(calculation_type & CALC_GENOME)) {
logerrprint("Error: --min must be used with --genome.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --min parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((dxx < -1.0) || (dxx > 1.0)) {
logerrprint("Error: --min threshold must be between -1 and 1 inclusive.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (dxx > genome_max_pi_hat) {
logerrprint("Error: --min value cannot be greater than --max value.\n");
goto main_ret_INVALID_CMDLINE;
}
genome_modifier |= GENOME_FILTER_PI_HAT;
genome_min_pi_hat = dxx;
} else if (!memcmp(argptr2, "ax", 3)) {
if (!(calculation_type & CALC_GENOME)) {
logerrprint("Error: --max must be used with --genome.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --max parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((dxx < -1.0) || (dxx > 1.0)) {
logerrprint("Error: --max threshold must be between -1 and 1 inclusive.\n");
goto main_ret_INVALID_CMDLINE_A;
}
genome_modifier |= GENOME_FILTER_PI_HAT;
genome_max_pi_hat = dxx;
} else if (!memcmp(argptr2, "ake-founders", 13)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "require-2-missing")) {
misc_flags |= MISC_MAKE_FOUNDERS_REQUIRE_2_MISSING;
} else if (!strcmp(argv[cur_arg + uii], "first")) {
misc_flags |= MISC_MAKE_FOUNDERS_FIRST;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --make-founders parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
filter_flags |= FILTER_FAM_REQ | FILTER_MAKE_FOUNDERS;
} else if (!memcmp(argptr2, "issing", 7)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (strcmp(argv[cur_arg + 1], "gz")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --missing parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
misc_flags |= MISC_MISSING_GZ;
}
calculation_type |= CALC_MISSING_REPORT;
} else if (!memcmp(argptr2, "h", 2)) {
if (calculation_type & CALC_CMH) {
logerrprint("Error: --mh is redundant with --bd.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 3)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "perm")) {
if (cluster.modifier & CLUSTER_CMH_MPERM) {
logerrprint("Error: --mh 'mperm' and 'perm' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
cluster.modifier |= CLUSTER_CMH_PERM;
} else if ((strlen(argv[cur_arg + uii]) > 6) && (!memcmp(argv[cur_arg + uii], "mperm=", 6))) {
if (cluster.modifier & CLUSTER_CMH_PERM) {
logerrprint("Error: --mh 'mperm' and 'perm' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (cluster.modifier & CLUSTER_CMH_MPERM) {
logerrprint("Error: Duplicate --mh 'mperm' modifier.\n");
goto main_ret_INVALID_CMDLINE;
}
if (scan_posint_defcapx(&(argv[cur_arg + uii][6]), &(cluster.cmh_mperm_val))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --mh mperm parameter '%s'.\n", &(argv[cur_arg + uii][6]));
goto main_ret_INVALID_CMDLINE_WWA;
}
cluster.modifier |= CLUSTER_CMH_MPERM;
} else if (!strcmp(argv[cur_arg + uii], "perm-count")) {
cluster.modifier |= CLUSTER_CMH_PERM_COUNT;
} else if (!strcmp(argv[cur_arg + uii], "set-test")) {
cluster.modifier |= CLUSTER_CMH_SET_TEST;
} else if (!strcmp(argv[cur_arg + uii], "mperm")) {
logerrprint("Error: Improper --mh mperm syntax. (Use \"--mh mperm=\".)\n");
goto main_ret_INVALID_CMDLINE_A;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --mh parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_CMH;
} else if (!memcmp(argptr2, "h2", 3)) {
if (calculation_type & CALC_CMH) {
logerrprint("Error: --mh2 cannot be used with --mh/--bd.\n");
goto main_ret_INVALID_CMDLINE;
}
calculation_type |= CALC_CMH;
cluster.modifier |= CLUSTER_CMH2;
goto main_param_zero;
} else if (!memcmp(argptr2, "ake-set", 8)) {
if (load_rare & (LOAD_RARE_CNV | LOAD_RARE_DOSAGE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --make-set cannot be used with %s.\n", (load_rare == LOAD_RARE_CNV)? "a .cnv fileset" : "--dosage");
goto main_ret_INVALID_CMDLINE_2A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&set_info.fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
set_info.modifier |= SET_MAKE_FROM_RANGES;
filter_flags |= FILTER_BIM_REQ;
} else if (!memcmp(argptr2, "ake-set-border", 15)) {
if (!set_info.fname) {
logerrprint("Error: --make-set-border must be used with --make-set.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --make-set-border parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_A;
}
if (dxx > 2147483.646) {
set_info.make_set_border = 2147483646;
} else {
set_info.make_set_border = ((int32_t)(dxx * 1000 * (1 + SMALL_EPSILON)));
}
} else if (!memcmp(argptr2, "ake-set-collapse-group", 23)) {
if (!set_info.fname) {
logerrprint("Error: --make-set-collapse-group must be used with --make-set.\n");
goto main_ret_INVALID_CMDLINE_A;
}
set_info.modifier |= SET_MAKE_COLLAPSE_GROUP;
goto main_param_zero;
} else if (!memcmp(argptr2, "ake-set-complement-all", 23)) {
if (set_info.modifier & SET_COMPLEMENTS) {
logerrprint("Error: --make-set-complement-all cannot be used with --complement-sets.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&set_info.merged_set_name, argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
set_info.modifier |= SET_COMPLEMENTS;
} else if (!memcmp(argptr2, "ake-set-complement-group", 25)) {
if (!set_info.fname) {
logerrprint("Error: --make-set-complement-group must be used with --make-set.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (set_info.modifier & (SET_COMPLEMENTS | SET_MAKE_COLLAPSE_GROUP)) {
logerrprint("Error: --make-set-complement-group cannot be used with --complement-sets,\n--make-set-collapse-group, or --make-set-complement-all.\n");
goto main_ret_INVALID_CMDLINE_A;
}
set_info.modifier |= SET_COMPLEMENTS | SET_C_PREFIX | SET_MAKE_COLLAPSE_GROUP;
goto main_param_zero;
} else if (!memcmp(argptr2, "erge-x", 7)) {
if ((chrom_info.xymt_codes[X_OFFSET] == -2) || (chrom_info.xymt_codes[XY_OFFSET] == -2)) {
logerrprint("Error: --merge-x must be used with a chromosome set containing X and XY codes.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct == 1) {
if (strcmp(argv[cur_arg + 1], "no-fail")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --merge-x parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_A;
}
misc_flags |= MISC_SPLIT_MERGE_NOFAIL;
}
misc_flags |= MISC_MERGEX;
} else if (!memcmp(argptr2, "issing-var-code", 16)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&missing_marker_id_match, argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "e", 2)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 2, 3)) {
goto main_ret_INVALID_CMDLINE_2A;
}
uii = 1;
ujj = 2;
if (param_ct == 3) {
if (!strcmp(argv[cur_arg + 1], "var-first")) {
uii = 2;
ujj = 3;
} else if (!strcmp(argv[cur_arg + 2], "var-first")) {
ujj = 3;
} else if (strcmp(argv[cur_arg + 3], "var-first")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --me parameter '%s'.\n", argv[cur_arg + 3]);
goto main_ret_INVALID_CMDLINE_WWA;
}
family_info.mendel_modifier |= MENDEL_FILTER_VAR_FIRST;
}
if (scan_doublex(argv[cur_arg + uii], &family_info.mendel_max_trio_error) || (family_info.mendel_max_trio_error < 0.0) || (family_info.mendel_max_trio_error > 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --me maximum per-trio error rate '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (scan_doublex(argv[cur_arg + ujj], &family_info.mendel_max_var_error) || (family_info.mendel_max_var_error < 0.0) || (family_info.mendel_max_var_error > 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --me maximum per-variant error rate '%s'.\n", argv[cur_arg + ujj]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((family_info.mendel_max_trio_error < 1.0) || (family_info.mendel_max_var_error < 1.0)) {
if (covar_fname && (family_info.mendel_max_trio_error < 1.0)) {
// corner case: --me screws up covariate filtered indices
logerrprint("Error: --covar cannot be used with --me.\n");
goto main_ret_INVALID_CMDLINE;
}
// silently skip if both parameters are one, for backward
// compatibility
family_info.mendel_modifier |= MENDEL_FILTER;
filter_flags |= FILTER_ALL_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
}
} else if (!memcmp(argptr2, "e-exclude-one", 14)) {
if (!(family_info.mendel_modifier & MENDEL_FILTER)) {
logerrprint("Error: --me-exclude-one must be used with a --me parameter smaller than one.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (scan_doublex(argv[cur_arg + 1], &family_info.mendel_exclude_one_ratio) || (family_info.mendel_exclude_one_ratio < 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --me-exclude-one ratio '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else {
family_info.mendel_exclude_one_ratio = -1;
}
} else if (!memcmp(argptr2, "at", 3)) {
logprint("Note: --mat flag deprecated. Use e.g. \"--tdt poo mperm= mat\".\n");
family_info.tdt_modifier |= TDT_POOPERM_MAT;
goto main_param_zero;
} else if (!memcmp(argptr2, "endel", 6)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (strcmp(argv[cur_arg + 1], "summaries-only")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --mendel parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE;
}
family_info.mendel_modifier |= MENDEL_SUMMARIES_ONLY;
}
calculation_type |= CALC_MENDEL;
} else if (!memcmp(argptr2, "endel-duos", 11)) {
family_info.mendel_modifier |= MENDEL_DUOS;
goto main_param_zero;
} else if (!memcmp(argptr2, "endel-multigen", 15)) {
family_info.mendel_modifier |= MENDEL_MULTIGEN;
goto main_param_zero;
} else if (!memcmp(argptr2, "ake-perm-pheno", 15)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &permphe_ct)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --make-perm-pheno parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
calculation_type |= CALC_MAKE_PERM_PHENO;
} else if (!memcmp(argptr2, "eta-analysis", 13)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 2, 0x1fffffff)) {
goto main_ret_INVALID_CMDLINE_2A;
}
// if '+' present, must detect it before using alloc_and_flatten()
// must detect '+'
for (uii = 1; uii <= param_ct; uii++) {
if (argv[cur_arg + uii][0] == '+') {
if (!argv[cur_arg + uii][1]) {
if (uii <= 2) {
logerrprint("Error: --meta-analysis requires at least two PLINK report files.\n");
goto main_ret_INVALID_CMDLINE_A;
}
break;
} else {
const char* post_plus = &(argv[cur_arg + uii][1]);
if ((!strcmp(post_plus, "study")) ||
(!strcmp(post_plus, "no-map")) ||
(!strcmp(post_plus, "no-allele")) ||
(!strcmp(post_plus, "report-all")) ||
(!strcmp(post_plus, "logscale")) ||
(!strcmp(post_plus, "qt")) ||
(!strcmp(post_plus, "weighted-z"))) {
// This is far more likely to be a mistake than a real
// filename...
LOGERRPRINTFWW("Warning: In order to end the filename list, --meta-analysis '+' must be followed by a space. Currently interpreting %s as a literal filename, which probably isn't what you want...\n", argv[cur_arg + uii]);
}
}
}
}
retval = alloc_and_flatten(&metaanal_fnames, &(argv[cur_arg + 1]), uii - 1);
if (retval) {
goto main_ret_1;
}
for (uii++; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "study")) {
metaanal_flags |= METAANAL_STUDY;
} else if (!strcmp(argv[cur_arg + uii], "no-map")) {
metaanal_flags |= METAANAL_NO_MAP | METAANAL_NO_ALLELE;
} else if (!strcmp(argv[cur_arg + uii], "no-allele")) {
metaanal_flags |= METAANAL_NO_ALLELE;
} else if (!strcmp(argv[cur_arg + uii], "report-all")) {
metaanal_flags |= METAANAL_REPORT_ALL;
} else if (!strcmp(argv[cur_arg + uii], "logscale")) {
metaanal_flags |= METAANAL_LOGSCALE;
} else if (!strcmp(argv[cur_arg + uii], "qt")) {
metaanal_flags |= METAANAL_QT | METAANAL_LOGSCALE;
} else if (!strcmp(argv[cur_arg + uii], "weighted-z")) {
metaanal_flags |= METAANAL_WEIGHTED_Z;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --meta-analysis parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
} else if (!memcmp(argptr2, "eta-analysis-a1-field", 22)) {
if (!metaanal_fnames) {
logerrprint("Error: --meta-analysis-a1-field must be used with --meta-analysis.\n");
goto main_ret_INVALID_CMDLINE;
} else if (metaanal_flags & METAANAL_NO_ALLELE) {
logerrprint("Error: --meta-analysis-a1-field cannot be used with --meta-analysis\n'no-map'/'no-allele'.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x10000000)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten(&metaanal_a1field_search_order, &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "eta-analysis-a2-field", 22)) {
if (!metaanal_fnames) {
logerrprint("Error: --meta-analysis-a2-field must be used with --meta-analysis.\n");
goto main_ret_INVALID_CMDLINE;
} else if (metaanal_flags & METAANAL_NO_ALLELE) {
logerrprint("Error: --meta-analysis-a2-field cannot be used with --meta-analysis\n'no-map'/'no-allele'.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x10000000)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten(&metaanal_a2field_search_order, &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "eta-analysis-chr-field", 23)) {
if (!metaanal_fnames) {
logerrprint("Error: --meta-analysis-chr-field must be used with --meta-analysis.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x10000000)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten(&metaanal_chrfield_search_order, &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "eta-analysis-snp-field", 23)) {
if (!metaanal_fnames) {
logerrprint("Error: --meta-analysis-snp-field must be used with --meta-analysis.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x10000000)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten(&metaanal_snpfield_search_order, &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "eta-analysis-bp-field", 22)) {
if (!metaanal_fnames) {
logerrprint("Error: --meta-analysis-bp-field must be used with --meta-analysis.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x10000000)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten(&metaanal_bpfield_search_order, &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "eta-analysis-p-field", 21)) {
if ((!metaanal_fnames) || (!(metaanal_flags & METAANAL_WEIGHTED_Z))) {
logerrprint("Error: --meta-analysis-p-field must be used with --meta-analysis + weighted-z.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x10000000)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten(&metaanal_pfield_search_order, &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "eta-analysis-se-field", 22)) {
if (!metaanal_fnames) {
logerrprint("Error: --meta-analysis-se-field must be used with --meta-analysis.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x10000000)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten(&metaanal_sefield_search_order, &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "eta-analysis-ess-field", 23)) {
if ((!metaanal_fnames) || (!(metaanal_flags & METAANAL_WEIGHTED_Z))) {
logerrprint("Error: --meta-analysis-ess-field must be used with --meta-analysis + weighted-z.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x10000000)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten(&metaanal_essfield_search_order, &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "eta-analysis-report-dups", 25)) {
if (!metaanal_fnames) {
logerrprint("Error: --meta-analysis-report-dups must be used with --meta-analysis.\n");
}
metaanal_flags |= METAANAL_REPORT_DUPS;
goto main_param_zero;
} else if (!memcmp(argptr2, "ac", 3)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_uint_defcapx(argv[cur_arg + 1], &min_ac)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --mac parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
filter_flags |= FILTER_ALL_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "ax-mac", 7)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_uint_defcapx(argv[cur_arg + 1], &max_ac)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --max-mac parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (max_ac < min_ac) {
logerrprint("Error: --max-mac parameter cannot be smaller than --mac parameter.\n");
goto main_ret_INVALID_CMDLINE;
}
filter_flags |= FILTER_ALL_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "lma", 4)) {
logerrprint("Error: --mlma is not implemented yet.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "lma-loco", 9)) {
logerrprint("Error: --mlma-loco is not implemented yet.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "lma-no-adj-covar", 17)) {
logerrprint("Error: --mlma-no-adj-covar is not implemented yet.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "ishap-window", 13)) {
logerrprint("Error: --mishap-window is provisionally retired. Contact the developers if you\nneed this function.\n");
goto main_ret_INVALID_CMDLINE;
} else if ((!memcmp(argptr2, "ake-bpgen", 10)) || (!memcmp(argptr2, "ake-pgen", 9))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Unrecognized flag (%s). (This is PLINK 1.9, not 2.x.)\n", argv[cur_arg]);
goto main_ret_INVALID_CMDLINE_2;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'n':
if (!memcmp(argptr2, "o-fid", 6)) {
fam_cols &= ~FAM_COL_1;
goto main_param_zero;
} else if (!memcmp(argptr2, "o-parents", 10)) {
fam_cols &= ~FAM_COL_34;
goto main_param_zero;
} else if (!memcmp(argptr2, "o-sex", 6)) {
if (filter_flags & (FILTER_BINARY_FEMALES | FILTER_BINARY_MALES)) {
logerrprint("Error: --filter-males/--filter-females cannot be used with --no-sex.\n");
goto main_ret_INVALID_CMDLINE;
}
fam_cols &= ~FAM_COL_5;
sex_missing_pheno |= ALLOW_NO_SEX;
goto main_param_zero;
} else if (!memcmp(argptr2, "o-pheno", 8)) {
fam_cols &= ~FAM_COL_6;
goto main_param_zero;
} else if (!memcmp(argptr2, "onfounders", 11)) {
if (misc_flags & MISC_AC_FOUNDERS) {
logerrprint("Error: --ac-founders and --nonfounders cannot be used together.\n");
goto main_ret_INVALID_CMDLINE;
}
misc_flags |= MISC_NONFOUNDERS;
goto main_param_zero;
} else if (!memcmp(argptr2, "eighbour", 9)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 2, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &neighbor_n1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --neighbour parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (scan_posint_defcapx(argv[cur_arg + 2], &neighbor_n2)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --neighbour parameter '%s'.\n", argv[cur_arg + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (neighbor_n2 < neighbor_n1) {
logerrprint("Error: Second --neighbour parameter cannot be smaller than first parameter.\n");
goto main_ret_INVALID_CMDLINE_A;
}
calculation_type |= CALC_NEIGHBOR;
} else if (!memcmp(argptr2, "ot-chr", 7)) {
if (markername_from) {
logerrprint("Error: --from cannot be used with --autosome[-xy] or --[not-]chr.\n");
goto main_ret_INVALID_CMDLINE_A;
}
// allowed:
// --allow-extra-chr --chr 5-22 bobs_chrom --not-chr 17
// allowed:
// --allow-extra-chr --not-chr 12-17 bobs_chrom
// does not make sense, disallowed:
// --allow-extra-chr --chr 5-22 --not-chr bobs_chrom
// --allow-extra-chr present, --chr/--autosome[-xy] not present
uii = ((misc_flags / MISC_ALLOW_EXTRA_CHROMS) & 1) && (!chrom_info.is_include_stack);
retval = parse_chrom_ranges(param_ct, '-', &(argv[cur_arg]), chrom_exclude, &chrom_info, uii, argptr);
if (retval) {
goto main_ret_1;
}
if (chrom_info.is_include_stack || (!chrom_flag_present)) {
init_default_chrom_mask(&chrom_info);
}
for (uii = 0; uii < CHROM_MASK_INITIAL_WORDS; uii++) {
chrom_info.chrom_mask[uii] &= ~chrom_exclude[uii];
}
if (are_all_words_zero(chrom_info.chrom_mask, CHROM_MASK_INITIAL_WORDS) && ((!((misc_flags / MISC_ALLOW_EXTRA_CHROMS) & 1)) || (chrom_info.is_include_stack && (!chrom_info.incl_excl_name_stack)))) {
logerrprint("Error: All chromosomes excluded.\n");
goto main_ret_INVALID_CMDLINE_A;
}
chrom_flag_present = 1;
} else if (!memcmp(argptr2, "udge", 5)) {
if (!(calculation_type & CALC_GENOME)) {
logerrprint("Error: --nudge must be used with --genome.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --nudge flag deprecated. Use \"--genome nudge\".\n");
genome_modifier |= GENOME_NUDGE;
goto main_param_zero;
} else if (!memcmp(argptr2, "ew-id-max-allele-len", 21)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_cappedx(argv[cur_arg + 1], MAX_ID_SLEN - 2, &new_id_max_allele_len)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --new-id-max-allele-len parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "o-snp", 6)) {
if (!(calculation_type & CALC_GLM)) {
logerrprint("Error: --no-snp must be used with --linear or --logistic.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (mtest_adjust) {
logerrprint("Error: --no-snp cannot be used with --adjust.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (mperm_save & MPERM_DUMP_BEST) {
logerrprint("Error: --no-snp cannot be used with --mperm-save.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((glm_modifier & (GLM_NO_SNP_EXCL - GLM_HETHOM - GLM_DOMINANT)) || ((glm_modifier & (GLM_HETHOM | GLM_DOMINANT)) && (!(glm_modifier & (GLM_CONDITION_DOMINANT | GLM_CONDITION_RECESSIVE))))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --no-snp conflicts with a --%s modifier.\n", (glm_modifier & GLM_LOGISTIC)? "logistic" : "linear");
goto main_ret_INVALID_CMDLINE_2A;
}
logprint("Note: --no-snp flag deprecated. Use e.g. \"--linear no-snp\".\n");
glm_modifier |= GLM_NO_SNP;
goto main_param_zero;
} else if (!memcmp(argptr2, "o-x-sex", 8)) {
if (!(calculation_type & CALC_GLM)) {
logerrprint("Error: --no-x-sex must be used with --linear or --logistic.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (glm_modifier & (GLM_NO_SNP | GLM_SEX)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --no-x-sex conflicts with a --%s modifier.\n", (glm_modifier & GLM_LOGISTIC)? "logistic" : "linear");
goto main_ret_INVALID_CMDLINE_2A;
}
logprint("Note: --no-x-sex flag deprecated. Use e.g. \"--linear no-x-sex\".\n");
glm_modifier |= GLM_NO_X_SEX;
goto main_param_zero;
} else if (!memcmp(argptr2, "op", 3)) {
if (!(epi_info.modifier & EPI_FAST)) {
logerrprint("Error: --nop must be used with --fast-epistasis.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --nop flag deprecated. Use \"--fast-epistasis nop\".\n");
epi_info.modifier |= EPI_FAST_NO_P_VALUE;
goto main_param_zero;
} else if (!memcmp(argptr2, "o-const-covar", 14)) {
if (!covar_fname) {
logerrprint("Error: --no-const-covar must be used with --covar.\n");
goto main_ret_INVALID_CMDLINE;
}
covar_modifier |= COVAR_NO_CONST;
goto main_param_zero;
} else if (!memcmp(argptr2, "oweb", 5)) {
logprint("Note: --noweb has no effect since no web check is implemented yet.\n");
goto main_param_zero;
} else if (!memcmp(argptr2, "ative", 6)) {
#ifdef USE_MKL
mkl_native = 1;
#endif
goto main_param_zero;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'o':
if (!memcmp(argptr2, "utput-chr", 10)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (!strcmp(argv[cur_arg + 1], "M")) {
chrom_info.output_encoding = CHR_OUTPUT_M;
} else if (!strcmp(argv[cur_arg + 1], "MT")) {
chrom_info.output_encoding = CHR_OUTPUT_MT;
} else if (!strcmp(argv[cur_arg + 1], "0M")) {
chrom_info.output_encoding = CHR_OUTPUT_0M;
} else if (!strcmp(argv[cur_arg + 1], "chr26")) {
chrom_info.output_encoding = CHR_OUTPUT_PREFIX;
} else if (!strcmp(argv[cur_arg + 1], "chrM")) {
chrom_info.output_encoding = CHR_OUTPUT_PREFIX | CHR_OUTPUT_M;
} else if (!strcmp(argv[cur_arg + 1], "chrMT")) {
chrom_info.output_encoding = CHR_OUTPUT_PREFIX | CHR_OUTPUT_MT;
} else if (strcmp(argv[cur_arg + 1], "26")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --output-chr parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "utput-missing-genotype", 23)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
cc = extract_char_param(argv[cur_arg + 1]);
if (((unsigned char)cc) <= ' ') {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --output-missing-genotype parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
g_output_missing_geno_ptr = &(g_one_char_strs[((unsigned char)cc) * 2]);
} else if (!memcmp(argptr2, "utput-missing-phenotype", 24)) {
if (load_rare == LOAD_RARE_DOSAGE) {
logerrprint("Error: --output-missing-phenotype has no effect with --dosage.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
jj = strlen(argv[cur_arg + 1]);
if (jj > 31) {
logerrprint("Error: --output-missing-phenotype string too long (max 31 chars).\n");
goto main_ret_INVALID_CMDLINE;
}
memcpy(output_missing_pheno, argv[cur_arg + 1], jj + 1);
} else if (!memcmp(argptr2, "blig-clusters", 14)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&oblig_missing_info.sample_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
logprint("Note: --oblig-clusters flag deprecated. Use just --oblig-missing.\n");
} else if (!memcmp(argptr2, "blig-missing", 13)) {
if ((geno_thresh == 1.0) && (mind_thresh == 1.0) && (!(calculation_type & CALC_MISSING_REPORT))) {
logerrprint("Error: --oblig-missing must be used with --geno, --mind, or --missing.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (!oblig_missing_info.sample_fname) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 2, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
} else if (param_ct != 1) {
logerrprint("Error: --oblig-missing requires exactly one parameter when --oblig-clusters is\nalso present.\n");
goto main_ret_INVALID_CMDLINE_A;
}
retval = alloc_fname(&oblig_missing_info.marker_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
if (param_ct == 2) {
retval = alloc_fname(&oblig_missing_info.sample_fname, argv[cur_arg + 2], argptr, 0);
if (retval) {
goto main_ret_1;
}
}
} else if (!memcmp(argptr2, "xford-single-chr", 17)) {
if (!(load_params & LOAD_PARAMS_OXGEN)) {
if (load_params & LOAD_PARAMS_OXBGEN) {
logerrprint("Error: --oxford-single-chr must be used with .gen input. (Single-chromosome\n.bgen files do not require this, since they still contain chromosome codes.)\n");
} else {
logerrprint("Error: --oxford-single-chr must be used with .gen input.\n");
}
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (!(misc_flags & MISC_ALLOW_EXTRA_CHROMS)) {
if (get_chrom_code_raw(argv[cur_arg + 1]) < 0) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --oxford-single-chr chromosome code '%s'. (Did you forget --allow-extra-chr?)\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
if (alloc_string(&oxford_single_chr, argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "xford-pheno-name", 17)) {
if (!(load_params & LOAD_PARAMS_OX_ALL)) {
logerrprint("Error: --oxford-pheno-name must be used with an Oxford-format fileset.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&oxford_pheno_name, argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "utput-min-p", 12)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &output_min_p) || (!(output_min_p >= 0.0)) || (output_min_p >= 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --output-min-p parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (memcmp(argptr2, "ut", 3)) {
// --out is a special case due to logging
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'p':
if (!memcmp(argptr2, "ed", 3)) {
if ((load_params & (LOAD_PARAMS_BFILE_ALL | LOAD_PARAMS_OX_ALL)) || load_rare) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (!(load_params & LOAD_PARAMS_MAP)) {
logerrprint("Error: --ped must be used with --map (or --file).\n");
goto main_ret_INVALID_CMDLINE_A;
}
load_params |= LOAD_PARAMS_PED;
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (strlen(argv[cur_arg + 1]) > (FNAMESIZE - 1)) {
logerrprint("Error: --ped parameter too long.\n");
goto main_ret_OPEN_FAIL;
} else if (!memcmp(argv[cur_arg + 1], "-", 2)) {
logerrprint("Error: \"--ped -\" is no longer supported. Redirect to a temporary file and load\nit the usual way, or use PLINK 1.07.\n");
goto main_ret_INVALID_CMDLINE;
}
strcpy(pedname, argv[cur_arg + 1]);
} else if (!memcmp(argptr2, "heno", 5)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (makepheno_str) {
logerrprint("Error: --pheno and --make-pheno flags cannot coexist.\n");
goto main_ret_INVALID_CMDLINE;
}
retval = alloc_fname(&phenoname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_FAM_REQ;
} else if (!memcmp(argptr2, "heno-name", 10)) {
if (!phenoname) {
logerrprint("Error: --pheno-name must be used with --pheno.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (mpheno_col != 0) {
logerrprint("Error: --mpheno and --pheno-name flags cannot coexist.\n");
goto main_ret_INVALID_CMDLINE;
}
if (alloc_string(&phenoname_str, argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "heno-merge", 11)) {
if (!phenoname) {
logerrprint("Error: --pheno-merge must be used with --pheno.\n");
goto main_ret_INVALID_CMDLINE;
}
pheno_modifier |= PHENO_MERGE;
goto main_param_zero;
} else if (!memcmp(argptr2, "rune", 5)) {
filter_flags |= FILTER_FAM_REQ | FILTER_PRUNE;
goto main_param_zero;
} else if (!memcmp(argptr2, "arallel", 8)) {
if ((dist_calc_type & DISTANCE_SHAPEMASK) == DISTANCE_SQ) {
logerrprint("Error: --parallel cannot be used with \"--distance square\". Use \"--distance\nsquare0\" or plain --distance instead.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((dist_calc_type & (DISTANCE_BIN | DISTANCE_BIN4)) && (!(dist_calc_type & DISTANCE_SHAPEMASK))) {
logerrprint("Error: --parallel cannot be used with plain \"--distance bin[4]\". Use e.g.\n\"--distance bin square0\" or \"--distance bin triangle\" instead.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((rel_info.modifier & REL_CALC_SHAPEMASK) == REL_CALC_SQ) {
logerrprint("Error: --parallel cannot be used with \"--make-rel square\". Use \"--make-rel\nsquare0\" or plain --make-rel instead.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((rel_info.modifier & (REL_CALC_BIN | REL_CALC_BIN4)) && (!(rel_info.modifier & (REL_CALC_SHAPEMASK | REL_CALC_GRM_BIN)))) {
logerrprint("Error: --parallel cannot be used with plain \"--make-rel bin[4]\". Use e.g.\n\"--make-rel bin square0\" or \"--make-rel bin triangle\" instead.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (calculation_type & CALC_PLINK1_DISTANCE_MATRIX) {
logerrprint("Error: --parallel and --distance-matrix cannot be used together. Use\n--distance instead.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (calculation_type & CALC_GROUPDIST) {
logerrprint("Error: --parallel and --groupdist cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (calculation_type & CALC_CLUSTER) {
logerrprint("Error: --parallel and --cluster cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (calculation_type & CALC_NEIGHBOR) {
logerrprint("Error: --parallel and --neighbour cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 2, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_cappedx(argv[cur_arg + 1], PARALLEL_MAX, ¶llel_idx)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --parallel job index '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (scan_posint_cappedx(argv[cur_arg + 2], PARALLEL_MAX, ¶llel_tot) || (parallel_tot == 1) || (parallel_tot < parallel_idx)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --parallel total job count '%s'.\n", argv[cur_arg + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
parallel_idx--; // internal 0..(n-1) indexing
} else if (!memcmp(argptr2, "pc-gap", 7)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --ppc-gap parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
dxx *= 1000;
if (dxx < 0) {
ppc_gap = 0;
} else if (dxx > 2147483646) {
ppc_gap = 0x7ffffffe;
} else {
ppc_gap = (int32_t)(dxx * (1 + SMALL_EPSILON));
}
} else if (!memcmp(argptr2, "erm", 4)) {
if (model_modifier & MODEL_MPERM) {
if (calculation_type & CALC_MODEL) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --perm cannot be used with --%s mperm.\n", (model_modifier & MODEL_ASSOC)? "assoc" : "model");
goto main_ret_INVALID_CMDLINE_2A;
} else {
logerrprint("Error: --perm cannot be used with --mperm.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else if ((calculation_type & CALC_GLM) && (glm_modifier & (GLM_MPERM | GLM_NO_SNP))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --perm cannot be used with --%s %s.\n", (glm_modifier & GLM_LOGISTIC)? "logistic" : "linear", (glm_modifier & GLM_MPERM)? "mperm" : "no-snp");
goto main_ret_INVALID_CMDLINE_2A;
} else if (family_info.dfam_modifier & DFAM_MPERM) {
logerrprint("Error: --perm cannot be used with --dfam mperm.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (calculation_type & CALC_CMH) {
if (cluster.modifier & CLUSTER_CMH_MPERM) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --perm cannot be used with --%s mperm.\n", (cluster.modifier & CLUSTER_CMH_BD)? "bd" : "mh");
goto main_ret_INVALID_CMDLINE_2A;
} else if (cluster.modifier & CLUSTER_CMH_PERM_BD) {
logerrprint("Error: --perm cannot be used with --bd perm-bd.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
model_modifier |= MODEL_PERM;
glm_modifier |= GLM_PERM;
testmiss_modifier |= TESTMISS_PERM;
family_info.tdt_modifier |= TDT_PERM;
family_info.dfam_modifier |= DFAM_PERM;
family_info.qfam_modifier |= QFAM_PERM;
cluster.modifier |= CLUSTER_CMH_PERM;
logprint("Note: --perm flag deprecated. Use e.g. \"--model perm\".\n");
goto main_param_zero;
} else if (!memcmp(argptr2, "erm-count", 10)) {
model_modifier |= MODEL_PERM_COUNT;
glm_modifier |= GLM_PERM_COUNT;
testmiss_modifier |= TESTMISS_PERM_COUNT;
family_info.tdt_modifier |= TDT_PERM_COUNT;
family_info.dfam_modifier |= DFAM_PERM_COUNT;
family_info.qfam_modifier |= QFAM_PERM_COUNT;
cluster.modifier |= CLUSTER_CMH_PERM_COUNT;
logprint("Note: --perm-count flag deprecated. Use e.g. \"--model perm-count\".\n");
goto main_param_zero;
} else if (!memcmp(argptr2, "2", 2)) {
logerrprint("Error: --p2 has been provisionally retired. Contact the developers if you need\nthis functionality.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (!memcmp(argptr2, "filter", 7)) {
if (load_rare == LOAD_RARE_DOSAGE) {
logerrprint("Error: --pfilter is currently ignored by --dosage.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --pfilter parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((dxx <= 0.0) || (dxx > 1.0)) {
logerrprint("Error: --pfilter threshold must be in (0, 1].\n");
goto main_ret_INVALID_CMDLINE_A;
}
pfilter = dxx;
} else if (!memcmp(argptr2, "erm-batch-size", 15)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &perm_batch_size)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --perm-batch-size parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "pc", 3)) {
if (!(calculation_type & (CALC_NEIGHBOR | CALC_CLUSTER))) {
logerrprint("Error: --ppc must be used with --cluster or --neigbour.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --ppc parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((dxx <= 0.0) || (dxx >= 1.0)) {
logerrprint("Error: --ppc threshold must be between 0 and 1 exclusive.\n");
goto main_ret_INVALID_CMDLINE_A;
}
cluster.ppc = dxx;
} else if (!memcmp(argptr2, "ool-size", 9)) {
if (!(homozyg.modifier & (HOMOZYG_GROUP | HOMOZYG_GROUP_VERBOSE))) {
logerrprint("Error: --pool-size must be used with --homozyg group{-verbose}.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &homozyg.pool_size_min) || (homozyg.pool_size_min == 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --pool-size parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "arameters", 10)) {
if (!(calculation_type & CALC_GLM)) {
// drop --dosage since --covar-number has same functionality
logerrprint("Error: --parameters must be used with --linear or --logistic.\n");
goto main_ret_INVALID_CMDLINE_A;
}
retval = parse_name_ranges(param_ct, '-', &(argv[cur_arg]), ¶meters_range_list, 1);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "ca", 3)) {
#ifdef NOLAPACK
logerrprint("Error: --pca requires " PROG_NAME_CAPS " to be built with LAPACK.\n");
goto main_ret_INVALID_CMDLINE;
#else
if (rel_info.modifier & REL_CALC_COV) {
logerrprint("Error: --pca flag cannot coexist with a covariance matrix calculation.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (parallel_tot > 1) {
logerrprint("Error: --parallel and --pca cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
ujj = 0;
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "header")) {
rel_info.modifier |= REL_PCA_HEADER;
} else if (!strcmp(argv[cur_arg + uii], "tabs")) {
rel_info.modifier |= REL_PCA_TABS;
} else if (!strcmp(argv[cur_arg + uii], "var-wts")) {
rel_info.modifier |= REL_PCA_VAR_WTS;
} else {
if (ujj || scan_posint_defcapx(argv[cur_arg + uii], &rel_info.pc_ct)) {
logerrprint("Error: Invalid --pca parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (rel_info.pc_ct > 8000) {
logerrprint("Error: --pca does not support more than 8000 PCs.\n");
goto main_ret_INVALID_CMDLINE;
}
ujj = 1;
}
}
calculation_type |= CALC_PCA;
#endif
} else if (!memcmp(argptr2, "ca-cluster-names", 17)) {
if (!(calculation_type & CALC_PCA)) {
logerrprint("Error: --pca-cluster-names must be used with --pca.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x7fffffff)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten(&(rel_info.pca_cluster_names_flattened), &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "ca-clusters", 12)) {
if (!(calculation_type & CALC_PCA)) {
logerrprint("Error: --pca-clusters must be used with --pca.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&(rel_info.pca_clusters_fname), argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "oo", 3)) {
logprint("Note: --poo flag deprecated. Use \"--tdt poo\".\n");
family_info.tdt_modifier |= TDT_POO;
goto main_param_zero;
} else if (!memcmp(argptr2, "arentdt1", 9)) {
logprint("Note: --parentdt1 flag deprecated. Use e.g.\n\"--tdt exact mperm= parentdt1\".\n");
family_info.tdt_modifier |= TDT_PARENPERM1;
goto main_param_zero;
} else if (!memcmp(argptr2, "arentdt2", 9)) {
logprint("Note: --parentdt2 flag deprecated. Use e.g.\n\"--tdt exact mperm= parentdt2\".\n");
family_info.tdt_modifier |= TDT_PARENPERM2;
goto main_param_zero;
} else if (!memcmp(argptr2, "at", 3)) {
logprint("Note: --pat flag deprecated. Use e.g. \"--tdt poo mperm= pat\".\n");
family_info.tdt_modifier |= TDT_POOPERM_PAT;
goto main_param_zero;
} else if ((!memcmp(argptr2, "roxy-assoc", 11)) ||
(!memcmp(argptr2, "roxy-drop", 10)) ||
(!memcmp(argptr2, "roxy-impute", 12)) ||
(!memcmp(argptr2, "roxy-impute-threshold", 22)) ||
(!memcmp(argptr2, "roxy-genotypic-concordance", 27)) ||
(!memcmp(argptr2, "roxy-show-proxies", 18)) ||
(!memcmp(argptr2, "roxy-dosage", 12)) ||
(!memcmp(argptr2, "roxy-replace", 13)) ||
(!memcmp(argptr2, "roxy-verbose", 13))) {
// Apparently there are no good alternatives for Y and MT imputation?
// May want to modify this error message to suggest PLINK 1.07 for that
// case. (Since BEAGLE 4 is open source, it may be practical to build
// a PLINK 2.1 which includes a port of its imputation routine, and
// that can be written to handle Y/MT in a sane manner. But that's not
// happening before 2016.)
logerrprint("Error: PLINK 1 proxy association and imputation commands have been retired due\nto poor accuracy. (See Nothnagel M et al. (2009) A comprehensive evaluation of\nSNP genotype imputation.) We suggest using another tool, such as BEAGLE 4 or\nIMPUTE2, for imputation instead, and performing association analysis on those\nresults. (\"--recode vcf\" and --vcf can be used to exchange data with BEAGLE 4,\nwhile \"--recode oxford\" and --data let you work with IMPUTE2.)\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "file", 5)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Unrecognized flag (%s). (This is PLINK 1.9, not 2.x.)\n", argv[cur_arg]);
goto main_ret_INVALID_CMDLINE_2;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'q':
if (!memcmp(argptr2, "t-means", 8)) {
if ((!(calculation_type & CALC_MODEL)) || (!(model_modifier & MODEL_ASSOC))) {
logerrprint("Error: --qt-means must be used with --assoc.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (model_modifier & MODEL_DMASK) {
logerrprint("Error: --qt-means does not make sense with a case/control-specific --assoc\nmodifier.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --qt-means flag deprecated. Use \"--assoc qt-means ...\".\n");
model_modifier |= MODEL_QT_MEANS;
goto main_param_zero;
} else if (!memcmp(argptr2, "q-plot", 7)) {
if (!mtest_adjust) {
logerrprint("Error: --qq-plot must be used with --adjust.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --qq-plot flag deprecated. Use \"--adjust qq-plot\".\n");
mtest_adjust |= ADJUST_QQ;
goto main_param_zero;
} else if (!memcmp(argptr2, "match", 6)) {
if (!(calculation_type & CALC_CLUSTER)) {
logerrprint("Error: --qmatch must be used with --cluster.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&cluster.qmatch_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
if (param_ct == 2) {
if (alloc_string(&cluster.qmatch_missing_str, argv[cur_arg + 2])) {
goto main_ret_NOMEM;
}
}
} else if (!memcmp(argptr2, "t", 2)) {
if (!cluster.qmatch_fname) {
logerrprint("Error: --qt must be used with --qmatch.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&cluster.qt_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "-score-file", 12)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&score_info.data_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
logprint("Note: --q-score-file flag deprecated. Pass multiple parameters to\n--q-score-range instead.\n");
} else if (!memcmp(argptr2, "-score-range", 13)) {
if (score_info.data_fname) {
if (param_ct != 1) {
logerrprint("Error: --q-score-range must be given exactly one parameter when --q-score-file\nis present.\n");
goto main_ret_INVALID_CMDLINE;
}
retval = alloc_fname(&score_info.range_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
// no need for separate deprecation message
} else {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 2, 5)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&score_info.range_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
retval = alloc_fname(&score_info.data_fname, argv[cur_arg + 2], argptr, 0);
ujj = 0; // number of numeric parameters
for (uii = 3; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "header")) {
score_info.modifier |= SCORE_DATA_HEADER;
} else if (ujj == 2) {
logerrprint("Error: --q-score-range takes at most two numeric parameters.\n");
goto main_ret_INVALID_CMDLINE_A;
} else {
if (scan_posint_cappedx(argv[cur_arg + uii], MAXLINEBUFLEN / 2, (uint32_t*)&ii)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --q-score-range parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (!ujj) {
score_info.data_varid_col = ii;
score_info.data_col = ii + 1;
} else {
if ((uint32_t)ii == score_info.data_varid_col) {
logerrprint("Error: --q-score-range variant ID and data column numbers cannot match.\n");
goto main_ret_INVALID_CMDLINE_A;
}
score_info.data_col = ii;
}
ujj++;
}
}
}
} else if (!memcmp(argptr2, "ual-scores", 11)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_2col(&qual_filter, &(argv[cur_arg + 1]), argptr, param_ct);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP | FILTER_NOCNV;
} else if (!memcmp(argptr2, "ual-threshold", 14)) {
if (!qual_filter) {
logerrprint("Error: --qual-threshold must be used with --qual-scores.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &qual_min_thresh)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --qual-threshold parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (qual_min_thresh > qual_max_thresh) {
logerrprint("Error: --qual-threshold value cannot be larger than --qual-max-threshold value.\n");
goto main_ret_INVALID_CMDLINE;
}
} else if (!memcmp(argptr2, "ual-max-threshold", 18)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &qual_max_thresh)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --qual-max-threshold parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if ((!memcmp(argptr2, "fam", 4)) || (!memcmp(argptr2, "fam-parents", 12)) || (!memcmp(argptr2, "fam-between", 12)) || (!memcmp(argptr2, "fam-total", 10))) {
if (calculation_type & CALC_QFAM) {
logerrprint("Error: Only one QFAM test can be run at a time.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 3)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "emp-se")) {
family_info.qfam_modifier |= QFAM_EMP_SE;
} else if (!strcmp(argv[cur_arg + uii], "perm")) {
if (family_info.qfam_modifier & QFAM_MPERM) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s 'mperm' and 'perm' cannot be used together.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
}
family_info.qfam_modifier |= QFAM_PERM;
} else if ((strlen(argv[cur_arg + uii]) > 6) && (!memcmp(argv[cur_arg + uii], "mperm=", 6))) {
if (family_info.qfam_modifier & QFAM_PERM) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s 'mperm' and 'perm' cannot be used together.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
} else if (family_info.qfam_modifier & QFAM_MPERM) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Duplicate --%s 'mperm' modifier.\n", argptr);
goto main_ret_INVALID_CMDLINE_2;
}
if (scan_posint_defcapx(&(argv[cur_arg + uii][6]), &(family_info.qfam_mperm_val))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --%s mperm parameter '%s'.\n", argptr, &(argv[cur_arg + uii][6]));
goto main_ret_INVALID_CMDLINE_WWA;
}
family_info.qfam_modifier |= QFAM_MPERM;
} else if (!strcmp(argv[cur_arg + uii], "perm-count")) {
family_info.qfam_modifier |= QFAM_PERM_COUNT;
} else if (!strcmp(argv[cur_arg + uii], "mperm")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Improper --%s mperm syntax. (Use \"--%s mperm=\".)\n", argptr, argptr);
goto main_ret_INVALID_CMDLINE_WWA;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --%s parameter '%s'.\n", argptr, argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
if (!(family_info.qfam_modifier & (QFAM_PERM | QFAM_MPERM))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s requires permutation.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
}
if (!memcmp(argptr2, "fam", 4)) {
family_info.qfam_modifier |= QFAM_WITHIN1;
} else if (!memcmp(argptr2, "fam-parents", 12)) {
family_info.qfam_modifier |= QFAM_WITHIN2;
} else if (!memcmp(argptr2, "fam-between", 12)) {
family_info.qfam_modifier |= QFAM_BETWEEN;
} else {
family_info.qfam_modifier |= QFAM_TOTAL;
}
calculation_type |= CALC_QFAM;
} else if ((!memcmp(argptr2, "ual-geno-scores", 16)) ||
(!memcmp(argptr2, "ual-geno-threshold", 19)) ||
(!memcmp(argptr2, "ual-geno-max-threshold", 23))) {
logerrprint("Error: --qual-geno-scores has been provisionally retired, since it cannot be\nextended in a VCF-friendly manner. Contact the developers if you prefer to\ncontinue using its interface.\n");
goto main_ret_INVALID_CMDLINE;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'r':
if (!memcmp(argptr2, "emove", 6)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&removename, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_FAM_REQ;
} else if (!memcmp(argptr2, "emove-fam", 10)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&removefamname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_FAM_REQ;
} else if (!memcmp(argptr2, "emove-clusters", 15)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&(cluster.remove_fname), argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_FAM_REQ;
} else if (!memcmp(argptr2, "emove-cluster-names", 20)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x7fffffff)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten(&(cluster.remove_flattened), &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_FAM_REQ;
} else if (!memcmp(argptr2, "el-cutoff", 10)) {
if (parallel_tot > 1) {
logerrprint("Error: --parallel cannot be used with --rel-cutoff. (Use a combination of\n--make-rel, --keep/--remove, and a filtering script.)\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (rel_info.pca_cluster_names_flattened || rel_info.pca_clusters_fname) {
logerrprint("Error: --pca-cluster-names/--pca-clusters cannot be used with --rel-cutoff.\n");
goto main_ret_INVALID_CMDLINE;
}
if (covar_fname) {
// corner case: --rel-cutoff screws up covariate filtered indices
logerrprint("Error: --covar cannot be used with --rel-cutoff.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (scan_doublex(argv[cur_arg + 1], &rel_info.cutoff) || (rel_info.cutoff <= 0.0) || (rel_info.cutoff >= 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --rel-cutoff parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_REL_CUTOFF;
} else if (!memcmp(argptr2, "egress-distance", 16)) {
if (parallel_tot > 1) {
logerrprint("Error: --parallel and --regress-distance cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (scan_posintptrx(argv[cur_arg + 1], ®ress_iters) || (regress_iters == 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --regress-distance jackknife iteration count '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (param_ct == 2) {
if (scan_posint_defcapx(argv[cur_arg + 2], ®ress_d)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --regress-distance jackknife delete parameter '%s'.\n", argv[cur_arg + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
}
calculation_type |= CALC_REGRESS_DISTANCE;
} else if (!memcmp(argptr2, "egress-rel", 11)) {
if (parallel_tot > 1) {
logerrprint("Error: --parallel and --regress-rel flags cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (rel_info.pca_cluster_names_flattened || rel_info.pca_clusters_fname) {
logerrprint("Error: --pca-cluster-names/--pca-clusters cannot be used with --regress-rel.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (scan_posintptrx(argv[cur_arg + 1], &rel_info.regress_rel_iters) || (rel_info.regress_rel_iters == 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --regress-rel jackknife iteration count '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (param_ct == 2) {
if (scan_posint_defcapx(argv[cur_arg + 2], &rel_info.regress_rel_d)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --regress-rel jackknife delete parameter '%s'.\n", argv[cur_arg + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
}
calculation_type |= CALC_REGRESS_REL;
} else if ((!memcmp(argptr2, "egress-pcs", 11)) || (!memcmp(argptr2, "egress-pcs-distance", 20))) {
logerrprint("Error: --regress-pcs has been retired. Contact the developers if you need a\nlibrary which efficiently computes genotype residuals on the fly.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (!memcmp(argptr2, "ead-freq", 9)) {
if (calculation_type & CALC_FREQ) {
logerrprint("Error: --freq and --read-freq flags cannot coexist.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (misc_flags & MISC_HET_SMALL_SAMPLE) {
logerrprint("Error: \"--het small-sample\" cannot currently be used with --read-freq. Contact\nthe developers if you need to combine them.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&freqname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_ALL_REQ;
} else if ((!memcmp(argptr2, "ecode", 6)) || (!memcmp(argptr2, "ecode ", 6))) {
if (argptr2[5] == ' ') {
kk = 1;
} else {
kk = 0;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 4 - kk)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if ((!strcmp(argv[cur_arg + uii], "01")) || (!strcmp(argv[cur_arg + uii], "12"))) {
if (recode_modifier & (RECODE_A | RECODE_AD)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: The '%s' modifier does not apply to --recode's A and AD output formats.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_2A;
} else if (recode_modifier & RECODE_VCF) {
main_recode_012_vcf_conflict:
logerrprint("Error: '01'/'12' cannot be used with --recode's VCF output formats.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (argv[cur_arg + uii][0] == '0') {
if (recode_modifier & RECODE_12) {
logerrprint("Error: --recode '01' and '12' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE;
}
recode_modifier |= RECODE_01;
} else {
if (recode_modifier & RECODE_01) {
logerrprint("Error: --recode '01' and '12' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE;
}
recode_modifier |= RECODE_12;
}
} else if (!strcmp(argv[cur_arg + uii], "23")) {
if (recode_type_set(&recode_modifier, RECODE_23)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if ((!argv[cur_arg + uii][1]) && (tolower(argv[cur_arg + uii][0]) == 'a')) {
if (recode_type_set(&recode_modifier, RECODE_A)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if ((tolower(argv[cur_arg + uii][0]) == 'a') && ((!strcmp(&(argv[cur_arg + uii][1]), "-transpose")) || (!strcmp(&(argv[cur_arg + uii][1]), "v")))) {
if (recode_type_set(&recode_modifier, RECODE_A_TRANSPOSE)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if ((!argv[cur_arg + uii][2]) && match_upper(argv[cur_arg + uii], "AD")) {
if (recode_type_set(&recode_modifier, RECODE_AD)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(argv[cur_arg + uii], "compound-genotypes")) {
if (recode_type_set(&recode_modifier, RECODE_COMPOUND)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (match_upper_counted(argv[cur_arg + uii], "HV", 2)) {
if (!argv[cur_arg + uii][2]) {
if (recode_type_set(&recode_modifier, RECODE_HV)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(&(argv[cur_arg + uii][2]), "-1chr")) {
if (recode_type_set(&recode_modifier, RECODE_HV_1CHR)) {
goto main_ret_INVALID_CMDLINE_A;
}
}
} else if (!strcmp(argv[cur_arg + uii], "tab")) {
if (recode_modifier & (RECODE_TAB | RECODE_DELIMX)) {
logerrprint("Error: Multiple --recode delimiter modifiers.\n");
goto main_ret_INVALID_CMDLINE_A;
}
recode_modifier |= RECODE_TAB;
} else if (!strcmp(argv[cur_arg + uii], "tabx")) {
if (recode_modifier & (RECODE_TAB | RECODE_DELIMX)) {
logerrprint("Error: Multiple --recode delimiter modifiers.\n");
goto main_ret_INVALID_CMDLINE_A;
}
recode_modifier |= RECODE_TAB | RECODE_DELIMX;
} else if (!strcmp(argv[cur_arg + uii], "spacex")) {
if (recode_modifier & (RECODE_TAB | RECODE_DELIMX)) {
logerrprint("Error: Multiple --recode delimiter modifiers.\n");
goto main_ret_INVALID_CMDLINE_A;
}
recode_modifier |= RECODE_DELIMX;
} else if (!strcmp(argv[cur_arg + uii], "bgz")) {
recode_modifier |= RECODE_BGZ;
} else if (!strcmp(argv[cur_arg + uii], "gen-gz")) {
recode_modifier |= RECODE_GEN_GZ;
} else if (!strcmp(argv[cur_arg + uii], "beagle")) {
if (recode_type_set(&recode_modifier, RECODE_BEAGLE)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(argv[cur_arg + uii], "beagle-nomap")) {
if (recode_type_set(&recode_modifier, RECODE_BEAGLE_NOMAP)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(argv[cur_arg + uii], "bimbam")) {
if (recode_type_set(&recode_modifier, RECODE_BIMBAM)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(argv[cur_arg + uii], "bimbam-1chr")) {
if (recode_type_set(&recode_modifier, RECODE_BIMBAM_1CHR)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(argv[cur_arg + uii], "fastphase")) {
if (recode_type_set(&recode_modifier, RECODE_FASTPHASE)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(argv[cur_arg + uii], "fastphase-1chr")) {
if (recode_type_set(&recode_modifier, RECODE_FASTPHASE_1CHR)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(argv[cur_arg + uii], "lgen")) {
if (recode_type_set(&recode_modifier, RECODE_LGEN)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(argv[cur_arg + uii], "lgen-ref")) {
if (recode_type_set(&recode_modifier, RECODE_LGEN_REF)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(argv[cur_arg + uii], "list")) {
if (recode_type_set(&recode_modifier, RECODE_LIST)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(argv[cur_arg + uii], "oxford")) {
if (recode_type_set(&recode_modifier, RECODE_OXFORD)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(argv[cur_arg + uii], "ped")) {
if (recode_type_set(&recode_modifier, RECODE_PED)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(argv[cur_arg + uii], "rlist")) {
if (recode_type_set(&recode_modifier, RECODE_RLIST)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(argv[cur_arg + uii], "structure")) {
if (recode_type_set(&recode_modifier, RECODE_STRUCTURE)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if ((!strcmp(argv[cur_arg + uii], "transpose")) || (!strcmp(argv[cur_arg + uii], "tped"))) {
if (recode_type_set(&recode_modifier, RECODE_TRANSPOSE)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(argv[cur_arg + uii], "vcf")) {
if (recode_modifier & RECODE_VCF) {
main_recode_vcf_conflict:
logerrprint("Error: Conflicting or redundant --recode modifiers.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (recode_modifier & (RECODE_01 | RECODE_12)) {
goto main_recode_012_vcf_conflict;
}
if (recode_type_set(&recode_modifier, RECODE_VCF)) {
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!strcmp(argv[cur_arg + uii], "vcf-fid")) {
if (recode_modifier & (RECODE_VCF | RECODE_IID)) {
goto main_recode_vcf_conflict;
} else if (recode_modifier & (RECODE_01 | RECODE_12)) {
goto main_recode_012_vcf_conflict;
}
if (recode_type_set(&recode_modifier, RECODE_VCF)) {
goto main_ret_INVALID_CMDLINE_A;
}
recode_modifier |= RECODE_FID;
} else if (!strcmp(argv[cur_arg + uii], "vcf-iid")) {
if (recode_modifier & (RECODE_VCF | RECODE_FID)) {
goto main_recode_vcf_conflict;
} else if (recode_modifier & (RECODE_01 | RECODE_12)) {
goto main_recode_012_vcf_conflict;
}
if (recode_type_set(&recode_modifier, RECODE_VCF)) {
goto main_ret_INVALID_CMDLINE_A;
}
recode_modifier |= RECODE_IID;
} else if (!strcmp(argv[cur_arg + uii], "include-alt")) {
recode_modifier |= RECODE_INCLUDE_ALT;
} else if (!strcmp(argv[cur_arg + uii], "omit-nonmale-y")) {
recode_modifier |= RECODE_OMIT_NONMALE_Y;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --recode parameter '%s'.%s\n", argv[cur_arg + uii], ((uii == param_ct) && (!outname_end))? " (Did you forget '--out'?)" : "");
goto main_ret_INVALID_CMDLINE_WWA;
}
}
if (!(recode_modifier & RECODE_TYPEMASK)) {
// thought about including a warning here, and then outright
// prohibiting parameterless --recode in v2.0, but that usage is
// simply too common. new plan: --export requires an explicit output
// format, but --recode will continue to be translated without a
// warning even when defaulting to ped output.
if (recode_require_format) {
logerrprint("Error: --export requires an output format. (Did you forget 'ped' or 'vcf'?)\n");
goto main_ret_INVALID_CMDLINE_A;
}
recode_modifier |= RECODE_PED;
}
if ((recode_modifier & RECODE_INCLUDE_ALT) && (!(recode_modifier & (RECODE_A | RECODE_AD)))) {
logerrprint("Error: The 'include-alt' modifier only applies to --recode's A and AD output\nformats.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((recode_modifier & RECODE_OMIT_NONMALE_Y) && (!(recode_modifier & (RECODE_LIST | RECODE_RLIST)))) {
logerrprint("Error: The 'omit-nonmale-y' modifier only applies to --recode's list and rlist\noutput formats.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((recode_modifier & RECODE_BGZ) && (!(recode_modifier & RECODE_VCF))) {
logerrprint("Error: The 'bgz' modifier only applies to --recode's VCF output formats.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((recode_modifier & RECODE_GEN_GZ) && (!(recode_modifier & RECODE_OXFORD))) {
logerrprint("Error: The 'gen-gz' modifier only applies to --recode's oxford output format.\n");
goto main_ret_INVALID_CMDLINE_A;
}
calculation_type |= CALC_RECODE;
} else if (!memcmp(argptr2, "ecode-whap", 11)) {
logerrprint("Error: --recode-whap flag retired since WHAP is no longer supported.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "ecode-allele", 13)) {
if (!(recode_modifier & (RECODE_A | RECODE_A_TRANSPOSE | RECODE_AD))) {
logerrprint("Error: --recode-allele must be used with --recode A/A-transpose/AD.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (recode_modifier & (RECODE_01 | RECODE_12)) {
logerrprint("Error: --recode-allele cannot be used with --recode 01/12.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&recode_allele_name, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "eference", 9)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&lgen_reference_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
lgen_modifier |= LGEN_REFERENCE;
} else if (!memcmp(argptr2, "ead-genome", 11)) {
if (calculation_type & CALC_GENOME) {
logerrprint("Error: --read-genome cannot be used with --genome.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (!(calculation_type & (CALC_CLUSTER | CALC_NEIGHBOR))) {
logerrprint("Error: --read-genome cannot be used without --cluster or --neighbour.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((cluster.ppc == 0.0) && ((calculation_type & (CALC_DISTANCE | CALC_PLINK1_DISTANCE_MATRIX)) || read_dists_fname)) {
logerrprint("Error: --read-genome is pointless with --distance, --distance-matrix, and\n--read-dists unless --ppc is also present.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&read_genome_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "ead-genome-list", 16)) {
logerrprint("Error: --read-genome-list flag retired. Use --parallel + Unix cat instead.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "ead-genome-minimal", 19)) {
logerrprint("Error: --read-genome-minimal flag retired. Use --genome gz + --read-genome\ninstead.");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "ead-dists", 10)) {
if (calculation_type & (CALC_DISTANCE | CALC_PLINK1_DISTANCE_MATRIX)) {
logerrprint("Error: --read-dists cannot be used with a distance matrix calculation.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (cluster.modifier & CLUSTER_MISSING) {
logerrprint("Error: --read-dists cannot be used with \"--cluster missing\".\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&read_dists_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
if (param_ct == 2) {
retval = alloc_fname(&read_dists_id_fname, argv[cur_arg + 2], argptr, 0);
if (retval) {
goto main_ret_1;
}
}
} else if (!memcmp(argptr2, "el-check", 9)) {
if (!(calculation_type & CALC_GENOME)) {
logerrprint("Error: --rel-check must be used with --genome.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --rel-check flag deprecated. Use \"--genome rel-check\".\n");
genome_modifier |= GENOME_REL_CHECK;
goto main_param_zero;
} else if (!memcmp(argptr2, "ecessive", 9)) {
if (!(calculation_type & CALC_GLM)) {
logerrprint("Error: --recessive must be used with --linear or --logistic.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (glm_modifier & (GLM_GENOTYPIC | GLM_HETHOM | GLM_DOMINANT)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --recessive conflicts with a --%s modifier.\n", (glm_modifier & GLM_LOGISTIC)? "logistic" : "linear");
goto main_ret_INVALID_CMDLINE_2A;
}
logprint("Note: --recessive flag deprecated. Use e.g. \"--linear recessive\" (and\n\"--condition-list recessive\" to change covariate coding).\n");
glm_modifier |= GLM_RECESSIVE | GLM_CONDITION_RECESSIVE;
glm_xchr_model = 0;
goto main_param_zero;
} else if ((*argptr2 == '\0') || (!memcmp(argptr2, "2", 2))) {
if (calculation_type & CALC_LD) {
logerrprint("Error: --r and --r2 cannot be used together.\n");
goto main_ret_INVALID_CMDLINE;
}
if (calculation_type & CALC_BLOCKS) {
// prevent --ld-window-r2 conflict
logerrprint("Error: --r/--r2 cannot be used with --blocks.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 6)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (*argptr2 == '2') {
ld_info.modifier |= LD_R2;
}
if (matrix_flag_state) {
matrix_flag_state = 2;
ld_info.modifier |= LD_MATRIX_SQ | LD_MATRIX_SPACES;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "square")) {
if (ld_info.modifier & LD_MATRIX_SHAPEMASK) {
logerrprint("Error: Multiple --r/--r2 shape modifiers.\n");
goto main_ret_INVALID_CMDLINE;
} else if (ld_info.modifier & (LD_INTER_CHR | LD_INPHASE | LD_DX | LD_WITH_FREQS)) {
main_r2_matrix_conflict:
snprintf(g_logbuf, LOGBUFLEN, "Error: --r/--r2 '%s' cannot be used with matrix output.\n", (ld_info.modifier & LD_INTER_CHR)? "inter-chr" : ((ld_info.modifier & LD_INPHASE)? "in-phase" : ((ld_info.modifier & LD_DX)? "d'/'dprime'/'dprime-signed" : "with-freqs")));
goto main_ret_INVALID_CMDLINE_2A;
}
ld_info.modifier |= LD_MATRIX_SQ;
} else if (!strcmp(argv[cur_arg + uii], "square0")) {
if (ld_info.modifier & LD_MATRIX_SHAPEMASK) {
logerrprint("Error: Multiple --r/--r2 shape modifiers.\n");
goto main_ret_INVALID_CMDLINE;
} else if (ld_info.modifier & (LD_INTER_CHR | LD_INPHASE | LD_DX | LD_WITH_FREQS)) {
goto main_r2_matrix_conflict;
}
ld_info.modifier |= LD_MATRIX_SQ0;
} else if (!strcmp(argv[cur_arg + uii], "triangle")) {
if (ld_info.modifier & LD_MATRIX_SHAPEMASK) {
logerrprint("Error: Multiple --r/--r2 shape modifiers.\n");
goto main_ret_INVALID_CMDLINE;
} else if (ld_info.modifier & (LD_INTER_CHR | LD_INPHASE | LD_DX | LD_WITH_FREQS)) {
goto main_r2_matrix_conflict;
}
ld_info.modifier |= LD_MATRIX_TRI;
} else if (!strcmp(argv[cur_arg + uii], "inter-chr")) {
ld_info.modifier |= LD_INTER_CHR;
if (ld_info.modifier & (LD_MATRIX_SHAPEMASK | LD_MATRIX_BIN | LD_MATRIX_BIN4 | LD_MATRIX_SPACES)) {
goto main_r2_matrix_conflict;
}
} else if (!strcmp(argv[cur_arg + uii], "gz")) {
if (ld_info.modifier & (LD_MATRIX_BIN | LD_MATRIX_BIN4)) {
logerrprint("Error: Conflicting --r/--r2 modifiers.\n");
goto main_ret_INVALID_CMDLINE;
}
ld_info.modifier |= LD_REPORT_GZ;
} else if (!strcmp(argv[cur_arg + uii], "bin")) {
if (ld_info.modifier & (LD_INTER_CHR | LD_INPHASE | LD_DX | LD_WITH_FREQS)) {
goto main_r2_matrix_conflict;
} else if (ld_info.modifier & (LD_REPORT_GZ | LD_MATRIX_BIN4)) {
logerrprint("Error: Conflicting --r/--r2 modifiers.\n");
goto main_ret_INVALID_CMDLINE;
} else if (ld_info.modifier & LD_MATRIX_SPACES) {
logerrprint("Error: --r/--r2 'bin[4]' and 'spaces' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE;
}
ld_info.modifier |= LD_MATRIX_BIN;
} else if (!strcmp(argv[cur_arg + uii], "bin4")) {
if (ld_info.modifier & (LD_INTER_CHR | LD_INPHASE | LD_DX | LD_WITH_FREQS)) {
goto main_r2_matrix_conflict;
} else if (ld_info.modifier & (LD_REPORT_GZ | LD_MATRIX_BIN)) {
logerrprint("Error: Conflicting --r/--r2 modifiers.\n");
goto main_ret_INVALID_CMDLINE;
} else if (ld_info.modifier & LD_MATRIX_SPACES) {
logerrprint("Error: --r/--r2 'bin[4]' and 'spaces' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE;
}
ld_info.modifier |= LD_MATRIX_BIN4;
} else if (!strcmp(argv[cur_arg + uii], "single-prec")) {
logerrprint("Error: --r/--r2 'single-prec' modifier has been retired. Use 'bin4'.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!strcmp(argv[cur_arg + uii], "spaces")) {
if (ld_info.modifier & (LD_INTER_CHR | LD_INPHASE | LD_DX | LD_WITH_FREQS)) {
goto main_r2_matrix_conflict;
} else if (ld_info.modifier & (LD_MATRIX_BIN | LD_MATRIX_BIN4)) {
logerrprint("Error: --r/--r2 'bin[4]' and 'spaces' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE;
}
ld_info.modifier |= LD_MATRIX_SPACES;
} else if (!strcmp(argv[cur_arg + uii], "in-phase")) {
ld_info.modifier |= LD_INPHASE;
if (ld_info.modifier & (LD_MATRIX_SHAPEMASK | LD_MATRIX_BIN | LD_MATRIX_BIN4 | LD_MATRIX_SPACES)) {
goto main_r2_matrix_conflict;
}
} else if (!strcmp(argv[cur_arg + uii], "d")) {
ld_info.modifier |= LD_D;
if (ld_info.modifier & (LD_MATRIX_SHAPEMASK | LD_MATRIX_BIN | LD_MATRIX_BIN4 | LD_MATRIX_SPACES)) {
goto main_r2_matrix_conflict;
}
if (ld_info.modifier & (LD_DPRIME | LD_DPRIME_SIGNED)) {
logerrprint("Error: --r/--r2 'd' cannot be used with 'dprime'/'dprime-signed'.\n");
goto main_ret_INVALID_CMDLINE;
}
} else if (!strcmp(argv[cur_arg + uii], "dprime")) {
ld_info.modifier |= LD_DPRIME;
if (ld_info.modifier & (LD_MATRIX_SHAPEMASK | LD_MATRIX_BIN | LD_MATRIX_BIN4 | LD_MATRIX_SPACES)) {
goto main_r2_matrix_conflict;
}
if (ld_info.modifier & (LD_D | LD_DPRIME_SIGNED)) {
logerrprint("Error: --r/--r2 'dprime' cannot be used with 'd'/'dprime-signed'.\n");
goto main_ret_INVALID_CMDLINE;
}
} else if (!strcmp(argv[cur_arg + uii], "dprime-signed")) {
ld_info.modifier |= LD_DPRIME_SIGNED;
if (ld_info.modifier & (LD_MATRIX_SHAPEMASK | LD_MATRIX_BIN | LD_MATRIX_BIN4 | LD_MATRIX_SPACES)) {
goto main_r2_matrix_conflict;
}
if (ld_info.modifier & (LD_D | LD_DPRIME)) {
logerrprint("Error: --r/--r2 'dprime-signed' cannot be used with 'd'/'dprime'.\n");
goto main_ret_INVALID_CMDLINE;
}
} else if (!strcmp(argv[cur_arg + uii], "with-freqs")) {
ld_info.modifier |= LD_WITH_FREQS;
if (ld_info.modifier & (LD_MATRIX_SHAPEMASK | LD_MATRIX_BIN | LD_MATRIX_BIN4 | LD_MATRIX_SPACES)) {
goto main_r2_matrix_conflict;
}
} else if (!strcmp(argv[cur_arg + uii], "yes-really")) {
ld_info.modifier |= LD_YES_REALLY;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --r/--r2 parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
if ((ld_info.modifier & (LD_MATRIX_BIN | LD_MATRIX_BIN4)) && (!(ld_info.modifier & LD_MATRIX_SHAPEMASK))) {
ld_info.modifier |= LD_MATRIX_SQ;
}
if ((ld_info.modifier & LD_MATRIX_SPACES) && (!(ld_info.modifier & LD_MATRIX_SHAPEMASK))) {
logerrprint("Error: --r/--r2 'spaces' modifier must be used with a shape modifier.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((ld_info.modifier & LD_WEIGHTED_X) && (ld_info.modifier & (LD_MATRIX_SHAPEMASK | LD_INTER_CHR))) {
logerrprint("Error: --ld-xchr 3 cannot be used with --r/--r2 non-windowed reports.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (ld_info.modifier & LD_WEIGHTED_X) {
logerrprint("Error: --r/--r2 + --ld-xchr 3 is not currently supported.\n");
goto main_ret_INVALID_CMDLINE;
}
calculation_type |= CALC_LD;
} else if (!memcmp(argptr2, "eal-ref-alleles", 16)) {
if (load_rare & (LOAD_RARE_CNV | LOAD_RARE_DOSAGE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --real-ref-alleles has no effect with %s.\n", (load_rare == LOAD_RARE_CNV)? "a .cnv fileset" : "--dosage");
goto main_ret_INVALID_CMDLINE_2A;
}
misc_flags |= MISC_REAL_REF_ALLELES | MISC_KEEP_ALLELE_ORDER;
goto main_param_zero;
} else if (!memcmp(argptr2, "ange", 5)) {
if (extractname) {
misc_flags |= MISC_EXTRACT_RANGE;
} else if (!excludename) {
logerrprint("Error: --range must be used with --extract and/or --exclude.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (excludename) {
misc_flags |= MISC_EXCLUDE_RANGE;
}
logprint("Note: --range flag deprecated. Use e.g. \"--extract range \".\n");
goto main_param_zero;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 's':
if (!memcmp(argptr2, "eed", 4)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x7fffffff)) {
goto main_ret_INVALID_CMDLINE_2A;
}
rseed_ct = param_ct;
rseeds = (uint32_t*)malloc(param_ct * sizeof(int32_t));
for (uii = 1; uii <= param_ct; uii++) {
if (scan_uint_cappedx(argv[cur_arg + uii], 0xffffffffU, &(rseeds[uii - 1]))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --seed parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
} else if (!memcmp(argptr2, "ample", 6)) {
if ((load_params & (LOAD_PARAMS_TEXT_ALL | LOAD_PARAMS_BFILE_ALL)) || load_rare) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
} else if (!(load_params & LOAD_PARAMS_OX_ALL)) {
logerrprint("Error: --sample cannot be used without --data, --gen, or --bgen.\n");
goto main_ret_INVALID_CMDLINE_A;
}
load_params |= LOAD_PARAMS_OXSAMPLE;
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (strlen(argv[cur_arg + 1]) > (FNAMESIZE - 1)) {
logerrprint("Error: --sample parameter too long.\n");
goto main_ret_OPEN_FAIL;
}
strcpy(mapname, argv[cur_arg + 1]);
} else if (!memcmp(argptr2, "np", 3)) {
if (markername_from) {
logerrprint("Error: --snp cannot be used with --from.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (marker_pos_start != -1) {
logerrprint("Error: --snp cannot be used with --from-bp/-kb/-mb.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((!are_all_words_zero(chrom_info.chrom_mask, CHROM_MASK_INITIAL_WORDS)) || chrom_info.incl_excl_name_stack) {
logerrprint("Error: --snp cannot be used with --autosome[-xy] or --[not-]chr.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (markername_snp) {
logerrprint("Error: --snp cannot be used with --exclude-snp.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (snps_range_list.names) {
logerrprint("Error: --snp cannot be used with --exclude-snps.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&markername_snp, argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP | FILTER_NOCNV;
} else if (!memcmp(argptr2, "nps", 4)) {
if (markername_from) {
logerrprint("Error: --snps cannot be used with --from.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (marker_pos_start != -1) {
logerrprint("Error: --snps cannot be used with --from-bp/-kb/-mb.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (markername_snp) {
logerrprint("Error: --snps cannot be used with --snp or --exclude-snp.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (snps_range_list.names) {
logerrprint("Error: --snps cannot be used with --exclude-snps.\n");
goto main_ret_INVALID_CMDLINE_A;
}
// mise well allow --snps + --autosome/--autosome-xy/--chr/--not-chr
retval = parse_name_ranges(param_ct, range_delim, &(argv[cur_arg]), &snps_range_list, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP | FILTER_NOCNV;
} else if (!memcmp(argptr2, "et-hh-missing", 14)) {
misc_flags |= MISC_SET_HH_MISSING;
goto main_param_zero;
} else if (!memcmp(argptr2, "et-mixed-mt-missing", 20)) {
misc_flags |= MISC_SET_MIXED_MT_MISSING;
goto main_param_zero;
} else if (!memcmp(argptr2, "et", 3)) {
if (set_info.fname) {
logerrprint("Error: --set cannot be used with --make-set.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (load_rare & (LOAD_RARE_CNV | LOAD_RARE_DOSAGE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --set cannot be used with %s.\n", (load_rare == LOAD_RARE_CNV)? "a .cnv fileset" : "--dosage");
goto main_ret_INVALID_CMDLINE_2A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&set_info.fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_BIM_REQ;
} else if (!memcmp(argptr2, "et-collapse-all", 16)) {
if (!set_info.fname) {
logerrprint("Error: --set-collapse-all must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE;
} else if (set_info.modifier & SET_MAKE_COLLAPSE_GROUP) {
logerrprint("Error: --set-collapse-all cannot be used with --make-set-collapse-group or\n--make-set-complement-group.\n");
goto main_ret_INVALID_CMDLINE;
} else if (set_info.merged_set_name) {
logerrprint("Error: --set-collapse-all cannot be used with --make-set-complement-all.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&set_info.merged_set_name, argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "et-names", 9)) {
if (!set_info.fname) {
logerrprint("Error: --set-names must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 0x7fffffff)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_and_flatten(&(set_info.setnames_flattened), &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "ubset", 6)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (!set_info.fname) {
logerrprint("Error: --subset must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE;
}
retval = alloc_fname(&set_info.subset_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if ((!memcmp(argptr2, "imulate", 8)) || (!memcmp(argptr2, "imulate-qt", 11))) {
if (load_params || load_rare) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 3)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&simulate_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
if (argptr2[7] == '-') {
simulate_flags |= SIMULATE_QT;
}
for (uii = 2; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "tags")) {
if (simulate_flags & SIMULATE_HAPS) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s 'tags' and 'haps' modifiers cannot be used together.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
}
simulate_flags |= SIMULATE_TAGS;
} else if (!strcmp(argv[cur_arg + uii], "haps")) {
if (simulate_flags & SIMULATE_TAGS) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s 'tags' and 'haps' modifiers cannot be used together.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
}
simulate_flags |= SIMULATE_HAPS;
} else if (match_upper(argv[cur_arg + uii], "ACGT")) {
if (simulate_flags & (SIMULATE_1234 | SIMULATE_12)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s 'acgt' modifier cannot be used with '1234' or '12'.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
}
simulate_flags |= SIMULATE_ACGT;
} else if (!strcmp(argv[cur_arg + uii], "1234")) {
if (simulate_flags & (SIMULATE_ACGT | SIMULATE_12)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s '1234' modifier cannot be used with 'acgt' or '12'.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
}
simulate_flags |= SIMULATE_1234;
} else if (!strcmp(argv[cur_arg + uii], "12")) {
if (simulate_flags & (SIMULATE_ACGT | SIMULATE_1234)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s '12' modifier cannot be used with 'acgt' or '1234'.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
}
simulate_flags |= SIMULATE_12;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --%s parameter '%s'.\n", argptr, argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
load_rare = LOAD_RARE_SIMULATE;
} else if (!memcmp(argptr2, "imulate-ncases", 15)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (load_rare != LOAD_RARE_SIMULATE) {
logerrprint("Error: --simulate-ncases must be used with --simulate.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (scan_uint_defcapx(argv[cur_arg + 1], &simulate_cases)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --simulate-ncases parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "imulate-ncontrols", 18)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (load_rare != LOAD_RARE_SIMULATE) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --simulate-ncontrols must be used with --simulate.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (scan_uint_defcapx(argv[cur_arg + 1], &simulate_controls)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --simulate-ncontrols parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((!simulate_controls) && (!simulate_cases)) {
logerrprint("Error: \"--simulate-ncases 0\" cannot be used with \"--simulate-ncontrols 0\".\n");
goto main_ret_INVALID_CMDLINE;
}
} else if (!memcmp(argptr2, "imulate-prevalence", 19)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &simulate_prevalence) || (simulate_prevalence < 0) || (simulate_prevalence > 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --simulate-prevalence parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "imulate-label", 14)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&simulate_label, argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
} else if (!memcmp(argptr2, "imulate-missing", 16)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &simulate_missing) || (simulate_missing < 0) || (simulate_missing > 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --simulate-missing parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "imulate-n", 10)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (load_rare == LOAD_RARE_SIMULATE) {
logerrprint("Error: --simulate-n must be used with --simulate-qt, not --simulate.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &simulate_qt_samples)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --simulate-n parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "imulate-haps", 13)) {
if (simulate_flags & SIMULATE_TAGS) {
logerrprint("Error: --simulate-tags cannot be used with --simulate-haps.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --simulate-haps flag deprecated. Use e.g. \"--simulate haps\".\n");
simulate_flags |= SIMULATE_HAPS;
goto main_param_zero;
} else if (!memcmp(argptr2, "imulate-tags", 13)) {
if (simulate_flags & SIMULATE_HAPS) {
logerrprint("Error: --simulate-tags cannot be used with --simulate-haps.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --simulate-tags flag deprecated. Use e.g. \"--simulate tags\".\n");
simulate_flags |= SIMULATE_TAGS;
goto main_param_zero;
} else if (!memcmp(argptr2, "ex", 3)) {
if (load_rare == LOAD_RARE_DOSAGE) {
dosage_info.modifier |= DOSAGE_SEX;
} else {
if (!(calculation_type & CALC_GLM)) {
logerrprint("Error: --sex must be used with --linear/--logistic/--dosage.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (glm_modifier & GLM_NO_X_SEX) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --sex conflicts with a --%s modifier.\n", (glm_modifier & GLM_LOGISTIC)? "logistic" : "linear");
goto main_ret_INVALID_CMDLINE_2A;
}
logprint("Note: --sex flag deprecated. Use e.g. \"--linear sex\".\n");
glm_modifier |= GLM_SEX;
}
goto main_param_zero;
} else if (!memcmp(argptr2, "tandard-beta", 13)) {
if (((!(calculation_type & CALC_GLM)) || (glm_modifier & GLM_LOGISTIC)) && (!(dosage_info.modifier & DOSAGE_GLM))) {
logerrprint("Error: --standard-beta must be used with --linear or --dosage.\n");
goto main_ret_INVALID_CMDLINE_A;
}
// "--linear standard-beta" is ALSO deprecated now for plink2's
// --{covar-}variance-normalize, so this note is pointless.
// logprint("Note: --standard-beta flag deprecated. Use e.g. \"--linear standard-beta\".\n");
glm_modifier |= GLM_STANDARD_BETA;
goto main_param_zero;
} else if (!memcmp(argptr2, "et-table", 9)) {
if (!set_info.fname) {
logerrprint("Error: --set-table must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE_A;
}
calculation_type |= CALC_WRITE_SET;
set_info.modifier |= SET_WRITE_TABLE;
goto main_param_zero;
} else if (!memcmp(argptr2, "et-test", 8)) {
if (!set_info.fname) {
logerrprint("Error: --set-test must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --set-test flag deprecated. Use e.g. \"--assoc perm set-test\".\n");
if (calculation_type & CALC_MODEL) {
model_modifier |= MODEL_SET_TEST;
}
if (calculation_type & CALC_GLM) {
if (glm_modifier & GLM_NO_SNP) {
logerrprint("Error: --set-test cannot be used with --linear/--logistic no-snp.\n");
goto main_ret_INVALID_CMDLINE_A;
}
glm_modifier |= GLM_SET_TEST;
}
if (calculation_type & CALC_TDT) {
family_info.tdt_modifier |= TDT_SET_TEST;
}
if (calculation_type & CALC_DFAM) {
family_info.dfam_modifier |= DFAM_SET_TEST;
}
if ((calculation_type & CALC_CMH) && (!(cluster.modifier & CLUSTER_CMH2))) {
cluster.modifier |= CLUSTER_CMH_SET_TEST;
}
if ((epi_info.modifier & (EPI_FAST | EPI_REG)) && (!(epi_info.modifier & EPI_SET_BY_ALL))) {
epi_info.modifier |= EPI_SET_BY_SET;
}
goto main_param_zero;
} else if (!memcmp(argptr2, "et-p", 5)) {
if (!set_info.fname) {
logerrprint("Error: --set-p must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx <= 0) || (dxx > 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --set-p parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
set_info.set_p = dxx;
} else if (!memcmp(argptr2, "et-r2", 5)) {
if (!set_info.fname) {
logerrprint("Error: --set-r2 must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
uii = 1;
if (!strcmp(argv[cur_arg + 1], "write")) {
uii = 2;
set_info.modifier |= SET_R2_WRITE;
} else if (param_ct == 2) {
if (!strcmp(argv[cur_arg + 2], "write")) {
set_info.modifier |= SET_R2_WRITE;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --set-r2 parameter '%s'.\n", argv[cur_arg + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
if (uii <= param_ct) {
if (scan_doublex(argv[cur_arg + uii], &dxx) || (dxx < 0.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --set-r2 parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (dxx > 0.0) {
// greater than 1 = no LD check. (it still happens with a
// parameter of 1.)
set_info.set_r2 = dxx;
} else {
set_info.set_max = 1;
}
}
} else if (!memcmp(argptr2, "et-r2-phase", 11)) {
logerrprint("Error: --set-r2-phase is provisionally retired. Contact the developers if you\nneed this function.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "et-max", 5)) {
if (!set_info.fname) {
logerrprint("Error: --set-max must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &set_info.set_max)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --set-max parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "et-test-lambda", 15)) {
if (!set_info.fname) {
logerrprint("Error: --set-test-lambda must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &set_info.set_test_lambda)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --set-test-lambda parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (set_info.set_test_lambda < 1) {
logprint("Note: --set-test-lambda parameter set to 1.\n");
set_info.set_test_lambda = 1;
}
} else if (!memcmp(argptr2, "et-by-all", 10)) {
if (!set_info.fname) {
logerrprint("Error: --set-by-all must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (!(epi_info.modifier & (EPI_FAST | EPI_REG))) {
logerrprint("Error: --set-by-all must be used with --{fast-}epistasis.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --set-by-all flag deprecated. Use e.g. \"--fast-epistasis set-by-all\".\n");
epi_info.modifier |= EPI_SET_BY_ALL;
goto main_param_zero;
} else if (!memcmp(argptr2, "nps-only", 9)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
const char* cur_modif = argv[cur_arg + 1];
const uint32_t slen = strlen(cur_modif);
if ((slen != 9) || memcmp(cur_modif, "just-acgt", 9)) {
if ((slen != 5) || (memcmp(cur_modif, "no-", 3)) || (!match_upper(&(cur_modif[3]), "DI"))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --snps-only parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
logerrprint("Warning: --snps-only 'no-DI' modifier has been changed to 'just-acgt', and now\nexcludes all non-ACGT allele codes.\n");
}
misc_flags |= MISC_SNPS_ONLY_JUST_ACGT;
}
filter_flags |= FILTER_BIM_REQ | FILTER_SNPS_ONLY | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "plit-x", 7)) {
if (misc_flags & MISC_MERGEX) {
logerrprint("Error: --split-x cannot be used with --merge-x.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((chrom_info.xymt_codes[X_OFFSET] == -2) || (chrom_info.xymt_codes[XY_OFFSET] == -2)) {
logerrprint("Error: --split-x must be used with a chromosome set containing X and XY codes.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 3)) {
goto main_ret_INVALID_CMDLINE_2A;
}
uii = 1;
ujj = param_ct;
// 'no-fail' must be either the first or last parameter.
if (!strcmp(argv[cur_arg + 1], "no-fail")) {
misc_flags |= MISC_SPLIT_MERGE_NOFAIL;
uii = 2;
} else if (!strcmp(argv[cur_arg + param_ct], "no-fail")) {
misc_flags |= MISC_SPLIT_MERGE_NOFAIL;
ujj--;
}
if ((ujj < uii) || (ujj == uii + 2)) {
logerrprint("Error: Invalid --split-x parameter sequence.\n");
goto main_ret_INVALID_CMDLINE;
}
if (ujj == uii) {
if ((!strcmp(argv[cur_arg + uii], "b36")) || (!strcmp(argv[cur_arg + uii], "hg18"))) {
splitx_bound1 = 2709521;
splitx_bound2 = 154584237;
} else if ((!strcmp(argv[cur_arg + uii], "b37")) || (!strcmp(argv[cur_arg + uii], "hg19"))) {
splitx_bound1 = 2699520;
splitx_bound2 = 154931044;
} else if ((!strcmp(argv[cur_arg + uii], "b38")) || (!strcmp(argv[cur_arg + uii], "hg38"))) {
splitx_bound1 = 2781479;
splitx_bound2 = 155701383;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Unrecognized --split-x build code '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (chrom_info.species != SPECIES_HUMAN) {
logerrprint("Error: --split-x build codes cannot be used with nonhuman chromosome sets.\n");
goto main_ret_INVALID_CMDLINE;
}
} else {
if (scan_uint_defcapx(argv[cur_arg + uii], &splitx_bound1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --split-x parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (scan_posint_defcapx(argv[cur_arg + ujj], &splitx_bound2) || (splitx_bound2 <= splitx_bound1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --split-x parameter '%s'.\n", argv[cur_arg + ujj]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
} else if (!memcmp(argptr2, "et-missing-snp-ids", 19)) {
logerrprint("Error: --set-missing-snp-ids has been retired. Use --set-missing-var-ids with\n'$1' and '$2' instead.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (!memcmp(argptr2, "et-missing-nonsnp-ids", 22)) {
logerrprint("Error: --set-missing-nonsnp-ids has been retired. Use --set-missing-var-ids\nwith '$1' and '$2' instead.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (!memcmp(argptr2, "et-missing-var-ids", 19)) {
if (load_rare & (LOAD_RARE_CNV | LOAD_RARE_DOSAGE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --set-missing-var-ids cannot be used with %s.\n", (load_rare == LOAD_RARE_CNV)? "a .cnv fileset" : "--dosage");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (!valid_varid_template_string(argv[cur_arg + 1], "--set-missing-var-ids")) {
goto main_ret_INVALID_CMDLINE_A;
}
if (alloc_string(&missing_mid_template, argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP | FILTER_NOCNV;
} else if (!memcmp(argptr2, "core", 5)) {
if (load_rare & LOAD_RARE_DOSAGE) {
if (dosage_info.modifier & DOSAGE_OCCUR) {
logerrprint("Error: --dosage 'occur' mode cannot be used with --score.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (dosage_info.modifier & DOSAGE_ZOUT) {
logerrprint("Error: --dosage 'Zout' modifier cannot be used with --score.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((glm_modifier & GLM_STANDARD_BETA) || (dosage_info.modifier & DOSAGE_SEX)) {
logerrprint("Error: --dosage + --score cannot be used with association analysis\nmodifiers/flags.\n");
goto main_ret_INVALID_CMDLINE_A;
}
dosage_info.modifier += (DOSAGE_SCORE - DOSAGE_GLM);
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 9)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&score_info.fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
ujj = 0; // number of numeric parameters so far
for (uii = 2; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "header")) {
score_info.modifier |= SCORE_HEADER;
} else if (!strcmp(argv[cur_arg + uii], "sum")) {
if (score_info.modifier & SCORE_NO_MEAN_IMPUTATION) {
logerrprint("Error: --score 'sum' and 'no-mean-imputation' modifiers cannot be used\ntogether.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (dosage_info.modifier & DOSAGE_SCORE_NOSUM) {
logerrprint("Error: --score 'sum' and 'no-sum' modifiers conflict.\n");
goto main_ret_INVALID_CMDLINE;
}
score_info.modifier |= SCORE_SUM;
} else if (!strcmp(argv[cur_arg + uii], "no-mean-imputation")) {
if (score_info.modifier & SCORE_SUM) {
logerrprint("Error: --score 'sum' and 'no-mean-imputation' modifiers cannot be used\ntogether.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (score_info.modifier & SCORE_CENTER) {
logerrprint("Error: --score 'center' and 'no-mean-imputation' modifiers cannot be used\ntogether.\n");
goto main_ret_INVALID_CMDLINE_A;
}
score_info.modifier |= SCORE_NO_MEAN_IMPUTATION;
} else if (!strcmp(argv[cur_arg + uii], "center")) {
if (score_info.modifier & SCORE_NO_MEAN_IMPUTATION) {
logerrprint("Error: --score 'center' and 'no-mean-imputation' modifiers cannot be used\ntogether.\n");
goto main_ret_INVALID_CMDLINE_A;
}
score_info.modifier |= SCORE_CENTER;
} else if (!strcmp(argv[cur_arg + uii], "no-sum")) {
if (score_info.modifier & SCORE_SUM) {
logerrprint("Error: --score 'sum' and 'no-sum' modifiers conflict.\n");
goto main_ret_INVALID_CMDLINE;
}
dosage_info.modifier |= DOSAGE_SCORE_NOSUM;
} else if (!strcmp(argv[cur_arg + uii], "include-cnt")) {
dosage_info.modifier |= DOSAGE_SCORE_CNT;
} else if (!strcmp(argv[cur_arg + uii], "double-dosage")) {
dosage_info.modifier |= DOSAGE_SCORE_DOUBLE;
} else if (ujj == 3) {
logerrprint("Error: --score takes at most three numeric parameters.\n");
goto main_ret_INVALID_CMDLINE_A;
} else {
if (scan_posint_cappedx(argv[cur_arg + uii], MAXLINEBUFLEN / 2, (uint32_t*)&ii)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --score parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (!ujj) {
score_info.varid_col = ii;
score_info.allele_col = ii + 1;
score_info.effect_col = ii + 2;
} else if (ujj == 1) {
if ((uint32_t)ii == score_info.varid_col) {
logerrprint("Error: --score variant ID and allele column numbers cannot match.\n");
goto main_ret_INVALID_CMDLINE_A;
}
score_info.allele_col = ii;
score_info.effect_col = ii + 1;
} else {
if ((uint32_t)ii == score_info.varid_col) {
logerrprint("Error: --score variant ID and effect column numbers cannot match.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((uint32_t)ii == score_info.allele_col) {
logerrprint("Error: --score allele and effect column numbers cannot match.\n");
goto main_ret_INVALID_CMDLINE_A;
}
score_info.effect_col = ii;
}
ujj++;
}
}
calculation_type |= CALC_SCORE;
} else if (!memcmp(argptr2, "core-no-mean-imputation", 24)) {
if (!(calculation_type & CALC_SCORE)) {
logerrprint("Error: --score-no-mean-imputation must be used with --score.\n");
goto main_ret_INVALID_CMDLINE;
} else if (score_info.modifier & SCORE_CENTER) {
logerrprint("Error: --score-no-mean-imputation cannot be used with --score 'center'\nmodifier.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --score-no-mean-imputation flag deprecated. Use e.g.\n\"--score ... no-mean-imputation\".\n");
score_info.modifier |= SCORE_NO_MEAN_IMPUTATION;
goto main_param_zero;
} else if (!memcmp(argptr2, "et-me-missing", 14)) {
if (load_rare & LOAD_RARE_CNV) {
logerrprint("Error: --set-me-missing cannot be used with a .cnv fileset.\n");
goto main_ret_INVALID_CMDLINE_A;
}
misc_flags |= MISC_SET_ME_MISSING;
goto main_param_zero;
} else if (!memcmp(argptr2, "how-tags", 9)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (strcmp(argv[cur_arg + 1], "all")) {
// no explicit flag for now, instead just let null show_tags_fname
// indicate 'all' mode;
retval = alloc_fname(&ld_info.show_tags_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else {
if (ld_info.modifier & LD_SHOW_TAGS_LIST_ALL) {
logerrprint("Error: --list-all cannot be used with \"--show-tags all\".\n");
goto main_ret_INVALID_CMDLINE_A;
}
ld_info.modifier |= LD_SHOW_TAGS_LIST_ALL;
}
calculation_type |= CALC_SHOW_TAGS;
} else if (!memcmp(argptr2, "egment", 7)) {
logerrprint("Error: --segment flag retired. Use another package, such as BEAGLE or\nGERMLINE, for this analysis.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!memcmp(argptr2, "kato", 5)) {
logerrprint("Error: --skato is not implemented yet. Use e.g. PLINK/SEQ to perform this test\nfor now.\n");
retval = RET_CALC_NOT_YET_SUPPORTED;
goto main_ret_1;
} else if (memcmp(argptr2, "ilent", 6)) {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 't':
if (!memcmp(argptr2, "ail-pheno", 10)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (makepheno_str) {
logerrprint("Error: --tail-pheno cannot be used with --make-pheno.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (scan_doublex(argv[cur_arg + 1], &tail_bottom)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --tail-pheno parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (param_ct == 1) {
tail_top = tail_bottom;
} else {
if (scan_doublex(argv[cur_arg + 2], &tail_top)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --tail-pheno parameter '%s'.\n", argv[cur_arg + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
if (tail_bottom > tail_top) {
logerrprint("Error: Ltop cannot be larger than Hbottom for --tail-pheno.\n");
goto main_ret_INVALID_CMDLINE_A;
}
filter_flags |= FILTER_FAM_REQ | FILTER_TAIL_PHENO;
} else if (!memcmp(argptr2, "hreads", 7)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &g_thread_ct)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --threads parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (g_thread_ct > MAX_THREADS) {
LOGPRINTF("Note: Reducing --threads parameter to %u. (If this is not large enough,\nrecompile with a larger MAX_THREADS setting.)\n", MAX_THREADS);
g_thread_ct = MAX_THREADS;
} else if (known_procs == -1) {
// trigger BLAS/LAPACK warning
known_procs = 0;
}
} else if (!memcmp(argptr2, "ab", 3)) {
logprint("Note: --tab flag deprecated. Use \"--recode tab ...\".\n");
if (recode_modifier & RECODE_DELIMX) {
logerrprint("Error: Multiple --recode delimiter modifiers.\n");
goto main_ret_INVALID_CMDLINE_A;
}
recode_modifier |= RECODE_TAB;
goto main_param_zero;
} else if (!memcmp(argptr2, "ranspose", 9)) {
logprint("Note: --transpose flag deprecated. Use \"--recode transpose ...\".\n");
if (recode_modifier & RECODE_LGEN) {
logerrprint("Error: --recode 'transpose' and 'lgen' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
recode_modifier |= RECODE_TRANSPOSE;
goto main_param_zero;
} else if (!memcmp(argptr2, "fam", 4)) {
if (load_params || load_rare) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
jj = strlen(argv[cur_arg + 1]);
if (jj > FNAMESIZE - 1) {
logerrprint("Error: --tfam filename prefix too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(famname, argv[cur_arg + 1], jj + 1);
load_rare |= LOAD_RARE_TFAM;
} else if (!memcmp(argptr2, "file", 5)) {
if (load_params || (load_rare & (~LOAD_RARE_TFAM))) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
jj = strlen(argv[cur_arg + 1]);
if (jj > FNAMESIZE - 6) {
logerrprint("Error: --tfile filename prefix too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(memcpya(pedname, argv[cur_arg + 1], jj), ".tped", 6);
if (!(load_rare & LOAD_RARE_TFAM)) {
memcpy(memcpya(famname, argv[cur_arg + 1], jj), ".tfam", 6);
}
} else {
memcpy(pedname, PROG_NAME_STR ".tped", 11);
if (!(load_rare & LOAD_RARE_TFAM)) {
memcpy(famname, PROG_NAME_STR ".tfam", 11);
}
}
load_rare |= LOAD_RARE_TRANSPOSE;
} else if (!memcmp(argptr2, "ped", 4)) {
if (load_params || (load_rare & (~(LOAD_RARE_TRANSPOSE | LOAD_RARE_TFAM)))) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (!(load_rare & (LOAD_RARE_TRANSPOSE | LOAD_RARE_TFAM))) {
logerrprint("Error: --tped must be used with --tfam or --tfile.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
jj = strlen(argv[cur_arg + 1]);
if (jj > FNAMESIZE - 1) {
logerrprint("Error: --tped filename prefix too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(pedname, argv[cur_arg + 1], jj + 1);
load_rare |= LOAD_RARE_TPED;
} else if (!memcmp(argptr2, "o", 2)) {
if ((!are_all_words_zero(chrom_info.chrom_mask, CHROM_MASK_INITIAL_WORDS)) || chrom_info.incl_excl_name_stack) {
logerrprint("Error: --to cannot be used with --autosome[-xy] or --[not-]chr.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (markername_snp) {
logerrprint("Error: --to cannot be used with --snp.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (snps_range_list.names) {
logerrprint("Error: --to cannot be used with --snps.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&markername_to, argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP | FILTER_NOCNV;
} else if ((!memcmp(argptr2, "o-bp", 5)) || (!memcmp(argptr2, "o-kb", 5)) || (!memcmp(argptr2, "o-mb", 5))) {
if (markername_snp && (!(filter_flags & FILTER_EXCLUDE_MARKERNAME_SNP))) {
logerrprint("Error: --to-bp/-kb/-mb cannot be used with --snp.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (snps_range_list.names) {
logerrprint("Error: --to-bp/-kb/-mb cannot be used with --snps.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (markername_to) {
logerrprint("Error: --to-bp/-kb/-mb cannot be used with --to.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((!markername_from) && (marker_pos_start == -1)) {
marker_pos_start = 0;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
cc = argptr2[2];
if (cc == 'b') {
if (scan_uint_defcapx(argv[cur_arg + 1], (uint32_t*)&ii)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --to-bp parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else {
if (marker_pos_end != -1) {
logerrprint("Error: Multiple --to-bp/-kb/-mb values.\n");
goto main_ret_INVALID_CMDLINE;
}
if (scan_doublex(argv[cur_arg + 1], &dxx)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --to-kb/-mb parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
dxx *= (cc == 'k')? 1000 : 1000000;
if (dxx < 0) {
ii = 0;
} else if (dxx > 2147483646) {
ii = 0x7ffffffe;
} else {
ii = (int32_t)(dxx * (1 + SMALL_EPSILON));
}
}
if (ii < marker_pos_start) {
marker_pos_end = marker_pos_start;
marker_pos_start = ii;
} else {
marker_pos_end = ii;
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP;
} else if (!memcmp(argptr2, "rend", 5)) {
if (model_modifier & MODEL_ASSOC) {
logerrprint("Error: --trend cannot be used with --assoc.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (model_modifier & MODEL_FISHER) {
logerrprint("Error: --trend cannot be used with --model fisher.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (model_modifier & (MODEL_PDOM | MODEL_PREC | MODEL_PGEN)) {
logerrprint("Error: --trend cannot be used with --model dom/rec/gen.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --trend flag deprecated. Use \"--model trend-only ...\".\n");
model_modifier |= MODEL_PTREND | MODEL_TRENDONLY;
calculation_type |= CALC_MODEL;
goto main_param_zero;
} else if (!memcmp(argptr2, "hin", 4)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &thin_keep_prob)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --thin variant retention probability '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (thin_keep_prob < (0.5 / 4294967296.0)) {
logerrprint("Error: --thin variant retention probability too small.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (thin_keep_prob >= (4294967295.5 / 4294967296.0)) {
if (scan_uint_defcapx(argv[cur_arg + 1], &uii)) {
logerrprint("Error: --thin variant retention probability too large.\n");
} else {
// VCFtools --thin = --bp-space...
logerrprint("Error: --thin variant retention probability too large. (Did you mean\n--bp-space?)\n");
}
goto main_ret_INVALID_CMDLINE_A;
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP | FILTER_NOCNV;
} else if (!memcmp(argptr2, "hin-count", 10)) {
if (thin_keep_prob != 1.0) {
logerrprint("Error: --thin cannot be used with --thin-count.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_uint_defcapx(argv[cur_arg + 1], &thin_keep_ct) || ((!thin_keep_ct) && (!(misc_flags & MISC_ALLOW_NO_VARS)))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --thin-count parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP | FILTER_NOCNV;
} else if (!memcmp(argptr2, "hin-indiv", 10)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &thin_keep_sample_prob)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --thin-indiv %s retention probability '%s'.\n", g_species_singular, argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (thin_keep_sample_prob < (0.5 / 4294967296.0)) {
LOGERRPRINTF("Error: --thin-indiv %s retention probability too small.\n", g_species_singular);
goto main_ret_INVALID_CMDLINE_A;
} else if (thin_keep_sample_prob >= (4294967295.5 / 4294967296.0)) {
LOGERRPRINTF("Error: --thin-indiv %s retention probability too large.\n", g_species_singular);
goto main_ret_INVALID_CMDLINE_A;
}
} else if (!memcmp(argptr2, "hin-indiv-count", 16)) {
if (thin_keep_sample_prob != 1.0) {
logerrprint("Error: --thin-indiv cannot be used with --thin-indiv-count.\n");
goto main_ret_INVALID_CMDLINE_WWA;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_uint_defcapx(argv[cur_arg + 1], &thin_keep_sample_ct) || ((!thin_keep_sample_ct) && (!(misc_flags & MISC_ALLOW_NO_SAMPLES)))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --thin-indiv-count parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "ests", 5)) {
if (!(calculation_type & CALC_GLM)) {
logerrprint("Error: --tests must be used with --linear or --logistic.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((param_ct == 1) && (!strcmp(argv[cur_arg + 1], "all"))) {
glm_modifier |= GLM_TEST_ALL;
} else {
if (glm_modifier & GLM_TEST_ALL) {
logerrprint("Error: --test-all cannot be used with --tests.\n");
goto main_ret_INVALID_CMDLINE_A;
}
retval = parse_name_ranges(param_ct, '-', &(argv[cur_arg]), &tests_range_list, 1);
if (retval) {
goto main_ret_1;
}
}
} else if (!memcmp(argptr2, "est-all", 8)) {
if (!(calculation_type & CALC_GLM)) {
logerrprint("Error: --test-all must be used with --linear or --logistic.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --test-all flag deprecated. Use \"--tests all\".\n");
glm_modifier |= GLM_TEST_ALL;
goto main_param_zero;
} else if (!memcmp(argptr2, "wolocus", 8)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 2, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (alloc_string(&(epi_info.twolocus_mkr1), argv[cur_arg + 1])) {
goto main_ret_NOMEM;
}
if (alloc_string(&(epi_info.twolocus_mkr2), argv[cur_arg + 2])) {
goto main_ret_NOMEM;
}
if (!strcmp(epi_info.twolocus_mkr1, epi_info.twolocus_mkr2)) {
logerrprint("Error: --twolocus parameters cannot match.\n");
goto main_ret_INVALID_CMDLINE;
}
calculation_type |= CALC_EPI;
} else if (!memcmp(argptr2, "est-missing", 12)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 3)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "perm")) {
if (testmiss_modifier & TESTMISS_MPERM) {
logerrprint("Error: --test-missing 'mperm' and 'perm' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
testmiss_modifier |= TESTMISS_PERM;
} else if ((strlen(argv[cur_arg + uii]) > 6) && (!memcmp(argv[cur_arg + uii], "mperm=", 6))) {
if (testmiss_modifier & TESTMISS_PERM) {
logerrprint("Error: --test-missing 'mperm' and 'perm' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (testmiss_modifier & TESTMISS_MPERM) {
// when --mperm and --test-missing mperm=[] are used together
logerrprint("Error: Duplicate --test-missing 'mperm' modifier.\n");
goto main_ret_INVALID_CMDLINE;
}
if (scan_posint_defcapx(&(argv[cur_arg + uii][6]), &testmiss_mperm_val)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --test-missing mperm parameter '%s'.\n", &(argv[cur_arg + uii][6]));
goto main_ret_INVALID_CMDLINE_WWA;
}
testmiss_modifier |= TESTMISS_MPERM;
} else if (!strcmp(argv[cur_arg + uii], "perm-count")) {
testmiss_modifier |= TESTMISS_PERM_COUNT;
} else if (!strcmp(argv[cur_arg + uii], "midp")) {
testmiss_modifier |= TESTMISS_MIDP;
} else if (!strcmp(argv[cur_arg + uii], "mperm")) {
logerrprint("Error: Improper --test-missing mperm syntax. (Use \"--test-missing\nmperm=\".)\n");
goto main_ret_INVALID_CMDLINE;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --test-missing parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
calculation_type |= CALC_TESTMISS;
} else if (!memcmp(argptr2, "est-mishap", 11)) {
calculation_type |= CALC_TESTMISHAP;
goto main_param_zero;
} else if (!memcmp(argptr2, "dt", 3)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 5)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "exact")) {
if (family_info.tdt_modifier & TDT_MIDP) {
logerrprint("Error: --tdt 'exact' modifier cannot be used with 'exact-midp'.\n");
goto main_ret_INVALID_CMDLINE;
} else if (family_info.tdt_modifier & TDT_POO) {
logerrprint("Error: --tdt parent-of-origin analysis does not currently support exact tests.\n");
goto main_ret_INVALID_CMDLINE_A;
}
family_info.tdt_modifier |= TDT_EXACT;
} else if (!strcmp(argv[cur_arg + uii], "exact-midp")) {
if ((family_info.tdt_modifier & (TDT_EXACT | TDT_MIDP)) == TDT_EXACT) {
logerrprint("Error: --tdt 'exact' modifier cannot be used with 'exact-midp'.\n");
goto main_ret_INVALID_CMDLINE;
} else if (family_info.tdt_modifier & TDT_POO) {
logerrprint("Error: --tdt parent-of-origin analysis does not currently support exact tests.\n");
goto main_ret_INVALID_CMDLINE_A;
}
family_info.tdt_modifier |= TDT_EXACT | TDT_MIDP;
} else if (!strcmp(argv[cur_arg + uii], "poo")) {
if (family_info.tdt_modifier & TDT_EXACT) {
logerrprint("Error: --tdt parent-of-origin analysis does not currently support exact tests.\n");
goto main_ret_INVALID_CMDLINE_A;
}
family_info.tdt_modifier |= TDT_POO;
} else if (!strcmp(argv[cur_arg + uii], "perm")) {
if (family_info.tdt_modifier & TDT_MPERM) {
logerrprint("Error: --tdt 'mperm' and 'perm' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
family_info.tdt_modifier |= TDT_PERM;
} else if (!strcmp(argv[cur_arg + uii], "perm-count")) {
family_info.tdt_modifier |= TDT_PERM_COUNT;
} else if ((strlen(argv[cur_arg + uii]) > 6) && (!memcmp(argv[cur_arg + uii], "mperm=", 6))) {
if (family_info.tdt_modifier & TDT_PERM) {
logerrprint("Error: --tdt 'mperm' and 'perm' cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (family_info.tdt_modifier & TDT_MPERM) {
logerrprint("Error: Duplicate --tdt 'mperm' modifier.\n");
goto main_ret_INVALID_CMDLINE;
}
if (scan_posint_defcapx(&(argv[cur_arg + uii][6]), &family_info.tdt_mperm_val)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --tdt mperm parameter '%s'.\n", &(argv[cur_arg + uii][6]));
goto main_ret_INVALID_CMDLINE_WWA;
}
family_info.tdt_modifier |= TDT_MPERM;
} else if (!strcmp(argv[cur_arg + uii], "parentdt1")) {
if (family_info.tdt_modifier & TDT_PARENPERM2) {
logerrprint("Error: --tdt 'parentdt1' and 'parentdt2' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
family_info.tdt_modifier |= TDT_PARENPERM1;
} else if (!strcmp(argv[cur_arg + uii], "parentdt2")) {
if (family_info.tdt_modifier & TDT_PARENPERM1) {
logerrprint("Error: --tdt 'parentdt1' and 'parentdt2' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
family_info.tdt_modifier |= TDT_PARENPERM2;
} else if (!strcmp(argv[cur_arg + uii], "pat")) {
if (family_info.tdt_modifier & TDT_POOPERM_MAT) {
logerrprint("Error: --tdt 'pat' and 'mat' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
family_info.tdt_modifier |= TDT_POOPERM_PAT;
} else if (!strcmp(argv[cur_arg + uii], "parentdt2")) {
if (family_info.tdt_modifier & TDT_POOPERM_PAT) {
logerrprint("Error: --tdt 'pat' and 'mat' modifiers cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
}
family_info.tdt_modifier |= TDT_POOPERM_MAT;
} else if (!strcmp(argv[cur_arg + uii], "set-test")) {
family_info.tdt_modifier |= TDT_SET_TEST;
} else if (!strcmp(argv[cur_arg + uii], "mperm")) {
logerrprint("Error: Improper --tdt mperm syntax. (Use \"--tdt mperm=\".)\n");
goto main_ret_INVALID_CMDLINE;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --tdt parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
if (!(family_info.tdt_modifier & TDT_POO)) {
if (family_info.tdt_modifier & TDT_PERM) {
logerrprint("Error: Regular --tdt analysis no longer supports adaptive permutation. Use an\nexact test instead.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (family_info.tdt_modifier & (TDT_POOPERM_PAT | TDT_POOPERM_MAT)) {
logerrprint("Error: --tdt 'pat'/'mat' must be used with parent-of-origin analysis.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((family_info.tdt_modifier & (TDT_PARENPERM1 | TDT_PARENPERM2 | TDT_SET_TEST)) && (!(family_info.tdt_modifier & TDT_MPERM))) {
logerrprint("Error: --tdt 'parentdt1'/'parentdt2'/'set-test' requires permutation.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else {
if (family_info.tdt_modifier & (TDT_PARENPERM1 | TDT_PARENPERM2)) {
logerrprint("Error: --tdt 'parentdt1'/'parentdt2' cannot be used with parent-of-origin\nanalysis.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((family_info.tdt_modifier & (TDT_POOPERM_PAT | TDT_POOPERM_MAT | TDT_SET_TEST)) && (!(family_info.tdt_modifier & (TDT_PERM | TDT_MPERM)))) {
logerrprint("Error: --tdt poo 'pat'/'mat'/'set-test' requires permutation.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
calculation_type |= CALC_TDT;
} else if (!memcmp(argptr2, "ag-kb", 6)) {
if (!(calculation_type & CALC_SHOW_TAGS)) {
logerrprint("Error: --tag-kb must be used with --show-tags.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --tag-kb parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (dxx > 2147483.646) {
ld_info.show_tags_bp = 2147483646;
} else {
ld_info.show_tags_bp = ((int32_t)(dxx * 1000 * (1 + SMALL_EPSILON)));
}
} else if (!memcmp(argptr2, "ag-r2", 6)) {
if (!(calculation_type & CALC_SHOW_TAGS)) {
logerrprint("Error: --tag-r2 must be used with --show-tags.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0) || (dxx > 1)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --tag-r2 threshold '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
ld_info.show_tags_r2 = dxx;
} else if (!memcmp(argptr2, "ag-mode2", 8)) {
if (!(calculation_type & CALC_SHOW_TAGS)) {
logerrprint("Error: --tag-mode2 must be used with --show-tags.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (!(ld_info.show_tags_fname)) {
logerrprint("Error: --tag-mode2 cannot be used with \"--show-tags all\".\n");
goto main_ret_INVALID_CMDLINE_A;
}
ld_info.modifier |= LD_SHOW_TAGS_MODE2;
goto main_param_zero;
} else if (!memcmp(argptr2, "ucc", 4)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (strcmp(argv[cur_arg + 1], "write-bed")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --tucc parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE;
}
family_info.tucc_bed = 1;
} else {
logerrprint("Warning: --tucc without 'write-bed' is deprecated.\n");
}
calculation_type |= CALC_TUCC;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'u':
if (!memcmp(argptr2, "nrelated-heritability", 22)) {
#ifdef NOLAPACK
logerrprint("Error: --unrelated-heritability requires " PROG_NAME_CAPS " to be built with LAPACK.\n");
goto main_ret_INVALID_CMDLINE;
#else
UNSTABLE("unrelated-heritability");
if (rel_info.modifier & REL_CALC_COV) {
logerrprint("Error: --unrelated-heritability flag cannot coexist with a covariance\nmatrix calculation.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (parallel_tot > 1) {
logerrprint("Error: --parallel and --unrelated-heritability cannot be used together.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (calculation_type & CALC_PCA) {
logerrprint("Error: --pca cannot be used with --unrelated-heritability.\n");
goto main_ret_INVALID_CMDLINE;
}
if (load_rare & (LOAD_RARE_GRM | LOAD_RARE_GRM_BIN)) {
if (calculation_type & CALC_REL_CUTOFF) {
logerrprint("Error: --unrelated-heritability + --grm-gz/--grm-bin cannot be used with\n--rel-cutoff.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (!phenoname) {
logerrprint("Error: --unrelated-heritability + --grm-gz/--grm-bin requires --pheno as well.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (!strcmp(argv[cur_arg + 1], "strict")) {
rel_info.modifier |= REL_UNRELATED_HERITABILITY_STRICT;
uii = 2;
} else {
uii = 1;
}
if (param_ct >= uii) {
if (scan_doublex(argv[cur_arg + uii], &rel_info.unrelated_herit_tol)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --unrelated-heritability EM tolerance parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (rel_info.unrelated_herit_tol <= 0.0) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --unrelated-heritability EM tolerance parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (param_ct > uii) {
if (scan_doublex(argv[cur_arg + uii + 1], &rel_info.unrelated_herit_covg)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --unrelated-heritability genomic covariance prior '%s'.\n", argv[cur_arg + uii + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((rel_info.unrelated_herit_covg <= 0.0) || (rel_info.unrelated_herit_covg > 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --unrelated-heritability genomic covariance prior '%s'.\n", argv[cur_arg + uii + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (param_ct == uii + 2) {
if (scan_doublex(argv[cur_arg + uii + 2], &rel_info.unrelated_herit_covr)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --unrelated-heritability residual covariance prior '%s'.\n", argv[cur_arg + uii + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if ((rel_info.unrelated_herit_covr <= 0.0) || (rel_info.unrelated_herit_covr > 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --unrelated-heritability residual covariance prior '%s'.\n", argv[cur_arg + uii + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else {
rel_info.unrelated_herit_covr = 1.0 - rel_info.unrelated_herit_covg;
}
}
}
}
calculation_type |= CALC_UNRELATED_HERITABILITY;
#endif
} else if (!memcmp(argptr2, "pdate-alleles", 14)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&update_alleles_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_BIM_REQ | FILTER_NODOSAGE | FILTER_NOCNV;
} else if (!memcmp(argptr2, "pdate-chr", 10)) {
if (cnv_calc_type & CNV_MAKE_MAP) {
logprint("--update-chr cannot be used with --cnv-make-map.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((misc_flags & MISC_MERGEX) || splitx_bound2) {
logprint("--update-chr cannot be used with --split-x or --merge-x.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (!param_ct) {
update_map_modifier = 1;
} else {
retval = alloc_2col(&update_chr, &(argv[cur_arg + 1]), argptr, param_ct);
if (retval) {
goto main_ret_1;
}
}
} else if (!memcmp(argptr2, "pdate-cm", 9)) {
if (cnv_calc_type & CNV_MAKE_MAP) {
logerrprint("Error: --update-cm cannot be used with --cnv-make-map.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (cm_map_fname) {
logerrprint("Error: --update-cm cannot be used with --cm-map.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (update_map_modifier) {
logerrprint("Error: --update-map 'cm' modifier cannot be used with 'chr'.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (!param_ct) {
update_map_modifier = 2;
} else {
retval = alloc_2col(&update_cm, &(argv[cur_arg + 1]), argptr, param_ct);
if (retval) {
goto main_ret_1;
}
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP;
} else if (!memcmp(argptr2, "pdate-ids", 10)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&update_ids_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_FAM_REQ;
} else if (!memcmp(argptr2, "pdate-map", 10)) {
if (cnv_calc_type & CNV_MAKE_MAP) {
logprint("--update-map cannot be used with --cnv-make-map.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (update_map_modifier) {
if (param_ct != 1) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Multi-parameter --update-map cannot be used with deprecated\nparameter-free --update-%s.\n", (update_map_modifier == 1)? "chr" : "cm");
goto main_ret_INVALID_CMDLINE_2;
}
retval = alloc_2col((update_map_modifier == 1)? (&update_chr) : (&update_cm), &(argv[cur_arg + 1]), argptr, 1);
if (retval) {
goto main_ret_1;
}
LOGPRINTF("Note: --update-map + parameter-free --update-%s deprecated. Use\n--update-%s instead.\n", (update_map_modifier == 1)? "chr" : "cm", (update_map_modifier == 1)? "chr" : "cm");
update_map_modifier = 0;
} else {
retval = alloc_2col(&update_map, &(argv[cur_arg + 1]), argptr, param_ct);
if (retval) {
goto main_ret_1;
}
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP;
} else if (!memcmp(argptr2, "pdate-name", 11)) {
if (cnv_calc_type & CNV_MAKE_MAP) {
logprint("--update-name cannot be used with --cnv-make-map.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (update_chr) {
logerrprint("Error: --update-name cannot be used with --update-chr.\n");
goto main_ret_INVALID_CMDLINE;
} else if (update_cm) {
logerrprint("Error: --update-name cannot be used with --update-cm.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 4)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (!param_ct) {
if (!update_map) {
logerrprint("Error: Deprecated parameter-free --update-name cannot be used without\n--update-map.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((update_map->colx != 2) || (update_map->colid != 1) || (update_map->skip) || (update_map->skipchar)) {
logerrprint("Error: Multi-parameter --update-map cannot be used with deprecated\nparameter-free --update-name.\n");
goto main_ret_INVALID_CMDLINE;
}
logprint("Note: --update-map + parameter-free --update-name deprecated. Use\n--update-name instead.\n");
update_name = update_map;
update_map = nullptr;
} else {
if (update_map) {
// no point in explaining the deprecated exception to this in the
// error message
logerrprint("Error: --update-name cannot be used with --update-map.\n");
goto main_ret_INVALID_CMDLINE;
}
retval = alloc_2col(&update_name, &(argv[cur_arg + 1]), argptr, param_ct);
if (retval) {
goto main_ret_1;
}
}
filter_flags |= FILTER_BIM_REQ | FILTER_DOSAGEMAP;
} else if (!memcmp(argptr2, "pdate-parents", 14)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (update_ids_fname) {
logerrprint("Error: --update-parents cannot be used with --update-ids.\n");
goto main_ret_INVALID_CMDLINE;
}
retval = alloc_fname(&update_parents_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_FAM_REQ;
} else if (!memcmp(argptr2, "pdate-sex", 10)) {
if (update_ids_fname) {
logerrprint("Error: --update-sex cannot be used with --update-ids.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
retval = alloc_fname(&update_sex_fname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
if (param_ct == 2) {
if (scan_posint_defcapx(argv[cur_arg + 2], &update_sex_col)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --update-sex column parameter '%s'. (This must be a positive integer.)\n", argv[cur_arg + 2]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
filter_flags |= FILTER_FAM_REQ;
} else if (!memcmp(argptr2, "nbounded", 9)) {
if (!(calculation_type & CALC_GENOME)) {
logerrprint("Error: --unbounded must be used with --genome.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logprint("Note: --unbounded flag deprecated. Use \"--genome unbounded\".\n");
genome_modifier |= GENOME_IBD_UNBOUNDED;
goto main_param_zero;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'v':
if (!memcmp(argptr2, "if", 3)) {
if (((!(calculation_type & CALC_GLM)) || (glm_modifier & GLM_LOGISTIC)) && (!((calculation_type & CALC_EPI) || (!(epi_info.modifier & EPI_REG))))) {
logerrprint("Error: --vif must be used with --linear/--epistasis.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &glm_vif_thresh)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --linear/--epistasis VIF threshold '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
if (glm_vif_thresh < 1.0) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --linear/--epistasis VIF threshold '%s' too small (must be >= 1).\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "egas", 5)) {
if (!set_info.fname) {
logerrprint("Error: --vegas must be used with --set.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logerrprint("Error: --vegas is currently under development.\n");
retval = RET_CALC_NOT_YET_SUPPORTED;
goto main_ret_1;
goto main_param_zero;
} else if (!memcmp(argptr2, "cf", 3)) {
if (load_params || load_rare) {
goto main_ret_INVALID_CMDLINE_INPUT_CONFLICT;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
uii = strlen(argv[cur_arg + 1]);
if (uii > FNAMESIZE - 1) {
logerrprint("Error: --vcf filename too long.\n");
goto main_ret_OPEN_FAIL;
}
memcpy(pedname, argv[cur_arg + 1], uii + 1);
load_rare = LOAD_RARE_VCF;
} else if (!memcmp(argptr2, "cf-min-qual", 12)) {
if (!(load_rare & (LOAD_RARE_VCF | LOAD_RARE_BCF))) {
logerrprint("Error: --vcf-min-qual must be used with --vcf/--bcf.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &vcf_min_qual) || (vcf_min_qual < 0.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --vcf-min-qual parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
vcf_min_qual *= 1 - SMALL_EPSILON;
} else if (!memcmp(argptr2, "cf-filter", 10)) {
if (!(load_rare & (LOAD_RARE_VCF | LOAD_RARE_BCF))) {
logerrprint("Error: --vcf-filter must be used with --vcf/--bcf.\n");
goto main_ret_INVALID_CMDLINE;
}
if (param_ct) {
retval = alloc_and_flatten(&vcf_filter_exceptions_flattened, &(argv[cur_arg + 1]), param_ct);
if (retval) {
goto main_ret_1;
}
}
misc_flags |= MISC_VCF_FILTER;
} else if (!memcmp(argptr2, "cf-min-gp", 10)) {
if (!(load_rare & LOAD_RARE_VCF)) {
// er, probably want to support BCF too
logerrprint("Error: --vcf-min-gp must be used with --vcf.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &vcf_min_gp) || (vcf_min_gp <= 0.0) || (vcf_min_gp > 1.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --vcf-min-gp parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
vcf_min_gp *= 1 - SMALL_EPSILON;
} else if (!memcmp(argptr2, "cf-min-gq", 10)) {
if (!(load_rare & LOAD_RARE_VCF)) {
// probably want to support BCF too
logerrprint("Error: --vcf-min-gq must be used with --vcf.\n");
goto main_ret_INVALID_CMDLINE;
}
if (vcf_half_call) {
logerrprint("Error: --vcf-min-gq cannot currently be used with --vcf-half-call.\n");
retval = RET_CALC_NOT_YET_SUPPORTED;
goto main_ret_1;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &vcf_min_gq) || (vcf_min_gq < 0.0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --vcf-min-gq parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
vcf_min_gq *= 1 - SMALL_EPSILON;
} else if (!memcmp(argptr2, "cf-idspace-to", 14)) {
if (!(load_rare & (LOAD_RARE_VCF | LOAD_RARE_BCF))) {
logerrprint("Error: --vcf-idspace-to must be used with --vcf/--bcf.\n");
goto main_ret_INVALID_CMDLINE;
}
if (id_delim == ' ') {
logerrprint("Error: --vcf-idspace-to cannot be used when the --id-delim character is space.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
vcf_idspace_to = extract_char_param(argv[cur_arg + 1]);
if (!vcf_idspace_to) {
logerrprint("Error: --vcf-idspace-to parameter must be a single character.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (((unsigned char)vcf_idspace_to) <= ' ') {
logerrprint("Error: --vcf-idspace-to parameter must be a nonspace character.\n");
goto main_ret_INVALID_CMDLINE;
}
} else if (!memcmp(argptr2, "cf-half-call", 13)) {
if (!(load_rare & LOAD_RARE_VCF)) {
logerrprint("Error: --vcf-half-call must be used with --vcf.\n");
goto main_ret_INVALID_CMDLINE;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if ((!strcmp(argv[cur_arg + 1], "h")) || (!strcmp(argv[cur_arg + 1], "haploid"))) {
vcf_half_call = VCF_HALF_CALL_HAPLOID;
} else if ((!strcmp(argv[cur_arg + 1], "m")) || (!strcmp(argv[cur_arg + 1], "missing"))) {
vcf_half_call = VCF_HALF_CALL_MISSING;
} else if ((!strcmp(argv[cur_arg + 1], "e")) || (!strcmp(argv[cur_arg + 1], "error"))) {
vcf_half_call = VCF_HALF_CALL_ERROR;
} else if ((!strcmp(argv[cur_arg + 1], "r")) || (!strcmp(argv[cur_arg + 1], "reference"))) {
vcf_half_call = VCF_HALF_CALL_REFERENCE;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: '%s' is not a valid mode for --vcf-half-call.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
} else if (!memcmp(argptr2, "cf-require-gt", 14)) {
if (!(load_rare & (LOAD_RARE_VCF | LOAD_RARE_BCF))) {
logerrprint("Error: --vcf-require-gt must be used with --vcf/--bcf.\n");
goto main_ret_INVALID_CMDLINE;
}
misc_flags |= MISC_VCF_REQUIRE_GT;
goto main_param_zero;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'w':
if (!memcmp(argptr2, "rite-snplist", 13)) {
calculation_type |= CALC_WRITE_SNPLIST;
goto main_param_zero;
} else if (!memcmp(argptr2, "rite-var-ranges", 16)) {
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_posint_defcapx(argv[cur_arg + 1], &write_var_range_ct)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --write-var-ranges parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
calculation_type |= CALC_WRITE_VAR_RANGES;
} else if (!memcmp(argptr2, "indow", 6)) {
if (!markername_snp) {
logerrprint("Error: --window must be used with --snp or --exclude-snp.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (scan_doublex(argv[cur_arg + 1], &dxx) || (dxx < 0)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --window parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
dxx *= 500;
if (dxx > 2147483646) {
snp_window_size = 0x7ffffffe;
} else {
snp_window_size = (int32_t)(dxx * (1 + SMALL_EPSILON));
}
// no need to set filter_flags due to --snp/--exclude-snp req.
} else if (!memcmp(argptr2, "ithin", 6)) {
if (loop_assoc_fname) {
logerrprint("Error: --within cannot be used with --loop-assoc.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (misc_flags & MISC_FAMILY_CLUSTERS) {
logerrprint("Error: --within cannot be used with --family.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((calculation_type & CALC_FREQ) && (misc_flags & MISC_FREQ_COUNTS)) {
logerrprint("Error: --within cannot be used with \"--freq counts\".\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
uii = 1;
if (param_ct == 2) {
if ((strlen(argv[cur_arg + 1]) == 7) && (!memcmp(argv[cur_arg + 1], "keep-", 5)) && match_upper(&(argv[cur_arg + 1][5]), "NA")) {
uii = 2;
} else if ((strlen(argv[cur_arg + 2]) != 7) || memcmp(argv[cur_arg + 2], "keep-", 5) || (!match_upper(&(argv[cur_arg + 2][5]), "NA"))) {
logerrprint("Error: Invalid --within parameter sequence.\n");
goto main_ret_INVALID_CMDLINE_A;
}
misc_flags |= MISC_LOAD_CLUSTER_KEEP_NA;
}
retval = alloc_fname(&cluster.fname, argv[cur_arg + uii], argptr, 0);
if (retval) {
goto main_ret_1;
}
filter_flags |= FILTER_FAM_REQ;
} else if (!memcmp(argptr2, "ith-phenotype", 14)) {
if (!covar_fname) {
logerrprint("Error: --with-phenotype cannot be used without --covar.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 2)) {
goto main_ret_INVALID_CMDLINE_2A;
}
for (uii = 1; uii <= param_ct; uii++) {
if (!strcmp(argv[cur_arg + uii], "no-parents")) {
write_covar_modifier |= WRITE_COVAR_NO_PARENTS;
} else if (!strcmp(argv[cur_arg + uii], "no-sex")) {
if (write_covar_modifier & WRITE_COVAR_FEMALE_2) {
logerrprint("Error: --with-phenotype 'female-2' modifier cannot be used with 'no-sex'.\n");
goto main_ret_INVALID_CMDLINE_A;
}
write_covar_modifier |= WRITE_COVAR_NO_SEX;
} else if (!strcmp(argv[cur_arg + uii], "female-2")) {
if (write_covar_modifier & WRITE_COVAR_NO_SEX) {
logerrprint("Error: --with-phenotype 'female-2' modifier cannot be used with 'no-sex'.\n");
goto main_ret_INVALID_CMDLINE_A;
}
write_covar_modifier |= WRITE_COVAR_FEMALE_2;
} else {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --with-phenotype parameter '%s'.\n", argv[cur_arg + uii]);
goto main_ret_INVALID_CMDLINE_WWA;
}
}
write_covar_modifier |= WRITE_COVAR_PHENO;
} else if (!memcmp(argptr2, "ith-reference", 14)) {
if ((recode_modifier & RECODE_TYPEMASK) != RECODE_LGEN) {
logerrprint("Error: --with-reference must be used with --recode lgen.\n");
goto main_ret_INVALID_CMDLINE;
}
logprint("Note: --with-reference flag deprecated. Use \"--recode lgen-ref\" instead.\n");
recode_modifier += RECODE_LGEN_REF - RECODE_LGEN;
goto main_param_zero;
} else if (!memcmp(argptr2, "rite-covar", 11)) {
if (calculation_type & (CALC_MAKE_BED | CALC_MAKE_FAM | CALC_RECODE)) {
logerrprint("Error: --write-covar cannot be used with --make-bed/--make-just-fam/--recode.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (!covar_fname) {
logerrprint("Error: --write-covar cannot be used without --covar.\n");
goto main_ret_INVALID_CMDLINE_A;
}
calculation_type |= CALC_WRITE_COVAR;
goto main_param_zero;
} else if (!memcmp(argptr2, "rite-cluster", 13)) {
if ((!cluster.fname) && (!(misc_flags & MISC_FAMILY_CLUSTERS))) {
logerrprint("Error: --write-cluster must be used with --within/--family.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 0, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if (param_ct) {
if (strcmp(argv[cur_arg + 1], "omit-unassigned")) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --write-cluster parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
misc_flags |= MISC_WRITE_CLUSTER_OMIT_UNASSIGNED;
}
calculation_type |= CALC_WRITE_CLUSTER;
} else if (!memcmp(argptr2, "rite-set", 9)) {
if (!set_info.fname) {
logerrprint("Error: --write-set must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE_A;
}
calculation_type |= CALC_WRITE_SET;
set_info.modifier |= SET_WRITE_LIST;
goto main_param_zero;
} else if (!memcmp(argptr2, "rite-set-r2", 11)) {
if (!set_info.fname) {
logerrprint("Error: --write-set-r2 must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE_A;
}
set_info.modifier |= SET_R2_WRITE;
logprint("Note: --write-set-r2 flag deprecated. Use \"--set-r2 write\".\n");
goto main_param_zero;
} else if (!memcmp(argptr2, "ith-freqs", 10)) {
if (!(calculation_type & CALC_LD)) {
logerrprint("Error: --with-freqs must be used with --r/--r2.\n");
goto main_ret_INVALID_CMDLINE_A;
}
ld_info.modifier |= LD_WITH_FREQS;
if (ld_info.modifier & (LD_MATRIX_SHAPEMASK | LD_MATRIX_BIN | LD_MATRIX_BIN4 | LD_MATRIX_SPACES)) {
goto main_r2_matrix_conflict;
}
logprint("Note: --with-freqs flag deprecated. Use e.g. \"--r2 with-freqs\".\n");
goto main_param_zero;
} else if (!memcmp(argptr2, "rite-dosage", 12)) {
if (!(dosage_info.modifier & DOSAGE_GLM)) {
if (dosage_info.modifier & DOSAGE_OCCUR) {
logerrprint("Error: --write-dosage cannot be used with \"--dosage occur\".\n");
} else if (dosage_info.modifier & DOSAGE_SCORE) {
logerrprint("Error: --write-dosage cannot be used with --score.\n");
} else {
logerrprint("Error: --write-dosage must be used with --dosage.\n");
}
goto main_ret_INVALID_CMDLINE_A;
} else if ((glm_modifier & GLM_STANDARD_BETA) || (dosage_info.modifier & DOSAGE_SEX)) {
logerrprint("Error: --write-dosage cannot be used with --dosage association analysis flags.\n");
goto main_ret_INVALID_CMDLINE_A;
}
dosage_info.modifier += (DOSAGE_WRITE - DOSAGE_GLM);
goto main_param_zero;
} else if (!memcmp(argptr2, "hap", 4)) {
goto main_hap_disabled_message;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'x':
if (!memcmp(argptr2, "chr-model", 10)) {
if (!(calculation_type & CALC_GLM)) {
logerrprint("Error: --xchr-model must be used with --linear or --logistic.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (glm_modifier & (GLM_GENOTYPIC | GLM_HETHOM | GLM_DOMINANT | GLM_RECESSIVE)) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --xchr-model cannot be used with --%s %s.\n", (glm_modifier & GLM_LOGISTIC)? "logistic" : "linear", (glm_modifier & GLM_GENOTYPIC)? "genotypic" : ((glm_modifier & GLM_HETHOM)? "hethom" : ((glm_modifier & GLM_DOMINANT)? "dominant" : "recessive")));
goto main_ret_INVALID_CMDLINE_2A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
if ((argv[cur_arg + 1][1] != '\0') || (argv[cur_arg + 1][0] < '0') || (argv[cur_arg + 1][0] > '3')) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Invalid --xchr-model parameter '%s'.\n", argv[cur_arg + 1]);
goto main_ret_INVALID_CMDLINE_WWA;
}
glm_xchr_model = (uint32_t)(argv[cur_arg + 1][0] - '0');
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
case 'z':
if (!memcmp(argptr2, "ero-cluster", 12)) {
if ((!cluster.fname) && (!(misc_flags & MISC_FAMILY_CLUSTERS))) {
logerrprint("Error: --zero-cluster must be used with --within/--family.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((calculation_type != CALC_MAKE_BED) || (geno_thresh != 1.0) || (mind_thresh != 1.0) || (hwe_thresh != 0.0) || (min_maf != 0.0) || (max_maf != 0.5)) {
// prevent old pipelines from silently breaking
logerrprint("Error: --zero-cluster must now be used with --make-bed, no other output\ncommands, and no genotype-based filters.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (enforce_param_ct_range(param_ct, argv[cur_arg], 1, 1)) {
goto main_ret_INVALID_CMDLINE_2A;
}
// bugfix (9 Apr 2018): had wrong array index
retval = alloc_fname(&cluster.zerofname, argv[cur_arg + 1], argptr, 0);
if (retval) {
goto main_ret_1;
}
} else if (!memcmp(argptr2, "ero-cms", 8)) {
filter_flags |= FILTER_BIM_REQ | FILTER_ZERO_CMS | FILTER_NODOSAGE | FILTER_NOCNV;
goto main_param_zero;
} else {
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
}
break;
default:
goto main_ret_INVALID_CMDLINE_UNRECOGNIZED;
main_param_zero:
if (param_ct) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --%s doesn't accept parameters.\n", argptr);
goto main_ret_INVALID_CMDLINE_2A;
}
}
} while ((++cur_flag) < flag_ct);
if (!outname_end) {
outname_end = &(outname[5]);
}
// command-line restrictions which don't play well with alphabetical order
if (load_rare) {
if (load_rare & (LOAD_RARE_GRM | LOAD_RARE_GRM_BIN)) {
if ((!(calculation_type & (CALC_REL_CUTOFF | CALC_UNRELATED_HERITABILITY))) || (calculation_type & (~(CALC_REL_CUTOFF | CALC_RELATIONSHIP | CALC_UNRELATED_HERITABILITY)))) {
if (load_rare == LOAD_RARE_GRM) {
logerrprint("Error: --grm-gz currently must be used with --rel-cutoff (possibly combined\nwith --make-grm-gz/--make-grm-bin) or --unrelated-heritability.\n");
} else {
logerrprint("Error: --grm-bin currently must be used with --rel-cutoff (possibly combined\nwith --make-grm-gz/--make-grm-bin) or --unrelated-heritability.\n");
}
goto main_ret_INVALID_CMDLINE_A;
}
}
if (!mperm_val) {
if ((cnv_calc_type & CNV_SAMPLE_PERM) && (!cnv_sample_mperms)) {
logerrprint("Error: --cnv-indiv-perm requires a permutation count.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((cnv_calc_type & CNV_TEST_REGION) && (!cnv_test_region_mperms)) {
logerrprint("Error: --cnv-test-region requires a permutation count.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
} else if ((load_params & LOAD_PARAMS_BFILE_ALL) && (load_params != LOAD_PARAMS_BFILE_ALL)) {
if ((calculation_type & (~(CALC_ONLY_BIM | CALC_ONLY_FAM))) || (filter_flags & FILTER_ALL_REQ)) {
logerrprint("Error: A full .bed + .bim + .fam fileset is required for this.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((!mapname[0]) && ((calculation_type & (~CALC_ONLY_FAM)) || (filter_flags & FILTER_BIM_REQ))) {
logerrprint("Error: A .bim file is required for this.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((!famname[0]) && ((calculation_type & (~CALC_ONLY_BIM)) || (filter_flags & FILTER_FAM_REQ))) {
logerrprint("Error: A .fam file is required for this.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
if (sample_sort && (calculation_type & (~(CALC_MERGE | CALC_MAKE_BED)))) {
logerrprint("Error: --indiv-sort only affects --make-bed and --merge/--bmerge/--merge-list.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((cnv_intersect_filter_type & CNV_COUNT) && (!(cnv_calc_type & (CNV_SAMPLE_PERM | CNV_ENRICHMENT_TEST)))) {
logerrprint("Error: --cnv-count must be used with --cnv-indiv-perm or --cnv-enrichment-test.\n");
goto main_ret_INVALID_CMDLINE;
}
if (!phenoname) {
if ((filter_flags & FILTER_PRUNE) && (!(fam_cols & FAM_COL_6))) {
logerrprint("Error: --prune and --no-pheno cannot coexist without an alternate phenotype\nfile.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (pheno_modifier & PHENO_ALL) {
logerrprint("Error: --all-pheno must be used with --pheno.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else if (read_dists_fname && (!(calculation_type & (CALC_CLUSTER | CALC_IBS_TEST | CALC_GROUPDIST | CALC_NEIGHBOR | CALC_REGRESS_DISTANCE)))) {
logerrprint("Error: --read-dists cannot be used without --cluster, --ibs-test/--groupdist,\n--neighbour, or --regress-distance.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((cluster.ppc != 0.0) && (!read_genome_fname) && (calculation_type & (CALC_DISTANCE))) {
logerrprint("Error: --ppc cannot be used with --distance without --read-genome.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((calculation_type & (CALC_CLUSTER | CALC_NEIGHBOR)) && (((calculation_type & CALC_DISTANCE) && (dist_calc_type & (DISTANCE_1_MINUS_IBS | DISTANCE_ALCT))) || (calculation_type & CALC_PLINK1_DISTANCE_MATRIX)) && (!(calculation_type & CALC_GENOME))) {
// actually allow this for now if --genome present, since it auto-clobbers
// the wrong-unit distance matrix
logerrprint("Error: --cluster and --neighbour cannot be used with non-IBS distance matrix\ncalculations.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (matrix_flag_state == 1) {
calculation_type |= CALC_PLINK1_IBS_MATRIX;
}
if (calculation_type & CALC_PLINK1_IBS_MATRIX) {
if (distance_wts_fname || (distance_exp != 0.0)) {
logerrprint("Error: --ibs-matrix cannot be used with --distance-wts.\n");
goto main_ret_INVALID_CMDLINE;
}
if (dist_calc_type & DISTANCE_IBS) {
logerrprint("Error: --ibs-matrix cannot be used with \"--distance ibs\".\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (read_genome_fname && (cluster.ppc == 0.0)) {
logerrprint("Error: --read-genome is pointless with --ibs-matrix unless --ppc is also\npresent.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (read_dists_fname) {
logerrprint("Error: --read-dists cannot be used with a distance matrix calculation.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (parallel_tot > 1) {
logerrprint("Error: --parallel and --ibs-matrix cannot be used together. Use --distance\ninstead.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
if (distance_wts_fname && (!(calculation_type & (CALC_DISTANCE | CALC_RELATIONSHIP)))) {
logerrprint("Error: --distance-wts must be used with --distance, --make-rel, --make-grm-bin,\nor --make-grm-gz.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((parallel_tot > 1) && (!(calculation_type & (CALC_LD | CALC_DISTANCE | CALC_GENOME | CALC_RELATIONSHIP)))) {
if ((!(calculation_type & CALC_EPI)) || (!(epi_info.modifier & (EPI_FAST | EPI_REG)))) {
logerrprint("Error: --parallel only affects --r/--r2, --distance, --genome, --make-rel,\n--make-grm-gz/--make-grm-bin, and --epistasis/--fast-epistasis.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
if (update_map_modifier) {
snprintf(g_logbuf, LOGBUFLEN, "Error: Deprecated parameter-free --update-%s cannot be used without\n--update-map.\n", (update_map_modifier == 1)? "chr" : "cm");
goto main_ret_INVALID_CMDLINE_2A;
}
if (((misc_flags & (MISC_FILL_MISSING_A2 | MISC_MERGEX | MISC_SET_ME_MISSING)) || splitx_bound2 || update_chr) && (((load_rare == LOAD_RARE_CNV) && (cnv_calc_type != CNV_WRITE)) || ((load_rare != LOAD_RARE_CNV) && (calculation_type != CALC_MAKE_BED)))) {
snprintf(g_logbuf, LOGBUFLEN, "Error: --merge-x/--split-x/--update-chr/--set-me-missing/--fill-missing-a2\nmust be used with --%s and no other commands.\n", (load_rare == LOAD_RARE_CNV)? "cnv-write" : "make-bed");
goto main_ret_INVALID_CMDLINE_2A;
}
if (load_rare == LOAD_RARE_CNV) {
if (filter_flags & FILTER_NOCNV) {
logerrprint("Error: .cnv fileset specified with incompatible filtering flag(s). (Check if\nthere is a --cnv-... flag with the functionality you're looking for.)\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else if (load_rare == LOAD_RARE_DOSAGE) {
if (filter_flags & FILTER_NODOSAGE) {
logerrprint("Error: --dosage used with incompatible filtering flag(s).\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((!mapname[0]) && (filter_flags & FILTER_DOSAGEMAP)) {
logerrprint("Error: --dosage cannot be used with variant filters unless a .map file is\nspecified.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (!famname[0]) {
logerrprint("Error: --dosage must be used with --fam.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
if ((family_info.mendel_modifier & MENDEL_DUOS) && (!(calculation_type & CALC_MENDEL)) && (!(family_info.mendel_modifier & MENDEL_FILTER)) && (!(misc_flags & MISC_SET_ME_MISSING))) {
logerrprint("Error: --mendel-duos must be used with --me/--mendel/--set-me-missing.\n");
goto main_ret_INVALID_CMDLINE;
} else if ((family_info.mendel_modifier & MENDEL_MULTIGEN) && (!(calculation_type & (CALC_MENDEL | CALC_TDT | CALC_DFAM | CALC_QFAM))) && (!(family_info.mendel_modifier & MENDEL_FILTER)) && (!(misc_flags & MISC_SET_ME_MISSING))) {
logerrprint("Error: --mendel-multigen must be used with --me, --mendel, --set-me-missing, or\nan association test which checks for Mendel errors.\n");
goto main_ret_INVALID_CMDLINE;
}
if (flip_subset_fname && (load_rare || (calculation_type != CALC_MAKE_BED) || (min_maf != 0.0) || (max_maf != 0.5) || (hwe_thresh != 0.0))) {
logerrprint("Error: --flip-subset must be used with --flip, --make-bed, and no other\ncommands or MAF-based filters.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (calculation_type & CALC_RECODE) {
if (recode_modifier & RECODE_23) {
if (chrom_info.species != SPECIES_HUMAN) {
logerrprint("Error: --recode 23 can only be used on human data.\n");
goto main_ret_INVALID_CMDLINE;
}
if ((recode_modifier & RECODE_23) && (misc_flags & MISC_ALLOW_EXTRA_CHROMS) && (!chrom_info.zero_extra_chroms)) {
logerrprint("Error: --allow-extra-chr requires the '0' modifier when used with --recode 23.\n");
goto main_ret_INVALID_CMDLINE;
} else if ((recode_modifier & RECODE_BEAGLE) && chrom_info.zero_extra_chroms) {
logerrprint("Error: --allow-extra-chr cannot have the '0' modifier when used with\n--recode beagle.\n");
goto main_ret_INVALID_CMDLINE;
}
} else if ((recode_modifier & RECODE_BIMBAM) && (misc_flags & MISC_ALLOW_EXTRA_CHROMS) && (!chrom_info.zero_extra_chroms)) {
logerrprint("Error: --allow-extra-chr requires the '0' modifier when used with\n--recode bimbam.\n");
goto main_ret_INVALID_CMDLINE;
}
}
if (sex_missing_pheno & MUST_HAVE_SEX) {
if (load_rare & LOAD_RARE_CNV) {
if (!(cnv_calc_type & CNV_WRITE)) {
logerrprint("Error: --must-have-sex must be used with --cnv-write.\n");
goto main_ret_INVALID_CMDLINE;
}
} else {
if (!(calculation_type & (CALC_WRITE_COVAR | CALC_MAKE_BED | CALC_MAKE_FAM | CALC_RECODE))) {
logerrprint("Error: --must-have-sex must be used with --make-bed, --make-just-fam, --recode,\nor --write-covar.\n");
goto main_ret_INVALID_CMDLINE;
}
}
}
if (misc_flags & MISC_IMPUTE_SEX) {
if (!(calculation_type & (CALC_WRITE_COVAR | CALC_MAKE_BED | CALC_RECODE))) {
logerrprint("Error: --impute-sex must be used with --make-bed/--recode/--write-covar.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (calculation_type & (~(CALC_WRITE_COVAR | CALC_MAKE_BED | CALC_RECODE | CALC_SEXCHECK))) {
logerrprint("Error: --impute-sex cannot be used with any commands other than\n--make-bed/--recode/--write-covar.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
if (cluster.qmatch_fname && (!cluster.qt_fname)) {
logerrprint("Error: --qt must be used with --qmatch.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (mwithin_col && (!loop_assoc_fname) && (!cluster.fname)) {
logerrprint("Error: --mwithin must be used with --within/--loop-assoc.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((!cluster.fname) && (!(misc_flags & MISC_FAMILY_CLUSTERS))) {
if (cluster.keep_fname) {
logerrprint("Error: --keep-clusters must be used with --within/--family.\n");
goto main_ret_INVALID_CMDLINE;
} else if (cluster.keep_flattened) {
logerrprint("Error: --keep-cluster-names must be used with --within/--family.\n");
goto main_ret_INVALID_CMDLINE;
} else if (cluster.remove_fname) {
logerrprint("Error: --remove-clusters must be used with --within/--family.\n");
goto main_ret_INVALID_CMDLINE;
} else if (cluster.remove_flattened) {
logerrprint("Error: --remove-cluster-names must be used with --within/--family.\n");
goto main_ret_INVALID_CMDLINE;
} else if (rel_info.pca_cluster_names_flattened) {
logerrprint("Error: --pca-cluster-names must be used with --within/--family.\n");
goto main_ret_INVALID_CMDLINE;
} else if (rel_info.pca_clusters_fname) {
logerrprint("Error: --pca-clusters must be used with --within/--family.\n");
goto main_ret_INVALID_CMDLINE;
} else if (calculation_type & CALC_CMH) {
logerrprint("Error: --mh/--bd/--mh2 must be used with --within/--family.\n");
goto main_ret_INVALID_CMDLINE;
} else if (calculation_type & CALC_HOMOG) {
logerrprint("Error: --homog must be used with --within/--family.\n");
goto main_ret_INVALID_CMDLINE;
} else if ((calculation_type & CALC_FST) && (!(misc_flags & MISC_FST_CC))) {
logerrprint("Error: --fst should be used with --within, unless the 'case-control' modifier\nis specified.\n");
goto main_ret_INVALID_CMDLINE;
}
}
if (!set_info.fname) {
if (set_info.modifier) {
if (set_info.modifier & SET_COMPLEMENTS) {
if (set_info.merged_set_name) {
logerrprint("Error: --make-set-complement-all must be used with --set/--make-set.\n");
} else {
logerrprint("Error: --complement-sets must be used with --set/--make-set.\n");
}
} else { // only remaining possibility for now
logerrprint("Error: --gene-all must be used with --set/--make-set.\n");
}
goto main_ret_INVALID_CMDLINE;
} else if (set_info.genekeep_flattened) {
logerrprint("Error: --gene must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE;
} else if (model_modifier & MODEL_SET_TEST) {
logerrprint("Error: --assoc/--model set-test must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE;
} else if (glm_modifier & GLM_SET_TEST) {
logerrprint("Error: --linear/--logistic set-test must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE;
} else if (family_info.tdt_modifier & TDT_SET_TEST) {
logerrprint("Error: --tdt set-test must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE;
} else if (cluster.modifier & CLUSTER_CMH_SET_TEST) {
logerrprint("Error: --mh/--bd set-test must be used with --set/--make-set.\n");
goto main_ret_INVALID_CMDLINE;
}
} else {
uii = 0;
if (model_modifier & MODEL_SET_TEST) {
if ((!(model_modifier & MODEL_PERM)) && (!model_mperm_val)) {
logerrprint("Error: --assoc/--model set-test requires permutation.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (model_modifier & MODEL_FISHER) {
logerrprint("Error: --assoc/--model set-test cannot be used with Fisher's exact test.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (model_modifier & MODEL_PGEN) {
logerrprint("Error: --model set-test cannot be used with 2df genotypic chi-square stats.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (model_modifier & MODEL_LIN) {
logerrprint("Error: --assoc set-test does not currently support the Lin statistic; contact\nthe developers if you need this combination.\n");
goto main_ret_INVALID_CMDLINE_A;
}
uii = 1;
}
if (glm_modifier & GLM_SET_TEST) {
if ((!(glm_modifier & GLM_PERM)) && (!glm_mperm_val)) {
logerrprint("Error: --linear/--logistic set-test requires permutation.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if ((glm_modifier & (GLM_GENOTYPIC | GLM_HETHOM | GLM_TEST_ALL)) || tests_range_list.name_ct) {
logerrprint("Error: --linear/--logistic set-test cannot be used with joint tests.\n");
goto main_ret_INVALID_CMDLINE_A;
}
uii = 1;
}
if (family_info.tdt_modifier & TDT_SET_TEST) {
if (!(family_info.tdt_modifier & (TDT_PERM | TDT_MPERM))) {
logerrprint("Error: --tdt set-test requires permutation.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logerrprint("Error: --tdt set-test is currently under development.\n");
retval = RET_CALC_NOT_YET_SUPPORTED;
goto main_ret_1;
uii = 1;
}
if (family_info.dfam_modifier & DFAM_SET_TEST) {
if (!(family_info.dfam_modifier & (DFAM_PERM | DFAM_MPERM))) {
logerrprint("Error: --dfam set-test requires permutation.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logerrprint("Error: --dfam set-test is currently under development.\n");
retval = RET_CALC_NOT_YET_SUPPORTED;
goto main_ret_1;
uii = 1;
}
if (cluster.modifier & CLUSTER_CMH_SET_TEST) {
if (!(cluster.modifier & (CLUSTER_CMH_PERM | CLUSTER_CMH_MPERM))) {
logerrprint("Error: --mh/--bd set-test requires permutation.\n");
goto main_ret_INVALID_CMDLINE_A;
}
logerrprint("Error: --mh/--bd set-test is currently under development.\n");
retval = RET_CALC_NOT_YET_SUPPORTED;
goto main_ret_1;
uii = 1;
}
if (mtest_adjust & ADJUST_LAMBDA) {
if (set_info.set_test_lambda == 0.0) {
// backward compatibility: --lambda and --set-test-lambda weren't
// distinct in 1.07
logprint("Note: set test + --lambda is deprecated. Use --set-test-lambda instead.\n");
set_info.set_test_lambda = adjust_lambda;
if (!(mtest_adjust & 1)) {
mtest_adjust = 0;
adjust_lambda = 0.0;
}
} else {
logprint("Note: Set test --adjust ignores --lambda.\n");
}
}
}
if ((family_info.tdt_modifier & (TDT_POO | TDT_PARENPERM1 | TDT_PARENPERM2 | TDT_POOPERM_PAT | TDT_POOPERM_MAT)) && (!(calculation_type & CALC_TDT))) {
logerrprint("Error: --poo/--parentdt1/--parentdt2/--pat/--mat must be used with --tdt.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (calculation_type & CALC_FLIPSCAN) {
if (ld_info.flipscan_window_size == 0xffffffffU) {
if (ld_info.window_size != 0xffffffffU) {
logprint("Note: --ld-window + --flip-scan combination deprecated. Use --flip-scan-window\nwith --flip-scan instead.\n");
ld_info.flipscan_window_size = ld_info.window_size;
} else {
ld_info.flipscan_window_size = 10;
}
}
if (ld_info.flipscan_window_bp == 0xffffffffU) {
if (ld_info.window_bp != 0xffffffffU) {
logprint("Note: --ld-window-kb + --flip-scan combination deprecated. Use\n--flip-scan-window-kb with --flip-scan instead.\n");
ld_info.flipscan_window_bp = ld_info.window_bp;
} else {
ld_info.flipscan_window_bp = 1000000;
}
}
}
if (calculation_type & CALC_BLOCKS) {
if (ld_info.blocks_recomb_highci > ld_info.blocks_strong_highci) {
logerrprint("Error: --blocks-recomb-highci value cannot be larger than\n--blocks-strong-highci value.\n");
goto main_ret_INVALID_CMDLINE;
}
if (ld_info.blocks_max_bp == 0xffffffffU) {
if (ld_info.window_bp != 0xffffffffU) {
logprint("Note: --ld-window-kb + --blocks combination deprecated. Use --blocks-max-kb\nwith --blocks instead.\n");
ld_info.blocks_max_bp = ld_info.window_bp;
} else {
ld_info.blocks_max_bp = 200000;
}
}
}
if ((!(calculation_type & CALC_LD)) || ((calculation_type & CALC_LD) && (ld_info.modifier & (LD_MATRIX_SHAPEMASK | LD_INTER_CHR)))) {
if ((ld_info.snpstr || ld_info.snps_rl.name_ct) && (!(ld_info.modifier & LD_INTER_CHR))) {
if (calculation_type & CALC_LD) {
logerrprint("Error: --ld-snp/--ld-snps/--ld-snp-list cannot be used with the --r/--r2 matrix\noutput modifiers.\n");
} else {
logerrprint("Error: --ld-snp/--ld-snps/--ld-snp-list must be used with --r/--r2.\n");
}
goto main_ret_INVALID_CMDLINE_A;
} else if (ld_info.window_size != 0xffffffffU) {
if (calculation_type & CALC_LD) {
logerrprint("Error: --ld-window flag cannot be used with the --r/--r2 'inter-chr' or matrix\noutput modifiers.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (!(calculation_type & (CALC_BLOCKS | CALC_FLIPSCAN))) {
logerrprint("Error: --ld-window flag must be used with --r/--r2.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else if (ld_info.window_bp != 0xffffffffU) {
if (calculation_type & CALC_LD) {
logerrprint("Error: --ld-window-kb flag cannot be used with the --r/--r2 'inter-chr' or\nmatrix output modifiers.\n");
goto main_ret_INVALID_CMDLINE_A;
} else if (!(calculation_type & CALC_BLOCKS)) {
logerrprint("Error: --ld-window-kb flag must be used with --r/--r2.\n");
goto main_ret_INVALID_CMDLINE_A;
}
} else if ((ld_info.window_r2 != 0.2) && (!(ld_info.modifier & LD_INTER_CHR))) {
if (calculation_type & CALC_LD) {
// error-message logic incorrectly distinguished between --r and --r2
// before 9 Oct 2023
logerrprint("Error: --ld-window-r2 flag cannot be used with the --r/--r2 matrix output\nmodifiers.\n");
goto main_ret_INVALID_CMDLINE_A;
} else {
logerrprint("Error: --ld-window-r2 flag must be used with --r/--r2.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
} else {
if (ld_info.window_size == 0xffffffffU) {
ld_info.window_size = 10;
}
if (ld_info.window_bp == 0xffffffffU) {
ld_info.window_bp = 1000000;
}
}
if ((ld_info.modifier & LD_DPRIME) && (!(calculation_type & CALC_LD))) {
logerrprint("Error: --D/--dprime must be used with --r/--r2.\n");
goto main_ret_INVALID_CMDLINE_A;
}
// --from-bp/-kb/-mb without any --to/--to-bp/...: include to end of
// chromosome
if ((marker_pos_start != -1) && (!markername_to) && (marker_pos_end == -1)) {
marker_pos_end = 0x7ffffffe;
}
if (!chrom_flag_present) {
init_default_chrom_mask(&chrom_info);
}
if (((marker_pos_start != -1) && (!markername_to)) || ((marker_pos_end != -1) && (!markername_from))) {
// require exactly one chromosome to be defined given --from-bp/--to-bp
// without --from/--to
uii = next_set(chrom_info.chrom_mask, 0, CHROM_MASK_INITIAL_WORDS * BITCT);
if (uii == CHROM_MASK_INITIAL_WORDS * BITCT) {
uii = 0;
} else {
uii = next_set(chrom_info.chrom_mask, uii + 1, CHROM_MASK_INITIAL_WORDS * BITCT);
}
if (((uii == CHROM_MASK_INITIAL_WORDS * BITCT) && chrom_info.incl_excl_name_stack) || ((uii != CHROM_MASK_INITIAL_WORDS * BITCT) && (uii || (!chrom_info.incl_excl_name_stack) || chrom_info.incl_excl_name_stack->next))) {
logerrprint("Error: --from-bp/-kb/-mb and --to-bp/-kb/-mb require a single chromosome to be\nidentified (either explicitly with --chr, or implicitly with --from/--to).\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
if (mperm_save) {
uii = 0;
if ((calculation_type & CALC_MODEL) && ((model_modifier & (MODEL_MPERM | MODEL_SET_TEST)) == MODEL_MPERM)) {
uii++;
}
if ((calculation_type & CALC_GLM) && ((glm_modifier & (GLM_MPERM | GLM_SET_TEST)) == GLM_MPERM)) {
uii++;
}
if ((calculation_type & CALC_TESTMISS) && (testmiss_modifier & TESTMISS_MPERM)) {
uii++;
}
if ((calculation_type & CALC_TDT) && ((family_info.tdt_modifier & (TDT_MPERM | TDT_SET_TEST)) == TDT_MPERM)) {
uii++;
}
if ((calculation_type & CALC_DFAM) && ((family_info.dfam_modifier & (DFAM_MPERM | DFAM_SET_TEST)) == DFAM_MPERM)) {
uii++;
}
// no qfam since that's a nonstandard permutation test
if ((calculation_type & CALC_CMH) && ((cluster.modifier & (CLUSTER_CMH_MPERM | CLUSTER_CMH_SET_TEST)) == CLUSTER_CMH_MPERM)) {
uii++;
}
if (uii != 1) {
// prevent one permutation test's values from clobbering another's
logerrprint("Error: --mperm-save{-all} must be used with exactly one max(T) permutation\ntest.\n");
goto main_ret_INVALID_CMDLINE;
}
}
if (calculation_type & CALC_MODEL) {
if (!(model_modifier & (MODEL_ASSOC | MODEL_PDOM | MODEL_PREC | MODEL_PTREND))) {
if (mtest_adjust && (!(model_modifier & MODEL_SET_TEST))) {
// this is actually okay with the set test
logerrprint("Error: In order to use --model with --adjust, you must include the 'trend',\n'trend-only', 'dom', or 'rec' modifier.\n");
goto main_ret_INVALID_CMDLINE;
}
}
if (model_cell_ct == -1) {
model_cell_ct = (model_modifier & MODEL_FISHER)? 0 : 5;
}
if ((model_modifier & (MODEL_PERM | MODEL_MPERM | MODEL_GENEDROP)) == MODEL_GENEDROP) {
model_modifier |= MODEL_PERM;
}
}
if (aperm_present && (calculation_type & (CALC_MODEL | CALC_GLM | CALC_TESTMISS | CALC_TDT | CALC_DFAM | CALC_QFAM | CALC_CMH)) &&
(!(model_modifier & MODEL_PERM)) &&
(!(glm_modifier & GLM_PERM)) &&
(!(testmiss_modifier & TESTMISS_PERM)) &&
(!(family_info.tdt_modifier & TDT_PERM)) &&
(!(family_info.dfam_modifier & DFAM_PERM)) &&
(!(family_info.qfam_modifier & QFAM_PERM)) &&
(!(cluster.modifier & (CLUSTER_CMH_PERM | CLUSTER_CMH_PERM_BD)))) {
// If --aperm is present, at least one association analysis command which
// supports adaptive permutation testing was also specified, but no actual
// adaptive permutation test is happening, the user is likely to be
// confused. Produce a warning. (Not an error since a sophisticated user
// may want to use --script with different --aperm defaults.)
logerrprint("Warning: --aperm only controls the settings for adaptive permutation tests; it\ndoes not cause such a test to be performed. (Did you forget to add the 'perm'\nmodifier to an association analysis flag?)\n");
}
if ((mtest_adjust & (ADJUST_LAMBDA + 1)) == ADJUST_LAMBDA) {
logerrprint("Error: --lambda must be used with --adjust.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((homozyg.modifier & (HOMOZYG_GROUP | HOMOZYG_GROUP_VERBOSE)) && (!(calculation_type & CALC_HOMOZYG))) {
if (homozyg.overlap_min == 0.95) {
logerrprint("Error: --homozyg-group must be used with another --homozyg... flag.\n");
} else {
logerrprint("Error: --homozyg-match must be used with another --homozyg... flag.\n");
}
goto main_ret_INVALID_CMDLINE_A;
}
if (score_info.data_fname) {
if (!score_info.range_fname) {
logerrprint("Error: --q-score-file cannot be used without --q-score-range.\n");
goto main_ret_INVALID_CMDLINE;
} else if (!(calculation_type & CALC_SCORE)) {
logerrprint("Error: --q-score-range must be used with --score.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
if (qual_max_thresh != DBL_MAX) {
if (!qual_filter) {
logerrprint("Error: --qual-max-threshold must be used with --qual-scores.\n");
goto main_ret_INVALID_CMDLINE;
} else if (qual_max_thresh < qual_min_thresh) {
logerrprint("Error: --qual-max-threshold value cannot be negative unless --qual-threshold is\nalso present.\n");
goto main_ret_INVALID_CMDLINE_A;
}
}
if (gene_report_border && (!gene_report_fname)) {
logerrprint("Error: --gene-list-border must be used with --gene-report.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((load_rare == LOAD_RARE_LGEN) && (!mapname[0])) {
logerrprint("Error: --lgen must be used with --lfile or --map.\n");
goto main_ret_INVALID_CMDLINE_A;
}
uii = load_params & LOAD_PARAMS_OX_ALL;
if ((uii == LOAD_PARAMS_OXGEN) || (uii == LOAD_PARAMS_OXBGEN)) {
logerrprint("Error: --gen/--bgen cannot be used without --data or --sample.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((load_rare & LOAD_RARE_TFAM) && (!(load_rare & (LOAD_RARE_TRANSPOSE | LOAD_RARE_TPED)))) {
logerrprint("Error: --tfam must be used with --tfile or --tped.\n");
goto main_ret_INVALID_CMDLINE_A;
}
if ((merge_type & MERGE_EQUAL_POS) && (!(calculation_type & CALC_MERGE))) {
logerrprint("Error: --merge-equal-pos must be used with --merge/--bmerge/--merge-list.\n(Note that you are permitted to merge a fileset with itself.)\n");
goto main_ret_INVALID_CMDLINE_A;
}
if (calculation_type && (!(calculation_type & (~(CALC_FREQ | CALC_MISSING_REPORT)))) && ((geno_thresh != 1.0) || (hwe_thresh != 0.0) || (min_maf != 0.0) || (max_maf != 0.5) || min_ac || (max_ac != 0x7fffffff))) {
logerrprint("Warning: --freq and --missing complete BEFORE --geno, --hwe, and --maf in\nplink's order of operations.\n");
}
// short batch job?
uii = 0;
if ((!calculation_type) && (!(load_rare & (LOAD_RARE_LGEN | LOAD_RARE_DUMMY | LOAD_RARE_SIMULATE | LOAD_RARE_TRANSPOSE_MASK | LOAD_RARE_23 | LOAD_RARE_CNV | LOAD_RARE_VCF | LOAD_RARE_BCF)))) {
if (epi_info.summary_merge_prefix || annot_info.fname || gene_report_fname || (load_rare == LOAD_RARE_DOSAGE) || metaanal_fnames) {
uii = 1;
} else if (famname[0] || load_rare) {
goto main_ret_NULL_CALC;
}
// otherwise, autoconversion job
}
if (!(load_params || load_rare || uii || (merge_type & MERGE_LIST))) {
logerrprint("Error: No input dataset.\n");
goto main_ret_INVALID_CMDLINE_A;
}
#ifdef USE_MKL
if (!mkl_native) {
mkl_cbwr_set(MKL_CBWR_COMPATIBLE);
}
#endif
free_cond(subst_argv);
free_cond(script_buf);
free_cond(rerun_buf);
free_cond(flag_buf);
free_cond(flag_map);
subst_argv = nullptr;
script_buf = nullptr;
rerun_buf = nullptr;
flag_buf = nullptr;
flag_map = nullptr;
if (!rseeds) {
ujj = (uint32_t)time(nullptr);
snprintf(g_logbuf, LOGBUFLEN, "Random number seed: %u\n", ujj);
logstr(g_logbuf);
sfmt_init_gen_rand(&g_sfmt, ujj);
} else {
if (rseed_ct == 1) {
sfmt_init_gen_rand(&g_sfmt, rseeds[0]);
} else {
sfmt_init_by_array(&g_sfmt, rseeds, rseed_ct);
}
free(rseeds);
rseeds = nullptr;
}
// guarantee contiguous malloc space outside of main workspace
bubble = (char*)malloc(NON_BIGSTACK_MIN * sizeof(char));
if (!bubble) {
goto main_ret_NOMEM;
}
// see e.g. http://nadeausoftware.com/articles/2012/09/c_c_tip_how_get_physical_memory_size_system .
#ifdef __APPLE__
mib[0] = CTL_HW;
mib[1] = HW_MEMSIZE;
llxx = 0;
sztmp = sizeof(int64_t);
sysctl(mib, 2, &llxx, &sztmp, nullptr, 0);
llxx /= 1048576;
#else
#ifdef _WIN32
memstatus.dwLength = sizeof(memstatus);
GlobalMemoryStatusEx(&memstatus);
llxx = memstatus.ullTotalPhys / 1048576;
#else
llxx = ((uint64_t)sysconf(_SC_PHYS_PAGES)) * ((size_t)sysconf(_SC_PAGESIZE)) / 1048576;
#endif
#endif
if (!llxx) {
default_alloc_mb = BIGSTACK_DEFAULT_MB;
} else if (llxx < (BIGSTACK_MIN_MB * 2)) {
default_alloc_mb = BIGSTACK_MIN_MB;
} else {
default_alloc_mb = llxx / 2;
}
if (!malloc_size_mb) {
malloc_size_mb = default_alloc_mb;
} else if (malloc_size_mb < BIGSTACK_MIN_MB) {
malloc_size_mb = BIGSTACK_MIN_MB;
}
#ifndef __LP64__
if (malloc_size_mb > 2047) {
malloc_size_mb = 2047;
}
#endif
if (llxx) {
snprintf(g_logbuf, LOGBUFLEN, "%" PRId64 " MB RAM detected; reserving %" PRIdPTR " MB for main workspace.\n", llxx, malloc_size_mb);
} else {
snprintf(g_logbuf, LOGBUFLEN, "Failed to calculate system memory. Attempting to reserve %" PRIdPTR " MB.\n", malloc_size_mb);
}
logprintb();
bigstack_ua = (unsigned char*)malloc(malloc_size_mb * 1048576 * sizeof(char));
while (!bigstack_ua) {
malloc_size_mb = (malloc_size_mb * 3) / 4;
if (malloc_size_mb < BIGSTACK_MIN_MB) {
malloc_size_mb = BIGSTACK_MIN_MB;
}
bigstack_ua = (unsigned char*)malloc(malloc_size_mb * 1048576 * sizeof(char));
if (bigstack_ua) {
LOGPRINTF("Allocated %" PRIdPTR " MB successfully, after larger attempt(s) failed.\n", malloc_size_mb);
} else if (malloc_size_mb == BIGSTACK_MIN_MB) {
goto main_ret_NOMEM;
}
}
// force 64-byte align to make cache line sensitivity work
bigstack_initial_base = (unsigned char*)round_up_pow2((uintptr_t)bigstack_ua, CACHELINE);
g_bigstack_base = bigstack_initial_base;
g_bigstack_end = &(bigstack_initial_base[(malloc_size_mb * 1048576 - (uintptr_t)(bigstack_initial_base - bigstack_ua)) & (~(CACHELINE - ONELU))]);
free(bubble);
bubble = nullptr;
// standalone stuff
if (epi_info.summary_merge_prefix) {
retval = epi_summary_merge(&epi_info, outname, outname_end);
if (retval) {
goto main_ret_1;
}
}
if (annot_info.fname) {
retval = annotate(&annot_info, (misc_flags / MISC_ALLOW_EXTRA_CHROMS) & 1, outname, outname_end, pfilter, &chrom_info);
}
if (gene_report_fname) {
retval = gene_report(gene_report_fname, gene_report_glist, gene_report_subset, gene_report_border, (misc_flags / MISC_ALLOW_EXTRA_CHROMS) & 1, (misc_flags & MISC_EXTRACT_RANGE)? nullptr : extractname, gene_report_snp_field, outname, outname_end, pfilter, &chrom_info);
if (retval) {
goto main_ret_1;
}
}
if (metaanal_fnames) {
// possible todo: make this support --aec (takes a bit of work since
// chromosome byte in data structure must be widened)
retval = meta_analysis(metaanal_fnames, metaanal_chrfield_search_order, metaanal_snpfield_search_order, metaanal_bpfield_search_order, metaanal_a1field_search_order, metaanal_a2field_search_order, metaanal_pfield_search_order, metaanal_sefield_search_order, metaanal_essfield_search_order, metaanal_flags, (misc_flags & MISC_EXTRACT_RANGE)? nullptr : extractname, outname, outname_end, output_min_p, &chrom_info);
if (retval) {
goto main_ret_1;
}
}
if (load_rare == LOAD_RARE_DOSAGE) {
if (calculation_type & (~CALC_SCORE)) {
// with --dosage, there *can't* be anything else to do
logerrprint("Error: --dosage cannot be used with other PLINK computations.\n");
goto main_ret_INVALID_CMDLINE;
}
pigz_init(g_thread_ct);
retval = plink1_dosage(&dosage_info, famname, mapname, outname, outname_end, phenoname, extractname, excludename, keepname, removename, keepfamname, removefamname, filtername, makepheno_str, phenoname_str, covar_fname, qual_filter, update_map, update_name, update_ids_fname, update_parents_fname, update_sex_fname, filtervals_flattened, filter_attrib_fname, filter_attrib_liststr, filter_attrib_sample_fname, filter_attrib_sample_liststr, qual_min_thresh, qual_max_thresh, thin_keep_prob, thin_keep_ct, min_bp_space, mfilter_col, fam_cols, missing_pheno, output_missing_pheno, mpheno_col, pheno_modifier, &chrom_info, tail_bottom, tail_top, misc_flags, filter_flags, sex_missing_pheno, update_sex_col, &cluster, marker_pos_start, marker_pos_end, snp_window_size, markername_from, markername_to, markername_snp, &snps_range_list, covar_modifier, &covar_range_list, mwithin_col, glm_modifier, glm_vif_thresh, output_min_p, known_procs, &score_info);
// unconditional; note that plink1_dosage() currently doesn't even bother
// to pop stuff off the stack when it's done
goto main_ret_1;
}
// quit if there's nothing else to do
if (uii) {
goto main_ret_1;
}
pigz_init(g_thread_ct);
if (load_rare & (LOAD_RARE_GRM | LOAD_RARE_GRM_BIN)) {
// --unrelated-heritability and --rel-cutoff batch mode special cases
#ifndef NOLAPACK
if (calculation_type & CALC_UNRELATED_HERITABILITY) {
retval = unrelated_herit_batch(load_rare & LOAD_RARE_GRM_BIN, pedname, phenoname, mpheno_col, phenoname_str, missing_pheno, &rel_info);
} else {
#endif
retval = rel_cutoff_batch(load_rare & LOAD_RARE_GRM_BIN, pedname, outname, outname_end, &rel_info);
#ifndef NOLAPACK
}
#endif
} else if (load_rare & LOAD_RARE_CNV) {
retval = plink_cnv(outname, outname_end, pedname, mapname, famname, phenoname, keepname, removename, filtername, misc_flags, update_chr, update_cm, update_map, update_name, update_ids_fname, update_parents_fname, update_sex_fname, filtervals_flattened, filter_flags, cnv_calc_type, cnv_min_seglen, cnv_max_seglen, cnv_min_score, cnv_max_score, cnv_min_sites, cnv_max_sites, cnv_intersect_filter_type, cnv_intersect_filter_fname, cnv_subset_fname, cnv_overlap_type, cnv_overlap_val, cnv_freq_type, cnv_freq_val, cnv_freq_val2, cnv_test_window, segment_modifier, segment_spanning_fname, cnv_sample_mperms, cnv_test_mperms, cnv_test_region_mperms, cnv_enrichment_test_mperms, marker_pos_start, marker_pos_end, &chrom_info);
} else if (load_rare & LOAD_RARE_GVAR) {
retval = plink_gvar(outname, outname_end, pedname, mapname, famname);
} else {
if (filter_flags) {
if (!calculation_type) {
logerrprint("Error: Basic file conversions do not support regular filtering operations.\nRerun your command with --make-bed.\n");
goto main_ret_INVALID_CMDLINE;
} else if (calculation_type == CALC_MERGE) {
logerrprint("Error: Basic merge does not support regular filtering operations. Rerun your\ncommand with --make-bed.\n");
goto main_ret_INVALID_CMDLINE;
}
}
if (load_rare || (load_params & (LOAD_PARAMS_TEXT_ALL | LOAD_PARAMS_OX_ALL))) {
sptr = outname_end;
if (calculation_type && (!(misc_flags & MISC_KEEP_AUTOCONV))) {
sptr = memcpyb(sptr, "-temporary", 11);
}
uii = (sptr - outname);
if (load_rare == LOAD_RARE_LGEN) {
retval = lgen_to_bed(pedname, mapname, famname, outname, sptr, missing_pheno, misc_flags, lgen_modifier, lgen_reference_fname, &chrom_info);
} else if (load_rare & LOAD_RARE_TRANSPOSE_MASK) {
retval = transposed_to_bed(pedname, famname, outname, sptr, misc_flags, &chrom_info);
} else if (load_rare & LOAD_RARE_VCF) {
retval = vcf_to_bed(pedname, outname, sptr, missing_pheno, misc_flags, const_fid, id_delim, vcf_idspace_to, vcf_min_qual, vcf_filter_exceptions_flattened, vcf_min_gq, vcf_min_gp, (uint32_t)vcf_half_call, &chrom_info);
} else if (load_rare & LOAD_RARE_BCF) {
retval = bcf_to_bed(pedname, outname, sptr, missing_pheno, misc_flags, const_fid, id_delim, vcf_idspace_to, vcf_min_qual, vcf_filter_exceptions_flattened, &chrom_info);
} else if (load_rare == LOAD_RARE_23) {
retval = bed_from_23(pedname, outname, sptr, modifier_23, fid_23, iid_23, (pheno_23 == DBL_MAX)? ((double)missing_pheno) : pheno_23, misc_flags, paternal_id_23, maternal_id_23, &chrom_info);
} else if (load_rare & LOAD_RARE_DUMMY) {
retval = generate_dummy(outname, sptr, dummy_flags, dummy_marker_ct, dummy_sample_ct, dummy_missing_geno, dummy_missing_pheno, missing_pheno);
} else if (load_rare & LOAD_RARE_SIMULATE) {
// no need to support zero samples/variants here since --dummy takes
// care of generating those test cases
retval = simulate_dataset(outname, sptr, simulate_flags, simulate_fname, simulate_cases, simulate_controls, simulate_prevalence, simulate_qt_samples, simulate_missing, simulate_label);
free(simulate_fname);
simulate_fname = nullptr;
if (simulate_label) {
free(simulate_label);
simulate_label = nullptr;
}
} else if (load_params & LOAD_PARAMS_OX_ALL) {
retval = oxford_to_bed(pedname, mapname, outname, sptr, oxford_single_chr, oxford_pheno_name, hard_call_threshold, oxford_missing_code, missing_pheno, misc_flags, (load_params / LOAD_PARAMS_OXBGEN) & 1, &chrom_info);
} else {
retval = ped_to_bed(pedname, mapname, outname, sptr, fam_cols, misc_flags, missing_pheno, &chrom_info);
fam_cols |= FAM_COL_1 | FAM_COL_34 | FAM_COL_5;
if (!(fam_cols & FAM_COL_6)) {
fam_cols |= FAM_COL_6;
missing_pheno = -9;
}
}
if (retval || (!calculation_type)) {
goto main_ret_1;
}
memcpy(memcpya(pedname, outname, uii), ".bed", 5);
memcpy(memcpya(mapname, outname, uii), ".bim", 5);
memcpy(memcpya(famname, outname, uii), ".fam", 5);
if (calculation_type && (!(misc_flags & MISC_KEEP_AUTOCONV))) {
if (push_ll_str(pedname, &file_delete_list) || push_ll_str(mapname, &file_delete_list) || push_ll_str(famname, &file_delete_list)) {
goto main_ret_NOMEM;
}
}
*outname_end = '\0';
}
if (rel_info.ibc_type == 3) { // todo: make this less ugly
rel_info.ibc_type = 0;
} else if (!rel_info.ibc_type) {
rel_info.ibc_type = 1;
}
retval = plink(outname, outname_end, pedname, mapname, famname, cm_map_fname, cm_map_chrname, phenoname, extractname, excludename, keepname, removename, keepfamname, removefamname, filtername, freqname, distance_wts_fname, read_dists_fname, read_dists_id_fname, evecname, mergename1, mergename2, mergename3, missing_mid_template, missing_marker_id_match, makepheno_str, phenoname_str, a1alleles, a2alleles, recode_allele_name, covar_fname, update_alleles_fname, read_genome_fname, qual_filter, update_chr, update_cm, update_map, update_name, update_ids_fname, update_parents_fname, update_sex_fname, loop_assoc_fname, flip_fname, flip_subset_fname, sample_sort_fname, filtervals_flattened, condition_mname, condition_fname, filter_attrib_fname, filter_attrib_liststr, filter_attrib_sample_fname, filter_attrib_sample_liststr, rplugin_fname, rplugin_host_or_socket, rplugin_port, qual_min_thresh, qual_max_thresh, thin_keep_prob, thin_keep_sample_prob, new_id_max_allele_len, thin_keep_ct, thin_keep_sample_ct, min_bp_space, mfilter_col, fam_cols, missing_pheno, output_missing_pheno, mpheno_col, pheno_modifier, &chrom_info, &oblig_missing_info, &family_info, check_sex_fthresh, check_sex_mthresh, check_sex_f_yobs, check_sex_m_yobs, distance_exp, min_maf, max_maf, geno_thresh, mind_thresh, hwe_thresh, tail_bottom, tail_top, misc_flags, filter_flags, calculation_type, dist_calc_type, groupdist_iters, groupdist_d, regress_iters, regress_d, parallel_idx, parallel_tot, splitx_bound1, splitx_bound2, ppc_gap, sex_missing_pheno, update_sex_col, hwe_modifier, min_ac, max_ac, genome_modifier, genome_min_pi_hat, genome_max_pi_hat, &homozyg, &cluster, neighbor_n1, neighbor_n2, &set_info, &ld_info, &epi_info, &clump_info, &rel_info, &score_info, recode_modifier, allelexxxx, merge_type, sample_sort, marker_pos_start, marker_pos_end, snp_window_size, markername_from, markername_to, markername_snp, &snps_range_list, write_var_range_ct, covar_modifier, &covar_range_list, write_covar_modifier, write_covar_dummy_max_categories, dupvar_modifier, mwithin_col, model_modifier, (uint32_t)model_cell_ct, model_mperm_val, glm_modifier, glm_vif_thresh, glm_xchr_model, glm_mperm_val, ¶meters_range_list, &tests_range_list, ci_size, pfilter, output_min_p, mtest_adjust, adjust_lambda, gxe_mcovar, &aperm, mperm_save, ibs_test_perms, perm_batch_size, lasso_h2, lasso_lambda_iters, lasso_minlambda, &lasso_select_covars_range_list, testmiss_modifier, testmiss_mperm_val, permphe_ct, known_procs, &file_delete_list);
}
while (0) {
main_ret_NOMEM:
retval = RET_NOMEM;
break;
main_ret_OPEN_FAIL:
retval = RET_OPEN_FAIL;
break;
main_ret_READ_FAIL:
retval = RET_READ_FAIL;
break;
main_ret_INVALID_CMDLINE_UNRECOGNIZED:
invalid_arg(argv[cur_arg]);
logerrprintb();
logerrprint(errstr_append);
retval = RET_INVALID_CMDLINE;
break;
main_ret_INVALID_CMDLINE_INPUT_CONFLICT:
LOGERRPRINTF("Error: --%s conflicts with another input flag.\n%s", argptr, errstr_append);
retval = RET_INVALID_CMDLINE;
break;
main_ret_INVALID_CMDLINE_WWA:
wordwrapb(0);
main_ret_INVALID_CMDLINE_2A:
logerrprintb();
main_ret_INVALID_CMDLINE_A:
logerrprint(errstr_append);
retval = RET_INVALID_CMDLINE;
break;
main_ret_INVALID_CMDLINE_WW:
wordwrapb(0);
main_ret_INVALID_CMDLINE_2:
logerrprintb();
main_ret_INVALID_CMDLINE:
retval = RET_INVALID_CMDLINE;
break;
main_ret_NULL_CALC:
if (filter_flags) {
logerrprint("Warning: No output requested. (Did you forget --make-bed?) Exiting.\n");
} else {
logerrprint("Warning: No output requested. Exiting.\n");
}
fputs(g_cmdline_format_str, stdout);
fputs(notestr_null_calc2, stdout);
retval = RET_NULL_CALC;
#ifdef STABLE_BUILD
break;
main_unstable_disabled:
// see the UNSTABLE macro in plink_common.h
memcpy(g_logbuf, "Error: --", 9);
strcpy(sptr, " is either unfinished or not yet well-tested. If you wish to help with testing, use the latest development build.\n");
wordwrapb(0);
logerrprintb();
retval = RET_CALC_NOT_YET_SUPPORTED;
#endif
}
main_ret_1:
disp_exit_msg(retval);
while (0) {
main_ret_NOMEM_NOLOG:
print_ver();
main_ret_NOMEM_NOLOG2:
fputs(errstr_nomem, stderr);
if (g_failed_alloc_attempt_size) {
fprintf(stderr, "Failed allocation size: %" PRIuPTR "\n", g_failed_alloc_attempt_size);
}
retval = RET_NOMEM;
break;
main_ret_READ_FAIL_NOLOG:
print_ver();
fputs(errstr_read, stderr);
retval = RET_READ_FAIL;
break;
}
main_ret_NOLOG:
fclose_cond(scriptfile);
free_cond(bubble);
free_cond(bigstack_ua);
free_cond(subst_argv);
free_cond(script_buf);
free_cond(rerun_buf);
free_cond(flag_buf);
free_cond(flag_map);
free_cond(makepheno_str);
free_cond(phenoname_str);
free_cond(a1alleles);
free_cond(a2alleles);
free_cond(sample_sort_fname);
free_cond(filtervals_flattened);
free_cond(evecname);
free_cond(filtername);
free_cond(distance_wts_fname);
free_cond(read_dists_fname);
free_cond(read_dists_id_fname);
free_cond(freqname);
free_cond(extractname);
free_cond(excludename);
free_cond(keepname);
free_cond(removename);
free_cond(keepfamname);
free_cond(removefamname);
free_cond(cm_map_fname);
free_cond(cm_map_chrname);
free_cond(phenoname);
free_cond(recode_allele_name);
free_cond(markername_from);
free_cond(markername_to);
free_cond(markername_snp);
free_range_list(&snps_range_list);
free_range_list(&covar_range_list);
free_range_list(&lasso_select_covars_range_list);
free_range_list(¶meters_range_list);
free_range_list(&tests_range_list);
free_cond(lgen_reference_fname);
free_cond(covar_fname);
free_cond(update_alleles_fname);
free_cond(qual_filter);
free_cond(update_chr);
free_cond(update_cm);
free_cond(update_map);
free_cond(update_name);
free_cond(oxford_missing_code);
free_cond(oxford_single_chr);
free_cond(oxford_pheno_name);
free_cond(update_ids_fname);
free_cond(update_parents_fname);
free_cond(update_sex_fname);
free_cond(loop_assoc_fname);
free_cond(flip_fname);
free_cond(flip_subset_fname);
free_cond(read_genome_fname);
free_cond(rseeds);
free_cond(simulate_fname);
free_cond(simulate_label);
free_cond(cnv_intersect_filter_fname);
free_cond(cnv_subset_fname);
free_cond(segment_spanning_fname);
free_cond(fid_23);
free_cond(iid_23);
free_cond(paternal_id_23);
free_cond(maternal_id_23);
free_cond(condition_mname);
free_cond(condition_fname);
free_cond(missing_mid_template);
free_cond(missing_marker_id_match);
free_cond(filter_attrib_fname);
free_cond(filter_attrib_liststr);
free_cond(filter_attrib_sample_fname);
free_cond(filter_attrib_sample_liststr);
free_cond(const_fid);
free_cond(vcf_filter_exceptions_flattened);
free_cond(gene_report_fname);
free_cond(gene_report_glist);
free_cond(gene_report_subset);
free_cond(gene_report_snp_field);
free_cond(metaanal_fnames);
free_cond(metaanal_chrfield_search_order);
free_cond(metaanal_snpfield_search_order);
free_cond(metaanal_bpfield_search_order);
free_cond(metaanal_a1field_search_order);
free_cond(metaanal_a2field_search_order);
free_cond(metaanal_pfield_search_order);
free_cond(metaanal_sefield_search_order);
free_cond(metaanal_essfield_search_order);
free_cond(rplugin_fname);
free_cond(rplugin_host_or_socket);
oblig_missing_cleanup(&oblig_missing_info);
cluster_cleanup(&cluster);
set_cleanup(&set_info, &annot_info);
ld_epi_cleanup(&ld_info, &epi_info, &clump_info);
rel_cleanup(&rel_info);
misc_cleanup(&score_info);
dosage_cleanup(&dosage_info);
if (file_delete_list) {
do {
ll_str_ptr = file_delete_list->next;
unlink(file_delete_list->ss);
free(file_delete_list);
file_delete_list = ll_str_ptr;
} while (file_delete_list);
}
cleanup_chrom_info(&chrom_info);
if (g_logfile) {
if (!g_log_failed) {
logstr("\nEnd time: ");
time(&rawtime);
logstr(ctime(&rawtime));
if (fclose(g_logfile)) {
fflush(stdout);
fputs("Error: Failed to finish writing to log.\n", stderr);
}
} else {
fclose(g_logfile);
}
g_logfile = nullptr;
}
if (misc_flags & MISC_GPLINK) {
memcpy(outname_end, ".gplink", 8);
g_logfile = fopen(outname, "w");
if (g_logfile) { // can't do much if an error occurs here...
putc_unlocked(retval? '1' : '0', g_logfile);
putc_unlocked('\n', g_logfile);
fclose(g_logfile);
}
}
return retval;
}