fb4ef5ddff422e6ddb8ee3695d73ab47f0f5d039
kent
  Tue May 27 10:44:56 2014 -0700
Adding Jim Kent copyright notices to a few files that needed it.
diff --git src/lib/xAli.c src/lib/xAli.c
index 1ec181d..f65adff 100644
--- src/lib/xAli.c
+++ src/lib/xAli.c
@@ -1,280 +1,282 @@
 /* xAli.c was originally generated by the autoSql program, which also 
  * generated xAli.h and xAli.sql.  This module links the database and
- * the RAM representation of objects. */
+ * the RAM representation of objects. 
+ * This file is copyright 2002 Jim Kent, but license is hereby
+ * granted for all use - public, private or commercial. */
 
 #include "common.h"
 #include "linefile.h"
 #include "dystring.h"
 #include "sqlNum.h"
 #include "sqlList.h"
 #include "xAli.h"
 
 
 struct xAli *xAliLoad(char **row)
 /* Load a xAli from row fetched with select * from xAli
  * from database.  Dispose of this with xAliFree(). */
 {
 struct xAli *ret;
 int sizeOne;
 
 AllocVar(ret);
 ret->blockCount = sqlUnsigned(row[17]);
 ret->match = sqlUnsigned(row[0]);
 ret->misMatch = sqlUnsigned(row[1]);
 ret->repMatch = sqlUnsigned(row[2]);
 ret->nCount = sqlUnsigned(row[3]);
 ret->qNumInsert = sqlUnsigned(row[4]);
 ret->qBaseInsert = sqlSigned(row[5]);
 ret->tNumInsert = sqlUnsigned(row[6]);
 ret->tBaseInsert = sqlSigned(row[7]);
 strcpy(ret->strand, row[8]);
 ret->qName = cloneString(row[9]);
 ret->qSize = sqlUnsigned(row[10]);
 ret->qStart = sqlUnsigned(row[11]);
 ret->qEnd = sqlUnsigned(row[12]);
 ret->tName = cloneString(row[13]);
 ret->tSize = sqlUnsigned(row[14]);
 ret->tStart = sqlUnsigned(row[15]);
 ret->tEnd = sqlUnsigned(row[16]);
 sqlUnsignedDynamicArray(row[18], &ret->blockSizes, &sizeOne);
 assert(sizeOne == ret->blockCount);
 sqlUnsignedDynamicArray(row[19], &ret->qStarts, &sizeOne);
 assert(sizeOne == ret->blockCount);
 sqlUnsignedDynamicArray(row[20], &ret->tStarts, &sizeOne);
 assert(sizeOne == ret->blockCount);
 sqlStringDynamicArray(row[21], &ret->qSeq, &sizeOne);
 assert(sizeOne == ret->blockCount);
 sqlStringDynamicArray(row[22], &ret->tSeq, &sizeOne);
 assert(sizeOne == ret->blockCount);
 return ret;
 }
 
 struct xAli *xAliLoadAll(char *fileName) 
 /* Load all xAli from a tab-separated file.
  * Dispose of this with xAliFreeList(). */
 {
 struct xAli *list = NULL, *el;
 struct lineFile *lf = lineFileOpen(fileName, TRUE);
 char *row[23];
 
 while (lineFileRow(lf, row))
     {
     el = xAliLoad(row);
     slAddHead(&list, el);
     }
 lineFileClose(&lf);
 slReverse(&list);
 return list;
 }
 
 struct xAli *xAliCommaIn(char **pS, struct xAli *ret)
 /* Create a xAli out of a comma separated string. 
  * This will fill in ret if non-null, otherwise will
  * return a new xAli */
 {
 char *s = *pS;
 int i;
 
 if (ret == NULL)
     AllocVar(ret);
 ret->match = sqlUnsignedComma(&s);
 ret->misMatch = sqlUnsignedComma(&s);
 ret->repMatch = sqlUnsignedComma(&s);
 ret->nCount = sqlUnsignedComma(&s);
 ret->qNumInsert = sqlUnsignedComma(&s);
 ret->qBaseInsert = sqlSignedComma(&s);
 ret->tNumInsert = sqlUnsignedComma(&s);
 ret->tBaseInsert = sqlSignedComma(&s);
 sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));
 ret->qName = sqlStringComma(&s);
 ret->qSize = sqlUnsignedComma(&s);
 ret->qStart = sqlUnsignedComma(&s);
 ret->qEnd = sqlUnsignedComma(&s);
 ret->tName = sqlStringComma(&s);
 ret->tSize = sqlUnsignedComma(&s);
 ret->tStart = sqlUnsignedComma(&s);
 ret->tEnd = sqlUnsignedComma(&s);
 ret->blockCount = sqlUnsignedComma(&s);
 s = sqlEatChar(s, '{');
 AllocArray(ret->blockSizes, ret->blockCount);
 for (i=0; i<ret->blockCount; ++i)
     {
     ret->blockSizes[i] = sqlUnsignedComma(&s);
     }
 s = sqlEatChar(s, '}');
 s = sqlEatChar(s, ',');
 s = sqlEatChar(s, '{');
 AllocArray(ret->qStarts, ret->blockCount);
 for (i=0; i<ret->blockCount; ++i)
     {
     ret->qStarts[i] = sqlUnsignedComma(&s);
     }
 s = sqlEatChar(s, '}');
 s = sqlEatChar(s, ',');
 s = sqlEatChar(s, '{');
 AllocArray(ret->tStarts, ret->blockCount);
 for (i=0; i<ret->blockCount; ++i)
     {
     ret->tStarts[i] = sqlUnsignedComma(&s);
     }
 s = sqlEatChar(s, '}');
 s = sqlEatChar(s, ',');
 s = sqlEatChar(s, '{');
 AllocArray(ret->qSeq, ret->blockCount);
 for (i=0; i<ret->blockCount; ++i)
     {
     ret->qSeq[i] = sqlStringComma(&s);
     }
 s = sqlEatChar(s, '}');
 s = sqlEatChar(s, ',');
 s = sqlEatChar(s, '{');
 AllocArray(ret->tSeq, ret->blockCount);
 for (i=0; i<ret->blockCount; ++i)
     {
     ret->tSeq[i] = sqlStringComma(&s);
     }
 s = sqlEatChar(s, '}');
 s = sqlEatChar(s, ',');
 *pS = s;
 return ret;
 }
 
 void xAliFree(struct xAli **pEl)
 /* Free a single dynamically allocated xAli such as created
  * with xAliLoad(). */
 {
 struct xAli *el;
 
 if ((el = *pEl) == NULL) return;
 freeMem(el->qName);
 freeMem(el->tName);
 freeMem(el->blockSizes);
 freeMem(el->qStarts);
 freeMem(el->tStarts);
 /* All strings in qSeq are allocated at once, so only need to free first. */
 if (el->qSeq != NULL)
     freeMem(el->qSeq[0]);
 freeMem(el->qSeq);
 /* All strings in tSeq are allocated at once, so only need to free first. */
 if (el->tSeq != NULL)
     freeMem(el->tSeq[0]);
 freeMem(el->tSeq);
 freez(pEl);
 }
 
 void xAliFreeList(struct xAli **pList)
 /* Free a list of dynamically allocated xAli's */
 {
 struct xAli *el, *next;
 
 for (el = *pList; el != NULL; el = next)
     {
     next = el->next;
     xAliFree(&el);
     }
 *pList = NULL;
 }
 
 void xAliOutput(struct xAli *el, FILE *f, char sep, char lastSep) 
 /* Print out xAli.  Separate fields with sep. Follow last field with lastSep. */
 {
 int i;
 fprintf(f, "%u", el->match);
 fputc(sep,f);
 fprintf(f, "%u", el->misMatch);
 fputc(sep,f);
 fprintf(f, "%u", el->repMatch);
 fputc(sep,f);
 fprintf(f, "%u", el->nCount);
 fputc(sep,f);
 fprintf(f, "%u", el->qNumInsert);
 fputc(sep,f);
 fprintf(f, "%d", el->qBaseInsert);
 fputc(sep,f);
 fprintf(f, "%u", el->tNumInsert);
 fputc(sep,f);
 fprintf(f, "%d", el->tBaseInsert);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->strand);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->qName);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 fprintf(f, "%u", el->qSize);
 fputc(sep,f);
 fprintf(f, "%u", el->qStart);
 fputc(sep,f);
 fprintf(f, "%u", el->qEnd);
 fputc(sep,f);
 if (sep == ',') fputc('"',f);
 fprintf(f, "%s", el->tName);
 if (sep == ',') fputc('"',f);
 fputc(sep,f);
 fprintf(f, "%u", el->tSize);
 fputc(sep,f);
 fprintf(f, "%u", el->tStart);
 fputc(sep,f);
 fprintf(f, "%u", el->tEnd);
 fputc(sep,f);
 fprintf(f, "%u", el->blockCount);
 fputc(sep,f);
 if (sep == ',') fputc('{',f);
 for (i=0; i<el->blockCount; ++i)
     {
     fprintf(f, "%u", el->blockSizes[i]);
     fputc(',', f);
     }
 if (sep == ',') fputc('}',f);
 fputc(sep,f);
 if (sep == ',') fputc('{',f);
 for (i=0; i<el->blockCount; ++i)
     {
     fprintf(f, "%u", el->qStarts[i]);
     fputc(',', f);
     }
 if (sep == ',') fputc('}',f);
 fputc(sep,f);
 if (sep == ',') fputc('{',f);
 for (i=0; i<el->blockCount; ++i)
     {
     fprintf(f, "%u", el->tStarts[i]);
     fputc(',', f);
     }
 if (sep == ',') fputc('}',f);
 fputc(sep,f);
 if (sep == ',') fputc('{',f);
 for (i=0; i<el->blockCount; ++i)
     {
     if (sep == ',') fputc('"',f);
     fprintf(f, "%s", el->qSeq[i]);
     if (sep == ',') fputc('"',f);
     fputc(',', f);
     }
 if (sep == ',') fputc('}',f);
 fputc(sep,f);
 if (sep == ',') fputc('{',f);
 for (i=0; i<el->blockCount; ++i)
     {
     if (sep == ',') fputc('"',f);
     fprintf(f, "%s", el->tSeq[i]);
     if (sep == ',') fputc('"',f);
     fputc(',', f);
     }
 if (sep == ',') fputc('}',f);
 fputc(lastSep,f);
 }
 
 /* --------------------Start of human generated code. -------------------- */
 
 struct xAli *xAliNext(struct lineFile *lf)
 /* Read next line from file and convert it to xAli.  Return
  * NULL at eof. */
 {
 char *row[23];
 if (!lineFileRow(lf, row))
     return NULL;
 return xAliLoad(row);
 }