inc/oldGff.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	gff
struct	gffSegment
struct	gffGene
Typedefs
typedef gffSegment	GffIntron
typedef gffSegment	GffExon
Functions
boolean	gffOpen (struct gff *gff, char *fileName)
boolean	gffOpenAndRead (struct gff *gff, char *fileName)
void	gffClose (struct gff *gff)
boolean	gffReadDna (struct gff *gff)
gffGene *	gffFindGene (struct gff *gff, char *geneName)
gffGene *	gffFindGeneIgnoreCase (struct gff *gff, char *geneName)
void	gffPrintInfo (struct gff *gff, FILE *out)
boolean	gffReadGenes (struct gff *gff)
gffGene *	gffDupeGene (struct gff *gff, struct gffGene *oldGene)
gffGene *	gffDupeGeneAndSurrounds (struct gff *gff, struct gffGene *oldGene, int leftExtra, int rightExtra)
gffGene *	gffGeneWithOwnDna (struct gff *gff, char *geneName)
void	gffFreeGene (struct gffGene **pGene)
dnaSeq *	gffReadDnaSeq (char *fileName)

---

Typedef Documentation

typedef struct gffSegment GffExon

Definition at line 40 of file oldGff.h.

typedef struct gffSegment GffIntron

Definition at line 39 of file oldGff.h.

---

Function Documentation

void gffClose

(

struct gff *

gff

)

Definition at line 74 of file oldGff.c.

References gff::dna, gff::file, freeMem(), lmCleanup(), gff::memPool, and zeroBytes().

Referenced by gffOpenAndRead(), and gffReadDnaSeq().

