7d39d6e6cbd055195a34ad066be052dbc338b258
markd
  Sun Mar 22 21:12:13 2026 -0700
added missing newlines in verbose() calls that led to hard to read message

diff --git src/lib/udc.c src/lib/udc.c
index a79c07c7ecb..b29eb7b1521 100644
--- src/lib/udc.c
+++ src/lib/udc.c
@@ -1297,31 +1297,31 @@
 }
 
 void udcLoadCachedResolvedUrl(struct udcFile *file)
 /* load resolved URL from cache or create a new one file and write it */
 {
 char *cacheFname = file->resolvedFileName;
 
 if (!cacheFname)
     return; // URL does not need resolving
 
 if (fileExists(cacheFname)) 
     {
     // read URL from cache
     char *newUrl = NULL;
     readInGulp(cacheFname, &newUrl, NULL);
-    verbose(4, "Read resolved URL %s from cache", newUrl);
+    verbose(4, "Read resolved URL %s from cache\n", newUrl);
     file->connInfo.resolvedUrl = newUrl;
     }
 else if (file->connInfo.resolvedUrl)
     {
     // write URL to cache
     char *newUrl = file->connInfo.resolvedUrl;
     char *temp = catTwoStrings(cacheFname, ".temp");
     writeGulp(temp, newUrl, strlen(newUrl));
     rename(temp, cacheFname);
     freeMem(temp);
     }
 }
 
 static void udcTestAndSetRedirect(struct udcFile *file, char *protocol, boolean useCacheInfo)
 /* update redirect info */
@@ -1397,33 +1397,33 @@
     if (udcCacheEnabled())
         useCacheInfo = (udcCacheAge(url, cacheDir) < udcCacheTimeout());
     if (!useCacheInfo)
 	{
 	if (!prot->fetchInfo(url, &info))
 	    {
 	    udcProtocolFree(&prot);
 	    freeMem(protocol);
 	    freeMem(afterProtocol);
 	    return NULL;
 	    }
 	}
     }
 
 if (useCacheInfo)
-    verbose(4, "Cache is used for %s", url);
+    verbose(4, "Cache is used for %s\n", url);
 else
-    verbose(4, "Cache is not used for %s", url);
+    verbose(4, "Cache is not used for %s\n", url);
 
 /* Allocate file object and start filling it in. */
 struct udcFile *file;
 AllocVar(file);
 file->url = cloneString(url);
 file->protocol = protocol;
 file->prot = prot;
 if (isTransparent)
     {
     /* If transparent dummy up things so that the "sparse" file pointer is actually
      * the file itself, which appears to be completely loaded in cache. */
     if (!fileExists(url))
 	return NULL;
     int fd = file->fdSparse = mustOpenFd(url, O_RDONLY);
     struct stat status;
@@ -1831,31 +1831,31 @@
 for (s = offset; s < endPos; s = e)
     {
     /* Figure out bounds of this section. */
     e = s + udcMaxBytesPerRemoteFetch;
     if (e > endPos)
 	e = endPos;
 
     struct udcBitmap *bits = file->bits;
     if (bits->version == file->bitmapVersion)
 	{
         udcFetchMissing(file, bits, s, e);
 	}
     else
 	{
 	ok = FALSE;
-	verbose(4, "udcCachePreload version check failed %d vs %d", 
+	verbose(4, "udcCachePreload version check failed %d vs %d\n", 
 		bits->version, file->bitmapVersion);
 	}
     if (!ok)
         break;
     }
 return ok;
 }
 
 #define READAHEADBUFSIZE 4096
 bits64 udcRead(struct udcFile *file, void *buf, bits64 size)
 /* Read a block from file.  Return amount actually read. */
 {
 file->ios.udc.numReads++;
 // if not caching, just fetch the data
 if (!udcCacheEnabled() && !sameString(file->protocol, "transparent"))
@@ -1918,31 +1918,31 @@
 	if (end > file->size)
 	    {
 	    end = file->size;
 	    size = end - start;
 	    }
 	}
 
 
     /* If we're outside of the window of file we already know is good, then have to
      * consult cache on disk, and maybe even fetch data remotely! */
     if (start < file->startData || end > file->endData)
 	{
 
 	if (!udcCachePreload(file, start, size))
 	    {
-	    verbose(4, "udcCachePreload failed");
+	    verbose(4, "udcCachePreload failed\n");
 	    bytesRead = 0;
 	    break;
 	    }
 
 	/* Currently only need fseek here.  Would be safer, but possibly
 	 * slower to move fseek so it is always executed in front of read, in
 	 * case other code is moving around file pointer. */
 
 	ourMustLseek(&file->ios.sparse,file->fdSparse, start, SEEK_SET);
 	}
 
     if (file->sparseReadAhead)
 	{
 	ourMustRead(&file->ios.sparse,file->fdSparse, file->sparseReadAheadBuf, size);
 	end = saveEnd;
@@ -2273,31 +2273,31 @@
     {
     struct stat status;
     int ret = stat(udc->url, &status);
     if (ret < 0)
 	return 0;
     else
 	return  status.st_mtime;
     }
 return udc->updateTime;
 }
 
 off_t udcFileSize(char *url)
 /* fetch file size from given URL or local path 
  * returns -1 if not found. */
 {
-verbose(4, "getting file size for %s", url);
+verbose(4, "getting file size for %s\n", url);
 if (udcIsLocal(url))
     return fileSize(url);
 
 // don't go to the network if we can avoid it
 off_t cacheSize = udcSizeFromCache(url, NULL);
 if (cacheSize!=-1)
     return cacheSize;
 
 off_t ret = -1;
 struct udcRemoteFileInfo info;
 
 if (startsWith("http://",url) || startsWith("https://",url) || udcIsResolvable(url) )
     {
     if (udcInfoViaHttp(url, &info))
 	ret = info.size;