lib/oldGff.c File Reference

#include "common.h"
#include "dnautil.h"
#include "oldGff.h"
#include "dnaseq.h"
#include "htmshell.h"
#include "portable.h"
#include "localmem.h"

Include dependency graph for oldGff.c:

Go to the source code of this file.

Data Structures
struct	gffSegLine
Defines
#define	errfile   stdout
Functions
static int	gffSegLineScan (struct gff *gff, struct gffSegLine *seg)
static boolean	_gffSeekDoubleSharpLine ()
boolean	gffOpen (struct gff *gff, char *fileName)
void	gffClose (struct gff *gff)
static boolean	_gffGetLine (struct gff *gff)
static boolean	_gffSeekDoubleSharpLine (struct gff *gff)
static boolean	_gffSeekDna (struct gff *gff)
static boolean	gffNextDnaLine (struct gff *gff)
boolean	gffReadDna (struct gff *gff)
gffGene *	gffFindGene (struct gff *gff, char *geneName)
gffGene *	gffFindGeneIgnoreCase (struct gff *gff, char *geneName)
static void *	gffNeedMem (struct gff *gff, int size)
static void	gffSegmentInsertSort (struct gffSegment **plist, struct gffSegment *seg)
static void	offsetsFromExons (struct gffGene *gene)
void	gffPrintInfo (struct gff *gff, FILE *out)
static boolean	checkWordCount (struct gff *gff, int wordCount)
boolean	gffReadGenes (struct gff *gff)
static boolean	geneDna (struct gff *gff, struct gffGene *gene, int leftExtra, int rightExtra, char **retDna, long *retDnaSize, int *retStartOffset)
static void	fixDirectionAndOffsets (struct gffGene *gene, char *dna, long dnaSize, int newStart)
static struct gffSegment *	dupeSegmentList (struct gffSegment *oldList, struct gffSegment *newList)
gffGene *	gffDupeGeneAndSurrounds (struct gff *gff, struct gffGene *oldGene, int leftExtra, int rightExtra)
gffGene *	gffDupeGene (struct gff *gff, struct gffGene *oldGene)
gffGene *	gffGeneWithOwnDna (struct gff *gff, char *geneName)
void	gffFreeGene (struct gffGene **pGene)
dnaSeq *	gffReadDnaSeq (char *fileName)
boolean	gffOpenAndRead (struct gff *gff, char *fileName)
Variables
static char const	rcsid [] = "$Id: oldGff.c,v 1.6 2005/04/10 14:41:24 markd Exp $"
static char	_gffIdent [] = "##gff-version"

---

Define Documentation

#define errfile   stdout

Definition at line 18 of file oldGff.c.

---

Function Documentation

static boolean _gffGetLine

(

struct gff *

gff

)

[static]

Definition at line 84 of file oldGff.c.

References gff::buf, gff::bufSize, gff::bytesInBuf, FALSE, gff::file, gff::lineNumber, gff::readIx, and TRUE.

Referenced by _gffSeekDna(), _gffSeekDoubleSharpLine(), and gffReadGenes().

{
char *s;
s = fgets(gff->buf, gff->bufSize, gff->file);
if (s == NULL)
    {
    return FALSE;
    }
gff->bytesInBuf = strlen(gff->buf);
gff->readIx = 0;
gff->lineNumber += 1;
return TRUE;
}

Here is the caller graph for this function:

static boolean _gffSeekDna

(

struct gff *

gff

)

[static]

Definition at line 133 of file oldGff.c.

References _gffGetLine(), gff::buf, gff::bytesInBuf, gff::dnaName, FALSE, gff::file, and TRUE.

Referenced by gffReadDna().

