d33d422222f6846b3eb05e49242e9d764d4c4aea
tdreszer
  Tue Nov 23 14:17:17 2010 -0800
Missing comma in whitelist of formats caused a problem
diff --git src/hg/hgTracks/searchTracks.c src/hg/hgTracks/searchTracks.c
index 7448d2b..1d362bb 100644
--- src/hg/hgTracks/searchTracks.c
+++ src/hg/hgTracks/searchTracks.c
@@ -163,85 +163,83 @@
     ix++;
     labels[ix] = pair->name;
     values[ix] = pair->val;
     freeMem(pair);
     }
 *pLabels = labels;
 *pTerms = values;
 return count;
 }
 
 #ifdef TRACK_SEARCH_ON_TYPE
 static int getFormatTypes(char ***pLabels, char ***pTypes)
 {
 char *crudeTypes[] = {
     ANYLABEL,
-    //"altGraphX",
     "bam",
     "psl",
     "chain",
     "netAlign",
     "maf",
     "bed",
     "bigBed",
     "ctgPos",
     "expRatio",
     "genePred",
     "broadPeak",
     "narrowPeak",
     "rmsk",
     "bedGraph",
     "bigWig",
     "wig",
-    "wigMaf",
+    "wigMaf"
 };
 // Non-standard:
 // type altGraphX
 // type axt
 // type bed5FloatScore
 // type bed5FloatScoreWithFdr
 // type chromGraph
 // type clonePos
 // type coloredExon
 // type encodeFiveC
 // type factorSource
 // type ld2
 // type logo
 // type maf
 // type sample
 // type wigMafProt 0.0 1.0
 
 char *nicerTypes[] = {
     ANYLABEL,
-    //"altGraphX",
     "Alignment binary (bam) - binary SAM",
     "Alignment Blast (psl) - Blast output",
     "Alignment Chains (chain) - Pairwise alignment",
     "Alignment Nets (netAlign) - Net alignments",
     "Alignments (maf) - multiple alignment format",
     "bed - browser extensible data",
     "bigBed - self index, often remote bed format",
     "ctgPos - Contigs",
     "expRatio - Expression ratios",
     "Genes (genePred) - Gene prediction and annotation",
     "Peaks Broad (broadPeak) - ENCODE large region peak format",
     "Peaks Narrow (narrowPeak) - ENCODE small region peak format",
     "Repeats (rmsk) - Repeat masking",
     "Signal (bedGraph) - graphically represented bed data",
     "Signal (bigWig) - self index, often remote wiggle format",
-    "Signal (wig) - wiggle format"
-    "Signal (wigMaf) - multiple alignment wiggle",
+    "Signal (wig) - wiggle format",
+    "Signal (wigMaf) - multiple alignment wiggle"
 };
 #endif///def TRACK_SEARCH_ON_TYPE
 
 int ix = 0, count = sizeof(crudeTypes)/sizeof(char *);
 char **labels;
 char **values;
 AllocArray(labels, count);
 AllocArray(values, count);
 for(ix=0;ix<count;ix++)
     {
     labels[ix] = cloneString(nicerTypes[ix]);
     values[ix] = cloneString(crudeTypes[ix]);
     }
 *pLabels = labels;
 *pTypes = values;
@@ -524,79 +522,72 @@
         for (el = metaTracks; el != NULL; el = el->next)
             hashAddInt(matchingTracks, el->name, 1);
 
         struct group *group;
         for (group = groupList; group != NULL; group = group->next)
             {
             if(groupSearch == NULL || sameString(group->name, groupSearch))
                 {
                 if (group->trackList != NULL)
                     {
                     struct trackRef *tr;
                     for (tr = group->trackList; tr != NULL; tr = tr->next)
                         {
                         struct track *track = tr->track;
                     #ifdef TRACK_SEARCH_ON_TYPE
-                        char *trackType = cloneFirstWord(track->tdb->type);
+                        char *trackType = cloneFirstWord(track->tdb->type); // will be spilled
                     #endif///def TRACK_SEARCH_ON_TYPE
                         if((isEmpty(nameSearch) || isNameMatch(track, nameSearch, "contains")) &&
                     #ifdef TRACK_SEARCH_ON_TYPE
                            (isEmpty(typeSearch) || (sameWord(typeSearch, trackType) && !tdbIsComposite(track->tdb))) &&
-                           //(isEmpty(typeSearch) || sameWord(typeSearch, trackType)) &&
                     #endif///def TRACK_SEARCH_ON_TYPE
                            (isEmpty(descSearch) || isDescriptionMatch(track, descWords, descWordCount)) &&
                           (!numMetadataNonEmpty || hashLookup(matchingTracks, track->track) != NULL))
                             {
                             if (track != NULL)
                                 {
                                 tracksFound++;
                                 refAdd(&tracks, track);
                                 }
                             else
                                 warn("found group track is NULL.");
                             }
-                        #ifdef TRACK_SEARCH_ON_TYPE
-                            freeMem(trackType);
-                        #endif///def TRACK_SEARCH_ON_TYPE
                         if (track->subtracks != NULL)
                             {
                             struct track *subTrack;
                             for (subTrack = track->subtracks; subTrack != NULL; subTrack = subTrack->next)
                                 {
                             #ifdef TRACK_SEARCH_ON_TYPE
-                                trackType = cloneFirstWord(subTrack->tdb->type);
+                                trackType = cloneFirstWord(subTrack->tdb->type); // will be spilled
                             #endif///def TRACK_SEARCH_ON_TYPE
                                 if((isEmpty(nameSearch) || isNameMatch(subTrack, nameSearch, "contains")) &&
                             #ifdef TRACK_SEARCH_ON_TYPE
                                    (isEmpty(typeSearch) || sameWord(typeSearch, trackType)) &&
                             #endif///def TRACK_SEARCH_ON_TYPE
                                    (isEmpty(descSearch) || isDescriptionMatch(subTrack, descWords, descWordCount)) &&
                                    (!numMetadataNonEmpty || hashLookup(matchingTracks, subTrack->track) != NULL))
                                     {
                                     // XXXX to parent hash. - use tdb->parent instead.
                                     //hashAdd(parents, subTrack->track, track);
                                     if (track != NULL)
                                         {
                                         tracksFound++;
                                         refAdd(&tracks, subTrack);
                                         }
                                     else
                                         warn("found subtrack is NULL.");
                                     }
-                            #ifdef TRACK_SEARCH_ON_TYPE
-                                freeMem(trackType);
-                            #endif///def TRACK_SEARCH_ON_TYPE
                                 }
                             }
                         }
                     }
                 }
             }
         }
 
 return tracks;
 }
 
 #define MAX_FOUND_TRACKS 100
 static void findTracksPageLinks(int tracksFound, int startFrom)
 {
 if (tracksFound <= MAX_FOUND_TRACKS)
@@ -838,30 +829,32 @@
 if (!advancedJavascriptFeaturesEnabled(cart))
     {
     warn("Requires advanced javascript features.");
     return;
     }
 struct group *group;
 char *groups[128];
 char *labels[128];
 int numGroups = 1;
 groups[0] = ANYLABEL;
 labels[0] = ANYLABEL;
 char *currentTab = cartUsualString(cart, TRACK_SEARCH_CURRENT_TAB, "simpleTab");
 char *nameSearch = cartOptionalString(cart, TRACK_SEARCH_ON_NAME);
 #ifdef TRACK_SEARCH_ON_TYPE
 char *typeSearch = cartOptionalString(cart, TRACK_SEARCH_ON_TYPE);
+#else///ifndef TRACK_SEARCH_ON_TYPE
+char *typeSearch = NULL;
 #endif///def TRACK_SEARCH_ON_TYPE
 char *descSearch;
 char *groupSearch = cartOptionalString(cart, TRACK_SEARCH_ON_GROUP);
 boolean doSearch = sameString(cartOptionalString(cart, TRACK_SEARCH), "Search") || cartUsualInt(cart, TRACK_SEARCH_PAGER, -1) >= 0;
 struct sqlConnection *conn = hAllocConn(database);
 boolean metaDbExists = sqlTableExists(conn, "metaDb");
 int numMetadataSelects, tracksFound = 0;
 int numMetadataNonEmpty = 0;
 char **mdbVar = NULL;
 char **mdbVal = NULL;
 #ifdef ONE_FUNC
 struct hash *parents = newHash(4);
 #endif///def ONE_FUNC
 boolean simpleSearch;
 struct trix *trix;
@@ -1035,35 +1028,31 @@
         }
     descWords = needMem(sizeof(char *) * descWordCount);
     for(i = 0, el = descList; el != NULL; i++, el = el->next)
         descWords[i] = strLower(el->name);
     }
 if (doSearch && simpleSearch && descWordCount <= 0)
     doSearch = FALSE;
 
 if(doSearch)
     {
     // Now search
     struct slRef *tracks = NULL;
     if(simpleSearch)
         tracks = simpleSearchForTracksstruct(trix,descWords,descWordCount);
     else
-#ifdef TRACK_SEARCH_ON_TYPE
         tracks = advancedSearchForTracks(conn,groupList,descWords,descWordCount,nameSearch,typeSearch,descSearch,groupSearch,numMetadataNonEmpty,numMetadataSelects,mdbVar,mdbVal);
-#else///ifndef TRACK_SEARCH_ON_TYPE
-        tracks = advancedSearchForTracks(conn,groupList,descWords,descWordCount,nameSearch,NULL,descSearch,groupSearch,numMetadataNonEmpty,numMetadataSelects,mdbVar,mdbVal);
-#endif///ndef TRACK_SEARCH_ON_TYPE
 
     // Sort and Print results
     enum sortBy sortBy = cartUsualInt(cart,TRACK_SEARCH_SORT,sbRelevance);
     tracksFound = slCount(tracks);
     if(tracksFound > 1)
         findTracksSort(&tracks,simpleSearch,sortBy);
 
     displayFoundTracks(cart,tracks,tracksFound,sortBy);
     }
 
 hFreeConn(&conn);
 webNewSection("About Track Search");
 if(metaDbExists)
     hPrintf("<p>Search for terms in track names, descriptions, groups, and ENCODE "
             "metadata.  If multiple terms are entered, only tracks with all terms "