jkOwnLib/gfPcrLib.c File Reference

#include "common.h"
#include "linefile.h"
#include "hash.h"
#include "options.h"
#include "dystring.h"
#include "fa.h"
#include "net.h"
#include "genoFind.h"
#include "sqlNum.h"
#include "gfInternal.h"
#include "gfPcrLib.h"

Include dependency graph for gfPcrLib.c:

Go to the source code of this file.

Functions
void	gfPcrOutputFree (struct gfPcrOutput **pOut)
void	gfPcrOutputFreeList (struct gfPcrOutput **pList)
void	gfPcrInputStaticLoad (char **row, struct gfPcrInput *ret)
gfPcrInput *	gfPcrInputLoad (char **row)
gfPcrInput *	gfPcrInputLoadAll (char *fileName)
void	gfPcrInputFree (struct gfPcrInput **pEl)
void	gfPcrInputFreeList (struct gfPcrInput **pList)
static boolean	goodMatch (char *a, char *b, int size)
static void	upperMatch (char *dna, char *primer, int size)
static void	outputFa (struct gfPcrOutput *out, FILE *f, char *url)
static int	countMatch (char *a, char *b, int size)
static void	outputBed (struct gfPcrOutput *out, FILE *f, char *url)
static void	outputPsl (struct gfPcrOutput *out, FILE *f, char *url)
void	gfPcrOutputWriteList (struct gfPcrOutput *outList, char *outType, char *url, FILE *f)
void	gfPcrOutputWriteAll (struct gfPcrOutput *outList, char *outType, char *url, char *fileName)
static void	pcrLocalStrand (char *pcrName, struct dnaSeq *seq, int seqOffset, char *seqName, int seqSize, int maxSize, char *fPrimer, int fPrimerSize, char *rPrimer, int rPrimerSize, int minPerfect, int minGood, char strand, struct gfPcrOutput **pOutList)
void	gfPcrLocal (char *pcrName, struct dnaSeq *seq, int seqOffset, char *seqName, int seqSize, int maxSize, char *fPrimer, int fPrimerSize, char *rPrimer, int rPrimerSize, int minPerfect, int minGood, char strand, struct gfPcrOutput **pOutList)
gfRange *	gfPcrGetRanges (char *host, char *port, char *fPrimer, char *rPrimer, int maxSize)
static void	gfPcrOneViaNet (char *host, char *port, char *seqDir, char *pcrName, char *fPrimer, char *rPrimer, int maxSize, int minPerfect, int minGood, struct hash *tFileCache, struct gfPcrOutput **pOutList)
gfPcrOutput *	gfPcrViaNet (char *host, char *port, char *seqDir, struct gfPcrInput *inList, int maxSize, int minPerfect, int minGood)
char *	gfPcrMakePrimer (char *s)
Variables
static char const	rcsid [] = "$Id: gfPcrLib.c,v 1.8 2006/03/15 18:36:16 angie Exp $"

---

Function Documentation

static int countMatch	(	char *	a,
		char *	b,
		int	size
	)			[static]

Definition at line 190 of file gfPcrLib.c.

Referenced by outputBed(), and outputPsl().

{
int count = 0, i;
for (i=0; i<size; ++i)
    if (a[i] == b[i])
       ++count;
return count;
}

Here is the caller graph for this function:

struct gfRange* gfPcrGetRanges	(	char *	host,
		char *	port,
		char *	fPrimer,
		char *	rPrimer,
		int	maxSize
	)			[read]

Definition at line 380 of file gfPcrLib.c.

References AllocVar, cloneString(), errAbort(), gfConnect(), gfSignature(), name, netGetString(), nextWord(), rangeList, safef(), sameString, slAddHead, slReverse(), and startsWith().

Referenced by gfPcrOneViaNet().