{
static char dnaIdent[] = "##DNA";

rewind(gff->file);
for (;;)
    {
    if (!_gffGetLine(gff)) return FALSE;
    if (strncmp(gff->buf, dnaIdent, strlen(dnaIdent)) == 0)
        {
        sscanf(gff->buf, "##DNA %s", gff->dnaName);
        gff->bytesInBuf = 0; /* We're done with gff line. */
        return TRUE;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static boolean _gffSeekDoubleSharpLine

(

struct gff *

gff

)

[static]

Definition at line 121 of file oldGff.c.

References _gffGetLine(), gff::buf, gff::bytesInBuf, FALSE, and TRUE.

{
for (;;)
    {
    if (!_gffGetLine(gff)) return FALSE;
    if (gff->bytesInBuf >= 2)
        if (gff->buf[0] == '#' && gff->buf[1] == '#') 
                return TRUE;
    }
}

Here is the call graph for this function:

static boolean _gffSeekDoubleSharpLine

(

)

[static]

Referenced by gffNextDnaLine(), and gffOpen().

Here is the caller graph for this function:

static boolean checkWordCount	(	struct gff *	gff,
		int	wordCount
	)			[static]

Definition at line 297 of file oldGff.c.

References gff::buf, FALSE, gff::fileName, gff::lineNumber, TRUE, and warn().

Referenced by gffReadGenes().

{
if (wordCount >= 9)
    return TRUE;
else
    {
    warn("???%s???\n", gff->buf);
    warn("Can't handle line %d of %s.\n", 
            gff->lineNumber, gff->fileName);
    return FALSE;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct gffSegment* dupeSegmentList	(	struct gffSegment *	oldList,
		struct gffSegment *	newList
	)			[static, read]

Definition at line 533 of file oldGff.c.

References gffSegment::next.

Referenced by gffDupeGeneAndSurrounds().

{
struct gffSegment *oldEl, *newEl;

if (oldList == NULL)
    return NULL;
for (oldEl = oldList, newEl = newList; oldEl != NULL; oldEl=oldEl->next, newEl += 1)
    {
    memcpy(newEl, oldEl, sizeof(*newEl));
    newEl->next = ((oldEl->next == NULL) ? NULL : newEl+1);
    }
return newList;
}

Here is the caller graph for this function:

static void fixDirectionAndOffsets	(	struct gffGene *	gene,
		char *	dna,
		long	dnaSize,
		int	newStart
	)			[static]

Definition at line 483 of file oldGff.c.

References gffSegment::end, gffGene::end, gffGene::exons, gffGene::introns, gffSegment::next, reverseComplement(), reverseOffset(), slReverse(), gffSegment::start, gffGene::start, and gffGene::strand.

Referenced by gffDupeGeneAndSurrounds().

{
long oldStart;
long offset;
GffIntron *intron;
GffExon *exon;
long temp;

oldStart = gene->start;
offset = oldStart - newStart;
gene->start -= offset;
gene->end -= offset;
for (intron = gene->introns; intron != NULL; intron = intron->next)
    {
    intron->start -= offset;
    intron->end -= offset;
    }
for (exon = gene->exons; exon != NULL; exon = exon->next)
    {
    exon->start -= offset;
    exon->end -= offset;
    }
if (gene->strand == '-')
    {
    reverseComplement(dna, dnaSize);
    temp = reverseOffset(gene->start, dnaSize);
    gene->start = reverseOffset(gene->end, dnaSize);
    gene->end = temp;
    for (intron = gene->introns; intron != NULL; intron = intron->next)
        {
        temp = reverseOffset(intron->start, dnaSize);
        intron->start = reverseOffset(intron->end, dnaSize);
        intron->end = temp;
        }
    for (exon = gene->exons; exon != NULL; exon = exon->next)
        {
        temp = reverseOffset(exon->start, dnaSize);
        exon->start = reverseOffset(exon->end, dnaSize);
        exon->end = temp;
        }
    slReverse(&gene->introns);
    slReverse(&gene->exons);
    gene->strand = '+';
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static boolean geneDna	(	struct gff *	gff,
		struct gffGene *	gene,
		int	leftExtra,
		int	rightExtra,
		char **	retDna,
		long *	retDnaSize,
		int *	retStartOffset
	)			[static]

Definition at line 441 of file oldGff.c.

References gff::dna, gffGene::dna, gff::dnaSize, gffGene::end, FALSE, needMem(), gffGene::start, and TRUE.

Referenced by gffDupeGeneAndSurrounds().

{
char *dna;
char *pt;
long geneSize;
long i;
long seqStart, seqEnd, seqSize;

/* Filter out unreasonable looking genes - input to this
 * program isn't totally clean. */
geneSize = gene->end - gene->start + 1;
if (geneSize <= 0 || geneSize >= 1000000)
    return FALSE;  

/* Figure out extents of DNA we're going to return.
 * Return extra they ask for if possible, but clip
 * it to what is actually in GFF file. */
seqStart = gene->start - leftExtra;
seqEnd = gene->end + rightExtra + 1;
if (seqStart < 0)
    seqStart = 0;
if (seqEnd > gff->dnaSize)
    seqEnd = gff->dnaSize;
seqSize = seqEnd - seqStart;

/* Allocate memory and fetch the dna. */
dna = needMem(seqSize+1);
pt = dna;
for (i=0; i<seqSize; i++)
    *pt++ = gff->dna[seqStart+i];
*pt = 0;

/* Report results back to caller. */
*retDna = dna;
*retDnaSize = seqSize;
*retStartOffset = (gene->start - seqStart);
return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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:

static void* gffNeedMem	(	struct gff *	gff,
		int	size
	)			[static]

Definition at line 234 of file oldGff.c.

References lmAlloc(), and gff::memPool.

Referenced by gffReadGenes().

{
return lmAlloc(gff->memPool, size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static boolean gffNextDnaLine

(

struct gff *

gff

)

[static]

Definition at line 151 of file oldGff.c.

References _gffSeekDoubleSharpLine(), gff::buf, gff::bytesInBuf, FALSE, and TRUE.

Referenced by gffReadDna().

{
static char endIdent[] = "##end-DNA";

if (!_gffSeekDoubleSharpLine(gff)) 
    return FALSE;
/* Check to see if have reached end of DNA sequence */
if (strncmp(gff->buf, endIdent, strlen(endIdent))==0)
    {
    gff->bytesInBuf = 0; /* We're done with gff line. */
    return FALSE;
    }
return TRUE;
}

Here is the call graph for this function:

Here is the caller 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:

static int gffSegLineScan	(	struct gff *	gff,
		struct gffSegLine *	seg
	)			[static]

Definition at line 34 of file oldGff.c.

References gff::buf, gffSegLine::end, gffSegLine::feature, gffSegLine::frame, gffSegLine::group, gffSegLine::score, gffSegLine::seqname, gffSegLine::source, gffSegLine::start, and gffSegLine::strand.

Referenced by gffReadGenes().

{
    int scanned = sscanf(gff->buf, "%s %s %s %ld %ld %s %1s %s %s",
        seg->seqname, seg->source, seg->feature,
        &seg->start, &seg->end,
        seg->score, seg->strand, seg->frame, seg->group);
    return scanned;
}

Here is the caller graph for this function:

static void gffSegmentInsertSort	(	struct gffSegment **	plist,
		struct gffSegment *	seg
	)			[static]

Definition at line 239 of file oldGff.c.

References gffSegment::next, and gffSegment::start.

             :
         gffSegment **plist;     Pointer to list. 
         gffSegment *seg;        Segment to insert 
 */
{
struct gffSegment *next;
long segStart = seg->start;

for (;;)
    {
    next = *plist;
    if (next == NULL)
        break;
    if (next->start > segStart)
        break;
    plist = &(next->next);
    }
seg->next = next;   
*plist = seg;
}

static void offsetsFromExons

(

struct gffGene *

gene

)

[static]

Definition at line 263 of file oldGff.c.

References gffGene::end, gffSegment::end, gffGene::exons, gffSegment::next, gffGene::start, and gffSegment::start.

{
GffExon *exon;
long end = 0;
long start = 0x7fffffff; /* I should use a .h file constant here... */
for (exon = gene->exons; exon != NULL; exon = exon->next)
    {
    if (exon->start < start)
        start = exon->start;
    if (exon->end > end)
        end = exon->end;
    }
gene->start = start;
gene->end = end;
}

---

Variable Documentation

char _gffIdent[] = "##gff-version" [static]

Definition at line 20 of file oldGff.c.

Referenced by gffOpen().

char const rcsid[] = "$Id: oldGff.c,v 1.6 2005/04/10 14:41:24 markd Exp $" [static]

Definition at line 16 of file oldGff.c.

---