lib/fa.c File Reference

#include "common.h"
#include "errabort.h"
#include "hash.h"
#include "portable.h"
#include "dnautil.h"
#include "dnaseq.h"
#include "fa.h"
#include "linefile.h"

Include dependency graph for fa.c:

Go to the source code of this file.

Functions
boolean	faReadNext (FILE *f, char *defaultName, boolean mustStartWithComment, char **retCommentLine, struct dnaSeq **retSeq)
boolean	faReadMixedNext (FILE *f, boolean preserveCase, char *defaultName, boolean mustStartWithComment, char **retCommentLine, struct dnaSeq **retSeq)
dnaSeq *	faReadOneDnaSeq (FILE *f, char *defaultName, boolean mustStartWithComment)
static bioSeq *	nextSeqFromMem (char **pText, boolean isDna, boolean doFilter)
bioSeq *	faNextSeqFromMemText (char **pText, boolean isDna)
bioSeq *	faNextSeqFromMemTextRaw (char **pText)
bioSeq *	faSeqListFromMemText (char *text, boolean isDna)
bioSeq *	faSeqListFromMemTextRaw (char *text)
bioSeq *	faSeqFromMemText (char *text, boolean isDna)
dnaSeq *	faFromMemText (char *text)
dnaSeq *	faReadSeq (char *fileName, boolean isDna)
dnaSeq *	faReadDna (char *fileName)
dnaSeq *	faReadAa (char *fileName)
static void	expandFaFastBuf (int bufPos, int minExp)
void	faFreeFastBuf ()
boolean	faFastReadNext (FILE *f, DNA **retDna, int *retSize, char **retName)
void	faWriteNext (FILE *f, char *startLine, DNA *dna, int dnaSize)
void	faWrite (char *fileName, char *startLine, DNA *dna, int dnaSize)
void	faWriteAll (char *fileName, bioSeq *seqList)
boolean	faMixedSpeedReadNext (struct lineFile *lf, DNA **retDna, int *retSize, char **retName)
void	faToProtein (char *poly, int size)
void	faToDna (char *poly, int size)
boolean	faSomeSpeedReadNext (struct lineFile *lf, DNA **retDna, int *retSize, char **retName, boolean isDna)
boolean	faPepSpeedReadNext (struct lineFile *lf, DNA **retDna, int *retSize, char **retName)
boolean	faSpeedReadNext (struct lineFile *lf, DNA **retDna, int *retSize, char **retName)
static struct dnaSeq *	faReadAllMixableInLf (struct lineFile *lf, boolean isDna, boolean mixed)
static struct dnaSeq *	faReadAllSeqMixable (char *fileName, boolean isDna, boolean mixed)
hash *	faReadAllIntoHash (char *fileName, enum dnaCase dnaCase)
dnaSeq *	faReadAllSeq (char *fileName, boolean isDna)
dnaSeq *	faReadAllDna (char *fileName)
dnaSeq *	faReadAllPep (char *fileName)
dnaSeq *	faReadAllMixed (char *fileName)
dnaSeq *	faReadAllMixedInLf (struct lineFile *lf)
Variables
static char const	rcsid [] = "$Id: fa.c,v 1.37 2007/02/20 18:50:21 kent Exp $"
static unsigned	faFastBufSize = 0
static DNA *	faFastBuf

---

Function Documentation

static void expandFaFastBuf	(	int	bufPos,
		int	minExp
	)			[static]

Definition at line 299 of file fa.c.

References errAbort(), faFastBuf, faFastBufSize, freeMem(), and needHugeMem().

Referenced by faFastReadNext(), and faMixedSpeedReadNext().