{
if (gff->file != NULL)
    fclose(gff->file);
freeMem(gff->dna);
lmCleanup(&gff->memPool);
zeroBytes(gff, sizeof(*gff));
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gffGene* gffDupeGene	(	struct gff *	gff,
		struct gffGene *	oldGene
	)			[read]

Definition at line 589 of file oldGff.c.

References gffDupeGeneAndSurrounds().

Referenced by gffGeneWithOwnDna().

{
return gffDupeGeneAndSurrounds(gff, oldGene, 0, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gffGene* gffDupeGeneAndSurrounds	(	struct gff *	gff,
		struct gffGene *	oldGene,
		int	leftExtra,
		int	rightExtra
	)			[read]

Definition at line 549 of file oldGff.c.

References gffGene::dna, gffGene::dnaSize, dupeSegmentList(), gffGene::end, gffGene::exons, fixDirectionAndOffsets(), geneDna(), gffFreeGene(), gffGene::introns, gffGene::name, needMem(), gffGene::next, slCount(), gffGene::start, and gffGene::strand.

Referenced by gffDupeGene().

{
struct gffGene *g;
int intronCount = slCount(oldGene->introns);
int exonCount = slCount(oldGene->exons);
int memSize = sizeof(*g) + (intronCount + exonCount) * sizeof(struct gffSegment);
char *memPt;
int firstExonOffset;


memPt = needMem(memSize);
g = (struct gffGene *)memPt;
memPt += sizeof(*g);
g->exons = (struct gffSegment *)memPt;
memPt += exonCount*sizeof(struct gffSegment);
g->introns = (struct gffSegment *)memPt;

g->next = NULL;
g->start = oldGene->start;
g->end = oldGene->end;
g->strand = oldGene->strand;
memcpy(g->name, oldGene->name, sizeof(g->name));
g->exons = dupeSegmentList(oldGene->exons, g->exons);
g->introns = dupeSegmentList(oldGene->introns, g->introns);
if (!geneDna(gff, oldGene, leftExtra, rightExtra, 
    &g->dna, &g->dnaSize, &firstExonOffset))
    {
    gffFreeGene(&g);
    return NULL;
    }
fixDirectionAndOffsets(g, g->dna, g->dnaSize, firstExonOffset);
return g;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gffGene* gffFindGene	(	struct gff *	gff,
		char *	geneName
	)			[read]

Definition at line 206 of file oldGff.c.

References gff::genes, gffGene::name, and gffGene::next.

Referenced by gffReadGenes().

{
struct gffGene *g;

for (g=gff->genes; g!=NULL; g=g->next)
    {
    if (strcmp(geneName, g->name) == 0)
        return g;
    }
return NULL;
}

Here is the caller graph for this function:

struct gffGene* gffFindGeneIgnoreCase	(	struct gff *	gff,
		char *	geneName
	)			[read]

Definition at line 219 of file oldGff.c.

References differentWord(), gff::genes, gffGene::name, and gffGene::next.

Referenced by gffGeneWithOwnDna().

{
struct gffGene *g;

for (g=gff->genes; g!=NULL; g=g->next)
    {
    if (differentWord(geneName, g->name) == 0)
        return g;
    }
return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gffFreeGene

(

struct gffGene **

pGene

)

Definition at line 606 of file oldGff.c.

References gffGene::dna, and freeMem().

Referenced by gffDupeGeneAndSurrounds().

{
struct gffGene *g = *pGene;
if (g == NULL)
    return;
freeMem(g->dna);
freeMem(g);
*pGene = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gffGene* gffGeneWithOwnDna	(	struct gff *	gff,
		char *	geneName
	)			[read]

Definition at line 595 of file oldGff.c.

References gffDupeGene(), and gffFindGeneIgnoreCase().

{
struct gffGene *oldGene;

oldGene = gffFindGeneIgnoreCase(gff, geneName);
if (oldGene == NULL)
    return NULL;
return gffDupeGene(gff, oldGene);
}

Here is the call graph for this function:

boolean gffOpen	(	struct gff *	gff,
		char *	fileName
	)

Definition at line 45 of file oldGff.c.

References _gffIdent, _gffSeekDoubleSharpLine(), ArraySize, dnaUtilOpen(), FALSE, fileSize(), lmInit(), TRUE, warn(), and zeroBytes().

Referenced by gffOpenAndRead(), and gffReadDnaSeq().

{
    dnaUtilOpen();

    /* Initialize structure and open file. */
    zeroBytes(gff, sizeof(*gff));
    gff->memPool = lmInit(16*1024);
    gff->fileSize = fileSize(fileName);
    if (gff->fileSize < 0 ||
       (gff->file = fopen(fileName, "rb")) == NULL)
            {
            warn("Couldn't find the file named %s\n", fileName);
            return FALSE;
            }
    strcpy(gff->fileName, fileName);
    gff->bufSize = ArraySize(gff->buf);

    /* Make sure it's a gff file. */
    _gffSeekDoubleSharpLine(gff);
    if (strncmp(gff->buf, _gffIdent, strlen(_gffIdent)) != 0)
        {
        warn("%s doesn't appear to be a .gff file\n", fileName);
        return FALSE;
        }

    return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

boolean gffOpenAndRead	(	struct gff *	gff,
		char *	fileName
	)

Definition at line 637 of file oldGff.c.

References FALSE, gffClose(), gffOpen(), gffReadDna(), gffReadGenes(), and TRUE.

{
if (gffOpen(gff, fileName))
    if (gffReadDna(gff))
        if (gffReadGenes(gff))
            return TRUE;
gffClose(gff);
return FALSE;
}

Here is the call graph for this function:

void gffPrintInfo	(	struct gff *	gff,
		FILE *	out
	)

Definition at line 280 of file oldGff.c.

References gff::dnaName, gff::dnaSize, gffGene::end, gffGene::exons, gff::fileName, gff::genes, gffGene::introns, gffGene::name, gffGene::next, slCount(), and gffGene::start.

{
struct gffGene *gene;

fprintf(out, "\n%s\n", gff->fileName);
fprintf(out, "DNA %s (%ld bases)\n", 
        gff->dnaName, gff->dnaSize);
fprintf(out, "%d genes\n", slCount(gff->genes));
for (gene = gff->genes; gene != NULL; gene = gene->next)
    {
    fprintf(out, "gene %s has %ld bases, %d exons, %d introns\n",
        gene->name, gene->end - gene->start + 1,
        slCount(gene->exons), slCount(gene->introns));
    }
}

Here is the call graph for this function:

boolean gffReadDna

(

struct gff *

gff

)

Definition at line 167 of file oldGff.c.

References _gffSeekDna(), gff::buf, gff::bytesInBuf, gff::dna, gff::dnaSize, FALSE, gff::fileSize, gffNextDnaLine(), ntChars, gff::readIx, TRUE, wantMem(), and warn().

Referenced by gffOpenAndRead(), and gffReadDnaSeq().

{
long dnaSize = 0;
DNA *dna;
DNA *line;
int lineCount;
DNA b;
if (gff->dna != NULL)
        return TRUE; /* We already read it. */
if (!_gffSeekDna(gff))
        return FALSE;
if ((gff->dna = wantMem(gff->fileSize)) == NULL)
    {
    warn("Couldn't allocate %ld bytes for DNA\n",
        gff->fileSize);
    return FALSE;
    }
dna = gff->dna;
for (;;)
    {
    if (!gffNextDnaLine(gff))
        break;
    line = gff->buf + gff->readIx;
    lineCount = gff->bytesInBuf-gff->readIx;
    while (--lineCount >= 0)
        {
        b = *line++;
        if ((b = ntChars[(int)b]) != 0)
            {
            *dna++ = b;
            dnaSize += 1;
            }
        }
    }
gff->dnaSize = dnaSize;
return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct dnaSeq* gffReadDnaSeq

(

char *

fileName

)

[read]

Definition at line 620 of file oldGff.c.

References gff::dna, gff::dnaName, gff::dnaSize, gffClose(), gffOpen(), gffReadDna(), and newDnaSeq().

{
struct gff gff;
struct dnaSeq *seq = NULL;

if (!gffOpen(&gff, fileName))
    return NULL;
if (gffReadDna(&gff))
    {
    seq = newDnaSeq(gff.dna, gff.dnaSize, gff.dnaName);
    gff.dna = NULL;
    }
gffClose(&gff);
return seq;
}

Here is the call graph for this function:

boolean gffReadGenes

(

struct gff *

gff

)

Definition at line 310 of file oldGff.c.

References _gffGetLine(), gff::buf, checkWordCount(), differentWord(), gffSegLine::end, FALSE, gffSegLine::feature, gff::fileName, gffSegLine::frame, gff::genes, gffFindGene(), gffNeedMem(), gffSegLineScan(), gffSegLine::group, gff::lineNumber, slAddTail(), gffSegLine::start, gffSegLine::strand, TRUE, and warn().

Referenced by gffOpenAndRead().

{
int wordCount;
struct gffSegLine seg;
char curGroup[128];
struct gffGene *gene = NULL;
GffIntron *intron = NULL;
GffExon *exon = NULL;
boolean warnedUnknown = FALSE;
boolean isNewGene;

curGroup[0] = 0; /* Start off with no group */

/* Line scanning loop. */
for (;;)
    {
    /* Get next line and parse it into segLine data structure. */
    if (!_gffGetLine(gff)) 
        break;   /* End of file. */
    if (gff->buf[0] == '#')
        continue; /* Ignore sharp containing lines. */
    wordCount = gffSegLineScan(gff, &seg);
    if (wordCount < 9)
        continue; /* Ignore blank lines and short ones. */

    /* Make sure that start is less than or equal end. */
    if (seg.start > seg.end)
        {
        warn("start greater than end line %d of %s.\n",
                gff->lineNumber, gff->fileName);
        return FALSE;
        }

    /* Get the gene we're working on.  First see if
     * it's the same as last time around. */
    isNewGene = FALSE;
    if (strcmp(seg.group, curGroup) != 0)
        {
        strcpy(curGroup, seg.group);
        if ((gene = gffFindGene(gff, seg.group)) == NULL)
            {
            /* It's a new gene! */
            if (!checkWordCount(gff, wordCount)) return FALSE;
            isNewGene = TRUE;
            gene = gffNeedMem(gff, sizeof(*gene));
            strcpy(gene->name, seg.group);
            slAddTail(&gff->genes, gene); 
            gene->strand = seg.strand[0];
            gene->frame = atoi(seg.frame);
            if (differentWord(seg.feature, "CDS") == 0)
                {
                gene->start = seg.start-1;
                gene->end = seg.end-1;
                }
            }
        }

    /* Look at what sort of feature it is, and decide what to do. */

    if (differentWord(seg.feature, "CDS")==0)
        {
        /* CDS (coding segments) have been processed already
         * for the most part. Here just make sure they aren't
         * duplicated. */
        if (!checkWordCount(gff, wordCount)) return FALSE;
        if (!isNewGene)
            {
            if (gene->start != 0 || gene->end != 0)
                {
                warn("Warning duplicate CDS for %s\n",
                        seg.group);
                warn("Line %d of %s\n", 
                        gff->lineNumber, gff->fileName);
                }
            }
        }
    else if (differentWord(seg.feature, "SE") == 0 
        ||   differentWord(seg.feature, "IE") == 0
        ||   differentWord(seg.feature, "FE") == 0
        ||   differentWord(seg.feature, "E") == 0
        ||   differentWord(seg.feature, "exon") == 0)
        {
        /* It's some sort of exon.  We'll deal with the complications
         * of it being possibly on the minus strand later, so can
         * tread initial, final, single, and regular exons the same
         * here. */
        if (!checkWordCount(gff, wordCount)) return FALSE;
        exon = gffNeedMem(gff, sizeof(*exon));
        exon->start = seg.start-1;
        exon->end = seg.end-1;
        exon->frame = atoi(seg.frame);
        gffSegmentInsertSort(&gene->exons, exon);
        }
    else if (differentWord(seg.feature, "I") == 0 
        ||   differentWord(seg.feature, "intron") == 0)
        {
        /* It's an intron. */
        if (!checkWordCount(gff, wordCount)) return FALSE;
        intron = gffNeedMem(gff, sizeof(*intron));
        intron->start = seg.start-1;
        intron->end = seg.end-1;
        intron->frame = atoi(seg.frame);
        gffSegmentInsertSort(&gene->introns, intron);
        }
    else if (strcmp(seg.feature, "IG")  == 0)
        {
        /* I don't know what it is, but we can ignore it. */
        }
    else
        {
        if (!warnedUnknown)
            {
            warn("Unknown feature %s line %d of %s, ignoring\n",
                    seg.feature,  gff->lineNumber, gff->fileName);
            warnedUnknown = TRUE;
            }
        }
    }

/* Fix up gene length from exons if needed. */
for (gene = gff->genes; gene != NULL; gene = gene->next)
    {
    if (gene->start >= gene->end)
        {
        offsetsFromExons(gene);
        }
    }
return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---