malacology/gde_linux
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
gde_linux/HGL_SRC/HGLfuncs.c
Kuoi b2951105ae fix: add include
2023-04-09 02:34:34 +08:00

2849 lines
68 KiB
C
Executable file
Raw Blame History

/****************************************************************
*
* This is a set of functions defined for the genome
* project.
*
****************************************************************/
#ifndef _GLOBAL_DEFS_H
#define _GLOBAL_DEFS_H
#include <ctype.h>
#include <stdlib.h>
#include "global_defs.h"
#endif
#define MAXLINELEN 256
static char Default_DNA_Trans[16] = {'-', 'a', 'c', 'm', 'g', 'r', 's', 'v',
't', 'w', 'y', 'h', 'k', 'd', 'b', 'n'};
/***********
*
* WriteRecord() outputs one record at a time in HGL format.
* Only the fields in the fields_array will be output. All the
* fields will be output if fields_array is NULL.
*
* fp : pointer to the output file.
* tSeq: pointer to the record.
* fields_array: contains the field ids of the selected fields.
* array_size: number of selected fields.
*
* Returns: 1 if any field is printed;
* 0 if no field is printed;
* -1 if anything is wrong.
*
**********/
int WriteRecord(fp, tSeq, fields_array, array_size)
FILE *fp;
const Sequence *tSeq;
int *fields_array;
int array_size;
{
int i, save_str_size, tt;
int all_fields = FALSE;
int first_field = TRUE;
char temp_str[256];
char *save_str;
char *ptr;
save_str = (char *)Calloc(256, 1);
save_str_size = 256;
/* When all the fields are selected. */
if (fields_array == NULL) {
all_fields = TRUE;
fields_array = (int *)Calloc(NUM_OF_FIELDS, sizeof(int));
for (i = 0; i < NUM_OF_FIELDS; i++) {
fields_array[i] = i;
}
array_size = NUM_OF_FIELDS;
}
for (i = 0; i < array_size; i++) {
save_str[0] = '\0';
if (fields_array[i] == e_creation_date &&
tSeq->creation_date[0] != 0) {
sprintf(save_str, "\n%s\t%d/%d/%d ",
at[fields_array[i]], tSeq->creation_date[1],
tSeq->creation_date[2], tSeq->creation_date[0]);
if (tSeq->creation_date[3] >= 0) {
if (tSeq->creation_date[4] < 0)
tSeq->creation_date[4] = 0;
if (tSeq->creation_date[5] < 0)
tSeq->creation_date[5] = 0;
sprintf(save_str, "%s%d:%d:%d", save_str,
tSeq->creation_date[3],
tSeq->creation_date[4],
tSeq->creation_date[5]);
}
}
else if (fields_array[i] == e_probing_date &&
tSeq->probing_date[0] != 0) {
sprintf(save_str, "\n%s\t%d/%d/%d ",
at[fields_array[i]], tSeq->probing_date[1],
tSeq->probing_date[2], tSeq->probing_date[0]);
if (tSeq->probing_date[3] >= 0) {
if (tSeq->probing_date[4] < 0)
tSeq->probing_date[4] = 0;
if (tSeq->probing_date[5] < 0)
tSeq->probing_date[5] = 0;
sprintf(save_str, "%s%d:%d:%d", save_str,
tSeq->probing_date[3],
tSeq->probing_date[4],
tSeq->probing_date[5]);
}
}
else if (fields_array[i] == e_autorad_date &&
tSeq->autorad_date[0] != 0) {
sprintf(save_str, "\n%s\t%d/%d/%d ",
at[fields_array[i]], tSeq->autorad_date[1],
tSeq->autorad_date[2], tSeq->autorad_date[0]);
if (tSeq->autorad_date[3] >= 0) {
if (tSeq->autorad_date[4] < 0)
tSeq->autorad_date[4] = 0;
if (tSeq->autorad_date[5] < 0)
tSeq->autorad_date[5] = 0;
sprintf(save_str, "%s%d:%d:%d", save_str,
tSeq->autorad_date[3],
tSeq->autorad_date[4],
tSeq->autorad_date[5]);
}
}
else if (fields_array[i] == e_c_elem && tSeq->c_elem != NULL) {
ptr = tSeq->c_elem;
sprintf(save_str, "\n%s\t\"", at[fields_array[i]]);
while (ptr < tSeq->c_elem + tSeq->seqlen) {
if (ptr != tSeq->c_elem) strcat(save_str, "\n");
strncpy(
temp_str, ptr,
MIN(60, tSeq->c_elem + tSeq->seqlen - ptr));
temp_str[MIN(60, tSeq->c_elem + tSeq->seqlen -
ptr)] = '\0';
/* Gurantee strlen(temp_str) chars for the
* string, one for \n, one for ", and one for
* \0.
*/
while (save_str_size - strlen(save_str) <
strlen(temp_str) + 3) {
save_str_size *= 2;
save_str = (char *)Realloc(
save_str, save_str_size);
}
strcat(save_str, temp_str);
ptr += 60;
}
strcat(save_str, "\"");
}
else if (fields_array[i] == e_comments &&
tSeq->commentslen != 0) {
while (save_str_size < 20 + tSeq->commentslen) {
save_str_size *= 2;
save_str =
(char *)Realloc(save_str, save_str_size);
}
strcat(save_str, "\n");
strcat(save_str, at[fields_array[i]]);
strcat(save_str, "\t\"\n");
/* put a \0 at the end of comments. */
while (tSeq->commentslen + 1 > tSeq->commentsmaxlen) {
tSeq->commentsmaxlen *= 2;
tSeq->comments = (char *)Realloc(
tSeq->comments, tSeq->commentsmaxlen);
}
tSeq->comments[tSeq->commentslen] = '\0';
/* clean up the leading empty lines.*/
tt = 0;
while (tSeq->comments[tt] == '\n' ||
tSeq->comments[tt] == ' ')
tt++;
tSeq->commentslen -= tt;
strcat(save_str, tSeq->comments + tt);
strcat(save_str, "\"");
}
else if (fields_array[i] == e_laneset && tSeq->laneset != -1)
sprintf(save_str, "\n%s\t\t%d", at[fields_array[i]],
tSeq->laneset);
else if (fields_array[i] == e_strandedness &&
tSeq->strandedness != 0)
sprintf(save_str, "\n%s\t%d", at[fields_array[i]],
tSeq->strandedness);
else if (fields_array[i] == e_direction && tSeq->direction != 0)
sprintf(save_str, "\n%s\t%d", at[fields_array[i]],
tSeq->direction);
else if (fields_array[i] == e_orig_strand &&
tSeq->orig_strand != 0)
sprintf(save_str, "\n%s\t%d", at[fields_array[i]],
tSeq->orig_strand);
else if (fields_array[i] == e_orig_direction &&
tSeq->orig_direction != 0)
sprintf(save_str, "\n%s\t%d", at[fields_array[i]],
tSeq->orig_direction);
else if (fields_array[i] == e_offset)
sprintf(save_str, "\n%s\t\t%d", at[fields_array[i]],
tSeq->offset);
else if (fields_array[i] == e_group_number &&
tSeq->group_number != 0)
sprintf(save_str, "\n%s\t%d", at[fields_array[i]],
tSeq->group_number);
else if (fields_array[i] == e_group_ID)
sprintf(save_str, "\n%s\t%d", at[fields_array[i]],
tSeq->group_ID);
else if (fields_array[i] == e_type && tSeq->type[0] != '\0')
sprintf(save_str, "\n%s\t\t\"%s\"", at[fields_array[i]],
tSeq->type);
else if (fields_array[i] == e_barcode &&
tSeq->barcode[0] != '\0')
sprintf(save_str, "\n%s\t\t\"%s\"", at[fields_array[i]],
tSeq->barcode);
else if (fields_array[i] == e_name && tSeq->name[0] != '\0')
sprintf(save_str, "\n%s\t\t\"%s\"", at[fields_array[i]],
tSeq->name);
else if (fields_array[i] == e_status && tSeq->status[0] != '\0')
sprintf(save_str, "\n%s\t\t\"%s\"", at[fields_array[i]],
tSeq->status);
else if (fields_array[i] == e_walk && tSeq->walk[0] != '\0')
sprintf(save_str, "\n%s\t\t\"%s\"", at[fields_array[i]],
tSeq->walk);
else if (fields_array[i] == e_sequence_ID &&
tSeq->sequence_ID[0] != '\0')
sprintf(save_str, "\n%s\t\"%s\"", at[fields_array[i]],
tSeq->sequence_ID);
else if (fields_array[i] == e_creator &&
tSeq->creator[0] != '\0')
sprintf(save_str, "\n%s\t\t\"%s\"", at[fields_array[i]],
tSeq->creator);
else if (fields_array[i] == e_film && tSeq->film[0] != '\0')
sprintf(save_str, "\n%s\t\t\"%s\"", at[fields_array[i]],
tSeq->film);
else if (fields_array[i] == e_membrane &&
tSeq->membrane[0] != '\0')
sprintf(save_str, "\n%s\t\"%s\"", at[fields_array[i]],
tSeq->membrane);
else if (fields_array[i] == e_source_ID &&
tSeq->source_ID[0] != '\0')
sprintf(save_str, "\n%s\t\"%s\"", at[fields_array[i]],
tSeq->source_ID);
else if (fields_array[i] == e_contig && tSeq->contig[0] != '\0')
sprintf(save_str, "\n%s\t\t\"%s\"", at[fields_array[i]],
tSeq->contig);
else if (fields_array[i] == e_baggage && tSeq->baglen != 0) {
if (save_str_size < tSeq->baglen + 2) {
save_str_size = tSeq->baglen + 2;
save_str =
(char *)Realloc(save_str, save_str_size);
}
save_str[0] = '\n';
save_str[1] = '\0';
/* put a \0 at the end of baggage. */
strncat(save_str, tSeq->baggage, tSeq->baglen);
while (save_str[tSeq->baglen - 1] == '\n') {
tSeq->baglen--;
}
save_str[tSeq->baglen] = '\0';
}
if (save_str[0] != '\0') {
if (first_field == TRUE) {
first_field = FALSE;
fprintf(fp, "{");
}
fprintf(fp, "%s", save_str);
}
}
if (first_field == FALSE) {
fprintf(fp, "\n}\n");
}
if (all_fields == TRUE && fields_array != NULL) {
Cfree(fields_array);
fields_array = NULL;
}
if (save_str != NULL) {
Cfree(save_str);
save_str = NULL;
}
if (first_field == TRUE)
return 0;
else
return 1;
}
/*********
*
* ReadRecord() reads one record from fp into tSeq. fp remains at
* the finishing position so that next time when ReadRecord() is
* called, it reads the next record.
*
* The caller program should LOCATE MEMORY for the tSeq before calling.
*
* ReadRecord() returns:
* TRUE if no error;
* FALSE if anything is wrong
* -1 if end-of-file is reached
*
**********/
int ReadRecord(fp, tSeq)
FILE *fp;
Sequence *tSeq;
{
char field_name[20], line[256], orig_line[256];
int temp_str_size, start, end, l, max_len = 255;
char *fgets_ret, *temp_str, *fgets_ret1;
int start_rec = FALSE;
int need_to_read = TRUE;
char started = 'F';
void InitRecord();
void FreeRecord();
temp_str = (char *)Calloc(256, 1);
temp_str_size = 256;
InitRecord(tSeq);
if (tSeq->c_elem == NULL) {
tSeq->c_elem = (char *)Calloc(256, 1);
tSeq->seqmaxlen = 256;
}
tSeq->c_elem[0] = '\0';
/* read file line-by-line. */
while (need_to_read == TRUE &&
((fgets_ret = fgets(line, max_len, fp)) != NULL ||
start_rec == TRUE)) {
strcpy(orig_line, line);
end = strlen(line) - 1;
while (end >= 0 && (line[end] == ' ' || line[end] == '\t' ||
line[end] == ',' || line[end] == '\n'))
end--;
/* ignore empty lines. */
if (end == -1) continue;
if (line[end] == '{') started = 'T';
/* to ignore the lines between a } and a {. */
while (started == 'F' && fgets_ret != NULL) {
fgets_ret = fgets(line, max_len, fp);
strcpy(orig_line, line);
end = strlen(line) - 1;
while (end >= 0 &&
(line[end] == ' ' || line[end] == '\t' ||
line[end] == ',' || line[end] == '\n'))
end--;
/* ignore empty lines. */
if (end == -1) continue;
if (line[end] == '{') started = 'T';
}
if (fgets_ret == NULL) return -1;
if (end < 0) {
}
else if ((line[end] == '}') && (end == 0)) {
start_rec = FALSE;
need_to_read = FALSE;
}
else if (line[end] == '{' && end <= 10) {
start_rec = TRUE;
}
else {
if (line[end] == '}') {
need_to_read = FALSE;
start_rec = FALSE;
}
/* locate the tag. */
start = 0;
while (line[start] == ' ' || line[start] == '\t' ||
line[start] == '\n' || line[start] == '{')
start++;
end = start + 1;
while (line[end] != ' ' && line[end] != '\t' &&
line[end] != '\n' && line[end] != '\0')
end++;
strncpy(field_name, line + start, end - start);
field_name[end - start] = '\0';
/* process the field value. */
/*
* creation_date, probing_date, or autorad_date
*/
if (strcmp(field_name, "creation-date") == 0) {
while (!isdigit(line[end])) end++;
if (strToDate(line + end,
tSeq->creation_date) == -1) {
return FALSE;
}
}
else if (strcmp(field_name, "probing-date") == 0) {
while (line[end] != '\0' && !isdigit(line[end]))
end++;
if (line[end] != '\0' &&
strToDate(line + end, tSeq->probing_date) ==
-1) {
return FALSE;
}
}
else if (strcmp(field_name, "autorad-date") == 0) {
while (line[end] != '\0' && !isdigit(line[end]))
end++;
if (line[end] != '\0' &&
strToDate(line + end, tSeq->autorad_date) ==
-1) {
return FALSE;
}
}
/*
* sequence or comments.
*/
else if (strcmp(field_name, "sequence") == 0 ||
strcmp(field_name, "comments") == 0) {
temp_str[0] = '\0';
/* locate the first ". */
while (line[end++] != '"')
;
start = end;
end = strlen(line);
/* ---"\n\0. */
if (line[end - 2] == '"')
end -= 2;
else if (line[end - 1] == '\n' &&
strcmp(field_name, "sequence") == 0)
end--;
while (temp_str_size < end - start + 1) {
temp_str_size *= 2;
temp_str = (char *)Realloc(
temp_str, temp_str_size);
}
if (end - start > 0)
strncat(temp_str, line + start,
end - start);
/* Read the second line of the seq. or comments,
if any. end-start<0 is the case that " is the
only char this line.*/
if (line[strlen(line) - 2] != '"' ||
end - start < 0) {
while ((fgets_ret1 =
fgets(line, max_len, fp)) !=
NULL) {
/* IGNORE empty lines. 5/4/92 */
int empty_line = 0;
while (line[empty_line] == ' ')
empty_line++;
if (line[empty_line] == '\n') {
continue;
/* strncat(temp_str,
* line, end); 5/4/92 */
}
l = strlen(line) - 1;
if (line[l - 1] == '"')
end = l - 1;
else
end = l;
if (line[end] == '\n' &&
strcmp(field_name,
"comments") == 0)
end++;
/* Gurantee 'end' chars for the
* string, one for ", and one
* for \0.
*/
while (temp_str_size -
strlen(temp_str) <
end + 3) {
temp_str_size *= 2;
temp_str =
(char *)Realloc(
temp_str,
temp_str_size);
}
strncat(temp_str, line, end);
if (line[l - 1] == '"') break;
}
if (fgets_ret1 == NULL &&
need_to_read == TRUE) {
fprintf(stderr,
"ReadRecord(): "
"incomplete record.\n");
return FALSE;
}
}
l = strlen(temp_str);
if (strcmp(field_name, "comments") == 0) {
if (tSeq->commentsmaxlen == 0) {
tSeq->comments =
(char *)Calloc(l + 1, 1);
tSeq->commentsmaxlen = l + 1;
}
else {
while (tSeq->commentslen + l +
1 >
tSeq->commentsmaxlen) {
tSeq->commentsmaxlen *=
2;
tSeq->comments =
(char *)Realloc(
tSeq->comments,
tSeq->commentsmaxlen);
}
}
tSeq->comments[tSeq->commentslen] =
'\0';
strcat(tSeq->comments, temp_str);
tSeq->commentslen += l;
}
else /* it is the sequence. */
{
if (tSeq->seqmaxlen == 0) {
tSeq->c_elem =
(char *)Calloc(l + 1, 1);
}
else if (l + 1 > tSeq->seqmaxlen) {
tSeq->c_elem = (char *)Realloc(
tSeq->c_elem, l + 1);
}
tSeq->seqmaxlen = l + 1;
tSeq->seqlen = l;
strcpy(tSeq->c_elem, temp_str);
}
}
/*
* Integer or String.
*/
else {
/* locate the value: a string or an integer. */
while (line[end] == ' ' || line[end] == '\t')
end++;
if (line[end] == '"') {
/* It is a string. */
end++;
start = end;
while (line[end] != '\0' &&
line[end] != '"')
end++;
/*
* strncat will not put a \0 at the end
* of a string if the copying string is
* longer than n.
*/
line[end++] = '\0';
}
else {
/* It is an integer. */
start = end;
while (line[end] != ' ' &&
line[end] != '\t' &&
line[end] != '\n' &&
line[end] != '\0')
end++;
strncpy(temp_str, line + start,
end - start + 1); /*4/26 add 1*/
temp_str[end - start] = '\0';
}
/* assign to an integer field. */
if (strcmp(field_name, "laneset") == 0)
tSeq->laneset = atoi(temp_str);
else if (strcmp(field_name, "strandedness") ==
0)
tSeq->strandedness = atoi(temp_str);
else if (strcmp(field_name, "direction") == 0)
tSeq->direction = atoi(temp_str);
else if (strcmp(field_name, "orig_strand") == 0)
tSeq->orig_strand = atoi(temp_str);
else if (strcmp(field_name, "orig_direction") ==
0)
tSeq->orig_direction = atoi(temp_str);
else if (strcmp(field_name, "offset") == 0)
tSeq->offset = atoi(temp_str);
else if (strcmp(field_name, "group-number") ==
0)
tSeq->group_number = atoi(temp_str);
else if (strcmp(field_name, "group-ID") == 0)
tSeq->group_ID = atoi(temp_str);
/* assign to a string field. */
else if (strcmp(field_name, "type") == 0) {
if (end - start > 31) end = start + 31;
strncpy(tSeq->type, line + start,
end - start);
tSeq->type[end - start] = '\0';
}
else if (strcmp(field_name, "barcode") == 0) {
if (end - start > 31) end = start + 31;
strncpy(tSeq->barcode, line + start,
end - start);
tSeq->barcode[end - start] = '\0';
}
else if (strcmp(field_name, "name") == 0) {
if (end - start > 31) end = start + 31;
strncpy(tSeq->name, line + start,
end - start);
tSeq->name[end - start] = '\0';
}
else if (strcmp(field_name, "status") == 0) {
if (end - start > 31) end = start + 31;
strncpy(tSeq->status, line + start,
end - start);
tSeq->status[end - start] = '\0';
}
else if (strcmp(field_name, "walk") == 0) {
if (end - start > 31) end = start + 31;
strncpy(tSeq->walk, line + start,
end - start);
tSeq->walk[end - start] = '\0';
}
else if (strcmp(field_name, "sequence-ID") ==
0) {
if (end - start > 31) end = start + 31;
strncpy(tSeq->sequence_ID, line + start,
end - start);
tSeq->sequence_ID[end - start] = '\0';
}
else if (strcmp(field_name, "creator") == 0) {
if (end - start > 31) end = start + 31;
strncpy(tSeq->creator, line + start,
end - start);
tSeq->creator[end - start] = '\0';
}
else if (strcmp(field_name, "film") == 0) {
if (end - start > 31) end = start + 31;
strncpy(tSeq->film, line + start,
end - start);
tSeq->film[end - start] = '\0';
}
else if (strcmp(field_name, "membrane") == 0) {
if (end - start > 31) end = start + 31;
strncpy(tSeq->membrane, line + start,
end - start);
tSeq->membrane[end - start] = '\0';
}
else if (strcmp(field_name, "source-ID") == 0) {
if (end - start > 31) end = start + 31;
strncpy(tSeq->source_ID, line + start,
end - start);
tSeq->source_ID[end - start] = '\0';
}
else if (strcmp(field_name, "contig") == 0) {
if (end - start > 31) end = start + 31;
strncpy(tSeq->contig, line + start,
end - start);
tSeq->contig[end - start] = '\0';
}
else {
if (tSeq->bagmaxlen == 0) {
tSeq->bagmaxlen =
4 * strlen(orig_line);
tSeq->baggage = (char *)Calloc(
tSeq->bagmaxlen, 1);
}
else {
while (tSeq->bagmaxlen <
tSeq->baglen + 2 +
strlen(orig_line)) {
tSeq->bagmaxlen *= 2;
tSeq->baggage =
(char *)Realloc(
tSeq->baggage,
tSeq->bagmaxlen);
}
}
if (tSeq->baglen == 0) {
/*
tSeq->baggage[0] = '\n';
tSeq->baggage[1] = '\0';
tSeq->baglen = 1;
*/
tSeq->baggage[0] = '\0';
}
/* strcat(tSeq->baggage, "\n");*/
strcat(tSeq->baggage, orig_line);
tSeq->baglen += strlen(orig_line);
}
}
}
}
if (temp_str != NULL) {
Cfree(temp_str);
temp_str = NULL;
}
if (start_rec == FALSE && fgets_ret == NULL) {
/* end of file, did not get a record. */
return -1;
}
else
return TRUE;
}
/*********
*
* Initialize a record.
*
* Note: no memory allocation is performed.
*
**********/
void InitRecord(tSeq) Sequence *tSeq;
{
int i;
strcpy(tSeq->type, "DNA");
tSeq->barcode[0] = '\0';
tSeq->name[0] = '\0';
tSeq->status[0] = '\0';
strcpy(tSeq->walk, "FALSE");
tSeq->sequence_ID[0] = '\0';
tSeq->c_elem = NULL;
tSeq->seqlen = 0;
tSeq->seqmaxlen = 0;
for (i = 0; i < 6; i++) {
tSeq->creation_date[i] = 0;
tSeq->probing_date[i] = 0;
tSeq->autorad_date[i] = 0;
}
tSeq->creator[0] = '\0';
tSeq->film[0] = '\0';
tSeq->membrane[0] = '\0';
tSeq->source_ID[0] = '\0';
tSeq->contig[0] = '\0';
tSeq->laneset = -1;
tSeq->direction = 1; /* (1/-1/0),default: 5 to 3. */
tSeq->strandedness = 1; /* (1/2/0), default: primary.*/
tSeq->orig_direction = 0; /* (0 unknown, -1:3'->5', 1:5'->3') */
tSeq->orig_strand = 0; /* (0 unknown, 1:primary, 2:secondary) */
tSeq->offset = 0;
tSeq->comments = NULL;
tSeq->commentslen = 0;
tSeq->commentsmaxlen = 0;
tSeq->baggage = NULL;
tSeq->baglen = 0;
tSeq->bagmaxlen = 0;
tSeq->group_number = 0;
tSeq->group_ID = 0;
}
void CopyRecord(to, from) Sequence *from, *to;
{
int i;
InitRecord(to);
strcpy(to->type, from->type);
strcpy(to->barcode, from->barcode);
strcpy(to->name, from->name);
strcpy(to->status, from->status);
strcpy(to->walk, from->walk);
strcpy(to->sequence_ID, from->sequence_ID);
if (from->c_elem != NULL) {
to->seqlen = from->seqlen;
to->seqmaxlen = from->seqmaxlen;
to->c_elem = (char *)Calloc(to->seqmaxlen, 1);
strncpy(to->c_elem, from->c_elem, to->seqlen);
to->c_elem[to->seqlen] = '\0';
}
for (i = 0; i < 6; i++) {
to->creation_date[i] = from->creation_date[i];
to->probing_date[i] = from->probing_date[i];
to->autorad_date[i] = from->autorad_date[i];
}
strcpy(to->creator, from->creator);
strcpy(to->film, from->film);
strcpy(to->membrane, from->membrane);
strcpy(to->source_ID, from->source_ID);
strcpy(to->contig, from->contig);
to->laneset = from->laneset;
to->strandedness = from->strandedness;
to->orig_direction = from->orig_direction;
to->orig_strand = from->orig_strand;
to->direction = from->direction;
to->offset = from->offset;
if (from->comments != NULL) {
to->commentsmaxlen = from->commentsmaxlen;
to->commentslen = from->commentslen;
to->comments = (char *)Calloc(to->commentsmaxlen, 1);
strncpy(to->comments, from->comments, to->commentslen);
to->comments[to->commentslen] = '\0';
}
if (from->baggage != NULL) {
to->baglen = from->baglen;
to->bagmaxlen = from->bagmaxlen;
to->baggage = (char *)Calloc(to->bagmaxlen, 1);
strncpy(to->baggage, from->baggage, to->baglen);
to->baggage[to->baglen] = '\0';
}
to->group_number = from->group_number;
to->group_ID = from->group_ID;
}
/*********
*
* Clean the contents of a record without changing the memory size.
*
**********/
void CleanRecord(tSeq) Sequence *tSeq;
{
int i;
strcpy(tSeq->type, "DNA");
tSeq->name[0] = '\0';
tSeq->barcode[0] = '\0';
tSeq->status[0] = '\0';
strcpy(tSeq->walk, "FALSE");
tSeq->sequence_ID[0] = '\0';
if (tSeq->c_elem != NULL) tSeq->c_elem[0] = '\0';
tSeq->seqlen = 0;
for (i = 0; i < 6; i++) {
tSeq->creation_date[i] = 0;
tSeq->probing_date[i] = 0;
tSeq->autorad_date[i] = 0;
}
tSeq->creator[0] = '\0';
tSeq->film[0] = '\0';
tSeq->membrane[0] = '\0';
tSeq->source_ID[0] = '\0';
tSeq->contig[0] = '\0';
tSeq->laneset = -1;
tSeq->strandedness = 1; /* (1/2/0), default. primary. */
tSeq->direction = 1; /* (1/-1/0),default. 5 to 3. */
tSeq->orig_direction = 0;
tSeq->orig_strand = 0;
tSeq->offset = 0;
if (tSeq->comments != NULL) tSeq->comments[0] = '\0';
tSeq->commentslen = 0;
if (tSeq->baggage != NULL) tSeq->baggage[0] = '\0';
tSeq->baglen = 0;
tSeq->group_number = 0;
tSeq->group_ID = 0;
}
/*********
*
* Free memory for a record.
*
**********/
void FreeRecord(tSeq) Sequence **tSeq;
{
Cfree((*tSeq)->c_elem);
Cfree((*tSeq)->comments);
Cfree((*tSeq)->baggage);
Cfree((*tSeq));
(*tSeq)->c_elem = NULL;
(*tSeq)->comments = NULL;
(*tSeq)->baggage = NULL;
(*tSeq) = NULL;
}
static max_day[2][13] = {{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
/***********
*
* strToDate() locates first six integers and translates them
* into a date.
*
* String should have the format of "mm/dd/yy hh/mn/sc xm",
* with anything except digit as the delimiters.
*
* Order in the date array is (0->5): (yy mm dd hh mn sc).
*
* Returns FALSE if anything is wrong, TRUE otherwise.
*
**********/
int strToDate(str, date) const char *str;
int date[];
{
int leap;
char temp_str[2];
char longstr[256];
/* locate 6 integers. */
strcpy(longstr, str);
strcat(longstr, " -1/-1/-1 ");
sscanf(longstr, "%d%*c%d%*c%d%*c%d%*c%d%*c%d%2s", &date[1], &date[2],
&date[0], &date[3], &date[4], &date[5], temp_str);
/* verify year. */
if (date[0] >= 100) date[0] -= 1900;
/* verify month. */
if (date[1] > 12 || date[1] < 1) {
fprintf(stderr, "invalid month %s\n", str);
return FALSE;
}
/* verify day. */
if ((date[0] % 4 == 0 && date[0] % 100 != 0) || date[0] % 400 == 0)
leap = 1;
else
leap = 0;
if (date[2] > max_day[leap][date[1]] || date[2] < 1) {
fprintf(stderr, "invalid day %s\n", str);
return FALSE;
}
/* verify time. */
if (strncmp(temp_str, "pm", 2) == 0) date[3] += 12;
if (date[3] < -1 || date[3] > 23 || date[4] < -1 || date[4] > 59 ||
date[5] < -1 || date[5] > 59) {
fprintf(stderr, "invalid time %s\n", str);
return FALSE;
}
return TRUE;
}
/**********
*
* Default_IUPAC_Trans() translates an ASCII IUPAC code into
* an (char) integer.
*
**********/
char Default_IUPAC_Trans(base)
char base;
{
int i;
char c;
c = base | 32;
if (c == 'u') return (char)8;
if (c == 'p') return (char)5;
for (i = 0; i < 16; i++) {
if (c == Default_DNA_Trans[i]) {
return ((char)i);
}
}
fprintf(stderr, "Character %c is not IUPAC coded.\n", base);
return -1;
}
char *uniqueID();
/***********
*
* MakeConsensus() takes an array of aligned sequence and an
* initialized 'Sequence' consensus. It modifies the consensus.
*
* The memory that 'consensus' has located will be reused, and
* consensus->seqmaxlen will be modified if necessary.
*
* Returns TRUE if successful, FALSE otherwise.
*
**********/
int MakeConsensus(aligned, numOfAligned, consensus, group)
Sequence aligned[]; /* input. */
int numOfAligned; /* input. */
Sequence *consensus; /* input and output. */
int group; /* Group number (if zero, use all groups) */
{
char occurence;
int i, j, index;
int max_cons = INT_MIN;
int min_offset = INT_MAX;
char temp_str[2];
unsigned char case_bit;
/*
* Search for the minimun offset.
*/
for (i = 0; i < numOfAligned; i++) {
if (group == 0 || aligned[i].group_number == group) {
SeqNormal(&aligned[i]);
min_offset = MIN(min_offset, aligned[i].offset);
max_cons = MAX(max_cons,
aligned[i].offset + aligned[i].seqlen);
}
}
/*
* Decide consensus base by base.
*/
CleanRecord(consensus);
consensus->offset = min_offset;
if (aligned[0].contig[0] != '\0') {
strcpy(consensus->name, aligned[0].contig);
strcat(consensus->name, ".");
}
else if (strncmp(aligned[0].name, "cons.", 5) != 0) {
strcpy(consensus->name, "cons.");
strcat(consensus->name, aligned[0].name);
}
strcpy(consensus->sequence_ID, uniqueID());
strcpy(consensus->contig, aligned[0].contig);
for (j = min_offset; j < max_cons; j++) {
occurence = 00;
case_bit = 0;
for (i = 0; i < numOfAligned; i++) {
if (group == 0 || aligned[i].group_number == group) {
if (j >= aligned[i].offset &&
j < aligned[i].offset + aligned[i].seqlen) {
index = j - aligned[i].offset;
if (aligned[i].c_elem[index] == '-')
case_bit = 32;
else if (case_bit == 0)
case_bit |=
(aligned[i].c_elem[index] &
32);
occurence =
occurence |
Default_IUPAC_Trans(
aligned[i].c_elem[index]);
if (occurence != 1 && occurence != 2 &&
occurence != 4 && occurence != 8)
case_bit = 32;
/*
printf("%1c", aligned[i].c_elem[index]);
*/
}
/*
else
printf(" ");
*/
}
}
sprintf(temp_str, "%1c", Default_DNA_Trans[(int)occurence]);
if (case_bit == 0) temp_str[0] = toupper(temp_str[0]);
if (InsertElems(consensus, j, temp_str) == FALSE) return FALSE;
/*
printf(" cons[%d]=%1c\n", j - min_offset,
consensus->c_elem[j - min_offset]);
*/
}
return TRUE;
}
/***********
*
* MakeScore() takes an array of aligned sequence, and generates
* a consensus. Note, memory for (Sequence* consensus) should be
* located before it is passed to this function.
*
* Returns TRUE if successful, FALSE otherwise.
*
**********/
int MakeScore(aligned, numOfAligned, consensus, group)
Sequence aligned[]; /* input. */
int numOfAligned; /* input. */
Sequence *consensus; /* input and output. */
int group;
{
int i, j, index, score;
int max_cons = INT_MIN;
int min_offset = INT_MAX;
int As, Cs, Ts, Gs, Ns, tot_in_grp;
char temp_str[2], occurence, base;
int max_occ;
static char map[17] = "0123456789ABCDEF";
/*
* Search for the minimum offset.
*/
for (i = 0; i < numOfAligned; i++) {
if (group == 0 || aligned[i].group_number == group) {
SeqNormal(&aligned[i]);
min_offset = MIN(min_offset, aligned[i].offset);
max_cons = MAX(max_cons,
aligned[i].offset + aligned[i].seqlen);
}
}
/*
* Decide consensus base by base.
*/
CleanRecord(consensus);
consensus->offset = min_offset;
if (aligned[0].contig[0] != '\0') {
strcpy(consensus->name, aligned[0].contig);
strcat(consensus->name, ".");
}
else if (strncmp(aligned[0].name, "cons.", 5) != 0) {
strcpy(consensus->name, "cons.");
strcat(consensus->name, aligned[0].name);
}
strcpy(consensus->sequence_ID, uniqueID());
strcpy(consensus->contig, aligned[0].contig);
for (j = min_offset; j < max_cons; j++) {
As = Cs = Ts = Gs = Ns = 0;
tot_in_grp = 0;
occurence = 00;
for (i = 0; i < numOfAligned; i++) {
if (group == 0 || aligned[i].group_number == group) {
if (j >= aligned[i].offset &&
j < aligned[i].offset + aligned[i].seqlen) {
tot_in_grp++;
index = j - aligned[i].offset;
/*
occurence =
Default_IUPAC_Trans(aligned[i].c_elem[index]);
if((occurence & 01) == 01)
As++;
if((occurence & 02) == 02)
Cs++;
if((occurence & 04) == 04)
Gs++;
if((occurence & 010) == 010)
Ts++;
*/
base = (aligned[i].c_elem[index] | 32);
if (base == 'a')
As++;
else if (base == 'c')
Cs++;
else if (base == 'g')
Gs++;
else if (base == 't')
Ts++;
else if (base == 'n' || base == '-')
Ns++;
/*
printf("%1c",
aligned[i].c_elem[index]);
*/
}
/*
else
printf(" ");
*/
}
}
max_occ = MAX(As, MAX(Cs, MAX(Gs, Ts)));
/* socre = [0,E], F:all mismatches are either 'n' or '-' */
if (Ns != 0 && max_occ + Ns == tot_in_grp)
score = 15;
else
score = max_occ * 14 / tot_in_grp;
/*
if( score > 0xF )
{
if (InsertElems(consensus, j, "F") == FALSE)
{
return FALSE;
}
}
else
{
*/
sprintf(temp_str, "%1c", map[score]);
if (InsertElems(consensus, j, temp_str) == FALSE) {
return FALSE;
}
/*
printf(" %2d-%2d-%2d-%2d %2d cons[%d]=%1c\n",
Ts, Gs, Cs, As, score, j,
consensus->c_elem[j]);
*/
}
return TRUE;
}
/***********
*
* MakePhyloMask() takes an array of aligned sequence, and generates
* a mask that has a '0' for all columns except the columns which contain
* a, c, g, t and u only.
*
* Returns TRUE if successful, FALSE otherwise.
*
**********/
int MakePhyloMask(aligned, numOfAligned, consensus, group, acgtu)
Sequence aligned[]; /* input. */
int numOfAligned; /* input. */
Sequence *consensus; /* input and output. */
int acgtu[];
int group;
{
int i, j, cnt, max_cons = INT_MIN, min_offset = INT_MAX;
/*
* Search for the minimum offset.
*/
for (i = 0; i < numOfAligned; i++) {
if (group == 0 || aligned[i].group_number == group) {
SeqNormal(&aligned[i]);
min_offset = MIN(min_offset, aligned[i].offset);
max_cons = MAX(max_cons,
aligned[i].offset + aligned[i].seqlen);
}
}
/*
* Decide consensus base by base.
*/
CleanRecord(consensus);
consensus->offset = min_offset;
strcpy(consensus->name, "mask");
strcpy(consensus->type, "MASK");
strcpy(consensus->sequence_ID, uniqueID());
strcpy(consensus->contig, aligned[0].contig);
consensus->seqlen = max_cons - min_offset;
if (consensus->seqmaxlen == 0) {
consensus->c_elem =
(char *)Calloc(max_cons - min_offset + 5, 1);
consensus->seqmaxlen = max_cons - min_offset + 5;
}
else if (consensus->seqmaxlen < max_cons - min_offset) {
consensus->seqmaxlen = max_cons - min_offset + 5;
consensus->c_elem = (char *)Realloc(consensus->c_elem,
max_cons - min_offset + 5);
}
cnt = 0;
for (j = min_offset; j < max_cons; j++) {
consensus->c_elem[j - min_offset] = '1';
for (i = 0; i < numOfAligned; i++) {
if (group == 0 || aligned[i].group_number == group) {
if (j < aligned[i].offset ||
j >=
aligned[i].offset + aligned[i].seqlen ||
acgtu[aligned[i]
.c_elem[j - aligned[i].offset]] ==
0) {
consensus->c_elem[j - min_offset] = '0';
cnt++;
break;
}
}
}
}
fprintf(stderr, "\nNumber of 1s in mask: %d\n",
max_cons - min_offset - cnt);
fprintf(stderr, "Number of 0s in mask: %d\n\n", cnt);
return TRUE;
}
/***********
*
* MajorityCons() takes an array of aligned sequence, and generates
* a MAJORITY consensus.
* Note, memory for (Sequence* consensus) should be
* located before it is passed to this function.
*
* Returns TRUE if successful, FALSE otherwise.
*
**********/
int MajorityCons(aligned, numOfAligned, consensus, group, major_perc)
Sequence aligned[]; /* input. */
int numOfAligned; /* input. */
Sequence *consensus; /* input and output. */
int group, major_perc;
{
int i, j, index, score, ii, base, max;
int max_cons = INT_MIN;
int min_offset = INT_MAX;
char temp_str[2], occurence;
int *cnts, tot_in_grp;
unsigned char case_bit;
cnts = (int *)Calloc(16, sizeof(int));
/*
* Search for the minimum offset.
*/
for (i = 0; i < numOfAligned; i++) {
if (group == 0 || aligned[i].group_number == group) {
SeqNormal(&aligned[i]);
min_offset = MIN(min_offset, aligned[i].offset);
max_cons = MAX(max_cons,
aligned[i].offset + aligned[i].seqlen);
}
}
/*
* Decide consensus base by base.
*/
CleanRecord(consensus);
consensus->offset = min_offset;
if (aligned[0].contig[0] != '\0') {
strcpy(consensus->name, aligned[0].contig);
strcat(consensus->name, ".");
}
else if (strncmp(aligned[0].name, "cons.", 5) != 0) {
strcpy(consensus->name, "cons.");
strcat(consensus->name, aligned[0].name);
}
strcpy(consensus->sequence_ID, uniqueID());
strcpy(consensus->contig, aligned[0].contig);
for (j = min_offset; j < max_cons; j++) {
case_bit = 0;
occurence = 00;
tot_in_grp = 0;
for (ii = 0; ii < 16; ii++) cnts[ii] = 0;
for (i = 0; i < numOfAligned; i++) {
if (group == 0 || aligned[i].group_number == group) {
if (j >= aligned[i].offset &&
j < aligned[i].offset + aligned[i].seqlen) {
tot_in_grp++;
index = j - aligned[i].offset;
if (aligned[i].c_elem[index] == '-')
case_bit = 32;
else if (case_bit == 0)
case_bit |=
(aligned[i].c_elem[index] &
32);
occurence |= Default_IUPAC_Trans(
aligned[i].c_elem[index]);
cnts[(int)Default_IUPAC_Trans(
aligned[i].c_elem[index])]++;
if (case_bit == 0 && occurence != 1 &&
occurence != 2 && occurence != 4 &&
occurence != 8)
case_bit = 32;
}
}
}
max = 0;
for (ii = 0; ii < 16; ii++) {
if (cnts[ii] > max) {
max = cnts[ii];
base = ii;
}
}
if (max * 100 / tot_in_grp >= major_perc) {
/* follow the majority rule. */
sprintf(temp_str, "%1c", Default_DNA_Trans[base]);
}
else {
/* use IUPAC code. */
sprintf(temp_str, "%1c",
Default_DNA_Trans[(int)occurence]);
}
if (case_bit == 0) temp_str[0] = toupper(temp_str[0]);
if (InsertElems(consensus, j, temp_str) == FALSE) {
return FALSE;
}
}
return TRUE;
}
/***********
*
* ReadGDEtoHGL() reads a GDE formated file into an array of HGL structure.
*
* Return -1 if anything is wrong, number_of_sequence otherwise.
*
***********/
int ReadGDEtoHGL(fp, tSeq_arr)
FILE *fp;
Sequence **tSeq_arr;
{
char line[MAXLINELEN];
int ptr, num_seq, max_num_seq = 20;
int seq_len = 200;
char *newline;
(*tSeq_arr) = (Sequence *)Calloc(max_num_seq, sizeof(Sequence));
num_seq = -1;
while (fgets(line, MAXLINELEN - 2, fp) != NULL) /* spaces for \n\0 */
{
/* ptr points to the last char. */
ptr = strlen(line) - 1;
/* clear up the tail. */
while (ptr >= 0 && (line[ptr] == '\n' || line[ptr] == ' ' ||
line[ptr] == '\t'))
ptr--;
line[ptr + 1] = '\0';
if (ptr <= 0) {
/* it is an empty line. */
}
else if (line[0] == '#') {
if (++num_seq == max_num_seq) {
max_num_seq *= 2;
/* printf("max_num_seq = %d\n", max_num_seq); */
(*tSeq_arr) = (Sequence *)Realloc(
(*tSeq_arr),
max_num_seq * sizeof(Sequence));
}
InitRecord((*tSeq_arr)[num_seq]);
if (line[ptr] == '<') {
(*tSeq_arr)[num_seq].direction = 2; /* 3to5 */
line[ptr] = '\0';
}
else if (line[ptr] == '>') {
(*tSeq_arr)[num_seq].direction = 1; /* 5to3 */
line[ptr] = '\0';
}
strcpy((*tSeq_arr)[num_seq].sequence_ID, line + 1);
}
else {
ptr = 0;
if ((*tSeq_arr)[num_seq].seqlen == 0) {
/* determine the offset. */
while (line[ptr] != '\0' && line[ptr] == '-') {
ptr++;
}
(*tSeq_arr)[num_seq].offset += ptr;
}
if (line[ptr] != '\0') {
newline = line + ptr;
if ((*tSeq_arr)[num_seq].seqmaxlen == 0) {
(*tSeq_arr)[num_seq].c_elem =
(char *)Calloc(seq_len, 1);
(*tSeq_arr)[num_seq].c_elem[0] = '\0';
(*tSeq_arr)[num_seq].seqmaxlen =
seq_len;
}
else {
while ((*tSeq_arr)[num_seq].seqlen +
strlen(newline) + 1 >
(*tSeq_arr)[num_seq].seqmaxlen) {
seq_len *= 2;
(*tSeq_arr)[num_seq]
.c_elem = (char *)Realloc(
(*tSeq_arr)[num_seq].c_elem,
seq_len);
(*tSeq_arr)[num_seq].seqmaxlen =
seq_len;
}
}
strcat((*tSeq_arr)[num_seq].c_elem, newline);
(*tSeq_arr)[num_seq].seqlen =
strlen((*tSeq_arr)[num_seq].c_elem);
}
}
}
return (num_seq + 1);
}
/********
*
* InsertElems returns TRUE if successful, FALSE otherwise.
*
********/
int InsertElems(seq, pos, c)
Sequence *seq; /* Sequence */
int pos; /* Position (in respect to the master consensus)
* to insert BEFORE
* always move string to the right. */
char c[]; /*Null terminated array of elements to insert */
{
int dashes, j, len;
len = strlen(c);
if (seq->seqlen == 0) {
/* get rid of '-'s at right. */
/*
dashes = len-1;
while(dashes >= 0 && c[dashes] == '-')
dashes--;
if(dashes < 0)
{
seq->offset = pos;
return TRUE;
}
c[dashes+1] = '\0';
*/
/* clear out '-'s at left. */
dashes = 0;
/*
while(c[dashes] == '-')
dashes++;
c += dashes;
len = strlen(c);
pos += dashes;
*/
if (seq->seqmaxlen == 0) {
seq->c_elem = (char *)Calloc(len + 1, 1);
seq->seqmaxlen = len + 1;
}
else if (len + 1 >= seq->seqmaxlen) {
seq->c_elem = (char *)Realloc(seq->c_elem, len + 1);
seq->seqmaxlen = len + 1;
}
strcpy(seq->c_elem, c);
seq->seqlen = len;
seq->offset = pos;
return TRUE;
}
/* to make sure there is a space for '\0'. */
if (seq->seqlen > seq->seqmaxlen) {
fprintf(
stderr,
"InsertElems(): seqlen>seqmaxlen. Something is wrong.\n");
return FALSE;
}
else {
while (seq->seqlen + 1 >= seq->seqmaxlen) {
seq->seqmaxlen *= 2;
seq->c_elem =
(char *)Realloc(seq->c_elem, seq->seqmaxlen);
}
}
seq->c_elem[seq->seqlen] = '\0';
if (pos < seq->offset) /* insert to the left of the seq. */
{
/* ignore the dashes at the left. */
dashes = 0;
/*
while(dashes < len && c[dashes] == '-')
dashes++;
if(c[dashes] == '\0')
{
seq->offset += len;
return TRUE;
}
c += dashes;
len -= dashes;
*/
if (seq->seqlen + len + seq->offset - pos > seq->seqmaxlen) {
seq->seqmaxlen =
seq->seqlen + len + seq->offset - pos + 256;
seq->c_elem =
(char *)Realloc(seq->c_elem, seq->seqmaxlen);
}
/* copy the old string including the last '\0'. */
for (j = seq->seqlen; j >= 0; j--)
seq->c_elem[j + len + seq->offset - pos] =
seq->c_elem[j];
/* insert dashes. */
for (j = len; j < len + seq->offset - pos; j++)
seq->c_elem[j] = '-';
/* copy the inserted string. */
for (j = 0; j < len; j++) seq->c_elem[j] = c[j];
/* detector. */
if (c[j] != '\0')
fprintf(stderr, "InsertElems: Problem.....\n");
seq->seqlen = strlen(seq->c_elem);
/* seq->offset = pos; commented on 6-3-91 */
seq->offset = pos + dashes;
if (dashes > 0)
printf("\nInsertElems(): dashes is not zero.\n\n");
}
else if (pos - seq->offset >= seq->seqlen) /* insert to the right. */
{
/* ignore the dashes at the right. */
/*
dashes = len -1;
while(dashes >= 0 && c[dashes] == '-')
dashes--;
if(dashes < 0)
return TRUE;
len = dashes+1;
c[len] = '\0';
*/
if (pos - seq->offset + len > seq->seqmaxlen) {
seq->seqmaxlen = pos - seq->offset + len + 256;
seq->c_elem =
(char *)Realloc(seq->c_elem, seq->seqmaxlen);
}
/* insert dashes. */
for (j = seq->seqlen; j < pos - seq->offset; j++)
seq->c_elem[j] = '-';
/* copy the inserted string. */
for (j = 0; j < len; j++)
seq->c_elem[pos - seq->offset + j] = c[j];
seq->c_elem[pos - seq->offset + len] = '\0';
/* detector. */
if (c[j] != '\0')
fprintf(stderr, "InsertElems: Problem too .....\n");
seq->seqlen = strlen(seq->c_elem);
}
else /* insert into the seq. */
{
if (seq->seqlen + len > seq->seqmaxlen) {
seq->seqmaxlen = seq->seqlen + len + 256;
seq->c_elem =
(char *)Realloc(seq->c_elem, seq->seqmaxlen);
}
/* move the bottom part of the older string including the last
* '\0'. */
for (j = seq->seqlen; j >= pos - seq->offset; j--)
seq->c_elem[j + len] = seq->c_elem[j];
/* copy the inserted string. */
for (j = 0; j < len; j++)
seq->c_elem[pos - seq->offset + j] = c[j];
/* detector. */
if (c[j] != '\0')
fprintf(stderr,
"InsertElems: Problem too too .....\n");
seq->seqlen = strlen(seq->c_elem);
}
return TRUE;
}
/******************************************************************
*
* int GetArgs(argArray, numArgs)
* Arg *argArray;
* int numArgs;
*
* Return TRUE if successful, FALSE otherwise.
*
******************************************************************/
#define MAX_ARGS 50 /* maximum args this can process */
int GetArgs(argArray, numArgs, argc, argv)
Args *argArray;
int numArgs;
int argc;
char **argv;
{
int i, j;
Args *curarg;
int noArgOK = TRUE;
if ((argArray == NULL) || (numArgs == 0) || (numArgs > MAX_ARGS)) {
fprintf(stderr, "GetArgs: Invalid number of args.\n");
return FALSE;
}
/*
* Test if all are either 'default' or 'optional'.
*/
curarg = argArray;
for (i = 0; i < numArgs; i++, curarg++) {
if (curarg->strvalue[0] == '\0' && curarg->optional == 'F') {
noArgOK = FALSE;
break;
}
}
/*
* show usage if some arg is required but no arg is
* supllied on command line.
*/
if (noArgOK == FALSE && argc == 1) {
fprintf(stderr, "\n%s arguments:\n\n", argv[0]);
curarg = argArray;
for (i = 0; i < numArgs; i++, curarg++) {
fprintf(stderr, " -%c %s ", curarg->tag,
curarg->prompt);
if (curarg->optional == 'T')
fprintf(stderr, " [Optional]");
fprintf(stderr, "\n");
if (curarg->strvalue[0] != '\0')
fprintf(stderr, " default = %s\n",
curarg->strvalue);
}
fprintf(stderr, "\n");
return FALSE;
}
/*
* Process
*/
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-') {
fprintf(stderr, "Arguments must start with -");
return FALSE;
}
/* check the tag. */
curarg = argArray;
for (j = 0; j < numArgs; j++, curarg++) {
if ((argv[i][1] | 32) == (curarg->tag | 32)) break;
}
if (j == numArgs) {
fprintf(stderr, "Invalid argument tag in %s\n",
argv[i]);
return FALSE;
}
strcpy(curarg->strvalue, argv[i] + 2);
if (curarg->strvalue[0] == '\'' &&
curarg->strvalue[strlen(curarg->strvalue) - 1] == '\'') {
char ttmm[256];
strcpy(ttmm, curarg->strvalue + 1);
ttmm[strlen(ttmm) - 1] = '\0';
strcpy(curarg->strvalue, ttmm);
}
}
return TRUE;
}
/*********
*
* GetCond interprets the -c argument, the condition.
*
* The condition will be set to NULL if no condition is specified,
* that is, if you pass '&p' as the address of a cond* structure,
* p will be set to NULL if no condition [(p == NULL) = TRUE].
*
* Return TRUE if successful, FALSE otherwise.
*
*********/
int GetCond(arg, cond)
char *arg;
str_cond **cond;
{
int start, end, i, found;
char message_buf[1000];
if (strcmp(arg, "null") == 0) {
(*cond) = NULL;
return TRUE;
}
else {
(*cond) = (str_cond *)Calloc(1, sizeof(str_cond));
start = end = 0;
/* find the field name. */
while (('a' <= arg[end] && arg[end] <= 'z') ||
('A' <= arg[end] && arg[end] <= 'Z') || arg[end] == '-')
end++;
found = FALSE;
for (i = 0; i < NUM_OF_FIELDS && found == FALSE; i++) {
if (strncmp(arg, at[i], strlen(at[i])) == 0) {
(*cond)->field =
i; /* condition on field &at[i]. */
found = TRUE;
break;
}
}
if (found == FALSE) {
strncpy(message_buf, arg, end - start);
message_buf[end - start] = '\0';
fprintf(stderr, "Field %s not found.\n", message_buf);
return FALSE;
}
start = end;
end++;
while (arg[end] == '=' || arg[end] == '!' || arg[end] == '>' ||
arg[end] == '<')
end++;
strncpy((*cond)->symbol, arg + start, end - start);
(*cond)->symbol[end - start] = '\0';
if (strlen((*cond)->symbol) > 2 ||
strlen((*cond)->symbol) < 1 ||
(strlen((*cond)->symbol) == 1 &&
*((*cond)->symbol) != '>' && *((*cond)->symbol) != '<') ||
(strlen((*cond)->symbol) == 2 &&
(strncmp((*cond)->symbol, "!=", 2) != 0) &&
(strncmp((*cond)->symbol, "==", 2) != 0) &&
(strncmp((*cond)->symbol, ">=", 2) != 0) &&
(strncmp((*cond)->symbol, "<=", 2) != 0))) {
fprintf(stderr, "Invalid condition.\n");
return FALSE;
}
if (arg[end] == '"' && arg[strlen(arg) - 1] == '"') {
end++;
arg[strlen(arg) - 1] = '\0';
}
(*cond)->value = (char *)Calloc(strlen(arg) - end + 2, 1);
strcpy((*cond)->value, arg + end);
}
return TRUE;
}
/*********
*
* GetFields interprets the -f arguments, the fields list.
*
* Returns number of selected fields, 0 if anything is wrong.
*
*********/
int GetFields(arg, selected_fields)
char *arg;
int selected_fields[];
{
int start, end, i, found, list_done, i_selected;
char message_buf[1000];
if (strcmp(arg, "all") == 0) {
selected_fields[0] = -1;
return NUM_OF_FIELDS;
}
else {
start = end = 0;
list_done = FALSE;
i_selected = 0;
while (list_done == FALSE) {
while (arg[end] != '\0' && arg[end] != ',') {
end++;
}
if (arg[end] == '\0') {
list_done = TRUE;
}
found = FALSE;
for (i = 0; i < NUM_OF_FIELDS && found == FALSE; i++) {
if (strncmp(arg + start, at[i],
strlen(at[i])) == 0) {
selected_fields[i_selected++] = i;
found = TRUE;
start = end + 1;
break;
}
}
if (found == FALSE) {
strncpy(message_buf, (arg + start),
end - start);
message_buf[end - start] = '\0';
fprintf(stderr, "Field %s not found.\n",
message_buf);
return 0;
}
end++;
}
}
return i_selected;
}
static char *pairs[] = {"aa", "ac", "ag", "at", "ca", "cc", "cg", "ct",
"ga", "gc", "gg", "gt", "ta", "tc", "tg", "tt"};
static int stemp[16] = {55, 98, 58, 57, 55, 86, 73, 58,
87, 136, 86, 98, 37, 87, 55, 55};
/*******
*
* MST() returns Mean Stacking Temperature for the given sequence,
* returns -1 if anything is wrong.
*
*******/
float MST(c_elem) const char *c_elem;
{
int i, j, l;
int tot_stemp = 0, non_amb_pairs = 0;
char *seq;
l = strlen(c_elem);
seq = (char *)Calloc(l, 1 + 1);
/* clean out dashes. */
j = 0;
for (i = 0; i < l; i++) {
if (c_elem[i] != '-') {
seq[j] = c_elem[i] | 32;
if (seq[j] == 'u') seq[j] = 't';
j++;
}
}
seq[j] = '\0';
l = j;
for (i = 0; i < l - 1; i++) {
j = 0;
while (j < 16 && strncmp(seq + i, pairs[j], 2) != 0) {
j++;
}
/* ignore the pairing of an ambiguous base. */
if (j != 16) {
tot_stemp += stemp[j];
non_amb_pairs++;
}
}
if (seq != NULL) {
Cfree(seq);
seq = NULL;
}
return ((float)tot_stemp / (float)non_amb_pairs);
}
/********
*
* SubStr() fill ss with a substring of at most 'length' chars and returns
* TRUE. If anything is wrong, it sets ss to be empty and returns FALSE.
*
********/
int SubStr(string, start, length, ss) const char *string;
int start, length;
char *ss;
{
int i;
if (strlen(string) <= start) {
fprintf(stderr,
"SubStr(): starting point is beyond the boundary.\n");
ss[0] = '\0';
return FALSE;
}
for (i = start; string[i] != '\0' && i < start + length; i++) {
ss[i - start] = string[i];
}
ss[i - start] = '\0';
return TRUE;
}
/*******
*
* FindPattern() searches string for pattern.
* Returns the number of appearences.
*
*******/
int FindPattern(string, pattern) const char *string;
const char *pattern;
{
int i, sl, pl, num_app = 0;
if (string == NULL || (sl = strlen(string)) == 0) return 0;
pl = strlen(pattern);
for (i = 0; i <= sl - pl; i++) {
if (strncmp(string + i, pattern, pl) == 0) num_app++;
}
return num_app;
}
/*******
*
* FindPattern2(), same as FindPattern(), but returns the #
* of appearences that do not overlap only.
*
*******/
int FindPattern2(string, pattern, orig_loc) const char *string;
const char *pattern;
int orig_loc;
{
int i, sl, pl, num_app = 0;
if (string == NULL || (sl = strlen(string)) == 0) return 0;
pl = strlen(pattern);
for (i = 0; i <= sl - pl; i++) {
if (abs(i - orig_loc) >= pl &&
strncmp(string + i, pattern, pl) == 0)
num_app++;
}
return num_app;
}
/*******
*
* FindPatternNC() searches string for pattern , CASE INSENSITIVE.
* Returns the number of appearences.
*
*******/
int FindPatternNC(string, pattern) const char *string;
const char *pattern;
{
int i, j, sl, pl, num_app = 0;
if (string == NULL || (sl = strlen(string)) == 0) return 0;
pl = strlen(pattern);
for (i = 0; i <= sl - pl; i++) {
j = 0;
while (j < pl && (string[i + j] | 32) == (pattern[j] | 32)) j++;
if (j == pl) num_app++;
}
return num_app;
}
/*******
*
* Complementary() CHANGES the given DNA/RNA string to its complementary,
* and returns TRUE. Returns FALSE if anything is wrong and keep the
* given string unchanged.
*
*******/
int Complementary(sequence, type)
char *sequence;
char type;
{
int i, l;
char *temp_str;
l = strlen(sequence);
temp_str = (char *)Calloc(l + 1, sizeof(char));
if (type == 'D' || type == 'd')
type = 0;
else if (type == 'R' || type == 'r')
type = 1;
else {
fprintf(stderr,
"Complementary(): type unknown. Type is D/d/R/r\n");
return (int)NULL;
}
for (i = 0; i < l; i++) {
switch (sequence[i]) {
case 'A':
temp_str[i] = (type == 0) ? 'T' : 'U';
break;
case 'a':
temp_str[i] = (type == 0) ? 't' : 'u';
break;
case 'C':
temp_str[i] = 'G';
break;
case 'c':
temp_str[i] = 'g';
break;
case 'G':
temp_str[i] = 'C';
break;
case 'g':
temp_str[i] = 'c';
break;
case 'T':
case 'U':
temp_str[i] = 'A';
break;
case 't':
case 'u':
temp_str[i] = 'a';
break;
}
}
temp_str[i] = '\0';
strcpy(sequence, temp_str);
if (temp_str != NULL) {
Cfree(temp_str);
temp_str = NULL;
}
return TRUE;
}
/********
*
* KnownSeq() returns an integer which is the index of the first
* occurence of an ambiguous base in the seq. -1 if no ambiguous
* base in the seq.
*
********/
int KnownSeq(seq)
char *seq;
{
int i;
char c;
for (i = 0; i < strlen(seq); i++) {
c = seq[i] | 32;
if (c != 'a' && c != 't' && c != 'g' && c != 'c' && c != 'u')
return i;
}
return -1;
}
/********
*
* Reverse() reverses the given string and returns TRUE.
* (NOTE: Reverse() actually changes the string).
* If anything goes wrong, leave seq unchanged.
*
*
********/
int Reverse(seq)
char *seq;
{
int i, l;
char c;
l = strlen(seq);
if (l < 2) {
return TRUE;
}
for (i = 0; i < l / 2; i++) {
c = seq[i];
seq[i] = seq[l - i - 1];
seq[l - i - 1] = c;
}
return TRUE;
}
/********
*
* GoodOligos() returns a pointer to an array of subsequences that
* do not contant secondary structure, nor self complementary structure.
* Returns NULL if anything is wrong.
*
* l_bnd and r_bnd are regards to the head of the probe.
*
* Note: this program Calloc-s memory for the returned pointer.
* The caller program is responsible of Freeing the memory when
* not needed.
*
********/
char **GoodOligos(c_elem, check_len, min_len, max_len, l_bnd, r_bnd)
char *c_elem;
int check_len, min_len, max_len, l_bnd, r_bnd;
/* l_bnd and r_bnd are relative to c_elem, so they should be in
[0,strlen(c_elem)] */
{
int i, l, seq_len, max_num_probe, seq_cnt = 0;
char **seq_set;
char *seq, *subseq, *scd_str, *PossibleOligo;
int BadOligo, PO_len, PO_index, PO_l;
/* constant(s): */
/* to check if there is a substr of length 'no_repeat_len' appears
* more than once in the PossibleOligo. */
int no_repeat_len = 15;
seq_len = strlen(c_elem);
/* A lower case copy of the c_elem. */
seq = (char *)Calloc(seq_len + 1, sizeof(char));
/* String used to check the PossibleOligo. */
PossibleOligo = (char *)Calloc(max_len + 1, sizeof(char));
subseq = (char *)Calloc(max_len + 1, sizeof(char));
scd_str = (char *)Calloc(max_len + 1, sizeof(char));
/* The output. A set of possibly good oligos. */
max_num_probe = 20;
seq_set = (char **)Calloc(max_num_probe, sizeof(char *));
for (i = 0; i < seq_len; i++) {
seq[i] = c_elem[i] | 32;
}
i = MAX(l_bnd, 0);
while (i <= MIN(r_bnd, seq_len - min_len)) {
BadOligo = FALSE;
for (l = min_len;
BadOligo == FALSE && l <= seq_len - i && l <= max_len;
l++) {
int uk;
SubStr(seq, i, l, PossibleOligo);
/* Any unknow base?
*/
if ((uk = KnownSeq(PossibleOligo)) != -1) {
fprintf(stderr, "%s has ambiguous base(s)\n",
PossibleOligo);
i += uk + 1;
BadOligo = TRUE;
}
PO_len = strlen(PossibleOligo);
/* check if there is a substr of len(no_repeat_len)
* repeat itself in the PossibleOligo.
DOESN'T MATTER! IT COULD MESS UP AT MOST SEVERAL
BASES READ INTO THE PROBE. CUT_SITE IS WHAT REALLY
MATTERS.
for(PO_index = 0;
BadOligo==FALSE && PO_index<=PO_len-no_repeat_len;
PO_index++)
{
SubStr(PossibleOligo,PO_index,no_repeat_len,subseq);
if(FindPattern(PossibleOligo, subseq) > 1)
{
fprintf(stderr,
"%s has 15 repatitive base(s) %s\n",
PossibleOligo, subseq);
i++;
BadOligo = TRUE;
}
}
*/
/*
* To ensure that the probe is not going to hybridize
* with itself:
*/
for (PO_index = 0; BadOligo == FALSE &&
PO_index <= PO_len - no_repeat_len;
PO_index++) {
SubStr(PossibleOligo, PO_index, no_repeat_len,
subseq);
strcpy(scd_str, subseq);
Complementary(scd_str, 'd');
Reverse(scd_str);
if (FindPattern(PossibleOligo, scd_str) > 0) {
fprintf(stderr,
"%s may hybridize with itself: "
"%s vs. %s.\n",
PossibleOligo, subseq, scd_str);
i++;
BadOligo = TRUE;
}
}
for (PO_index = 0; BadOligo == FALSE &&
PO_index <= PO_len - 2 * check_len;
PO_index++) {
SubStr(PossibleOligo, PO_index, check_len,
subseq);
Complementary(subseq, 'd');
strcpy(scd_str, subseq);
Reverse(scd_str);
/*
if(FindPattern2(PossibleOligo,subseq,PO_index)>0)
{
fprintf(stderr, "%s has self-compl %s\n",
PossibleOligo, subseq);
i += PO_index+1;
BadOligo = TRUE;
}
else
*/
if (FindPattern2(PossibleOligo, scd_str,
PO_index) > 0) {
fprintf(stderr,
"%s has 2nd struct %s\n",
PossibleOligo, scd_str);
i += PO_index + 1;
BadOligo = TRUE;
}
}
if (BadOligo == FALSE) {
seq_set[seq_cnt] = (char *)Calloc(
strlen(PossibleOligo) + 1, sizeof(char));
strcpy(seq_set[seq_cnt], PossibleOligo);
if (++seq_cnt == max_num_probe) {
max_num_probe *= 2;
seq_set = (char **)Realloc(
seq_set,
max_num_probe * sizeof(char *));
}
i++;
}
} /* end of l. */
} /* end of i. */
seq_set[seq_cnt] = NULL;
if (seq_cnt == 0) return NULL;
return seq_set;
}
/* ALWAYS COPY the result from uniqueID() to a char[32],
* (strlen(hostname)+1+10). Memory is lost when the function
* is finished.
*/
char vname[32];
char *uniqueID()
{
char hname[32], /* vname[32], rtm 18.III.98 */ tstr[32];
time_t *tp;
static cnt = 0;
int ll;
tp = (time_t *)Calloc(1, sizeof(time_t));
if (gethostname(hname, 32) == -1) {
fprintf(stderr, "UniqueID(): Failed to get host name.\n");
exit(1);
}
time(tp);
sprintf(tstr, ":%d:%ld", cnt, *tp);
if ((ll = strlen(tstr)) > 31) {
strncpy(vname, tstr, 31);
vname[31] = '\0';
}
else {
ll = strlen(hname) - (31 - ll);
if (ll < 0) ll = 0;
sprintf(vname, "%s%s", hname + ll, tstr);
}
cnt++;
Cfree(tp);
return (vname);
}
/* return the percentage of GCcontents. */
int GCcontent(seq)
char *seq;
{
int l, gc = 0, j;
l = strlen(seq);
for (j = 0; j < l; j++) {
if ((seq[j] | 32) == 'g' || (seq[j] | 32) == 'c') {
gc++;
}
}
return ((int)(gc * 100 / l));
}
/******
*
* HGLtoIQ() outputs a HGL format record to an ASCII file with
* the Input-Queue format, the format for the synthesizer.
*
******/
void HGLtoIQ(fname, tSeq) const char *fname;
Sequence *tSeq;
{
FILE *fp;
if ((fp = fopen(fname, "w")) == NULL) {
fprintf(stderr, "Can't open IQ file: %s\n", fname);
exit(1);
}
fprintf(fp, "%s %s\n", tSeq->comments, tSeq->c_elem);
}
Find2(string, key) char *key, *string;
/*
* Like find, but returns the index of the leftmost
* occurence, and -1 if not found.
* Note in this program, T==U, and case insensitive.
*/
{
int i, j, len1, len2, dif, flag = FALSE;
char *target;
if (string == NULL || string[0] == '\0') return -1;
len2 = strlen(string);
target = (char *)Calloc(len2 + 1, 1);
for (i = 0; i < len2; i++) {
target[i] = string[i] | 32;
if (target[i] == 'u') target[i] = 't';
}
len1 = strlen(key);
for (i = 0; i < len1; i++) {
key[i] |= 32;
if (key[i] == 'u') key[i] = 't';
}
dif = len2 - len1 + 1;
if (len1 > 0)
for (j = 0; j < dif && flag == FALSE; j++) {
flag = TRUE;
for (i = 0; i < len1 && flag; i++)
flag = (key[i] == target[i + j]) ? TRUE : FALSE;
}
Cfree(target);
return (flag ? j - 1 : -1);
}
/* return -1 if end-of-file.
FALSE if anything is wrong.
*/
int ReadGDE(fp, seq)
FILE *fp;
Sequence *seq;
{
char temp_line[1000], waste[64];
int ii, l1;
while (fgets(temp_line, 1000, fp) != NULL) {
if (strncmp(temp_line, "sequence-ID", 11) == 0) {
sscanf(temp_line, "%s%s", waste, seq->sequence_ID);
}
else if (temp_line[0] == '#') {
strncpy(seq->name, temp_line + 1, 31);
seq->name[31] = '\0';
ii = 0;
while (ii < strlen(seq->name) && seq->name[ii] != ' ' &&
seq->name[ii] != '\n')
ii++;
seq->name[ii] = '\0';
seq->seqmaxlen = 256;
seq->c_elem = (char *)Calloc(seq->seqmaxlen, 1);
seq->seqlen = 0;
while (fgets(temp_line, 1000, fp) != NULL) {
l1 = strlen(temp_line);
if (temp_line[l1 - 1] == '\n') {
l1--;
temp_line[l1] = '\0';
}
while (seq->seqmaxlen <
seq->seqlen + strlen(temp_line) + 1) {
seq->seqmaxlen *= 2;
seq->c_elem = (char *)Realloc(
seq->c_elem, seq->seqmaxlen);
}
strcat(seq->c_elem, temp_line);
seq->seqlen += strlen(temp_line);
}
if (seq->seqlen == 0) {
fprintf(stderr, "\n%s\n", "Sequence is empty.");
return FALSE;
}
}
}
return -1;
}
void heapify(seq_set, seq_size, heap_size, elem, Pkey, Skey, order) int seq_size
,
elem, heap_size, **order;
char Pkey[], Skey[];
Sequence *seq_set;
{
int l, r, temp, largest;
l = 2 * elem + 1;
r = 2 * elem + 2;
if (l <= heap_size && CompKey(seq_set[(*order)[l]],
seq_set[(*order)[elem]], Pkey, Skey) > 0)
largest = l;
else
largest = elem;
if (r <= heap_size &&
CompKey(seq_set[(*order)[r]], seq_set[(*order)[largest]], Pkey,
Skey) > 0)
largest = r;
if (largest != elem) {
temp = (*order)[elem];
(*order)[elem] = (*order)[largest];
(*order)[largest] = temp;
heapify(seq_set, seq_size, heap_size, largest, Pkey, Skey,
order);
}
}
heapsort(seq_set, seq_size, Pkey, Skey, order) int seq_size, **order;
char Pkey[], Skey[];
Sequence *seq_set;
{
int ii, temp, heap_size;
/*
* build_heap(seq_set, seq_size, &heap_size, order);
*/
heap_size = seq_size - 1;
for (ii = (seq_size - 1) / 2; ii >= 0; ii--) /* (L-1)/2-1?? */
{
heapify(seq_set, seq_size, heap_size, ii, Pkey, Skey, order);
}
for (ii = seq_size - 1; ii > 0; ii--) {
temp = (*order)[0];
(*order)[0] = (*order)[ii];
(*order)[ii] = temp;
heap_size--;
heapify(seq_set, seq_size, heap_size, 0, Pkey, Skey, order);
}
}
/*
* Return >0, ==0, <0.
*/
int CompKey(seq1, seq2, Pkey, Skey)
Sequence seq1, seq2;
char Pkey[], Skey[];
{
int ii, jj, Pret;
char b1[32], b2[32];
if (strcmp(Pkey, "type") == 0) {
Pret = strcmp(seq1.type, seq2.type);
if (Pret != 0 || Skey[0] == '\0') return Pret;
}
else if (strcmp(Pkey, "name") == 0) {
Pret = strcmp(seq1.name, seq2.name);
if (Pret != 0 || Skey[0] == '\0') return Pret;
}
else if (strcmp(Pkey, "sequence-ID") == 0) {
Pret = strcmp(seq1.sequence_ID, seq2.sequence_ID);
if (Pret != 0 || Skey[0] == '\0') return Pret;
}
else if (strcmp(Pkey, "creator") == 0) {
Pret = strcmp(seq1.creator, seq2.creator);
if (Pret != 0 || Skey[0] == '\0') return Pret;
}
else if (strcmp(Pkey, "offset") == 0) {
Pret = seq1.offset - seq2.offset;
if (Pret != 0 || Skey[0] == '\0') return Pret;
}
else if (strcmp(Pkey, "group-ID") == 0) {
Pret = seq1.group_ID - seq2.group_ID;
if (Pret != 0 || Skey[0] == '\0') return Pret;
}
else if (strcmp(Pkey, "barcode") == 0) {
if (seq1.barcode[0] == 'P')
strcpy(b1, seq1.barcode + 2);
else
strcpy(b1, seq1.barcode);
if (seq2.barcode[0] == 'P')
strcpy(b2, seq2.barcode + 2);
else
strcpy(b2, seq2.barcode);
Pret = strcmp(b1, b2);
if (Pret != 0 || Skey[0] == '\0') return Pret;
}
else if (strcmp(Pkey, "seqlen") == 0) {
Pret = seq1.seqlen - seq2.seqlen;
if (Pret != 0 || Skey[0] == '\0') return Pret;
}
else if (strcmp(Pkey, "creation-date") == 0) {
seq1.creation_date[0] %= 100;
seq2.creation_date[0] %= 100;
Pret = seq1.creation_date[0] * 10000 +
seq1.creation_date[1] * 100 + seq1.creation_date[2] -
seq2.creation_date[0] * 10000 -
seq2.creation_date[1] * 100 - seq2.creation_date[2];
if (Pret == 0) {
Pret = seq1.creation_date[3] * 10000 +
seq1.creation_date[4] * 100 +
seq1.creation_date[5] -
seq2.creation_date[3] * 10000 -
seq2.creation_date[4] * 100 -
seq2.creation_date[5];
}
if (Pret != 0 || Skey[0] == '\0') return Pret;
}
else if (strcmp(Pkey, "probing-date") == 0) {
seq1.probing_date[0] %= 100;
seq2.probing_date[0] %= 100;
Pret = seq1.probing_date[0] * 10000 +
seq1.probing_date[1] * 100 + seq1.probing_date[2] -
seq2.probing_date[0] * 10000 -
seq2.probing_date[1] * 100 - seq2.probing_date[2];
if (Pret == 0) {
Pret =
seq1.probing_date[3] * 10000 +
seq1.probing_date[4] * 100 + seq1.probing_date[5] -
seq2.probing_date[3] * 10000 -
seq2.probing_date[4] * 100 - seq2.probing_date[5];
}
if (Pret != 0 || Skey[0] == '\0') return Pret;
}
else if (strcmp(Pkey, "autorad_date") == 0) {
seq1.autorad_date[0] %= 100;
seq2.autorad_date[0] %= 100;
Pret = seq1.autorad_date[0] * 10000 +
seq1.autorad_date[1] * 100 + seq1.autorad_date[2] -
seq2.autorad_date[0] * 10000 -
seq2.autorad_date[1] * 100 - seq2.autorad_date[2];
if (Pret == 0) {
Pret =
seq1.autorad_date[3] * 10000 +
seq1.autorad_date[4] * 100 + seq1.autorad_date[5] -
seq2.autorad_date[3] * 10000 -
seq2.autorad_date[4] * 100 - seq2.autorad_date[5];
}
if (Pret != 0 || Skey[0] == '\0') return Pret;
}
else if (strcmp(Pkey, "film") == 0) {
Pret = strcmp(seq1.film, seq2.film);
if (Pret != 0 || Skey[0] == '\0') return Pret;
}
else if (strcmp(Pkey, "membrane") == 0) {
Pret = strcmp(seq1.membrane, seq2.membrane);
if (Pret != 0 || Skey[0] == '\0') return Pret;
}
else if (strcmp(Pkey, "contig") == 0) {
Pret = strcmp(seq1.contig, seq2.contig);
if (Pret != 0 || Skey[0] == '\0') return Pret;
}
else {
fprintf(stderr, "CompKey(): Invalid primary key %s.\n", Pkey);
exit(1);
}
if (strcmp(Skey, "type") == 0) {
return (strcmp(seq1.type, seq2.type));
}
else if (strcmp(Skey, "name") == 0) {
return (strcmp(seq1.name, seq2.name));
}
else if (strcmp(Skey, "sequence-ID") == 0) {
return (strcmp(seq1.sequence_ID, seq2.sequence_ID));
}
else if (strcmp(Skey, "creator") == 0) {
return (strcmp(seq1.creator, seq2.creator));
}
else if (strcmp(Skey, "offset") == 0) {
return (seq1.offset - seq2.offset);
}
else if (strcmp(Skey, "group-ID") == 0) {
return (seq1.group_ID - seq2.group_ID);
}
else if (strcmp(Skey, "barcode") == 0) {
if (seq1.barcode[0] == 'P')
strcpy(b1, seq1.barcode + 2);
else
strcpy(b1, seq1.barcode);
if (seq2.barcode[0] == 'P')
strcpy(b2, seq2.barcode + 2);
else
strcpy(b2, seq2.barcode);
return (strcmp(b1, b2));
}
else if (strcmp(Skey, "seqlen") == 0) {
return (seq1.seqlen - seq2.seqlen);
}
else if (strcmp(Skey, "creation-date") == 0) {
seq1.creation_date[0] %= 100;
seq2.creation_date[0] %= 100;
Pret = seq1.creation_date[0] * 10000 +
seq1.creation_date[1] * 100 + seq1.creation_date[2] -
seq2.creation_date[0] * 10000 -
seq2.creation_date[1] * 100 - seq2.creation_date[2];
if (Pret != 0) return Pret;
return (seq1.creation_date[3] * 10000 +
seq1.creation_date[4] * 100 + seq1.creation_date[5] -
seq2.creation_date[3] * 10000 -
seq2.creation_date[4] * 100 - seq2.creation_date[5]);
}
else if (strcmp(Skey, "probing-date") == 0) {
seq1.probing_date[0] %= 100;
seq2.probing_date[0] %= 100;
Pret = seq1.probing_date[0] * 10000 +
seq1.probing_date[1] * 100 + seq1.probing_date[2] -
seq2.probing_date[0] * 10000 -
seq2.probing_date[1] * 100 - seq2.probing_date[2];
if (Pret != 0) return Pret;
return (seq1.probing_date[3] * 10000 +
seq1.probing_date[4] * 100 + seq1.probing_date[5] -
seq2.probing_date[3] * 10000 -
seq2.probing_date[4] * 100 - seq2.probing_date[5]);
}
else if (strcmp(Skey, "autorad_date") == 0) {
seq1.autorad_date[0] %= 100;
seq2.autorad_date[0] %= 100;
Pret = seq1.autorad_date[0] * 10000 +
seq1.autorad_date[1] * 100 + seq1.autorad_date[2] -
seq2.autorad_date[0] * 10000 -
seq2.autorad_date[1] * 100 - seq2.autorad_date[2];
if (Pret != 0) return Pret;
return (seq1.autorad_date[3] * 10000 +
seq1.autorad_date[4] * 100 + seq1.autorad_date[5] -
seq2.autorad_date[3] * 10000 -
seq2.autorad_date[4] * 100 - seq2.autorad_date[5]);
}
else if (strcmp(Skey, "film") == 0) {
return (strcmp(seq1.film, seq2.film));
}
else if (strcmp(Skey, "membrane") == 0) {
return (strcmp(seq1.membrane, seq2.membrane));
}
else if (strcmp(Skey, "contig") == 0) {
return (strcmp(seq1.contig, seq2.contig));
}
else {
fprintf(stderr, "CompKey(): Invalid secondary key %s.\n", Skey);
exit(1);
}
}
int Lock(fname)
char *fname;
{
char buffer[1024];
FILE *fp;
int wait = 0;
while ((fp = fopen(fname, "r")) == NULL) {
sleep(1);
if (++wait == 30) {
fprintf(stderr,
"File %s not available, Try later.\n\n",
fname);
return FALSE;
}
}
fclose(fp);
sprintf(buffer, "mv %s %s.locked", fname, fname);
system(buffer);
return TRUE;
}
void Unlock(fname) char *fname;
{
char buffer[1024];
sprintf(buffer, "mv %s.locked %s", fname, fname);
system(buffer);
}
AppendComments(seq, str) Sequence *seq;
char *str;
{
int ii, jj, kk;
kk = strlen(str);
if (seq->commentsmaxlen == 0) {
seq->comments = (char *)Calloc(kk + 1, 1);
seq->commentsmaxlen = kk + 1;
seq->commentslen = 0;
}
else if (seq->commentslen + kk + 1 > seq->commentsmaxlen) {
seq->commentsmaxlen += 2 * (kk + 1);
seq->comments =
(char *)Realloc(seq->comments, seq->commentsmaxlen);
}
seq->comments[seq->commentslen] = '\0';
seq->comments[seq->commentslen] = '\0';
strcat(seq->comments, str);
seq->commentslen = strlen(seq->comments);
}
Reference in a new issue View git blame Copy permalink