{
char buf[256];
int conn = gfConnect(host, port);
struct gfRange *rangeList = NULL, *range;

/* Query server and put results into rangeList. */
safef(buf, sizeof(buf), "%spcr %s %s %d", gfSignature(), fPrimer, rPrimer, maxSize);
write(conn, buf, strlen(buf));
for (;;)
    {
    if (netGetString(conn, buf) == NULL)
        break;
    if (sameString(buf, "end"))
        break;
    else if (startsWith("Error:", buf))
        errAbort(buf);
    else
        {
        char *s = buf;
        char *name, *start, *end, *strand;
        name = nextWord(&s);
        start = nextWord(&s);
        end = nextWord(&s);
        strand = nextWord(&s);
        if (strand == NULL)
            errAbort("Truncated gfServer response");
        AllocVar(range);
        range->tName = cloneString(name);
        range->tStart = atoi(start);
        range->tEnd = atoi(end);
        range->tStrand = strand[0];
        slAddHead(&rangeList, range);
        }
    }
close(conn);
slReverse(&rangeList);
return rangeList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfPcrInputFree

(

struct gfPcrInput **

pEl

)

Definition at line 89 of file gfPcrLib.c.

References gfPcrInput::fPrimer, freeMem(), freez(), gfPcrInput::name, and gfPcrInput::rPrimer.

Referenced by gfPcrInputFreeList().

{
struct gfPcrInput *el;

if ((el = *pEl) == NULL) return;
freeMem(el->name);
freeMem(el->fPrimer);
freeMem(el->rPrimer);
freez(pEl);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfPcrInputFreeList

(

struct gfPcrInput **

pList

)

Definition at line 102 of file gfPcrLib.c.

References gfPcrInputFree(), and gfPcrInput::next.

{
struct gfPcrInput *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    gfPcrInputFree(&el);
    }
*pList = NULL;
}

Here is the call graph for this function:

struct gfPcrInput* gfPcrInputLoad

(

char **

row

)

[read]

Definition at line 57 of file gfPcrLib.c.

References AllocVar, cloneString(), gfPcrInput::fPrimer, gfPcrInput::name, and gfPcrInput::rPrimer.

Referenced by gfPcrInputLoadAll().

{
struct gfPcrInput *ret;

AllocVar(ret);
ret->name = cloneString(row[0]);
ret->fPrimer = cloneString(row[1]);
ret->rPrimer = cloneString(row[2]);
return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gfPcrInput* gfPcrInputLoadAll

(

char *

fileName

)

[read]

Definition at line 70 of file gfPcrLib.c.

References gfPcrInputLoad(), lineFileClose(), lineFileOpen(), lineFileRow, slAddHead, slReverse(), and TRUE.

{
struct gfPcrInput *list = NULL, *el;
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *row[3];

while (lineFileRow(lf, row))
    {
    el = gfPcrInputLoad(row);
    slAddHead(&list, el);
    }
lineFileClose(&lf);
slReverse(&list);
return list;
}

Here is the call graph for this function:

void gfPcrInputStaticLoad	(	char **	row,
		struct gfPcrInput *	ret
	)

Definition at line 48 of file gfPcrLib.c.

References gfPcrInput::fPrimer, gfPcrInput::name, and gfPcrInput::rPrimer.

{
ret->name = row[0];
ret->fPrimer = row[1];
ret->rPrimer = row[2];
}

void gfPcrLocal	(	char *	pcrName,
		struct dnaSeq *	seq,
		int	seqOffset,
		char *	seqName,
		int	seqSize,
		int	maxSize,
		char *	fPrimer,
		int	fPrimerSize,
		char *	rPrimer,
		int	rPrimerSize,
		int	minPerfect,
		int	minGood,
		char	strand,
		struct gfPcrOutput **	pOutList
	)

Definition at line 361 of file gfPcrLib.c.

References pcrLocalStrand().

Referenced by gfPcrOneViaNet().

{
/* For PCR primers reversing search strand just means switching
 * order of primers. */
if (strand == '-')
    pcrLocalStrand(pcrName, seq, seqOffset, seqName, seqSize, maxSize, 
        rPrimer, rPrimerSize, fPrimer, fPrimerSize, 
        minPerfect, minGood, strand, pOutList);
else
    pcrLocalStrand(pcrName, seq, seqOffset, seqName, seqSize, maxSize, 
        fPrimer, fPrimerSize, rPrimer, rPrimerSize, 
        minPerfect, minGood, strand, pOutList);
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* gfPcrMakePrimer

(

char *

s

)

Definition at line 482 of file gfPcrLib.c.

References countChars(), dnaFilter(), dnaFilteredSize(), errAbort(), and needMem().

{
int size = dnaFilteredSize(s);
int realSize;
char *primer = needMem(size+1);
dnaFilter(s, primer);
realSize = size - countChars(primer, 'n');
if (realSize < 10 || realSize < size/2)
   errAbort("%s does not seem to be a good primer", s);
return primer;
}

Here is the call graph for this function:

static void gfPcrOneViaNet	(	char *	host,
		char *	port,
		char *	seqDir,
		char *	pcrName,
		char *	fPrimer,
		char *	rPrimer,
		int	maxSize,
		int	minPerfect,
		int	minGood,
		struct hash *	tFileCache,
		struct gfPcrOutput **	pOutList
	)			[static]

Definition at line 422 of file gfPcrLib.c.

References dnaSeqFree, errAbort(), FALSE, gfiExpandAndLoadCached(), gfiGetSeqName(), gfPcrGetRanges(), gfPcrLocal(), gfRangeFreeList(), max, min, range::next, PATH_LEN, rangeList, and tolowers().

Referenced by gfPcrViaNet().

{
struct gfRange *rangeList = NULL, *range;
int fPrimerSize = strlen(fPrimer);
int rPrimerSize = strlen(rPrimer);
int maxPrimerSize = max(fPrimerSize, rPrimerSize);
int minPrimerSize = min(fPrimerSize, rPrimerSize);

tolowers(fPrimer);
tolowers(rPrimer);

/* Check for obvious user mistake. */
if (minPrimerSize < minGood || minPrimerSize < minPerfect)
    errAbort("Need longer primer in pair %s (%dbp) %s (%dbp).  Minimum size is %d\n",
        fPrimer, fPrimerSize, rPrimer, rPrimerSize, minGood);

/* Load ranges and do more detailed snooping. */
rangeList = gfPcrGetRanges(host, port, fPrimer, rPrimer, maxSize);
for (range = rangeList; range != NULL; range = range->next)
    {
    int tSeqSize;
    char seqName[PATH_LEN];
    struct dnaSeq *seq = gfiExpandAndLoadCached(range,
        tFileCache, seqDir,  0, &tSeqSize, FALSE, FALSE, maxPrimerSize);
    gfiGetSeqName(range->tName, seqName, NULL);
    gfPcrLocal(pcrName, seq, range->tStart, seqName, tSeqSize, maxSize, 
            fPrimer, fPrimerSize, rPrimer, rPrimerSize, 
            minPerfect, minGood, range->tStrand, pOutList);
    dnaSeqFree(&seq);
    }
gfRangeFreeList(&rangeList);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfPcrOutputFree

(

struct gfPcrOutput **

pOut

)

Definition at line 20 of file gfPcrLib.c.

References gfPcrOutput::dna, gfPcrOutput::fPrimer, freeMem(), freez(), gfPcrOutput::name, gfPcrOutput::rPrimer, and gfPcrOutput::seqName.

Referenced by gfPcrOutputFreeList().

{
struct gfPcrOutput *out = *pOut;
if (pOut != NULL)
    {
    freeMem(out->name);
    freeMem(out->fPrimer);
    freeMem(out->rPrimer);
    freeMem(out->seqName);
    freeMem(out->dna);
    freez(pOut);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gfPcrOutputFreeList

(

struct gfPcrOutput **

pList

)

Definition at line 35 of file gfPcrLib.c.

References gfPcrOutputFree(), and gfPcrOutput::next.

{
struct gfPcrOutput *el, *next;

for (el = *pList; el != NULL; el = next)
    {
    next = el->next;
    gfPcrOutputFree(&el);
    }
*pList = NULL;
}

Here is the call graph for this function:

void gfPcrOutputWriteAll	(	struct gfPcrOutput *	outList,
		char *	outType,
		char *	url,
		char *	fileName
	)

Definition at line 275 of file gfPcrLib.c.

References carefulClose(), gfPcrOutputWriteList(), and mustOpen().

{
FILE *f = mustOpen(fileName, "w");
gfPcrOutputWriteList(outList, outType, url, f);
carefulClose(&f);
}

Here is the call graph for this function:

void gfPcrOutputWriteList	(	struct gfPcrOutput *	outList,
		char *	outType,
		char *	url,
		FILE *	f
	)

Definition at line 255 of file gfPcrLib.c.

References errAbort(), gfPcrOutput::next, outputBed(), outputFa(), outputPsl(), and sameWord.

Referenced by gfPcrOutputWriteAll().

{
struct gfPcrOutput *out;
void (*output)(struct gfPcrOutput *out, FILE *f, char *url) = NULL;
if (sameWord(outType, "fa"))
    output = outputFa;
else if (sameWord(outType, "bed"))
    output = outputBed;
else if (sameWord(outType, "psl"))
    output = outputPsl;
else
    errAbort("Unrecognized pcr output type %s", outType);
for (out = outList; out != NULL; out = out->next)
    output(out, f, url);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct gfPcrOutput* gfPcrViaNet	(	char *	host,
		char *	port,
		char *	seqDir,
		struct gfPcrInput *	inList,
		int	maxSize,
		int	minPerfect,
		int	minGood
	)			[read]

Definition at line 462 of file gfPcrLib.c.

References gfPcrInput::fPrimer, gfFileCacheFree(), gfFileCacheNew(), gfPcrOneViaNet(), gfPcrInput::name, gfPcrInput::next, gfPcrInput::rPrimer, and slReverse().

{
struct hash *tFileCache = gfFileCacheNew();
struct gfPcrInput *in;
struct gfPcrOutput *outList = NULL;

for (in = inList; in != NULL; in = in->next)
    {
    gfPcrOneViaNet(host, port, seqDir,
        in->name, in->fPrimer, in->rPrimer, maxSize,
        minPerfect, minGood,
        tFileCache, &outList);
    }
gfFileCacheFree(&tFileCache);
slReverse(&outList);
return outList;
}

Here is the call graph for this function:

static boolean goodMatch	(	char *	a,
		char *	b,
		int	size
	)			[static]

Definition at line 119 of file gfPcrLib.c.

Referenced by pcrLocalStrand().

{
int score = 0, i;
for (i=0; i<size; ++i)
   {
   if (a[i] == b[i])
       score += 1;
   else
       score -= 2;
   }
return score >= 0;
}

Here is the caller graph for this function:

static void outputBed	(	struct gfPcrOutput *	out,
		FILE *	f,
		char *	url
	)			[static]

Definition at line 200 of file gfPcrLib.c.

References countMatch(), gfPcrOutput::dna, gfPcrOutput::fPos, gfPcrOutput::fPrimer, gfPcrOutput::name, name, reverseComplement(), round, gfPcrOutput::rPos, gfPcrOutput::rPrimer, gfPcrOutput::seqName, and gfPcrOutput::strand.

Referenced by gfPcrOutputWriteList().

{
int match;
int size = out->rPos - out->fPos;
int fPrimerSize = strlen(out->fPrimer);
int rPrimerSize = strlen(out->rPrimer);
char *name = out->name;
if (name == NULL) name = "n/a";
fprintf(f, "%s\t%d\t%d\t", out->seqName, out->fPos, out->rPos);
fprintf(f, "%s\t", name);
match = countMatch(out->dna, out->fPrimer, fPrimerSize);
assert(size > 0);
reverseComplement(out->rPrimer, rPrimerSize);
match += countMatch(out->dna + size - rPrimerSize, out->rPrimer, rPrimerSize);
reverseComplement(out->rPrimer, rPrimerSize);
fprintf(f, "%d\t", round(1000.0 * match / (double)(fPrimerSize + rPrimerSize) ));
fprintf(f, "%c\n", out->strand);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void outputFa	(	struct gfPcrOutput *	out,
		FILE *	f,
		char *	url
	)			[static]

Definition at line 144 of file gfPcrLib.c.

References cloneString(), cloneStringZ(), gfPcrOutput::dna, dyStringAppend(), dyStringFree, dyStringPrintf(), faWriteNext(), gfPcrOutput::fPos, gfPcrOutput::fPrimer, freez(), gfPcrOutput::name, name, newDyString(), reverseComplement(), gfPcrOutput::rPos, gfPcrOutput::rPrimer, gfPcrOutput::seqName, gfPcrOutput::strand, tolowers(), touppers(), and upperMatch().

Referenced by gfPcrOutputWriteList().

{
int fPrimerSize = strlen(out->fPrimer);
int rPrimerSize = strlen(out->rPrimer);
int productSize = out->rPos - out->fPos;
char *dna = cloneStringZ(out->dna, productSize);
char *rrPrimer = cloneString(out->rPrimer);
char *ffPrimer = cloneString(out->fPrimer);
struct dyString *faLabel = newDyString(0);
char *name = out->name;

/* Create fasta header with position, possibly empty name, and upper cased primers with position optionally hyperlinked. */
touppers(rrPrimer);
touppers(ffPrimer);
if (url != NULL)
    {
    dyStringAppend(faLabel, "<A HREF=\"");
    dyStringPrintf(faLabel, url, out->seqName, out->fPos+1, out->rPos);
    dyStringAppend(faLabel, "\">");
    }
dyStringPrintf(faLabel, "%s:%d%c%d", 
        out->seqName, out->fPos+1, out->strand, out->rPos);
if (url != NULL)
    dyStringAppend(faLabel, "</A>");
if (name != NULL)
    dyStringPrintf(faLabel, " %s", name);
dyStringPrintf(faLabel, " %dbp %s %s",
        out->rPos - out->fPos, ffPrimer, rrPrimer);

/* Flip reverse primer to be in same direction and case as sequence. */
reverseComplement(rrPrimer, rPrimerSize);
tolowers(rrPrimer);

/* Capitalize where sequence and primer match, and write out sequence. */
upperMatch(dna, out->fPrimer, fPrimerSize);
upperMatch(dna + productSize - rPrimerSize, rrPrimer, rPrimerSize);
faWriteNext(f, faLabel->string, dna, productSize);

/* Clean up. */
freez(&dna);
freez(&rrPrimer);
freez(&ffPrimer);
dyStringFree(&faLabel)
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void outputPsl	(	struct gfPcrOutput *	out,
		FILE *	f,
		char *	url
	)			[static]

Definition at line 220 of file gfPcrLib.c.

References countMatch(), gfPcrOutput::dna, gfPcrOutput::fPos, gfPcrOutput::fPrimer, gfPcrOutput::name, name, reverseComplement(), gfPcrOutput::rPos, gfPcrOutput::rPrimer, gfPcrOutput::seqName, gfPcrOutput::seqSize, and gfPcrOutput::strand.

Referenced by gfPcrOutputWriteList().

{
int match;
int size = out->rPos - out->fPos;
int fPrimerSize = strlen(out->fPrimer);
int rPrimerSize = strlen(out->rPrimer);
int bothSize = fPrimerSize + rPrimerSize;
int gapSize = size - bothSize;
char *name = out->name;
if (name == NULL) name = "n/a";
match = countMatch(out->dna, out->fPrimer, fPrimerSize);
reverseComplement(out->rPrimer, rPrimerSize);
assert(size > 0);
match += countMatch(out->dna + size - rPrimerSize, out->rPrimer, rPrimerSize);
reverseComplement(out->rPrimer, rPrimerSize);

fprintf(f, "%d\t", match);
fprintf(f, "%d\t", bothSize - match);
fprintf(f, "0\t0\t");   /* repMatch, nCount. */
fprintf(f, "1\t%d\t", gapSize);   /* qNumInsert, qBaseInsert */
fprintf(f, "1\t%d\t", gapSize);   /* tNumInsert, tBaseInsert */
fprintf(f, "%c\t", out->strand);
fprintf(f, "%s\t", name);
fprintf(f, "%d\t", size);
fprintf(f, "0\t%d\t", size);    /* qStart, qEnd */
fprintf(f, "%s\t%d\t", out->seqName, out->seqSize);
fprintf(f, "%d\t%d\t", out->fPos, out->rPos);
fprintf(f, "2\t");
fprintf(f, "%d,%d,\t", fPrimerSize, rPrimerSize);
fprintf(f, "%d,%d,\t", 0,size - rPrimerSize);
fprintf(f, "%d,%d,\n", out->fPos, out->rPos - rPrimerSize);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void pcrLocalStrand	(	char *	pcrName,
		struct dnaSeq *	seq,
		int	seqOffset,
		char *	seqName,
		int	seqSize,
		int	maxSize,
		char *	fPrimer,
		int	fPrimerSize,
		char *	rPrimer,
		int	rPrimerSize,
		int	minPerfect,
		int	minGood,
		char	strand,
		struct gfPcrOutput **	pOutList
	)			[static]

Definition at line 287 of file gfPcrLib.c.

References AllocVar, cloneString(), cloneStringZ(), dnaSeq::dna, gfPcrOutput::fPos, goodMatch(), memMatch(), reverseComplement(), gfPcrOutput::rPos, dnaSeq::size, and slAddHead.

Referenced by gfPcrLocal().

{
char *fDna = seq->dna, *rDna;
char *endDna = fDna + seq->size;
char *fpPerfect = fPrimer + fPrimerSize - minPerfect;
char *rpPerfect = rPrimer;
char *fpMatch, *rpMatch;
int sizeLeft;
int goodSize = minGood - minPerfect;
struct gfPcrOutput  *out;
int matchSize;

reverseComplement(rPrimer, rPrimerSize);
for (;;)
    {
    fpMatch = memMatch(fpPerfect, minPerfect, fDna, endDna - fDna);
    if (fpMatch == NULL)
        break;
    sizeLeft = endDna - fpMatch;
    rDna = fpMatch;
    for (;;)
        {
        int fPos, rPos, fGoodPos, rGoodPos;
        rpMatch = memMatch(rpPerfect, minPerfect, rDna, endDna - rDna);
        if (rpMatch == NULL)
            break;
        fPos = fpMatch - (fPrimerSize - minPerfect) - seq->dna;
        rPos = rpMatch + rPrimerSize - seq->dna;
        fGoodPos = fpMatch - goodSize - seq->dna;
        rGoodPos = rpMatch + minPerfect - seq->dna;
        matchSize = rPos - fPos;
        if (rPos >= 0 && fPos >= 0 && fPos < seq->size && matchSize <= maxSize)
            {
            /* If matches well enough create output record. */
            if (goodMatch(seq->dna + fGoodPos, fpPerfect - goodSize, goodSize) &&
                goodMatch(seq->dna + rGoodPos, rpPerfect + minPerfect, goodSize))
                {
                AllocVar(out);
                out->name  = cloneString(pcrName);
                out->fPrimer = cloneString(fPrimer);
                out->rPrimer = cloneString(rPrimer);
                reverseComplement(out->rPrimer, rPrimerSize);
                out->seqName = cloneString(seqName);
                out->seqSize = seqSize;
                out->fPos = fPos + seqOffset;
                out->rPos = rPos + seqOffset;
                out->strand = strand;
                out->dna = cloneStringZ(seq->dna + fPos, matchSize);

                /* Dealing with the strand of darkness....  Here we just have to swap
                 * forward and reverse primers to flip strands, and reverse complement
                 * the amplified area.. */
                if (strand == '-')
                    {
                    char *temp = out->rPrimer;
                    out->rPrimer = out->fPrimer;
                    out->fPrimer = temp;
                    reverseComplement(out->dna, matchSize);
                    }
                slAddHead(pOutList, out);
                }
            }
        rDna = rpMatch+1;
        }
    fDna = fpMatch + 1;
    }
reverseComplement(rPrimer, rPrimerSize);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void upperMatch	(	char *	dna,
		char *	primer,
		int	size
	)			[static]

Definition at line 133 of file gfPcrLib.c.

Referenced by outputFa().

{
int i;
for (i=0; i<size; ++i)
    {
    if (dna[i] == primer[i])
        dna[i] = toupper(dna[i]);
    }
}

Here is the caller graph for this function:

---

Variable Documentation

char const rcsid[] = "$Id: gfPcrLib.c,v 1.8 2006/03/15 18:36:16 angie Exp $" [static]

Definition at line 16 of file gfPcrLib.c.

---