static void
pr_append_new_chunk(pr_append_str *x,
const char *s)
{
if (pr_append_new_chunk_external(x, s))
out_of_memory_error();
}
void
print_format_output(FILE *f,
const int *io_version,
const p3_global_settings *pa,
const seq_args *sa,
const p3retval *retval,
const char *pr_release,
int explain_flag)
{
/* A place to put a string containing all error messages */
pr_append_str *combined_retval_err = NULL;
combined_retval_err = create_pr_append_str();
if (NULL == combined_retval_err) exit(-2); /* Out of memory */
if (pr_append_new_chunk_external(combined_retval_err,
retval->glob_err.data))
exit(-2);
if (pr_append_new_chunk_external(combined_retval_err,
retval->per_sequence_err.data))
exit(-2);
/* Print as primer pairs */
if (retval->output_type == primer_pairs) {
format_pairs(f, pa, sa, retval, &retval->best_pairs,
pr_release, combined_retval_err, explain_flag);
/* Print as primer list */
} else {
format_oligos(stdout, pa, sa, retval, pr_release,
combined_retval_err, explain_flag);
}
destroy_pr_append_str(combined_retval_err);
}
int
main (int argc, const char *argv[])
{
unsigned int idx;
char *end;
int debug = 0;
/* sequence file name specified by the user, otherwise STDIN will be used */
const char *sequence_file_name = NULL;
const char *lists_file_name = NULL;
/* data structure for all k-mer lists used for masking */
unsigned int nlists = 0;
unsigned int nlist_parameters = 0;
unsigned int npos = 0;
unsigned int list_pos[MAX_VARIABLES], list_components[MAX_VARIABLES];
masker_parameters mp = {};
parameters_builder pbuilder = {};
input_sequence *input_seq = NULL;
pr_append_str parse_err;
pr_append_str warnings;
init_pr_append_str (&parse_err);
init_pr_append_str (&warnings);
/* fill mp with default parameters */
mp.mdir = DEFAULT_MASKING_DIRECTION;
mp.failure_rate = DEFAULT_FAILURE_RATE;
mp.abs_cutoff = DEFAULT_ABS_CUTOFF;
mp.nucl_masked_in_5p_direction = DEFAULT_M5P;
mp.nucl_masked_in_3p_direction = DEFAULT_M3P;
mp.print_sequence = PRINT_SEQUENCE;
mp.do_soft_masking = HARD_MASKING;
mp.masking_char = DEFAULT_MASK_CHAR;
mp.list_prefix = DEFAULT_LIST_FILE_PREFIX;
/* parsing and checking the commandline arguments */
for (idx = 1; (int)idx < argc; idx++) {
if (!strcmp (argv[idx], "-h") || !strcmp (argv[idx], "--help") || !strcmp (argv[idx], "-?")) {
print_help (0);
} else if ((int)idx == argc - 1 && argv[idx][0] != '-') {
sequence_file_name = argv[idx];
} else if (!strcmp (argv[idx], "-lf") || !strcmp (argv[idx], "--lists_file")) {
/* lists specified from the file */
if (!argv[idx + 1] || argv[idx + 1][0] == '-') {
pr_append_new_chunk_external (&warnings, "No lists file specified.");
idx += 1;
continue;
}
lists_file_name = argv[idx + 1];
idx += 1;
} else if (!strcmp (argv[idx], "-l") || !strcmp (argv[idx], "--list")) {
/* lists specified from the commandline */
if (nlist_parameters == MAX_VARIABLES) {
pr_append_new_chunk_external (&parse_err, "Maximum number of list variables reached.");
break;
}
if (!argv[idx + 1]) {
pr_append_new_chunk_external (&warnings, "No list name specified with -l parameter!.");
continue;
}
/* get the positions of list files */
list_pos[nlist_parameters] = idx;
while (argv[idx + 1]) {
if (argv[idx + 1][0] == '-') {
if (!argv[idx + 1][1]) break;
strtod (argv[idx + 1] + 1, &end);
if (*end != 0) break;
} else if (idx + 1 != list_pos[nlist_parameters] + 1 && idx + 1 != list_pos[nlist_parameters] + 4) {
strtod (argv[idx + 1], &end);
if (*end != 0) break;
} else if (idx + 1 == list_pos[nlist_parameters] + 4 && strcmp (argv[idx + 1], "sq")) {
break;
}
idx += 1;
}
list_components[nlist_parameters] = idx - list_pos[nlist_parameters];
nlist_parameters += 1;
npos += 1;
} else if (!strcmp (argv[idx], "-lp") || !strcmp (argv[idx], "--list_prefix")) {
/* lists specified by the prefix */
if (!argv[idx + 1] || argv[idx + 1][0] == '-') {
pr_append_new_chunk_external (&warnings, "No list prefix specified! Using the default value.");
idx += 1;
continue;
}
mp.list_prefix = (char *)argv[idx + 1];
idx += 1;
} else if (!strcmp (argv[idx], "-p") || !strcmp (argv[idx], "--probability_cutoff")) {
if (!argv[idx + 1]) {
pr_append_new_chunk_external (&warnings, "No cutoff value specified! Using the default value.");
idx += 1;
continue;
}
mp.failure_rate = strtod (argv[idx + 1], &end);
mp.abs_cutoff = 0;
if (*end != 0 || mp.failure_rate < 0 || mp.failure_rate > 1) {
pr_append_new_chunk_external (&parse_err, "Invalid cutoff value: ");
pr_append_external (&parse_err, argv[idx + 1]);
break;
}
idx += 1;
} else if (!strcmp (argv[idx], "-a") || !strcmp (argv[idx], "--absolute_value_cutoff")) {
if (!argv[idx + 1]) {
pr_append_new_chunk_external (&warnings, "No absolute cutoff value specified! Using the default value.");
idx += 1;
continue;
}
mp.abs_cutoff = strtod (argv[idx + 1], &end);
mp.failure_rate = 0.0;
if (*end != 0 || mp.abs_cutoff < 0) {
pr_append_new_chunk_external (&parse_err, "Invalid absolute cutoff value: ");
pr_append_external (&parse_err, argv[idx + 1]);
break;
}
idx += 1;
} else if (!strcmp (argv[idx], "-m5") || !strcmp (argv[idx], "--mask_5p")) {
if (!argv[idx + 1]) {
pr_append_new_chunk_external (&warnings, "Number of nucleotides masked in 5' direction not specified! Using the default value.");
idx += 1;
continue;
}
mp.nucl_masked_in_5p_direction = strtod (argv[idx + 1], &end);
if (*end != 0) {
pr_append_new_chunk_external (&parse_err, "Invalid number of nucleotides masked in 5' direction: ");
pr_append_external (&parse_err, argv[idx + 1]);
break;
}
idx += 1;
} else if (!strcmp (argv[idx], "-m3") || !strcmp (argv[idx], "--mask_3p")) {
if (!argv[idx + 1]) {
pr_append_new_chunk_external (&warnings, "Number of nucleotides masked in 3' direction not specified! Using the default value.");
idx += 1;
continue;
}
mp.nucl_masked_in_3p_direction = strtod (argv[idx + 1], &end);
if (*end != 0) {
pr_append_new_chunk_external (&parse_err, "Invalid number of nucleotides masked in 3' direction: ");
pr_append_external (&parse_err, argv[idx + 1]);
break;
}
idx += 1;
} else if (!strcmp (argv[idx], "-c") || !strcmp (argv[idx], "--masking_char")) {
if (!argv[idx + 1 || argv[idx + 1][0] == '-']) {
pr_append_new_chunk_external (&warnings, "Character for masking not specified! Using the default value.");
idx += 1;
continue;
}
mp.masking_char = argv[idx + 1][0];
if (strlen(argv[idx + 1]) > 1 || mp.masking_char < 33 || mp.masking_char > 126) {
pr_append_new_chunk_external (&parse_err, "Invalid character for masking: ");
pr_append_external (&parse_err, argv[idx + 1]);
break;
}
idx += 1;
} else if (!strcmp (argv[idx], "-d") || !strcmp (argv[idx], "--masking_direction")) {
if (!argv[idx + 1] || argv[idx + 1][0] == '-') {
pr_append_new_chunk_external (&warnings, "Masking direction not specified! Masking both strands by default.");
} else if (!strcmp (argv[idx + 1], "both")) {
mp.mdir = both_on_same;
} else if (!strcmp (argv[idx + 1], "fwd")) {
mp.mdir = fwd;
} else if (!strcmp (argv[idx + 1], "rev")) {
mp.mdir = rev;
} else {
pr_append_new_chunk_external (&warnings, "Unknown masking direction: ");
pr_append_external (&warnings, argv[idx + 1]);
pr_append_external (&warnings, ". Masking both strands by default.");
}
idx += 1;
} else if (!strcmp (argv[idx], "-s") || !strcmp (argv[idx], "--soft_mask")) {
mp.do_soft_masking = SOFT_MASKING;
} else if (!strcmp (argv[idx], "-D")) {
debug += 1;
} else {
pr_append_new_chunk_external (&parse_err, "Unknown parameter: ");
pr_append_external (&parse_err, argv[idx]);
break;
}
}
input_seq = create_input_sequence_from_file_name (sequence_file_name, &parse_err);
if (parse_err.data != NULL) {
fprintf(stderr, "%s -> parsing commandline: ERROR: %s\n", pr_programme_name, parse_err.data);
exit(-1);
}
if (warnings.data != NULL) {
fprintf(stderr, "%s -> parsing commandline: WARNING: %s\n", pr_programme_name, warnings.data);
}
if (lists_file_name) {
/* if lists are given in a text file */
mp.fp = read_formula_parameters_from_file (lists_file_name, &nlist_parameters, &pbuilder, &mp.formula_intercept, &parse_err);
nlists = pbuilder.nfp;
}
if (npos != 0) {
/* if lists are given by commandline arguments (can be added to the ones given in a file) */
pbuilder.fp_array = mp.fp;
for (idx = 0; idx < npos; idx++) {
unsigned int pos = list_pos[idx] + 1;
char *values[4];
unsigned int nvalues = list_components[idx];
char *end;
memcpy (&values, &argv[pos], nvalues * sizeof(*argv));
if (nvalues == 1) {
double ic;
double neg = 1.0;
if (values[0][0] == '-') {
values[0] += 1;
neg = -1.0;
}
ic = strtod (values[0], &end);
if (*end == 0) {
mp.formula_intercept = ic * neg;
continue;
}
}
add_variable_to_formula_parameters (values, nvalues, &pbuilder, &parse_err);
}
nlists = pbuilder.nfp;
mp.fp = pbuilder.fp_array;
} else if (nlists == 0 && !lists_file_name) {
/* if there are no lists specified use the default formula */
mp.fp = create_default_formula_parameters (mp.list_prefix, &parse_err);
mp.formula_intercept = DEFAULT_INTERCEPT;
nlists = DEFAULT_NLISTS;
nlist_parameters = DEFAULT_NLIST_PARAMETERS;
}
mp.nlists = nlists;
if (mp.abs_cutoff > 0 && nlist_parameters != 1) {
fprintf (stderr, "Error: Absolute value cutoff works with one list and one k-mer frequency parameter only. Currently you are using %u lists and %u parameters.\n", nlists, nlist_parameters);
print_help(1);
}
if (parse_err.data != NULL) {
fprintf(stderr, "%s -> building formula: ERROR: %s\n", pr_programme_name, parse_err.data);
delete_input_sequence (input_seq);
exit(-1);
}
if (debug > 0) print_parameters (&mp);
read_and_mask_sequence (input_seq, NULL, &mp, &parse_err, debug);
if (parse_err.data != NULL) {
fprintf(stderr, "%s -> masking sequence: ERROR: %s\n", pr_programme_name, parse_err.data);
delete_input_sequence (input_seq);
delete_formula_parameters (mp.fp, nlists);
exit(-1);
}
destroy_pr_append_str_data (&warnings);
destroy_pr_append_str_data (&parse_err);
delete_input_sequence (input_seq);
delete_formula_parameters (mp.fp, nlists);
if (debug > 0) fprintf (stderr, "Done!\n");
return 0;
}
/* Print the data for chosen primer pairs to stdout in "boulderio" format. */
void
print_boulder(int io_version,
const p3_global_settings *pa,
const seq_args *sa,
const p3retval *retval,
int explain_flag) {
/* The pointers to warning tag */
char *warning;
/* A place to put a string containing all error messages */
pr_append_str *combined_retval_err = NULL;
/* A small spacer; WARNING this is a fixed size
buffer, but plenty bigger than
log(2^64, 10), the longest character
string that is needed for a 64 bit integer. */
char suffix [100];
/* Pointers for the primer set just printing */
primer_rec *fwd, *rev, *intl;
/* Variables only used for Primer Lists */
int num_fwd, num_rev, num_int, num_pair, num_print;
int print_fwd = 0;
int print_rev = 0;
int print_int = 0;
/* Switches for printing this primer */
int go_fwd = 0;
int go_rev = 0;
int go_int = 0;
/* The number of loop cycles */
int loop_max;
/* That links to the included region */
int i, incl_s = sa->incl_s;
/* This deals with the renaming of the internal oligo */
const char *new_oligo_name = "INTERNAL";
const char *old_oligo_name = "INTERNAL_OLIGO";
char *int_oligo = (char*) new_oligo_name;
/* Check: are all pointers linked to something*/
PR_ASSERT(NULL != pa);
PR_ASSERT(NULL != sa);
if (io_version == 3) {
int_oligo = (char*) old_oligo_name;
}
/* Check if there are warnings and print them */
if ((warning = p3_get_rv_and_gs_warnings(retval, pa)) != NULL) {
printf("PRIMER_WARNING=%s\n", warning);
free(warning);
}
/* Check if a settings file was read an print its id
* Not needed anymore, we do this when we read the setting file. */
/*
if (pa->settings_file_id != NULL) {
printf("P3_FILE_ID=%s\n", pa->settings_file_id);
free(warning);
}
*/
combined_retval_err = create_pr_append_str();
if (NULL == combined_retval_err) exit(-2); /* Out of memory */
if (pr_append_new_chunk_external(combined_retval_err,
retval->glob_err.data))
exit(-2);
if (pr_append_new_chunk_external(combined_retval_err,
retval->per_sequence_err.data))
exit(-2);
/* Check if there are errors, print and return */
if (!pr_is_empty(combined_retval_err)) {
print_boulder_error(pr_append_str_chars(combined_retval_err));
destroy_pr_append_str(combined_retval_err);
return;
}
destroy_pr_append_str(combined_retval_err);
/* Get how many primers are in the array */
num_fwd = retval->fwd.num_elem;
num_rev = retval->rev.num_elem;
num_int = retval->intl.num_elem;
num_pair = retval->best_pairs.num_pairs;
/* Prints out statistics about the primers */
if (explain_flag) print_all_explain(pa, sa, retval, io_version);
/* Print out the stop codon if a reading frame was specified */
if (!PR_START_CODON_POS_IS_NULL(sa))
printf("PRIMER_STOP_CODON_POSITION=%d\n", retval->stop_codon_pos);
/* How often has the loop to be done? */
if (retval->output_type == primer_list) {
/* For Primer Lists: Figure out how many primers are in
* the array that can be printed. If more than needed,
* set it to the number requested. */
/* Get how may primers should be printed */
num_print = pa->num_return;
/* Set how many primers will be printed */
print_fwd = (num_print < num_fwd) ? num_print : num_fwd;
print_rev = (num_print < num_rev) ? num_print : num_rev;
print_int = (num_print < num_int) ? num_print : num_int;
/* Get which list has to print most primers */
loop_max = 0;
if (loop_max < print_fwd) {
loop_max = print_fwd;
}
if (loop_max < print_rev) {
loop_max = print_rev;
}
if (loop_max < print_int) {
loop_max = print_int;
}
/* Now the vars are there how often we have to go
* through the loop and how many of each primer can
* be printed. */
num_pair = 0;
} else {
loop_max = num_pair;
/* Set how many primers will be printed */
print_fwd = num_pair;
print_rev = num_pair;
if (num_int != 0) {
print_int = num_pair;
}
}
if (io_version == 4) {
printf("PRIMER_LEFT_NUM_RETURNED=%d\n", print_fwd);
printf("PRIMER_RIGHT_NUM_RETURNED=%d\n", print_rev);
printf("PRIMER_%s_NUM_RETURNED=%d\n", int_oligo, print_int);
printf("PRIMER_PAIR_NUM_RETURNED=%d\n", num_pair);
}
/* --------------------------------------- */
/* Start of the loop printing all pairs or primers or oligos */
for(i=0; i<loop_max; i++) {
/* What needs to be printed */
/* The conditions for primer lists */
if (retval->output_type == primer_list) {
/* Attach the selected primers to the pointers */
fwd = &retval->fwd.oligo[i];
rev = &retval->rev.oligo[i];
intl = &retval->intl.oligo[i];
/* Do fwd oligos have to be printed? */
if ((pa->pick_left_primer) && (i < print_fwd)) {
go_fwd = 1;
} else {
go_fwd = 0;
}
/* Do rev oligos have to be printed? */
if ((pa->pick_right_primer) && (i < print_rev)) {
go_rev = 1;
} else {
go_rev = 0;
}
/* Do int oligos have to be printed? */
if ((pa->pick_internal_oligo) && (i < print_int)) {
go_int = 1;
} else {
go_int = 0;
}
} else {
/* We will print primer pairs or pairs plus internal oligos */
/* Get pointers to the primer_rec's that we will print */
fwd = retval->best_pairs.pairs[i].left;
rev = retval->best_pairs.pairs[i].right;
intl = retval->best_pairs.pairs[i].intl;
/* Pairs must have fwd and rev primers */
go_fwd = 1;
go_rev = 1;
/* Do hyb oligos have to be printed? */
if (pa->pick_internal_oligo == 1) {
go_int = 1;
} else {
go_int = 0;
}
}
/* Get the number for pimer counting in suffix[0] */
if ((i == 0) && (io_version == 3) ){
suffix[0] = '\0';
} else {
sprintf(suffix, "_%d", i);
}
/* Print out the Pair Penalties */
if (retval->output_type == primer_pairs) {
if (io_version == 3) {
printf("PRIMER_PAIR_PENALTY%s=%.4f\n", suffix,
retval->best_pairs.pairs[i].pair_quality);
} else {
printf("PRIMER_PAIR%s_PENALTY=%f\n", suffix,
retval->best_pairs.pairs[i].pair_quality);
}
}
/* Print single primer penalty */
if (go_fwd == 1)
printf("PRIMER_LEFT%s_PENALTY=%f\n", suffix, fwd->quality);
if (go_rev == 1)
printf("PRIMER_RIGHT%s_PENALTY=%f\n", suffix, rev->quality);
if (go_int == 1)
printf("PRIMER_%s%s_PENALTY=%f\n", int_oligo, suffix, intl->quality);
/* Print the oligo_problems */
if (io_version == 4) {
if (go_fwd == 1 && p3_ol_has_any_problem(fwd))
printf("PRIMER_LEFT%s_PROBLEMS=%s\n", suffix, p3_get_ol_problem_string(fwd));
if (go_rev == 1 && p3_ol_has_any_problem(rev))
printf("PRIMER_RIGHT%s_PROBLEMS=%s\n", suffix, p3_get_ol_problem_string(rev));
if (go_int == 1 && p3_ol_has_any_problem(intl))
printf("PRIMER_%s%s_PROBLEMS=%s\n", int_oligo, suffix, p3_get_ol_problem_string(intl));
}
/* Print primer sequences. */
if (go_fwd == 1)
printf("PRIMER_LEFT%s_SEQUENCE=%s\n", suffix,
pr_oligo_sequence(sa, fwd));
if (go_rev == 1)
printf("PRIMER_RIGHT%s_SEQUENCE=%s\n", suffix,
pr_oligo_rev_c_sequence(sa, rev));
if(go_int == 1)
printf("PRIMER_%s%s_SEQUENCE=%s\n", int_oligo, suffix,
pr_oligo_sequence(sa,intl));
/* Print primer start and length */
if (go_fwd == 1)
printf("PRIMER_LEFT%s=%d,%d\n", suffix,
fwd->start + incl_s + pa->first_base_index,
fwd->length);
if (go_rev == 1)
printf("PRIMER_RIGHT%s=%d,%d\n", suffix,
rev->start + incl_s + pa->first_base_index,
rev->length);
if (go_int == 1)
printf("PRIMER_%s%s=%d,%d\n", int_oligo, suffix,
intl->start + incl_s + pa->first_base_index,
intl->length);
/* Print primer Tm */
if (go_fwd == 1)
printf("PRIMER_LEFT%s_TM=%.3f\n", suffix, fwd->temp);
if (go_rev == 1)
printf("PRIMER_RIGHT%s_TM=%.3f\n", suffix, rev->temp);
if (go_int == 1)
printf("PRIMER_%s%s_TM=%.3f\n", int_oligo, suffix, intl->temp);
/* Print primer GC content */
if (go_fwd == 1)
printf("PRIMER_LEFT%s_GC_PERCENT=%.3f\n", suffix, fwd->gc_content);
if (go_rev == 1)
printf("PRIMER_RIGHT%s_GC_PERCENT=%.3f\n", suffix, rev->gc_content);
if (go_int == 1)
printf("PRIMER_%s%s_GC_PERCENT=%.3f\n", int_oligo, suffix,
intl->gc_content);
/* Print primer self_any */
if (go_fwd == 1 && pa->thermodynamic_alignment==0)
printf("PRIMER_LEFT%s_SELF_ANY=%.2f\n", suffix,
fwd->self_any);
if (go_rev == 1 && pa->thermodynamic_alignment==0)
printf("PRIMER_RIGHT%s_SELF_ANY=%.2f\n", suffix,
rev->self_any);
if (go_int == 1 && pa->thermodynamic_alignment==0)
printf("PRIMER_%s%s_SELF_ANY=%.2f\n", int_oligo, suffix,
intl->self_any);
if (go_int == 1 && pa->thermodynamic_alignment==1)
printf("PRIMER_%s%s_SELF_ANY_TH=%.2f\n", int_oligo, suffix,
intl->self_any);
/* Print primer self_any thermodynamical approach */
if (go_fwd == 1 && pa->thermodynamic_alignment==1)
printf("PRIMER_LEFT%s_SELF_ANY_TH=%.2f\n", suffix,
fwd->self_any);
if (go_rev == 1 && pa->thermodynamic_alignment==1)
printf("PRIMER_RIGHT%s_SELF_ANY_TH=%.2f\n", suffix,
rev->self_any);
/* Print primer self_end*/
if (go_fwd == 1 && pa->thermodynamic_alignment==0)
printf("PRIMER_LEFT%s_SELF_END=%.2f\n", suffix,
fwd->self_end);
if (go_rev == 1 && pa->thermodynamic_alignment==0)
printf("PRIMER_RIGHT%s_SELF_END=%.2f\n", suffix,
rev->self_end);
if (go_int == 1 && pa->thermodynamic_alignment==0)
printf("PRIMER_%s%s_SELF_END=%.2f\n", int_oligo, suffix,
intl->self_end);
if (go_int == 1 && pa->thermodynamic_alignment==1)
printf("PRIMER_%s%s_SELF_END_TH=%.2f\n", int_oligo, suffix,
intl->self_end);
/* Print primer self_end thermodynamical approach */
if (go_fwd == 1 && pa->thermodynamic_alignment==1)
printf("PRIMER_LEFT%s_SELF_END_TH=%.2f\n", suffix,
fwd->self_end);
if (go_rev == 1 && pa->thermodynamic_alignment==1)
printf("PRIMER_RIGHT%s_SELF_END_TH=%.2f\n", suffix,
rev->self_end);
/* Print primer hairpin */
if (go_fwd == 1 && pa->thermodynamic_alignment==1)
printf("PRIMER_LEFT%s_HAIRPIN_TH=%.2f\n", suffix,
fwd->hairpin_th);
if (go_rev == 1 && pa->thermodynamic_alignment==1)
printf("PRIMER_RIGHT%s_HAIRPIN_TH=%.2f\n", suffix,
rev->hairpin_th);
if (go_int == 1 && pa->thermodynamic_alignment==1)
printf("PRIMER_%s%s_HAIRPIN_TH=%.2f\n", int_oligo, suffix,
intl->hairpin_th);
/*Print out primer mispriming scores */
if (io_version == 3) {
if (seq_lib_num_seq(pa->p_args.repeat_lib) > 0) {
if (go_fwd == 1)
printf("PRIMER_LEFT%s_MISPRIMING_SCORE=%.2f, %s\n", suffix,
fwd->repeat_sim.score[fwd->repeat_sim.max],
fwd->repeat_sim.name);
if (go_rev == 1)
printf("PRIMER_RIGHT%s_MISPRIMING_SCORE=%.2f, %s\n", suffix,
rev->repeat_sim.score[rev->repeat_sim.max],
rev->repeat_sim.name);
if (retval->output_type == primer_pairs)
printf("PRIMER_PAIR%s_MISPRIMING_SCORE=%.2f, %s\n", suffix,
retval->best_pairs.pairs[i].repeat_sim,
retval->best_pairs.pairs[i].rep_name);
}
/* Print out internal oligo mispriming scores */
if (go_int == 1 && seq_lib_num_seq(pa->o_args.repeat_lib) > 0)
printf("PRIMER_%s%s_MISHYB_SCORE=%.2f, %s\n", int_oligo, suffix,
intl->repeat_sim.score[intl->repeat_sim.max],
intl->repeat_sim.name);
} else {
if (seq_lib_num_seq(pa->p_args.repeat_lib) > 0) {
if (go_fwd == 1)
printf("PRIMER_LEFT%s_LIBRARY_MISPRIMING=%.2f, %s\n", suffix,
fwd->repeat_sim.score[fwd->repeat_sim.max],
fwd->repeat_sim.name);
if (go_rev == 1)
printf("PRIMER_RIGHT%s_LIBRARY_MISPRIMING=%.2f, %s\n", suffix,
rev->repeat_sim.score[rev->repeat_sim.max],
rev->repeat_sim.name);
if (retval->output_type == primer_pairs)
printf("PRIMER_PAIR%s_LIBRARY_MISPRIMING=%.2f, %s\n", suffix,
retval->best_pairs.pairs[i].repeat_sim,
retval->best_pairs.pairs[i].rep_name);
}
/* Print out internal oligo mispriming scores */
if (go_int == 1 && seq_lib_num_seq(pa->o_args.repeat_lib) > 0)
printf("PRIMER_%s%s_LIBRARY_MISHYB=%.2f, %s\n", int_oligo, suffix,
intl->repeat_sim.score[intl->repeat_sim.max],
intl->repeat_sim.name);
}
/* If a sequence quality was provided, print it*/
if (NULL != sa->quality){
if (go_fwd == 1)
printf("PRIMER_LEFT%s_MIN_SEQ_QUALITY=%d\n", suffix,
fwd->seq_quality);
if (go_rev == 1)
printf("PRIMER_RIGHT%s_MIN_SEQ_QUALITY=%d\n", suffix,
rev->seq_quality);
if (go_int == 1 && (retval->output_type == primer_list))
printf("PRIMER_%s%s_MIN_SEQ_QUALITY=%d\n", int_oligo, suffix,
intl->seq_quality);
/* Has to be here and in primer pairs for backward compatibility */
}
/* Print position penalty, this is for backward compatibility */
if (!_PR_DEFAULT_POSITION_PENALTIES(pa)
|| !PR_START_CODON_POS_IS_NULL(sa)){
printf("PRIMER_LEFT%s_POSITION_PENALTY=%f\n", suffix,
fwd->position_penalty);
printf("PRIMER_RIGHT%s_POSITION_PENALTY=%f\n", suffix,
rev->position_penalty);
}
/* Print primer end stability */
if (go_fwd == 1)
printf("PRIMER_LEFT%s_END_STABILITY=%.4f\n",
suffix, fwd->end_stability);
if (go_rev == 1)
printf("PRIMER_RIGHT%s_END_STABILITY=%.4f\n",
suffix, rev->end_stability);
/* Print primer template mispriming */
if ( (pa->thermodynamic_alignment == 0) && (go_fwd == 1) &&
(oligo_max_template_mispriming(fwd) != ALIGN_SCORE_UNDEF))
printf("PRIMER_LEFT%s_TEMPLATE_MISPRIMING=%.4f\n", suffix,
oligo_max_template_mispriming(fwd));
if ( (pa->thermodynamic_alignment == 0) && (go_rev == 1) &&
(oligo_max_template_mispriming(rev) != ALIGN_SCORE_UNDEF))
printf("PRIMER_RIGHT%s_TEMPLATE_MISPRIMING=%.4f\n", suffix,
oligo_max_template_mispriming(rev));
/* Print primer template mispriming thermodynamical approach*/
if ( (pa->thermodynamic_alignment == 1) && (go_fwd == 1) &&
(oligo_max_template_mispriming_thermod(fwd) != ALIGN_SCORE_UNDEF))
printf("PRIMER_LEFT%s_TEMPLATE_MISPRIMING_TH=%.4f\n", suffix,
oligo_max_template_mispriming_thermod(fwd));
if ( (pa->thermodynamic_alignment == 1) && (go_rev == 1) &&
(oligo_max_template_mispriming_thermod(rev) != ALIGN_SCORE_UNDEF))
printf("PRIMER_RIGHT%s_TEMPLATE_MISPRIMING_TH=%.4f\n", suffix,
oligo_max_template_mispriming_thermod(rev));
/************************************************************************************/
/* Print the pair parameters*/
if (retval->output_type == primer_pairs) {
if (go_int == 1 && NULL != sa->quality) /* FIX ME - Uptate the tests */
printf("PRIMER_%s%s_MIN_SEQ_QUALITY=%d\n", int_oligo,
suffix, intl->seq_quality);
/* Print pair comp_any */
if(pa->thermodynamic_alignment==0)
printf("PRIMER_PAIR%s_COMPL_ANY=%.2f\n", suffix,
retval->best_pairs.pairs[i].compl_any);
if(pa->thermodynamic_alignment==1)
printf("PRIMER_PAIR%s_COMPL_ANY_TH=%.2f\n", suffix,
retval->best_pairs.pairs[i].compl_any);
/* Print pair comp_end */
if(pa->thermodynamic_alignment==0)
printf("PRIMER_PAIR%s_COMPL_END=%.2f\n", suffix,
retval->best_pairs.pairs[i].compl_end);
if(pa->thermodynamic_alignment==1)
printf("PRIMER_PAIR%s_COMPL_END_TH=%.2f\n", suffix,
retval->best_pairs.pairs[i].compl_end);
if (io_version == 3) {
/* Print product size */
printf("PRIMER_PRODUCT_SIZE%s=%d\n", suffix,
retval->best_pairs.pairs[i].product_size);
/* Print the product Tm if a Tm range is defined */
if (pa->product_max_tm != PR_DEFAULT_PRODUCT_MAX_TM ||
pa->product_min_tm != PR_DEFAULT_PRODUCT_MIN_TM) {
printf("PRIMER_PRODUCT_TM%s=%.4f\n", suffix,
retval->best_pairs.pairs[i].product_tm);
printf("PRIMER_PRODUCT_TM_OLIGO_TM_DIFF%s=%.4f\n", suffix,
retval->best_pairs.pairs[i].product_tm_oligo_tm_diff);
printf("PRIMER_PAIR%s_T_OPT_A=%.4f\n", suffix,
retval->best_pairs.pairs[i].t_opt_a);
}
} else {
/* Print product size */
printf("PRIMER_PAIR%s_PRODUCT_SIZE=%d\n", suffix,
retval->best_pairs.pairs[i].product_size);
/* Print the product Tm if a Tm range is defined */
if (pa->product_max_tm != PR_DEFAULT_PRODUCT_MAX_TM ||
pa->product_min_tm != PR_DEFAULT_PRODUCT_MIN_TM) {
printf("PRIMER_PAIR%s_PRODUCT_TM=%.4f\n", suffix,
retval->best_pairs.pairs[i].product_tm);
printf("PRIMER_PAIR%s_PRODUCT_TM_OLIGO_TM_DIFF=%.4f\n", suffix,
retval->best_pairs.pairs[i].product_tm_oligo_tm_diff);
printf("PRIMER_PAIR%s_T_OPT_A=%.4f\n", suffix,
retval->best_pairs.pairs[i].t_opt_a);
}
}
/* Print the primer pair temlate mispriming */
if ((pa->thermodynamic_alignment == 0) && (retval->best_pairs.pairs[i].template_mispriming != ALIGN_SCORE_UNDEF))
printf("PRIMER_PAIR%s_TEMPLATE_MISPRIMING=%.2f\n", suffix,
retval->best_pairs.pairs[i].template_mispriming);
/* Print the primer pair temlate mispriming. Thermodynamic approach. */
if ((pa->thermodynamic_alignment == 1) && (retval->best_pairs.pairs[i].template_mispriming != ALIGN_SCORE_UNDEF))
printf("PRIMER_PAIR%s_TEMPLATE_MISPRIMING_TH=%.2f\n", suffix,
retval->best_pairs.pairs[i].template_mispriming);
} /* End of print parameters of primer pairs */
} /* End of the big loop printing all data */
/* End the print with newline and flush all buffers */
printf("=\n");
if (fflush(stdout) == EOF) {
perror("fflush(stdout) failed");
exit(-1);
}
}
static void
p3sl_append_new_chunk(pr_append_str *x, const char *s)
{
int r = pr_append_new_chunk_external(x, s);
if (r) longjmp(_jmp_buf, 1);
}