{
if (faFastBufSize == 0)
    {
    faFastBufSize = 64 * 1024;
    while (minExp > faFastBufSize)
        faFastBufSize <<= 1;
    faFastBuf = needHugeMem(faFastBufSize);
    }
else
    {
    DNA *newBuf;
    unsigned newBufSize = faFastBufSize + faFastBufSize;
    while (newBufSize < minExp)
        {
        newBufSize <<= 1;
        if (newBufSize <= 0)
            errAbort("expandFaFastBuf: integer overflow when trying to "
                     "increase buffer size from %u to a min of %u.",
                     faFastBufSize, minExp);
        }
    newBuf = needHugeMem(newBufSize);
    memcpy(newBuf, faFastBuf, bufPos);
    freeMem(faFastBuf);
    faFastBuf = newBuf;
    faFastBufSize = newBufSize;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

boolean faFastReadNext	(	FILE *	f,
		DNA **	retDna,
		int *	retSize,
		char **	retName
	)

Definition at line 336 of file fa.c.

References ArraySize, dnaUtilOpen(), expandFaFastBuf(), faFastBuf, faFastBufSize, FALSE, name, ntChars, and TRUE.

{
int c;
int bufIx = 0;
static char name[256];
int nameIx = 0;
boolean gotSpace = FALSE;

/* Seek to next '\n' and save first word as name. */
dnaUtilOpen();
name[0] = 0;
for (;;)
    {
    if ((c = fgetc(f)) == EOF)
        {
        *retDna = NULL;
        *retSize = 0;
        *retName = NULL;
        return FALSE;
        }
    if (!gotSpace && nameIx < ArraySize(name)-1)
        {
        if (isspace(c))
            gotSpace = TRUE;
        else if (c != '>')
            {
            name[nameIx++] = c;
            }
        }
    if (c == '\n')
        break;
    }
name[nameIx] = 0;
/* Read until next '>' */
for (;;)
    {
    c = fgetc(f);
    if (c == EOF || c == '>')
        c = 0;
    else if (!isalpha(c))
        continue;
    else
        {
        c = ntChars[c];
        if (c == 0) c = 'n';
        }
    if (bufIx >= faFastBufSize)
        expandFaFastBuf(bufIx, 0);
    faFastBuf[bufIx++] = c;
    if (c == 0)
        {
        *retDna = faFastBuf;
        *retSize = bufIx-1;
        *retName = name;
        return TRUE;
        }
    }
}

Here is the call graph for this function:

void faFreeFastBuf

(

)

Definition at line 329 of file fa.c.

References faFastBuf, faFastBufSize, and freez().

Referenced by faReadAllMixableInLf().

{
freez(&faFastBuf);
faFastBufSize = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct dnaSeq* faFromMemText

(

char *

text

)

[read]

Definition at line 257 of file fa.c.

References faNextSeqFromMemText(), and TRUE.

{
return faNextSeqFromMemText(&text, TRUE);
}

Here is the call graph for this function:

boolean faMixedSpeedReadNext	(	struct lineFile *	lf,
		DNA **	retDna,
		int *	retSize,
		char **	retName
	)

Definition at line 430 of file fa.c.

References dnaUtilOpen(), errAbort(), expandFaFastBuf(), faFastBuf, faFastBufSize, FALSE, lineFile::fileName, firstWordInLine(), lineFileNext(), lineFileReuse(), lineFile::lineIx, name, skipLeadingSpaces(), TRUE, and warn().

Referenced by bigBlat(), dnaLoadNextFromStack(), faReadAllMixableInLf(), faSomeSpeedReadNext(), and searchOneIndex().

{
char c;
int bufIx = 0;
static char name[512];
int lineSize, i;
char *line;

dnaUtilOpen();

/* Read first line, make sure it starts with '>', and read first word
 * as name of sequence. */
name[0] = 0;
if (!lineFileNext(lf, &line, &lineSize))
    {
    *retDna = NULL;
    *retSize = 0;
    return FALSE;
    }
if (line[0] == '>')
    {
    line = firstWordInLine(skipLeadingSpaces(line+1));
    if (line == NULL)
        errAbort("Expecting sequence name after '>' line %d of %s", lf->lineIx, lf->fileName);
    strncpy(name, line, sizeof(name));
    name[sizeof(name)-1] = '\0'; /* Just to make sure name is NULL terminated. */
    }
else
    {
    errAbort("Expecting '>' line %d of %s", lf->lineIx, lf->fileName);
    }
/* Read until next '>' */
for (;;)
    {
    if (!lineFileNext(lf, &line, &lineSize))
        break;
    if (line[0] == '>')
        {
        lineFileReuse(lf);
        break;
        }
    if (bufIx + lineSize >= faFastBufSize)
        expandFaFastBuf(bufIx, lineSize);
    for (i=0; i<lineSize; ++i)
        {
        c = line[i];
        if (isalpha(c) || c == '-')
            faFastBuf[bufIx++] = c;
        }
    }
if (bufIx >= faFastBufSize)
    expandFaFastBuf(bufIx, 0);
faFastBuf[bufIx] = 0;
*retDna = faFastBuf;
*retSize = bufIx;
*retName = name;
if (bufIx == 0)
    {
    warn("Invalid fasta format: sequence size == 0 for element %s",name);
    }

return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bioSeq* faNextSeqFromMemText	(	char **	pText,
		boolean	isDna
	)

Definition at line 211 of file fa.c.

References nextSeqFromMem(), and TRUE.

Referenced by faFromMemText(), faSeqFromMemText(), and faSeqListFromMemText().

{
return nextSeqFromMem(pText, isDna, TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bioSeq* faNextSeqFromMemTextRaw

(

char **

pText

)

Definition at line 218 of file fa.c.

References FALSE, nextSeqFromMem(), and TRUE.

Referenced by faSeqListFromMemTextRaw().

{
return nextSeqFromMem(pText, TRUE, FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

boolean faPepSpeedReadNext	(	struct lineFile *	lf,
		DNA **	retDna,
		int *	retSize,
		char **	retName
	)

Definition at line 545 of file fa.c.

References FALSE, and faSomeSpeedReadNext().

{
return faSomeSpeedReadNext(lf, retDna, retSize, retName, FALSE);
}

Here is the call graph for this function:

struct dnaSeq* faReadAa

(

char *

fileName

)

[read]

Definition at line 290 of file fa.c.

References FALSE, and faReadSeq().

{
return faReadSeq(fileName, FALSE);
}

Here is the call graph for this function:

struct dnaSeq* faReadAllDna

(

char *

fileName

)

[read]

Definition at line 626 of file fa.c.

References faReadAllSeq(), and TRUE.

{
return faReadAllSeq(fileName, TRUE);
}

Here is the call graph for this function:

struct hash* faReadAllIntoHash	(	char *	fileName,
		enum dnaCase dnaCase
	)			[read]

Definition at line 602 of file fa.c.

References dnaLower, dnaMixed, errAbort(), faReadAllSeqMixable(), hashAdd(), hashLookup(), hashNew, isDna(), dnaSeq::name, and dnaSeq::next.

{
boolean isDna = (dnaCase == dnaLower);
boolean isMixed = (dnaCase == dnaMixed);
struct dnaSeq *seqList = faReadAllSeqMixable(fileName, isDna, isMixed);
struct hash *hash = hashNew(18);
struct dnaSeq *seq;
for (seq = seqList; seq != NULL; seq = seq->next)
    {
    if (hashLookup(hash, seq->name))
        errAbort("%s duplicated in %s", seq->name, fileName);
    hashAdd(hash, seq->name, seq);
    }
return hash;
}

Here is the call graph for this function:

static struct dnaSeq* faReadAllMixableInLf	(	struct lineFile *	lf,
		boolean	isDna,
		boolean	mixed
	)			[static, read]

Definition at line 560 of file fa.c.

References AllocVar, cloneMem(), cloneString(), dnaSeq::dna, faFreeFastBuf(), faMixedSpeedReadNext(), faSomeSpeedReadNext(), name, dnaSeq::size, slAddHead, and slReverse().

Referenced by faReadAllMixedInLf(), and faReadAllSeqMixable().

{
struct dnaSeq *seqList = NULL, *seq;
DNA *dna;
char *name;
int size;
boolean ok;

for (;;)
    {
    if (mixed)
        ok = faMixedSpeedReadNext(lf, &dna, &size, &name);
    else
        ok = faSomeSpeedReadNext(lf, &dna, &size, &name, isDna);
    if (!ok)
        break;
    AllocVar(seq);
    seq->name = cloneString(name);
    seq->size = size;
    seq->dna = cloneMem(dna, size+1);
    slAddHead(&seqList, seq);
    }
slReverse(&seqList);
faFreeFastBuf();
return seqList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct dnaSeq* faReadAllMixed

(

char *

fileName

)

[read]

Definition at line 638 of file fa.c.

References FALSE, faReadAllSeqMixable(), and TRUE.

Referenced by gfClientSeqList().

{
return faReadAllSeqMixable(fileName, FALSE, TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct dnaSeq* faReadAllMixedInLf

(

struct lineFile *

lf

)

[read]

Definition at line 644 of file fa.c.

References FALSE, faReadAllMixableInLf(), and TRUE.

{
return faReadAllMixableInLf(lf, FALSE, TRUE);
}

Here is the call graph for this function:

struct dnaSeq* faReadAllPep

(

char *

fileName

)

[read]

Definition at line 632 of file fa.c.

References FALSE, and faReadAllSeq().

Referenced by gfClientSeqList().

{
return faReadAllSeq(fileName, FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct dnaSeq* faReadAllSeq	(	char *	fileName,
		boolean	isDna
	)			[read]

Definition at line 620 of file fa.c.

References FALSE, and faReadAllSeqMixable().

Referenced by faReadAllDna(), faReadAllPep(), and gfMakeOoc().

{
return faReadAllSeqMixable(fileName, isDna, FALSE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct dnaSeq* faReadAllSeqMixable	(	char *	fileName,
		boolean	isDna,
		boolean	mixed
	)			[static, read]

Definition at line 591 of file fa.c.

References FALSE, faReadAllMixableInLf(), lineFileClose(), and lineFileOpen().

Referenced by faReadAllIntoHash(), faReadAllMixed(), and faReadAllSeq().

{
struct lineFile *lf = lineFileOpen(fileName, FALSE);
struct dnaSeq *seqList = faReadAllMixableInLf(lf, isDna, mixed);
lineFileClose(&lf);
return seqList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct dnaSeq* faReadDna

(

char *

fileName

)

[read]

Definition at line 284 of file fa.c.

References faReadSeq(), and TRUE.

{
return faReadSeq(fileName, TRUE);
}

Here is the call graph for this function:

boolean faReadMixedNext	(	FILE *	f,
		boolean	preserveCase,
		char *	defaultName,
		boolean	mustStartWithComment,
		char **	retCommentLine,
		struct dnaSeq **	retSeq
	)

Definition at line 29 of file fa.c.

References ArraySize, chopByWhite(), cloneString(), dnaUtilOpen(), errnoAbort(), FALSE, name, needHugeMem(), newDnaSeq(), ntChars, SEEK_SET, TRUE, and warn().

Referenced by faReadNext().

{
char lineBuf[1024];
int lineSize;
char *words[1];
int c;
off_t offset = ftello(f);
size_t dnaSize = 0;
DNA *dna, *sequence;
char *name = defaultName;

if (name == NULL)
    name = "";
dnaUtilOpen();
if (retCommentLine != NULL)
    *retCommentLine = NULL;
*retSeq = NULL;

/* Skip first lines until it starts with '>' */
for (;;)
    {
    if(fgets(lineBuf, sizeof(lineBuf), f) == NULL)
        {
        if (ferror(f))
            errnoAbort("read of fasta file failed");
        return FALSE;
        }
    lineSize = strlen(lineBuf);
    if (lineBuf[0] == '>')
        {
        if (retCommentLine != NULL)
            *retCommentLine = cloneString(lineBuf);
        offset = ftello(f);
        chopByWhite(lineBuf, words, ArraySize(words));
        name = words[0]+1;
        break;
        }
    else if (!mustStartWithComment)
        {
        if (fseeko(f, offset, SEEK_SET) < 0)
            errnoAbort("fseek on fasta file failed");
        break;
        }
    else
        offset += lineSize;
    }
/* Count up DNA. */
for (;;)
    {
    c = fgetc(f);
    if (c == EOF || c == '>')
        break;
    if (isalpha(c))
        {
        ++dnaSize;
        }
    }

if (dnaSize == 0)
    {
    warn("Invalid fasta format: sequence size == 0 for element %s",name);
    }

/* Allocate DNA and fill it up from file. */
dna = sequence = needHugeMem(dnaSize+1);
if (fseeko(f, offset, SEEK_SET) < 0)
    errnoAbort("fseek on fasta file failed");
for (;;)
    {
    c = fgetc(f);
    if (c == EOF || c == '>')
        break;
    if (isalpha(c))
        {
        /* check for non-DNA char */
        if (ntChars[c] == 0)
            {
            *dna++ = preserveCase ? 'N' : 'n';
            }
        else
            {
            *dna++ = preserveCase ? c : ntChars[c];
            }
        }
    }
if (c == '>')
    ungetc(c, f);
*dna = 0;

*retSeq = newDnaSeq(sequence, dnaSize, name);
if (ferror(f))
    errnoAbort("read of fasta file failed");    
return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

boolean faReadNext	(	FILE *	f,
		char *	defaultName,
		boolean	mustStartWithComment,
		char **	retCommentLine,
		struct dnaSeq **	retSeq
	)

Definition at line 17 of file fa.c.

References faReadMixedNext().

Referenced by faReadOneDnaSeq(), flyCdnaSeq(), nextWormCdnaAndInfo(), and wormCdnaSeq().

{
    return faReadMixedNext(f, 0, defaultName, mustStartWithComment,
                                        retCommentLine, retSeq);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct dnaSeq* faReadOneDnaSeq	(	FILE *	f,
		char *	defaultName,
		boolean	mustStartWithComment
	)			[read]

Definition at line 130 of file fa.c.

References faReadNext().

Referenced by nextWormCdna().

{
struct dnaSeq *seq;
if (!faReadNext(f, defaultName, mustStartWithComment, NULL, &seq))
    return NULL;
else
    return seq;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct dnaSeq* faReadSeq	(	char *	fileName,
		boolean	isDna
	)			[read]

Definition at line 267 of file fa.c.

References errAbort(), faSeqFromMemText(), fileSize(), and needHugeMem().

Referenced by faReadAa(), faReadDna(), and queryServer().

{
int maxSize = fileSize(fileName);
int fd;
DNA *s;

if (maxSize < 0)
    errAbort("can't open %s", fileName);
s = needHugeMem(maxSize+1);
fd = open(fileName, O_RDONLY);
read(fd, s, maxSize);
close(fd);
s[maxSize] = 0;
return faSeqFromMemText(s, isDna);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bioSeq* faSeqFromMemText	(	char *	text,
		boolean	isDna
	)

Definition at line 251 of file fa.c.

References faNextSeqFromMemText().

Referenced by faReadSeq().

{
return faNextSeqFromMemText(&text, isDna);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bioSeq* faSeqListFromMemText	(	char *	text,
		boolean	isDna
	)

Definition at line 225 of file fa.c.

References faNextSeqFromMemText(), slAddHead, and slReverse().

Referenced by doBlat().

{
bioSeq *seqList = NULL, *seq;
while ((seq = faNextSeqFromMemText(&text, isDna)) != NULL)
    {
    slAddHead(&seqList, seq);
    }
slReverse(&seqList);
return seqList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bioSeq* faSeqListFromMemTextRaw

(

char *

text

)

Definition at line 237 of file fa.c.

References faNextSeqFromMemTextRaw(), slAddHead, and slReverse().

{
bioSeq *seqList = NULL, *seq;
while ((seq = faNextSeqFromMemTextRaw(&text)) != NULL)
    {
    slAddHead(&seqList, seq);
    }
slReverse(&seqList);
return seqList;
}

Here is the call graph for this function:

boolean faSomeSpeedReadNext	(	struct lineFile *	lf,
		DNA **	retDna,
		int *	retSize,
		char **	retName,
		boolean	isDna
	)

Definition at line 528 of file fa.c.

References FALSE, faMixedSpeedReadNext(), faToDna(), faToProtein(), dnaSeq::size, and TRUE.

Referenced by faPepSpeedReadNext(), faReadAllMixableInLf(), faReadNamedSeq(), faSpeedReadNext(), and gfClient().

{
char *poly;
int size;

if (!faMixedSpeedReadNext(lf, retDna, retSize, retName))
    return FALSE;
size = *retSize;
poly = *retDna;
if (isDna)
    faToDna(poly, size);
else
    faToProtein(poly, size);
return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

boolean faSpeedReadNext	(	struct lineFile *	lf,
		DNA **	retDna,
		int *	retSize,
		char **	retName
	)

Definition at line 551 of file fa.c.

References faSomeSpeedReadNext(), and TRUE.

Referenced by genoFindDirect().

{
return faSomeSpeedReadNext(lf, retDna, retSize, retName, TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void faToDna	(	char *	poly,
		int	size
	)

Definition at line 512 of file fa.c.

References dnaUtilOpen(), and ntChars.

Referenced by faSomeSpeedReadNext(), gfClientSeqList(), gfClientUnmask(), and maskQuerySeq().

{
int i;
char c;
dnaUtilOpen();
for (i=0; i<size; ++i)
    {
    if ((c = ntChars[(int)poly[i]]) == 0)
        c = 'n';
    poly[i] = c;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void faToProtein	(	char *	poly,
		int	size
	)

Definition at line 496 of file fa.c.

References aaChars, and dnaUtilOpen().

Referenced by faSomeSpeedReadNext(), gfClientSeqList(), and maskQuerySeq().

{
int i;
char c;
dnaUtilOpen();
for (i=0; i<size; ++i)
    {
    if ((c = aaChars[(int)poly[i]]) == 0)
        c = 'X';
    poly[i] = c;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void faWrite	(	char *	fileName,
		char *	startLine,
		DNA *	dna,
		int	dnaSize
	)

Definition at line 409 of file fa.c.

References errnoAbort(), faWriteNext(), and mustOpen().

{
FILE *f = mustOpen(fileName, "w");
faWriteNext(f, startLine, dna, dnaSize);
if (fclose(f) != 0)
    errnoAbort("fclose failed");
}

Here is the call graph for this function:

void faWriteAll	(	char *	fileName,
		bioSeq *	seqList
	)

Definition at line 418 of file fa.c.

References dnaSeq::dna, errnoAbort(), faWriteNext(), mustOpen(), dnaSeq::name, dnaSeq::next, and dnaSeq::size.

Referenced by doBlat().

{
FILE *f = mustOpen(fileName, "w");
bioSeq *seq;

for (seq=seqList; seq != NULL; seq = seq->next)
    faWriteNext(f, seq->name, seq->dna, seq->size);
if (fclose(f) != 0)
    errnoAbort("fclose failed");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void faWriteNext	(	FILE *	f,
		char *	startLine,
		DNA *	dna,
		int	dnaSize
	)

Definition at line 399 of file fa.c.

References writeSeqWithBreaks().

Referenced by bandExt(), faWrite(), faWriteAll(), outputFa(), and startServer().

{
if (dnaSize == 0)
    return;
if (startLine != NULL)
    fprintf(f, ">%s\n", startLine);
writeSeqWithBreaks(f, dna, dnaSize, 50);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static bioSeq* nextSeqFromMem	(	char **	pText,
		boolean	isDna,
		boolean	doFilter
	)			[static]

Definition at line 141 of file fa.c.

References aaChars, AllocVar, cloneString(), dnaSeq::dna, dnaUtilOpen(), errAbort(), dnaSeq::name, name, ntChars, dnaSeq::size, skipLeadingSpaces(), and skipToSpaces().

Referenced by faNextSeqFromMemText(), and faNextSeqFromMemTextRaw().

{
char *name = "";
char *s, *d;
struct dnaSeq *seq;
int size = 0;
char c;
char *filter = (isDna ? ntChars : aaChars);
char *text = *pText;
char *p = skipLeadingSpaces(text);
if (p == NULL)
    return NULL;
dnaUtilOpen();
if (*p == '>')
    {
    char *end;
    s = strchr(p, '\n');
    if (s != NULL) ++s;
    name = skipLeadingSpaces(p+1);
    end = skipToSpaces(name);
    if (end >= s || name >= s)
        errAbort("No name in line starting with '>'");
    if (end != NULL)
        *end = 0;
    }
else
    {
    s = p; 
    if (s == NULL || s[0] == 0)
        return NULL;
    }
name = cloneString(name);
    
d = text;
if (s != NULL)
    {
    for (;;)
        {
        c = *s;
        if (c == 0 || c == '>')
            break;
        ++s;
        if (!isalpha(c))
            continue;
        if (doFilter)
            {
            if ((c = filter[(int)c]) == 0) 
                {
                if (isDna)
                    c = 'n';
                else
                    c = 'X';
                }
            }
        d[size++] = c;
        }
    }
d[size] = 0;

/* Put sequence into our little sequence structure. */
AllocVar(seq);
seq->name = name;
seq->dna = text;
seq->size = size;
*pText = s;
return seq;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

DNA* faFastBuf [static]

Definition at line 297 of file fa.c.

Referenced by expandFaFastBuf(), faFastReadNext(), faFreeFastBuf(), and faMixedSpeedReadNext().

unsigned faFastBufSize = 0 [static]

Definition at line 296 of file fa.c.

Referenced by expandFaFastBuf(), faFastReadNext(), faFreeFastBuf(), and faMixedSpeedReadNext().

char const rcsid[] = "$Id: fa.c,v 1.37 2007/02/20 18:50:21 kent Exp $" [static]

Definition at line 15 of file fa.c.

---