malacology/gde_linux
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
gde_linux/HGL_SRC/HGLfuncs.c
Kuoi a25316aa9e 2006 version init
2022-03-07 20:43:05 +00:00

3165 lines
71 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 "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