init
This commit is contained in:
commit
4e1ad169f4
1 changed files with 736 additions and 0 deletions
736
gb2tnt.c
Normal file
736
gb2tnt.c
Normal file
|
|
@ -0,0 +1,736 @@
|
|||
/*
|
||||
Copyright (C) 2008 Pablo A. Goloboff
|
||||
Copyright (C) 2023 Guoyi Zhang;
|
||||
|
||||
This program is free software; you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by the Free
|
||||
Software Foundation; either version 2 of the License, or (at your option)
|
||||
any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License along
|
||||
with this program; if not, write to the Free Software Foundation, Inc., 59
|
||||
Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
Email: pablogolo@csnat.edu.ar
|
||||
Mail: Pablo A. Goloboff, INSUE, Instituto Miguel Lillo, Miguel Lillo 205, 4000 S.M. de Tucuman, Argentina.
|
||||
Email: GuoyiZhang@malacology.net
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
int verb = 0 ;
|
||||
int use_translation = 0 ;
|
||||
int dargc , laquiero ;
|
||||
int showedskipped = 0 ;
|
||||
char ** dargv ;
|
||||
int fileargs ; // args 1 to fileargs-1 are file names!
|
||||
FILE * inpf , * opsf , * curinput , * opsf , * notsfile ;
|
||||
int laschar ;
|
||||
#define NUCLEAR 1
|
||||
#define MITOCH 2
|
||||
#define PLASTID 3
|
||||
#define CHLORO 4
|
||||
#define TRUE 1
|
||||
#define FALSE 0
|
||||
#define MAXUSERACC 50000
|
||||
int genometype = 0 ;
|
||||
int use_string_matching = 0 ;
|
||||
double string_similarity ;
|
||||
|
||||
int stringis ( char * , char * ) ; // are both strings the same, case aside ???
|
||||
int rd ( void ) ; // return next char. from input file; save it in laschar
|
||||
void outer ( int , char * txt ) ; // if first arg. is TRUE, then output txt and exit
|
||||
void gonln ( void ) ; // read all the way to the ENTER
|
||||
void gotostring ( char * , int ) ; // find string of first arg, with margin of sec arg characters
|
||||
void rdto ( int , char * ) ; // saves to string every byte it finds before first arg
|
||||
void stornexline ( void ) ; // puts in stringsp everything to the ENTER
|
||||
void * mymalloc ( unsigned long int ) ; // allocs mem or exits
|
||||
void process (void);
|
||||
void save_to_not ( void );
|
||||
void setopts ( void );
|
||||
void makelower ( char * txt );
|
||||
void parsit ( void );
|
||||
void parse_translation ( void );
|
||||
void spew_name ( void );
|
||||
void output_translation ( void );
|
||||
void effect_complementation ( void );
|
||||
|
||||
#define MAXNUMCHUNKS 200
|
||||
typedef struct { int from ; int to ; } Chunktyp ;
|
||||
Chunktyp chunk[MAXNUMCHUNKS] ;
|
||||
int numchunks = 0 ;
|
||||
|
||||
#define MAXSEQLENGTH 25000
|
||||
char bytestring[MAXSEQLENGTH] ;
|
||||
char complement_string[MAXSEQLENGTH] ;
|
||||
|
||||
unsigned long int accepted = 0 , rejected = 0 ;
|
||||
char stringsp[160] , headerline[160];
|
||||
int prodnumber = 0 , genenumber = 0 ;
|
||||
#define MAX_USER_DEFINITIONS 60
|
||||
char * prodname[MAX_USER_DEFINITIONS] , * genename[MAX_USER_DEFINITIONS ] ,
|
||||
accnumber [ 100 ] ;
|
||||
char taxname [ 100 ] ;
|
||||
char taxonomy [ 1000 ] ;
|
||||
char ** useraccname ;
|
||||
int useraccnumber = 0 ;
|
||||
|
||||
unsigned long int dafsize , bytesread = 0 ;
|
||||
|
||||
#ifdef LINUX
|
||||
|
||||
int getch ( void )
|
||||
{
|
||||
return ( getc ( stdin ) ) ;
|
||||
}
|
||||
#endif
|
||||
|
||||
void * mymalloc ( unsigned long int size )
|
||||
{
|
||||
void * pt = malloc ( size ) ;
|
||||
outer ( pt == NULL , "Not enough memory!" ) ;
|
||||
return pt ;
|
||||
}
|
||||
|
||||
void dildit ( void )
|
||||
{
|
||||
static int prv = 0 ;
|
||||
double fract ;
|
||||
unsigned long int ifract ;
|
||||
++ bytesread ;
|
||||
fract = ( ( double ) bytesread / dafsize ) * 100 ;
|
||||
ifract = fract ;
|
||||
if ( ifract == prv ) return ;
|
||||
prv = ifract ;
|
||||
fprintf ( stderr , "\rParsing ... %lu%%" , ifract ) ;
|
||||
}
|
||||
|
||||
void undild ( void )
|
||||
{
|
||||
fprintf ( stderr , "\r \r" ) ;
|
||||
}
|
||||
|
||||
int rd ( void )
|
||||
{
|
||||
int i ;
|
||||
if ( feof ( curinput ) ) {
|
||||
fclose ( curinput ) ;
|
||||
if ( inpf == curinput ) {
|
||||
undild () ;
|
||||
if ( !useraccnumber )
|
||||
fprintf ( stderr , "\nAccepted %lu accessions, rejected %lu" , accepted , rejected ) ;
|
||||
fprintf ( stderr , "\nFinished parsing %s (input)\n" , dargv[1] ) ; }
|
||||
else fprintf ( stderr , "\nFinished parsing %s (options)\n" , dargv[2] ) ;
|
||||
if ( inpf == curinput ) {
|
||||
getc ( stdin ) ;
|
||||
exit ( 1 ) ; }}
|
||||
if ( curinput == inpf ) dildit () ;
|
||||
i = getc ( curinput ) ;
|
||||
if ( i == 13 )
|
||||
if ( ( i = getc ( curinput ) ) != 10 ) ungetc ( i , curinput ) ;
|
||||
return ( laschar = i ) ;
|
||||
}
|
||||
|
||||
void openit ( void )
|
||||
{
|
||||
struct stat buf ;
|
||||
curinput = inpf = fopen ( dargv [ 1 ] , "rb" ) ;
|
||||
if ( inpf == NULL ) {
|
||||
fprintf ( stderr , "Error trying to open input file %s: " , dargv[1] ) ;
|
||||
outer ( 1 , "cannot open file" ) ; }
|
||||
fstat ( fileno ( inpf ) , &buf ) ;
|
||||
dafsize = buf.st_size ;
|
||||
}
|
||||
|
||||
void outer ( int doit , char * txt )
|
||||
{
|
||||
if ( !doit ) return ;
|
||||
fprintf ( stderr , "%s\n" , txt ) ;
|
||||
getc ( stdin ) ;
|
||||
exit ( 0 ) ;
|
||||
}
|
||||
|
||||
void dohelp ( void )
|
||||
{
|
||||
fprintf ( stderr , "\n\n"
|
||||
"Usage is: \n\n"
|
||||
|
||||
" Give input file name (1st arg) and options file (2nd arg)\n"
|
||||
" Output can be redirected with \">\"\n\n"
|
||||
|
||||
" Inside options file: \n\n"
|
||||
|
||||
" gene \"name(s)\"\n"
|
||||
" product \"name(s)\"\n"
|
||||
" protein\n"
|
||||
" genome \"type\"\n"
|
||||
" stringmatch S (S=similarity=1-(E/L)\n"
|
||||
" where E=edit cost, and L=length)\n\n"
|
||||
|
||||
" List of skipped sequences goes to file gb2tnt.not\n\n"
|
||||
|
||||
" To see details of skipped sequences, use gb2tnt.not as\n"
|
||||
" options file:\n\n"
|
||||
|
||||
" \"gb2tnt input gb2tnt.not\"\n\n"
|
||||
|
||||
" Alternatively, string similarity can be given as 3d and\n"
|
||||
" 4th argument (which overrides values in options file)\n\n"
|
||||
|
||||
) ;
|
||||
getc ( stdin ) ;
|
||||
exit ( 0 ) ;
|
||||
}
|
||||
|
||||
int main ( int argc , char ** argv )
|
||||
{
|
||||
dargc = argc ;
|
||||
dargv = argv ;
|
||||
setopts () ;
|
||||
process () ;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void gonln ( void )
|
||||
{
|
||||
while ( laschar != 10 ) rd () ;
|
||||
}
|
||||
|
||||
void gotostring ( char * string , int shift )
|
||||
{
|
||||
char * cp ;
|
||||
int i ;
|
||||
int somenonwhite ;
|
||||
strcpy ( stringsp , " " ) ;
|
||||
while ( strcmp ( stringsp , string ) && !feof ( inpf ) ) {
|
||||
gonln () ;
|
||||
somenonwhite = 0 ;
|
||||
if ( shift > 0 ) {
|
||||
for ( i = 0 ; i < shift && !somenonwhite ; ++ i )
|
||||
if ( rd () != 32 ) somenonwhite = 1 ;
|
||||
if ( somenonwhite ) continue ; }
|
||||
else {
|
||||
while ( isspace ( rd () ) ) ;
|
||||
ungetc ( laschar , inpf ) ; }
|
||||
* ( cp = stringsp ) = rd () ;
|
||||
if ( * cp ++ != * string ) continue ;
|
||||
while ( !isspace( * cp = rd () ) ) {
|
||||
cp ++ ;
|
||||
if ( cp - stringsp > 98 ) break ; }
|
||||
* cp = '\0' ; }
|
||||
if ( feof ( inpf ) ) {
|
||||
fprintf ( stderr , "\nDone!" ) ;
|
||||
exit ( 1 ) ; }
|
||||
}
|
||||
|
||||
void rdaccnumber ( void )
|
||||
{
|
||||
char * cp = accnumber ;
|
||||
while ( isspace ( rd () ) ) ;
|
||||
while ( !isspace ( laschar ) ) {
|
||||
* cp ++ = laschar ;
|
||||
rd () ; }
|
||||
* cp = '\0' ;
|
||||
}
|
||||
|
||||
void rdto ( int donde , char * stor )
|
||||
{
|
||||
char * cp ;
|
||||
int a = 0 ;
|
||||
cp = stor ;
|
||||
while ( isspace( laschar ) ) rd () ;
|
||||
while ( laschar != donde ) {
|
||||
if ( a != '_' || laschar != '_' )
|
||||
* cp ++ = laschar ;
|
||||
a = laschar ;
|
||||
rd () ;
|
||||
if ( laschar == 32 ) laschar = '_' ;
|
||||
if ( laschar == 10 && donde != 10 ) laschar = '_' ; }
|
||||
* cp = '\0' ;
|
||||
}
|
||||
|
||||
void stornexline ( void )
|
||||
{
|
||||
char * cp = stringsp ;
|
||||
rd () ;
|
||||
while ( isspace ( laschar ) ) rd () ;
|
||||
while ( laschar != 10 && laschar != 13 ) {
|
||||
* cp ++ = laschar ;
|
||||
rd () ; }
|
||||
* cp = '\0' ;
|
||||
}
|
||||
|
||||
typedef struct
|
||||
{ int up , diag , lef ;
|
||||
int min ; } Stringcomptyp ;
|
||||
Stringcomptyp ** cellcost ;
|
||||
int gapcost = 1 , gapextcost = 1 ;
|
||||
int suscost = 1 ;
|
||||
int mademem = 0 ;
|
||||
|
||||
void ** loray ( int wid , int hei , int size )
|
||||
{
|
||||
int a ;
|
||||
void ** pp ;
|
||||
pp = ( void ** ) malloc ( wid * sizeof ( void * ) ) ;
|
||||
outer ( ( pp == NULL ) , "Not enough RAM") ;
|
||||
for ( a = 0 ; a < wid ; ++ a )
|
||||
if ( ( pp [ a ] = ( void * ) malloc ( hei * size ) ) == NULL )
|
||||
outer ( 1 , "Not enough RAM") ;
|
||||
return pp ;
|
||||
}
|
||||
|
||||
double doneedwunsch ( char * ap , char * bp )
|
||||
{
|
||||
int wid , hei , i , j , dacos ;
|
||||
char * app , * bpp ;
|
||||
char * abecs , * bbecs , * anp , * bnp ;
|
||||
double val ;
|
||||
int HIGH = 10000000 ;
|
||||
wid = strlen ( ap ) ;
|
||||
hei = strlen ( bp ) ;
|
||||
if ( ! mademem ) {
|
||||
cellcost = ( Stringcomptyp ** ) loray ( 100 , 100 , sizeof ( Stringcomptyp ) ) ;
|
||||
mademem = 1 ; }
|
||||
outer ( ( hei >= 99 || wid >= 99 ) , "String is too long to use string-matching" ) ;
|
||||
cellcost[0][0].min = cellcost[0][0].diag = 0 ;
|
||||
cellcost[0][0].up = cellcost[0][0].lef = HIGH ;
|
||||
bpp = bp ;
|
||||
for ( j = 0 ; j < hei ; ++ j ) {
|
||||
app = ap ;
|
||||
for ( i = 0 ; i < wid ; ++ i ) {
|
||||
if ( !i && !j ) {
|
||||
continue ; }
|
||||
dacos = 0 ;
|
||||
if ( * app != * bpp ) dacos = suscost ;
|
||||
if ( j ) {
|
||||
if ( cellcost[i][j-1].min == cellcost[i][j-1].up )
|
||||
cellcost[i][j].up = cellcost[i][j-1].min + gapextcost ;
|
||||
else
|
||||
cellcost[i][j].up = cellcost[i][j-1].min + gapcost ; }
|
||||
else cellcost[i][j].up = cellcost[i][j].diag = HIGH ;
|
||||
if ( i ) {
|
||||
if ( cellcost[i-1][j].min == cellcost[i-1][j].lef )
|
||||
cellcost[i][j].lef = cellcost[i-1][j].min + gapextcost ;
|
||||
else
|
||||
cellcost[i][j].lef = cellcost[i-1][j].min + gapcost ; }
|
||||
else cellcost[i][j].lef = cellcost[i][j].diag = HIGH ;
|
||||
if ( i && j ) cellcost[i][j].diag = cellcost[i-1][j-1].min + dacos ;
|
||||
dacos = cellcost[i][j].diag ;
|
||||
if ( dacos > cellcost[i][j].up ) dacos = cellcost[i][j].up ;
|
||||
if ( dacos > cellcost[i][j].lef ) dacos = cellcost[i][j].lef ;
|
||||
cellcost[i][j].min = dacos ;
|
||||
++ app ; }
|
||||
++ bpp ; }
|
||||
dacos = cellcost[wid-1][hei-1].min ;
|
||||
val = ( double ) dacos / ( double ) hei ;
|
||||
val = 1 - val ;
|
||||
return val ;
|
||||
}
|
||||
|
||||
int stringis ( char * a , char * b )
|
||||
{
|
||||
|
||||
if ( !strcmp ( b , "\"?\"" ) ) return 1 ;
|
||||
if ( use_string_matching ) {
|
||||
if ( doneedwunsch ( a , b ) >= string_similarity ) return 1 ;
|
||||
return 0 ; }
|
||||
while ( * a && * b )
|
||||
if ( tolower ( * a ++ ) != tolower ( * b ++ ) ) return 0 ;
|
||||
return 1 ;
|
||||
}
|
||||
|
||||
int rdliteral ( void )
|
||||
{
|
||||
char * cp = stringsp ;
|
||||
rd () ;
|
||||
while ( isspace ( laschar ) && !feof ( curinput ) ) rd () ;
|
||||
if ( laschar == '\"' ) {
|
||||
* cp ++ = laschar ;
|
||||
while ( rd () != '\"' && !feof ( curinput ) ) * cp ++ = laschar ;
|
||||
* cp ++ = laschar ;
|
||||
* cp = '\0' ;
|
||||
return 1 ; }
|
||||
else {
|
||||
* cp = laschar ;
|
||||
while ( !isspace ( laschar ) && !feof ( curinput ) ) * ++ cp = rd () ;
|
||||
* cp = '\0' ;
|
||||
return 0 ; }
|
||||
}
|
||||
|
||||
int istrunc ( char * a ) // is a a truncation of stringsp ??
|
||||
{
|
||||
char * b = stringsp ;
|
||||
while ( 1 ) {
|
||||
if ( ! * a ) return 1 ;
|
||||
if ( * a ++ != * b ++ ) return 0 ; }
|
||||
}
|
||||
|
||||
int isamatch ( char * a , char * b )
|
||||
{
|
||||
while ( 1 ) {
|
||||
if ( ! * a ) return 1 ;
|
||||
if ( * a ++ != * b ++ ) return 0 ; }
|
||||
}
|
||||
|
||||
void process (void)
|
||||
{
|
||||
char * cp ;
|
||||
int i , mygenometype , showed_headerline ;
|
||||
int showacc_only ;
|
||||
int found_translation ;
|
||||
while ( !feof ( inpf ) ) {
|
||||
gotostring ( "ACCESSION" , 0 ) ;
|
||||
rdaccnumber () ;
|
||||
showacc_only = 0 ;
|
||||
if ( useraccnumber ) {
|
||||
for ( i = 0 ; i < useraccnumber && !showacc_only ; ++ i )
|
||||
if ( !strcmp ( accnumber , useraccname[i] ) ) showacc_only = 1 ; }
|
||||
laquiero = found_translation = 0 ;
|
||||
gotostring ( "ORGANISM" , -1 ) ;
|
||||
rdto ( 10 , taxname ) ;
|
||||
rdto ( '.' , taxonomy ) ;
|
||||
gotostring ( "FEATURES" , 0 ) ;
|
||||
mygenometype = NUCLEAR ;
|
||||
/**** Empieza accession... ****/
|
||||
while ( 1 ) {
|
||||
stornexline ( ) ;
|
||||
if ( istrunc ( "ORIGIN" ) ) { laquiero = -1 ; break ; }
|
||||
if ( istrunc ( "/organelle=" ) ) {
|
||||
if ( istrunc ( "/organelle=\"mitoc" ) )
|
||||
mygenometype = MITOCH ;
|
||||
else if ( istrunc ( "/organelle=\"chlorop" ) )
|
||||
mygenometype = CHLORO ;
|
||||
else if ( istrunc ( "/organelle=\"plastid" ) )
|
||||
mygenometype = PLASTID ; }
|
||||
if ( istrunc ( "tRNA" ) ) break ;
|
||||
if ( istrunc ( "rRNA" ) ) break ;
|
||||
if ( istrunc ( "CDS" ) ) {
|
||||
|
||||
/*** linea agregada por el caso de Marcos... ****/
|
||||
if ( use_translation ) laquiero = FALSE ;
|
||||
|
||||
break ; }} /***** End initial parsing... ******/
|
||||
if ( genometype && mygenometype != genometype )
|
||||
laquiero = -1 ;
|
||||
while ( laquiero == FALSE || ( use_translation && !found_translation ) ) {
|
||||
if ( !istrunc ( "gene" ) ) {
|
||||
if ( istrunc ( "ORIGIN" ) ) break ;
|
||||
if ( istrunc ( "tRNA" ) ||
|
||||
istrunc ( "rRNA" ) ||
|
||||
istrunc ( "CDS" ) ) {
|
||||
showed_headerline = 0 ;
|
||||
strcpy ( headerline , stringsp ) ;
|
||||
cp = stringsp + 10 ;
|
||||
while ( isspace ( * cp ) ) ++ cp ;
|
||||
if ( isamatch ( "join(" , cp ) ) {
|
||||
while ( * cp != ')' && * cp ) ++ cp ;
|
||||
if ( !*cp ) {
|
||||
stornexline () ;
|
||||
cp = stringsp ;
|
||||
while ( isspace ( * cp ) ) ++ cp ; }
|
||||
strcat ( headerline , cp ) ; }}
|
||||
stornexline () ;
|
||||
if ( showacc_only ) {
|
||||
if ( showacc_only ++ == 1 ) {
|
||||
fprintf ( stdout , "\n%s , %s " , accnumber , taxname ) ;
|
||||
if ( mygenometype == NUCLEAR ) fprintf ( stdout , ", nuclear " ) ;
|
||||
if ( mygenometype == CHLORO ) fprintf ( stdout , ", chloro " ) ;
|
||||
if ( mygenometype == MITOCH ) fprintf ( stdout , ", mitoch " ) ;
|
||||
if ( mygenometype == PLASTID ) fprintf ( stdout , ", plastid " ) ; }
|
||||
if ( !showed_headerline )
|
||||
if ( isamatch ( "tRNA" , headerline ) ||
|
||||
isamatch ( "rRNA" , headerline ) ||
|
||||
isamatch ( "CDS" , headerline ) ) {
|
||||
fprintf ( stdout , "\n %s , " , headerline ) ;
|
||||
++ showed_headerline ; }
|
||||
if ( ( istrunc ( "/product=" ) || istrunc ( "/gene=" ) ) ) {
|
||||
if ( istrunc ( "/product=" ) ) cp = stringsp + 9 ;
|
||||
else cp = stringsp + 6 ;
|
||||
fprintf ( stdout , ", %s" , cp ) ; }}
|
||||
if (
|
||||
|
||||
/*** linea agregada por el problema de Marcos.... ****/
|
||||
laquiero &&
|
||||
|
||||
istrunc ( "/translation=" ) && use_translation ) {
|
||||
parse_translation () ;
|
||||
found_translation = 1 ; }
|
||||
if ( istrunc ( "/product=" ) && prodnumber ) {
|
||||
cp = stringsp + 9 ;
|
||||
makelower ( cp ) ;
|
||||
for ( i = 0 ; i < prodnumber && !laquiero ; ++ i )
|
||||
if ( stringis ( cp , prodname[i] ) ) laquiero = 1 ; }
|
||||
if ( istrunc ( "/gene=" ) && genenumber ) {
|
||||
cp = stringsp + 6 ;
|
||||
makelower ( cp ) ;
|
||||
for ( i = 0 ; i < genenumber && !laquiero ; ++ i )
|
||||
if ( stringis ( cp , genename[i] ) ) laquiero = 1 ; }}
|
||||
else stornexline () ; }
|
||||
|
||||
if ( useraccnumber ) {
|
||||
// if ( showacc_only == 2 ) fprintf ( stdout , "\n" ) ;
|
||||
continue ; }
|
||||
if ( laquiero == TRUE && ( !use_translation || found_translation ) ) {
|
||||
if ( use_translation ) output_translation () ;
|
||||
else parsit () ; }
|
||||
else
|
||||
save_to_not () ;
|
||||
} // --- while ( !feof ( inpf ) )
|
||||
}
|
||||
|
||||
void save_to_not ( void )
|
||||
{
|
||||
++ rejected ;
|
||||
if ( !showedskipped )
|
||||
fprintf ( notsfile , "accession " ) ;
|
||||
showedskipped = 1 ;
|
||||
fprintf ( notsfile , "\"%s\" " , accnumber ) ;
|
||||
}
|
||||
|
||||
void setopts ( void )
|
||||
{
|
||||
int i ;
|
||||
if ( dargc > 1 )
|
||||
if ( !strcmp ( dargv[1] , "--help" ) ) dohelp () ;
|
||||
outer ( dargc < 3 , "Specify input file and option file (\"--help\" to get help)" ) ;
|
||||
outer ( ( curinput = opsf = fopen ( dargv[ 2 ] , "rb" ) ) == NULL , "Cannot open file with options" ) ;
|
||||
if ( dargc > 4 )
|
||||
if ( !strcmp ( dargv[3], "stringmatch" ) ) {
|
||||
use_string_matching = 1 ;
|
||||
string_similarity = atof ( dargv[4] ) ; }
|
||||
while ( !feof ( opsf ) ) {
|
||||
outer ( rdliteral () , "Unexpected literal string in options file" ) ;
|
||||
if ( !strcmp ( stringsp , "protein" ) ) use_translation = 1 ;
|
||||
else if ( !strcmp ( stringsp , "stringmatch" ) ) {
|
||||
rdliteral () ;
|
||||
if ( !use_string_matching ) {
|
||||
use_string_matching = 1 ;
|
||||
string_similarity = atof ( stringsp ) ; }}
|
||||
else if ( !strcmp ( stringsp , "gene" ) ) {
|
||||
while ( !feof ( curinput ) ) {
|
||||
while ( isspace ( rd () ) && !feof ( curinput ) ) ;
|
||||
ungetc ( laschar , opsf ) ;
|
||||
if ( laschar != '\"' ) break ;
|
||||
outer ( genenumber == MAX_USER_DEFINITIONS , "Cannot define so many gene names" ) ;
|
||||
rdliteral () ;
|
||||
makelower ( stringsp ) ;
|
||||
genename [ genenumber ] = mymalloc ( ( strlen ( stringsp ) + 1 ) * sizeof ( char ) ) ;
|
||||
strcpy ( genename [ genenumber ++ ] , stringsp ) ; }}
|
||||
else if ( !strcmp ( stringsp , "accession" ) ) {
|
||||
useraccname = mymalloc ( MAXUSERACC * sizeof ( char * ) ) ;
|
||||
while ( !feof ( curinput ) ) {
|
||||
while ( isspace ( rd () ) && !feof ( curinput ) ) ;
|
||||
ungetc ( laschar , opsf ) ;
|
||||
if ( laschar != '\"' ) break ;
|
||||
rdliteral () ;
|
||||
if ( useraccnumber == MAXUSERACC )
|
||||
fprintf ( stderr , "Cannot define so many accessions, will skip from %s on" , stringsp ) ;
|
||||
else {
|
||||
useraccname [ useraccnumber ] = mymalloc ( ( strlen ( stringsp ) + 1 ) * sizeof ( char ) ) ;
|
||||
strcpy ( useraccname [ useraccnumber ] , stringsp + 1 ) ;
|
||||
i = strlen ( useraccname [ useraccnumber ] ) ;
|
||||
useraccname [ useraccnumber ] [ i - 1 ] = '\0' ;
|
||||
++ useraccnumber ; }}}
|
||||
else if ( !strcmp ( stringsp , "product" ) ) {
|
||||
while ( !feof ( curinput ) ) {
|
||||
while ( isspace ( rd () ) && !feof ( curinput ) ) ;
|
||||
ungetc ( laschar , opsf ) ;
|
||||
if ( laschar != '\"' ) break ;
|
||||
outer ( prodnumber == MAX_USER_DEFINITIONS , "Cannot define so many product names" ) ;
|
||||
rdliteral () ;
|
||||
makelower ( stringsp ) ;
|
||||
prodname [ prodnumber ] = malloc ( ( strlen ( stringsp ) + 1 ) * sizeof ( char ) ) ;
|
||||
strcpy ( prodname [ prodnumber ++ ] , stringsp ) ; }}
|
||||
else if ( !strcmp ( stringsp , "genome" ) ) {
|
||||
outer ( !rdliteral () , "Syntax error after \"genome\"" ) ;
|
||||
if ( !strcmp ( stringsp , "\"mitochondrial\"" ) ) genometype = MITOCH ;
|
||||
else if ( !strcmp ( stringsp , "\"nuclear\"" ) ) genometype = NUCLEAR ;
|
||||
else if ( !strcmp ( stringsp , "\"plastid\"" ) ) genometype = PLASTID ;
|
||||
else if ( !strcmp ( stringsp , "\"chloroplast\"" ) ) genometype = CHLORO ;
|
||||
else outer ( 1 , "Unrecognized genome option" ) ; }}
|
||||
if ( use_string_matching )
|
||||
fprintf ( stderr , "\nUsing string similarity of %.3f\n" , string_similarity ) ;
|
||||
if ( !useraccnumber )
|
||||
outer ( ( notsfile = fopen ( "gb2tnt.not" , "wb" ) ) == NULL , "Cannot open file for skipped accessions" ) ;
|
||||
openit () ;
|
||||
}
|
||||
|
||||
void makelower ( char * txt )
|
||||
{
|
||||
char * cp = txt ;
|
||||
while ( * cp ) {
|
||||
* cp = tolower ( *cp ) ;
|
||||
++ cp ; }
|
||||
return ;
|
||||
}
|
||||
|
||||
int wrong_location ;
|
||||
|
||||
char * storchunk ( char * cp )
|
||||
{
|
||||
if ( * cp == '<' ) ++ cp ;
|
||||
if ( !isdigit ( * cp ) ) { wrong_location = 1 ; * cp = '0' ; return cp ; }
|
||||
chunk[numchunks].from = atoi ( cp ) ;
|
||||
while ( * cp ++ != '.' && * cp ) ;
|
||||
if ( * cp != '.' ) { wrong_location = 1 ; * cp = '0' ; return cp ; }
|
||||
++ cp ;
|
||||
if ( * cp == '>' ) ++ cp ;
|
||||
if ( !isdigit ( * cp ) ) { wrong_location = 1 ; * cp = '0' ; return cp ; }
|
||||
chunk[numchunks].to = atoi ( cp ) ;
|
||||
while ( isdigit ( * cp ) ) ++ cp ;
|
||||
++ numchunks ;
|
||||
return cp ;
|
||||
}
|
||||
|
||||
int species_read = 0 ;
|
||||
|
||||
void parsit ( void )
|
||||
{
|
||||
char * cp = headerline + 15 ;
|
||||
int i , atchunk , atpos ;
|
||||
char * bytept = bytestring , now ;
|
||||
int complement_it = 0 , didntmatch ;
|
||||
numchunks = 0 ;
|
||||
wrong_location = 0 ;
|
||||
while ( isspace ( * cp ) ) ++ cp ;
|
||||
if ( * cp == '<' || isdigit ( * cp ) ) storchunk ( cp ) ;
|
||||
else {
|
||||
i = cp [ 4 ] ;
|
||||
cp [ 4 ] = '\0' ;
|
||||
didntmatch = 0 ;
|
||||
if ( strcmp ( "join" , cp ) ) didntmatch = 1 ;
|
||||
cp [ 4 ] = i ;
|
||||
i = cp [ 10 ] ;
|
||||
cp [ 10 ] = '\0' ;
|
||||
if ( didntmatch )
|
||||
if ( strcmp ( "complement" , cp ) ) {
|
||||
fprintf ( stderr , "OOPS!!\nFound unrecognized location specifier: %s\nFor accession %s\n" , cp , accnumber ) ;
|
||||
save_to_not () ; return ; }
|
||||
if ( !strcmp ( "complement" , cp ) ) {
|
||||
complement_it = 1 ;
|
||||
cp += 11 ; }
|
||||
else { cp [ 10 ] = i ; cp += 5 ; }
|
||||
while ( * cp != ')' && !wrong_location ) {
|
||||
cp = storchunk ( cp ) ;
|
||||
while ( * cp == ',' || isspace ( * cp ) ) ++ cp ; }}
|
||||
if ( wrong_location ) { save_to_not () ; return ; }
|
||||
gotostring ( "ORIGIN" , 0 ) ;
|
||||
rdliteral () ;
|
||||
atchunk = atpos = 0 ;
|
||||
++ species_read ;
|
||||
while ( 1 ) {
|
||||
now = laschar ;
|
||||
while ( laschar == 10 || laschar == 13 || laschar == 32 || ( laschar >= '0' && laschar <= '9' ) ) {
|
||||
now = laschar ;
|
||||
rd () ; }
|
||||
if ( now == '/' || laschar == '/' ) return ;
|
||||
++ atpos ;
|
||||
if ( chunk[atchunk].from <= atpos && chunk[atchunk].to >= atpos ) {
|
||||
* bytept ++ = laschar ;
|
||||
outer ( ( bytept - bytestring >= MAXSEQLENGTH ) , "OOPS -- sequence is too long!\nChange MAXSEQLENGTH and re-compile" ) ; }
|
||||
laschar = 32 ;
|
||||
if ( atpos == chunk[atchunk].to )
|
||||
if ( ++ atchunk == numchunks ) break ; }
|
||||
* bytept = '\0' ;
|
||||
++ accepted ;
|
||||
spew_name () ;
|
||||
if ( complement_it ) effect_complementation () ;
|
||||
fprintf ( stdout , "%s" , bytestring ) ;
|
||||
fprintf ( stdout , "\n" ) ;
|
||||
fflush ( stdout ) ;
|
||||
}
|
||||
|
||||
void parse_translation ( void )
|
||||
{
|
||||
char * cp , * bytept ;
|
||||
cp = stringsp + 14 ;
|
||||
bytept = bytestring ;
|
||||
while ( * cp != '\"' && * cp ) {
|
||||
if ( !isspace ( * cp ) ) * bytept ++ = * cp ++ ;
|
||||
if ( * cp == 10 || * cp == 13 || * cp == '\0' ) {
|
||||
stornexline () ;
|
||||
cp = stringsp ;
|
||||
while ( isspace ( * cp ) ) ++ cp ; }}
|
||||
* bytept = '\0' ;
|
||||
}
|
||||
|
||||
void spew_name ( void )
|
||||
{
|
||||
char * cp = taxonomy , * here , * begg ;
|
||||
int numsemicols = 0 ;
|
||||
while ( * cp != ';' && * cp ) ++ cp ;
|
||||
begg = here = ( cp += 2 ) ;
|
||||
while ( numsemicols < 2 && * cp ) {
|
||||
if ( * cp == ';' ) {
|
||||
++ cp ;
|
||||
++ numsemicols ; }
|
||||
* here ++ = * cp ++ ; }
|
||||
* here = '\0' ;
|
||||
fprintf ( stdout , ">%s____%s_@%s\n" , taxname , accnumber , begg ) ;
|
||||
}
|
||||
|
||||
void output_translation ( void )
|
||||
{
|
||||
++ accepted ;
|
||||
spew_name () ;
|
||||
fprintf ( stdout , "%s" , bytestring ) ;
|
||||
fprintf ( stdout , "\n" ) ;
|
||||
fflush ( stdout ) ;
|
||||
}
|
||||
|
||||
char tmpmask[256] ;
|
||||
char makeit[9] ;
|
||||
char antimask[16] ;
|
||||
|
||||
void effect_complementation ( void )
|
||||
{
|
||||
int i , j , k , l ;
|
||||
int bit ;
|
||||
int x , y ;
|
||||
for ( i = 0 ; i < 256 ; ++ i ) tmpmask[i] = 0 ;
|
||||
tmpmask [ 'a' ] = tmpmask [ 'A' ] = 1 ; // tmpmask [ '0' ] ;
|
||||
tmpmask [ 'g' ] = tmpmask [ 'G' ] = 2 ; // tmpmask [ '1' ] ;
|
||||
tmpmask [ 'c' ] = tmpmask [ 'C' ] = 4 ; // tmpmask [ '2' ] ;
|
||||
tmpmask [ 't' ] = tmpmask [ 'T' ] = 8 ; // tmpmask [ '3' ] ;
|
||||
tmpmask [ 'R' ] = tmpmask [ 'r' ] = tmpmask [ 'a' ] | tmpmask [ 'g' ] ;
|
||||
tmpmask [ 'Y' ] = tmpmask [ 'y' ] = tmpmask [ 't' ] | tmpmask [ 'c' ] ;
|
||||
tmpmask [ 'W' ] = tmpmask [ 'w' ] = tmpmask [ 'a' ] | tmpmask [ 't' ] ;
|
||||
tmpmask [ 'S' ] = tmpmask [ 's' ] = tmpmask [ 'c' ] | tmpmask [ 'g' ] ;
|
||||
tmpmask [ 'M' ] = tmpmask [ 'm' ] = tmpmask [ 'a' ] | tmpmask [ 'c' ] ;
|
||||
tmpmask [ 'K' ] = tmpmask [ 'k' ] = tmpmask [ 'g' ] | tmpmask [ 't' ] ;
|
||||
tmpmask [ 'B' ] = tmpmask [ 'b' ] = tmpmask [ 'c' ] | tmpmask [ 'g' ] | tmpmask [ 't' ] ;
|
||||
tmpmask [ 'D' ] = tmpmask [ 'd' ] = tmpmask [ 'a' ] | tmpmask [ 'g' ] | tmpmask [ 't' ] ;
|
||||
tmpmask [ 'H' ] = tmpmask [ 'h' ] = tmpmask [ 'a' ] | tmpmask [ 'c' ] | tmpmask [ 't' ] ;
|
||||
tmpmask [ 'V' ] = tmpmask [ 'v' ] = tmpmask [ 'a' ] | tmpmask [ 'c' ] | tmpmask [ 'g' ] ;
|
||||
tmpmask [ 'N' ] = tmpmask [ 'n' ] = 1 | 2 | 4 | 8 ;
|
||||
makeit[tmpmask['a']] = tmpmask['t'] ;
|
||||
makeit[tmpmask['c']] = tmpmask['g'] ;
|
||||
makeit[tmpmask['g']] = tmpmask['c'] ;
|
||||
makeit[tmpmask['t']] = tmpmask['a'] ;
|
||||
for ( i = 0 ; i < 256 ; ++ i )
|
||||
if ( tmpmask[i] )
|
||||
antimask[ tmpmask[i] ] = i ;
|
||||
j = strlen ( bytestring ) ;
|
||||
for ( i = 0 ; i < j ; ++ i )
|
||||
complement_string[i] = bytestring[i] ;
|
||||
for ( i = 0 , k = j - 1 ; i < j ; ++ i , -- k ) {
|
||||
x = tmpmask [ complement_string [i]] ;
|
||||
y = 0 ;
|
||||
for ( l = 0 , bit = 1 ; l < 4 ; ++ l , bit <<= 1 )
|
||||
if ( ( bit & x ) )
|
||||
y |= makeit[ bit ] ;
|
||||
bytestring [ k ] = antimask [ y ] ; }
|
||||
return;
|
||||
}
|
||||
|
||||
Loading…
Reference in a new issue