code_c/Maasha/src/lib/fasta.c

   1 #include "common.h"
   2 #include "fasta.h"
   3 #include "list.h"
   4
   5
   6 uint fasta_count( FILE *fp )
   7 {
   8     /* Martin A. Hansen, May 2008 */
   9
  10     /* Counts all entries in a FASTA file given a file pointer. */
  11
  12     char buffer[ FASTA_BUFFER ];
  13     uint count;
  14
  15     count = 0;
  16
  17     while ( ( fgets( buffer, sizeof( buffer ), fp ) ) != NULL )
  18     {
  19         if ( buffer[ 0 ] == '>' ) {
  20             count++;
  21         }
  22     }
  23
  24     return count;
  25 }
  26
  27
  28 bool fasta_get_entry( FILE *fp, struct seq_entry *entry )
  29 {
  30     /* Martin A. Hansen, May 2008 */
  31
  32     /* Get next sequence entry from a FASTA file given a file pointer. */
  33
  34     int     i;
  35     size_t  j;
  36     size_t  offset;
  37     size_t  seq_len;
  38     char    buffer[ FASTA_BUFFER ];
  39     int     buffer_len;
  40     char   *seq_name = NULL;
  41     char   *seq      = NULL;
  42
  43     MEM_GET( entry );
  44
  45     offset = ftell( fp );
  46
  47     /* ---- Skip ahead until header line and include header ---- */
  48
  49     while ( fgets( buffer, sizeof( buffer ), fp ) != NULL )
  50     {
  51         buffer_len = strlen( buffer );
  52
  53         offset += buffer_len;
  54
  55         if ( ( buffer[ 0 ] == '>' ) )
  56         {
  57             seq_name = mem_get_zero( buffer_len - 1 );
  58
  59             for ( i = 1; i < buffer_len - 1; i++ ) {
  60                 seq_name[ i - 1 ] = buffer[ i ];
  61             }
  62
  63             seq_name[ i ] = '\0';
  64
  65             break;
  66         }
  67     }
  68
  69     /* ---- Determine length of sequence ---- */
  70
  71     seq_len = 0;
  72
  73     while ( ( fgets( buffer, sizeof( buffer ), fp ) != NULL ) )
  74     {
  75         for ( i = 0; buffer[ i ]; i++ )
  76         {
  77             if ( buffer[ i ] > 32 && buffer[ i ] < 127 ) {
  78                 seq_len++;
  79             }
  80         }
  81
  82         if ( ( buffer[ 0 ] == '>' ) )
  83         {
  84             seq_len -= strlen( buffer ) - 1;
  85
  86             break;
  87         }
  88     }
  89
  90     /* ---- Allocate memory for sequence ---- */
  91
  92     seq = mem_get_zero( seq_len + 1 );
  93
  94     /* ---- Rewind file pointer and read sequence ---- */
  95
  96     if ( fseek( fp, offset, SEEK_SET ) < 0 ) {
  97         die( "fseek SEEK_SET failed." );
  98     }
  99
 100     j = 0;
 101
 102     while ( ( fgets( buffer, sizeof( buffer ), fp ) != NULL ) )
 103     {
 104         for ( i = 0; buffer[ i ]; i++ )
 105         {
 106             if ( buffer[ i ] > 32 && buffer[ i ] < 127 )
 107             {
 108                 seq[ j ] = buffer[ i ];
 109
 110                 if ( j == seq_len - 1 )
 111                 {
 112                     seq[ j + 1 ] = '\0';
 113
 114                     entry->seq_name = seq_name;
 115                     entry->seq      = seq;
 116                     entry->seq_len  = seq_len;
 117
 118                     return TRUE;
 119                 }
 120
 121                 j++;
 122             }
 123         }
 124     }
 125
 126     return FALSE;
 127 }
 128
 129
 130 void fasta_put_entry( struct seq_entry *entry )
 131 {
 132     /* Martin A. Hansen, May 2008 */
 133
 134     /* Output a sequence entry in FASTA format. */
 135     printf( ">%s\n%s\n", entry->seq_name, entry->seq );
 136 }
 137
 138
 139 void fasta_get_entries( FILE *fp, struct list **entries )
 140 {
 141     /* Martin A. Hansen, May 2008 */
 142
 143     /* Given a file pointer to a FASTA file retreives all */
 144     /* sequence entries and insert those in a list. */
 145
 146     struct seq_entry *entry;
 147
 148     while ( 1 )
 149     {
 150         MEM_GET( entry );
 151
 152         if ( ! fasta_get_entry( fp, entry ) ) {
 153             break;
 154         }
 155
 156         list_add( entries, entry );
 157     }
 158
 159     list_reverse( entries );
 160 }
 161
 162
 163 void fasta_put_entries( struct list *entries )
 164 {
 165     /* Martin A. Hansen, May 2008 */
 166
 167     /* Output a list of sequence entries as FASTA records. */
 168
 169     struct list *elem;
 170
 171     for ( elem = entries; elem != NULL; elem = elem->next ) {
 172         fasta_put_entry( elem->val );
 173     }
 174 }
 175
 176
 177 void fasta_free_entry( struct seq_entry *entry )
 178 {
 179     /* Martin A. Hansen, June 2008 */
 180
 181     /* Deallocates memory from a seq_entry. */
 182
 183     mem_free( entry->seq_name );
 184     mem_free( entry->seq );
 185     mem_free( entry );
 186 }
 187
 188