add debug-logging for file.c, to help with analysis

Signed-off-by: Thomas E. Dickey <dickey@invisible-island.net>

2 files changed, 320 insertions, 152 deletions

diff --git a/src/file.c b/src/file.c
index ccc430f..c37cd0a 100644
--- a/src/file.c
+++ b/src/file.c
@@ -25,33 +25,84 @@
 #include <stdlib.h>
 #include <string.h>
 
-XcursorImage *
-XcursorImageCreate (int width, int height)
+#ifdef DEBUG_XCURSOR
+#include <stdarg.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+void _XcursorTrace(const char *fmt, ...)
 {
-    XcursorImage    *image;
+    FILE *fp = fopen("/tmp/xcursor.log", "a");
+    if (fp != NULL) {
+	unsigned save = umask(0);
+	va_list ap;
+	va_start(ap, fmt);
+	vfprintf(fp, fmt, ap);
+	va_end(ap);
+	fclose(fp);
+	umask(save);
+    }
+}
 
-    if (width < 0 || height < 0)
-       return NULL;
-    if (width > XCURSOR_IMAGE_MAX_SIZE || height > XCURSOR_IMAGE_MAX_SIZE)
-       return NULL;
+unsigned _XcursorReturnUint(unsigned code)
+{
+    _XcursorTrace(T_RETURN(u), code);
+    return code;
+}
 
-    image = malloc (sizeof (XcursorImage) +
-		    (size_t) (width * height) * sizeof (XcursorPixel));
-    if (!image)
-	return NULL;
-    image->version = XCURSOR_IMAGE_VERSION;
-    image->pixels = (XcursorPixel *) (image + 1);
-    image->size = (XcursorDim) (width > height ? width : height);
-    image->width = (XcursorDim) width;
-    image->height = (XcursorDim) height;
-    image->delay = 0;
-    return image;
+int _XcursorReturnCode(int code)
+{
+    _XcursorTrace(T_RETURN(d), code);
+    return code;
+}
+
+void *_XcursorReturnAddr(void *addr)
+{
+    _XcursorTrace(T_RETURN(p), addr);
+    return addr;
+}
+
+void _XcursorReturnVoid(void)
+{
+    _XcursorTrace(T_RETURN(s), "");
+    return;
+}
+#endif /* DEBUG_XCURSOR */
+
+XcursorImage *
+XcursorImageCreate (int width, int height)
+{
+    XcursorImage    *image = NULL;
+
+    enterFunc((T_CALLED(XcursorImageCreate) "(%d, %d)\n", width, height));
+
+    if (width < 0 || height < 0) {
+       /* EMPTY */;
+    } else if (width > XCURSOR_IMAGE_MAX_SIZE
+    	    || height > XCURSOR_IMAGE_MAX_SIZE) {
+       /* EMPTY */;
+    } else {
+	image = malloc (sizeof (XcursorImage) +
+			(size_t) (width * height) * sizeof (XcursorPixel));
+	if (image) {
+	    image->version = XCURSOR_IMAGE_VERSION;
+	    image->pixels  = (XcursorPixel *) (image + 1);
+	    image->size	   = (XcursorDim) (width > height ? width : height);
+	    image->width   = (XcursorDim) width;
+	    image->height  = (XcursorDim) height;
+	    image->delay   = 0;
+	}
+    }
+    returnAddr(image);
 }
 
 void
 XcursorImageDestroy (XcursorImage *image)
 {
+    enterFunc((T_CALLED(XcursorImageDestroy ) "(%p)\n", (void*)image));
+
     free (image);
+
+    returnVoid();
 }
 
 XcursorImages *
@@ -59,47 +110,54 @@ XcursorImagesCreate (int size)
 {
     XcursorImages   *images;
 
+    enterFunc((T_CALLED(XcursorImagesCreate) "(%d)\n", size));
+
     images = malloc (sizeof (XcursorImages) +
 		     (size_t) size * sizeof (XcursorImage *));
-    if (!images)
-	return NULL;
-    images->nimage = 0;
-    images->images = (XcursorImage **) (images + 1);
-    images->name = NULL;
-    return images;
+    if (images) {
+	images->nimage = 0;
+	images->images = (XcursorImage **) (images + 1);
+	images->name = NULL;
+    }
+    returnAddr(images);
 }
 
 void
 XcursorImagesDestroy (XcursorImages *images)
 {
-    int	n;
+    enterFunc((T_CALLED(XcursorImagesDestroy) "(%p)\n", (void*)images));
 
-    if (!images)
-        return;
+    if (images) {
+	int	n;
 
-    for (n = 0; n < images->nimage; n++)
-	XcursorImageDestroy (images->images[n]);
-    if (images->name)
-	free (images->name);
-    free (images);
+	for (n = 0; n < images->nimage; n++)
+	    XcursorImageDestroy (images->images[n]);
+	if (images->name)
+	    free (images->name);
+	free (images);
+    }
+
+    returnVoid();
 }
 
 void
 XcursorImagesSetName (XcursorImages *images, const char *name)
 {
-    char    *new;
+    enterFunc((T_CALLED(XcursorImagesSetName) "(%p, \"%s\")\n",
+	      (void*)images,
+	      NonNull(name)));
 
-    if (!images || !name)
-        return;
-
-    new = strdup (name);
+    if (images && name) {
+	char *new = strdup (name);
 
-    if (!new)
-	return;
+	if (new) {
+	    if (images->name)
+		free (images->name);
+	    images->name = new;
+	}
+    }
 
-    if (images->name)
-	free (images->name);
-    images->name = new;
+    returnVoid();
 }
 
 XcursorComment *
@@ -383,8 +441,11 @@ _XcursorFindBestSize (XcursorFileHeader *fileHeader,
     XcursorDim	bestSize = 0;
     XcursorDim	thisSize;
 
+    enterFunc((T_CALLED(_XcursorFindBestSize) "(%p, %u, %p)\n",
+              (void*)fileHeader, size, (void*)nsizesp));
+
     if (!fileHeader || !nsizesp)
-        return 0;
+        returnUint(0);
 
     for (n = 0; n < fileHeader->ntoc; n++)
     {
@@ -400,7 +461,7 @@ _XcursorFindBestSize (XcursorFileHeader *fileHeader,
 	    nsizes++;
     }
     *nsizesp = nsizes;
-    return bestSize;
+    returnUint(bestSize);
 }
 
 static int
@@ -411,8 +472,11 @@ _XcursorFindImageToc (XcursorFileHeader	*fileHeader,
     XcursorUInt		toc;
     XcursorDim		thisSize;
 
+    enterFunc((T_CALLED(_XcursorFindImageToc) "(%p, %u, %d)\n",
+              (void*)fileHeader, size, count));
+
     if (!fileHeader)
-        return 0;
+        returnCode(0);
 
     for (toc = 0; toc < fileHeader->ntoc; toc++)
     {
@@ -426,8 +490,8 @@ _XcursorFindImageToc (XcursorFileHeader	*fileHeader,
 	count--;
     }
     if (toc == fileHeader->ntoc)
-	return -1;
-    return (int) toc;
+	returnCode(-1);
+    returnCode((int) toc);
 }
 
 static XcursorImage *
@@ -441,34 +505,37 @@ _XcursorReadImage (XcursorFile		*file,
     int			n;
     XcursorPixel	*p;
 
+    enterFunc((T_CALLED(_XcursorReadImage) "(%p, %p, %d)\n",
+              (void*)file, (void*)fileHeader, toc));
+
     if (!file || !fileHeader)
-        return NULL;
+        returnAddr(NULL);
 
     if (!_XcursorFileReadChunkHeader (file, fileHeader, toc, &chunkHeader))
-	return NULL;
+	returnAddr(NULL);
     if (!_XcursorReadUInt (file, &head.width))
-	return NULL;
+	returnAddr(NULL);
     if (!_XcursorReadUInt (file, &head.height))
-	return NULL;
+	returnAddr(NULL);
     if (!_XcursorReadUInt (file, &head.xhot))
-	return NULL;
+	returnAddr(NULL);
     if (!_XcursorReadUInt (file, &head.yhot))
-	return NULL;
+	returnAddr(NULL);
     if (!_XcursorReadUInt (file, &head.delay))
-	return NULL;
+	returnAddr(NULL);
     /* sanity check data */
     if (head.width > XCURSOR_IMAGE_MAX_SIZE  ||
 	head.height > XCURSOR_IMAGE_MAX_SIZE)
-	return NULL;
+	returnAddr(NULL);
     if (head.width == 0 || head.height == 0)
-	return NULL;
+	returnAddr(NULL);
     if (head.xhot > head.width || head.yhot > head.height)
-	return NULL;
+	returnAddr(NULL);
 
     /* Create the image and initialize it */
     image = XcursorImageCreate ((int) head.width, (int) head.height);
     if (image == NULL)
-	return NULL;
+	returnAddr(NULL);
     if (chunkHeader.version < image->version)
 	image->version = chunkHeader.version;
     image->size = chunkHeader.subtype;
@@ -482,20 +549,22 @@ _XcursorReadImage (XcursorFile		*file,
 	if (!_XcursorReadUInt (file, p))
 	{
 	    XcursorImageDestroy (image);
-	    return NULL;
+	    returnAddr(NULL);
 	}
 	p++;
     }
-    return image;
+    returnAddr(image);
 }
 
 static XcursorUInt
 _XcursorImageLength (XcursorImage   *image)
 {
+    enterFunc((T_CALLED(_XcursorImageLength) "(%p)\n", (void*)image));
+
     if (!image)
-        return 0;
+        returnUint(0);
 
-    return XCURSOR_IMAGE_HEADER_LEN + (image->width * image->height) * 4;
+    returnUint(XCURSOR_IMAGE_HEADER_LEN + (image->width * image->height) * 4);
 }
 
 static XcursorBool
@@ -508,17 +577,20 @@ _XcursorWriteImage (XcursorFile		*file,
     int			n;
     XcursorPixel	*p;
 
+    enterFunc((T_CALLED(_XcursorWriteImage) "(%p, %p, %d, %p)\n",
+              (void*)file, (void*)fileHeader, toc, (void*)image));
+
     if (!file || !fileHeader || !image)
-        return XcursorFalse;
+        returnCode(XcursorFalse);
 
     /* sanity check data */
     if (image->width > XCURSOR_IMAGE_MAX_SIZE  ||
 	image->height > XCURSOR_IMAGE_MAX_SIZE)
-	return XcursorFalse;
+	returnCode(XcursorFalse);
     if (image->width == 0 || image->height == 0)
-	return XcursorFalse;
+	returnCode(XcursorFalse);
     if (image->xhot > image->width || image->yhot > image->height)
-	return XcursorFalse;
+	returnCode(XcursorFalse);
 
     /* write chunk header */
     chunkHeader.header = XCURSOR_IMAGE_HEADER_LEN;
@@ -527,19 +599,19 @@ _XcursorWriteImage (XcursorFile		*file,
     chunkHeader.version = XCURSOR_IMAGE_VERSION;
 
     if (!_XcursorFileWriteChunkHeader (file, fileHeader, toc, &chunkHeader))
-	return XcursorFalse;
+	returnCode(XcursorFalse);
 
     /* write extra image header fields */
     if (!_XcursorWriteUInt (file, image->width))
-	return XcursorFalse;
+	returnCode(XcursorFalse);
     if (!_XcursorWriteUInt (file, image->height))
-	return XcursorFalse;
+	returnCode(XcursorFalse);
     if (!_XcursorWriteUInt (file, image->xhot))
-	return XcursorFalse;
+	returnCode(XcursorFalse);
     if (!_XcursorWriteUInt (file, image->yhot))
-	return XcursorFalse;
+	returnCode(XcursorFalse);
     if (!_XcursorWriteUInt (file, image->delay))
-	return XcursorFalse;
+	returnCode(XcursorFalse);
 
     /* write the image */
     n = (int) (image->width * image->height);
@@ -547,10 +619,10 @@ _XcursorWriteImage (XcursorFile		*file,
     while (n--)
     {
 	if (!_XcursorWriteUInt (file, *p))
-	    return XcursorFalse;
+	    returnCode(XcursorFalse);
 	p++;
     }
-    return XcursorTrue;
+    returnCode(XcursorTrue);
 }
 
 static XcursorComment *
@@ -562,25 +634,28 @@ _XcursorReadComment (XcursorFile	    *file,
     XcursorUInt		length;
     XcursorComment	*comment;
 
+    enterFunc((T_CALLED(_XcursorReadComment) "(%p, %p, %d)\n",
+              (void*)file, (void*)fileHeader, toc));
+
     if (!file || !fileHeader)
-        return NULL;
+        returnAddr(NULL);
 
     /* read chunk header */
     if (!_XcursorFileReadChunkHeader (file, fileHeader, toc, &chunkHeader))
-	return NULL;
+	returnAddr(NULL);
     /* read extra comment header fields */
     if (!_XcursorReadUInt (file, &length))
-	return NULL;
+	returnAddr(NULL);
     comment = XcursorCommentCreate (chunkHeader.subtype, (int) length);
     if (!comment)
-	return NULL;
+	returnAddr(NULL);
     if (!_XcursorReadBytes (file, comment->comment, (int) length))
     {
 	XcursorCommentDestroy (comment);
-	return NULL;
+	returnAddr(NULL);
     }
     comment->comment[length] = '\0';
-    return comment;
+    returnAddr(comment);
 }
 
 static XcursorUInt
@@ -630,9 +705,14 @@ _XcursorResizeImage (XcursorImage *src, int size)
 {
     XcursorDim dest_y, dest_x;
     double scale = (double) size / src->size;
-    XcursorImage *dest = XcursorImageCreate ((int) (src->width * scale), (int) (src->height * scale));
+    XcursorImage *dest;
+
+    enterFunc((T_CALLED(_XcursorResizeImage) "(%p, %d)\n", (void*)src, size));
+
+    dest = XcursorImageCreate ((int) (src->width * scale),
+			       (int) (src->height * scale));
     if (!dest)
-	return NULL;
+	returnAddr(NULL);
 
     dest->size = (XcursorDim) size;
     dest->xhot = (XcursorDim) (src->xhot * scale);
@@ -651,7 +731,7 @@ _XcursorResizeImage (XcursorImage *src, int size)
 	}
     }
 
-    return dest;
+    returnAddr(dest);
 }
 
 static XcursorImage *
@@ -663,17 +743,20 @@ _XcursorXcFileLoadImage (XcursorFile *file, int size, XcursorBool resize)
     int			toc;
     XcursorImage	*image;
 
+    enterFunc((T_CALLED(_XcursorXcFileLoadImage) "(%p, %d, %d)\n",
+	      (void*)file, size, resize));
+
     if (size < 0)
-	return NULL;
+	returnAddr(NULL);
     fileHeader = _XcursorReadFileHeader (file);
     if (!fileHeader)
-	return NULL;
+	returnAddr(NULL);
     bestSize = _XcursorFindBestSize (fileHeader, (XcursorDim) size, &nsize);
     if (!bestSize)
-	return NULL;
+	returnAddr(NULL);
     toc = _XcursorFindImageToc (fileHeader, bestSize, 0);
     if (toc < 0)
-	return NULL;
+	returnAddr(NULL);
     image = _XcursorReadImage (file, fileHeader, toc);
     _XcursorFileHeaderDestroy (fileHeader);
 
@@ -684,13 +767,15 @@ _XcursorXcFileLoadImage (XcursorFile *file, int size, XcursorBool resize)
 	image = resized_image;
     }
 
-    return image;
+    returnAddr(image);
 }
 
 XcursorImage *
 XcursorXcFileLoadImage (XcursorFile *file, int size)
 {
-    return _XcursorXcFileLoadImage (file, size, XcursorFalse);
+    enterFunc((T_CALLED(XcursorXcFileLoadImage) "(%p, %d)\n", (void*)file, size));
+
+    returnAddr(_XcursorXcFileLoadImage (file, size, XcursorFalse));
 }
 
 XcursorImages *
@@ -703,22 +788,25 @@ _XcursorXcFileLoadImages (XcursorFile *file, int size, XcursorBool resize)
     int			n;
     XcursorImage        *image;
 
+    enterFunc((T_CALLED(_XcursorXcFileLoadImages) "(%p, %d, %d)\n",
+	      (void*)file, size, resize));
+
     if (!file || size < 0)
-	return NULL;
+	returnAddr(NULL);
     fileHeader = _XcursorReadFileHeader (file);
     if (!fileHeader)
-	return NULL;
+	returnAddr(NULL);
     bestSize = _XcursorFindBestSize (fileHeader, (XcursorDim) size, &nsize);
     if (!bestSize)
     {
         _XcursorFileHeaderDestroy (fileHeader);
-	return NULL;
+	returnAddr(NULL);
     }
     images = XcursorImagesCreate (nsize);
     if (!images)
     {
         _XcursorFileHeaderDestroy (fileHeader);
-	return NULL;
+	returnAddr(NULL);
     }
     for (n = 0; n < nsize; n++)
     {
@@ -744,13 +832,15 @@ _XcursorXcFileLoadImages (XcursorFile *file, int size, XcursorBool resize)
 	XcursorImagesDestroy (images);
 	images = NULL;
     }
-    return images;
+    returnAddr(images);
 }
 
 XcursorImages *
 XcursorXcFileLoadImages (XcursorFile *file, int size)
 {
-    return _XcursorXcFileLoadImages (file, size, XcursorFalse);
+    enterFunc((T_CALLED(XcursorXcFileLoadImages) "(%p, %d)\n", (void*)file, size));
+
+    returnAddr(_XcursorXcFileLoadImages (file, size, XcursorFalse));
 }
 
 XcursorImages *
@@ -763,12 +853,14 @@ XcursorXcFileLoadAllImages (XcursorFile *file)
     XcursorUInt		n;
     XcursorUInt		toc;
 
+    enterFunc((T_CALLED(XcursorXcFileLoadAllImages) "(%p)\n", (void*)file));
+
     if (!file)
-        return NULL;
+        returnAddr(NULL);
 
     fileHeader = _XcursorReadFileHeader (file);
     if (!fileHeader)
-	return NULL;
+	returnAddr(NULL);
     nimage = 0;
     for (n = 0; n < fileHeader->ntoc; n++)
     {
@@ -782,7 +874,7 @@ XcursorXcFileLoadAllImages (XcursorFile *file)
     if (!images)
     {
 	_XcursorFileHeaderDestroy (fileHeader);
-	return NULL;
+	returnAddr(NULL);
     }
     for (toc = 0; toc < fileHeader->ntoc; toc++)
     {
@@ -803,7 +895,7 @@ XcursorXcFileLoadAllImages (XcursorFile *file)
 	XcursorImagesDestroy (images);
 	images = NULL;
     }
-    return images;
+    returnAddr(images);
 }
 
 XcursorBool
@@ -820,11 +912,14 @@ XcursorXcFileLoad (XcursorFile	    *file,
     XcursorComments	*comments;
     XcursorUInt		toc;
 
+    enterFunc((T_CALLED(XcursorXcFileLoad) "(%p, %p, %p)\n",
+	      (void*)file, (void*)commentsp, (void*)imagesp));
+
     if (!file)
-        return 0;
+        returnCode(0);
     fileHeader = _XcursorReadFileHeader (file);
     if (!fileHeader)
-	return 0;
+	returnCode(0);
     nimage = 0;
     ncomment = 0;
     for (toc = 0; toc < fileHeader->ntoc; toc++)
@@ -842,14 +937,14 @@ XcursorXcFileLoad (XcursorFile	    *file,
     if (!images)
     {
 	_XcursorFileHeaderDestroy (fileHeader);
-	return 0;
+	returnCode(0);
     }
     comments = XcursorCommentsCreate (ncomment);
     if (!comments)
     {
 	_XcursorFileHeaderDestroy (fileHeader);
 	XcursorImagesDestroy (images);
-	return 0;
+	returnCode(0);
     }
     for (toc = 0; toc < fileHeader->ntoc; toc++)
     {
@@ -879,11 +974,11 @@ XcursorXcFileLoad (XcursorFile	    *file,
 	XcursorCommentsDestroy (comments);
 	images = NULL;
 	comments = NULL;
-	return XcursorFalse;
+	returnCode(XcursorFalse);
     }
     *imagesp = images;
     *commentsp = comments;
-    return XcursorTrue;
+    returnCode(XcursorTrue);
 }
 
 XcursorBool
@@ -896,12 +991,15 @@ XcursorXcFileSave (XcursorFile		    *file,
     int			n;
     int			toc;
 
+    enterFunc((T_CALLED(XcursorXcFileSave) "(%p, %p, %p)\n",
+	      (void*)file, (const void*)comments, (const void*)images));
+
     if (!file || !comments || !images)
-        return XcursorFalse;
+        returnCode(XcursorFalse);
 
     fileHeader = _XcursorFileHeaderCreate ((XcursorUInt) (comments->ncomment + images->nimage));
     if (!fileHeader)
-	return XcursorFalse;
+	returnCode(XcursorFalse);
 
     position = _XcursorFileHeaderLength (fileHeader);
 
@@ -957,10 +1055,11 @@ XcursorXcFileSave (XcursorFile		    *file,
     }
 
     _XcursorFileHeaderDestroy (fileHeader);
-    return XcursorTrue;
+    returnCode(XcursorTrue);
+
 bail:
     _XcursorFileHeaderDestroy (fileHeader);
-    return XcursorFalse;
+    returnCode(XcursorFalse);
 }
 
 static int
@@ -998,11 +1097,13 @@ _XcursorFileLoadImage (FILE *file, int size, XcursorBool resize)
 {
     XcursorFile	f;
 
+    enterFunc((T_CALLED(_XcursorFileLoadImage) "(%p, %d, %d)\n", (void*)file, size, resize));
+
     if (!file)
-        return NULL;
+        returnAddr(NULL);
 
     _XcursorStdioFileInitialize (file, &f);
-    return _XcursorXcFileLoadImage (&f, size, resize);
+    returnAddr(_XcursorXcFileLoadImage (&f, size, resize));
 }
 
 XcursorImages *
@@ -1010,11 +1111,13 @@ _XcursorFileLoadImages (FILE *file, int size, XcursorBool resize)
 {
     XcursorFile	f;
 
+    enterFunc((T_CALLED(_XcursorFileLoadImages) "(%p, %d, %d)\n", (void*)file, size, resize));
+
     if (!file)
-        return NULL;
+        returnAddr(NULL);
 
     _XcursorStdioFileInitialize (file, &f);
-    return _XcursorXcFileLoadImages (&f, size, resize);
+    returnAddr(_XcursorXcFileLoadImages (&f, size, resize));
 }
 
 XcursorImage *
@@ -1022,11 +1125,13 @@ XcursorFileLoadImage (FILE *file, int size)
 {
     XcursorFile	f;
 
+    enterFunc((T_CALLED(XcursorFileLoadImage) "(%p, %d)\n", (void*)file, size));
+
     if (!file)
-        return NULL;
+        returnAddr(NULL);
 
     _XcursorStdioFileInitialize (file, &f);
-    return XcursorXcFileLoadImage (&f, size);
+    returnAddr(XcursorXcFileLoadImage (&f, size));
 }
 
 XcursorImages *
@@ -1034,11 +1139,13 @@ XcursorFileLoadImages (FILE *file, int size)
 {
     XcursorFile	f;
 
+    enterFunc((T_CALLED(XcursorFileLoadImages) "(%p, %d)\n", (void*)file, size));
+
     if (!file)
-        return NULL;
+        returnAddr(NULL);
 
     _XcursorStdioFileInitialize (file, &f);
-    return XcursorXcFileLoadImages (&f, size);
+    returnAddr(XcursorXcFileLoadImages (&f, size));
 }
 
 XcursorImages *
@@ -1046,11 +1153,13 @@ XcursorFileLoadAllImages (FILE *file)
 {
     XcursorFile	f;
 
+    enterFunc((T_CALLED(XcursorFileLoadAllImages) "(%p)\n", (void*)file));
+
     if (!file)
-        return NULL;
+        returnAddr(NULL);
 
     _XcursorStdioFileInitialize (file, &f);
-    return XcursorXcFileLoadAllImages (&f);
+    returnAddr(XcursorXcFileLoadAllImages (&f));
 }
 
 XcursorBool
@@ -1060,11 +1169,14 @@ XcursorFileLoad (FILE		    *file,
 {
     XcursorFile	f;
 
+    enterFunc((T_CALLED(XcursorFileLoad) "(%p, %p, %p)\n",
+	       (void*)file, (void*)commentsp, (void*)imagesp));
+
     if (!file || !commentsp || !imagesp)
-        return XcursorFalse;
+        returnCode(XcursorFalse);
 
     _XcursorStdioFileInitialize (file, &f);
-    return XcursorXcFileLoad (&f, commentsp, imagesp);
+    returnCode(XcursorXcFileLoad (&f, commentsp, imagesp));
 }
 
 XcursorBool
@@ -1074,14 +1186,17 @@ XcursorFileSaveImages (FILE *file, const XcursorImages *images)
     XcursorFile	    f;
     XcursorBool	    ret;
 
+    enterFunc((T_CALLED(XcursorFileSaveImages) "(%p, %p)\n",
+	       (void*)file, (const void*)images));
+
     if (!file || !images)
-	return 0;
+	returnCode(0);
     if ((comments = XcursorCommentsCreate (0)) == NULL)
-	return 0;
+	returnCode(0);
     _XcursorStdioFileInitialize (file, &f);
     ret = XcursorXcFileSave (&f, comments, images) && fflush (file) != EOF;
     XcursorCommentsDestroy (comments);
-    return ret;
+    returnCode(ret);
 }
 
 XcursorBool
@@ -1091,11 +1206,14 @@ XcursorFileSave (FILE *			file,
 {
     XcursorFile	    f;
 
+    enterFunc((T_CALLED(_XcursorFileSave) "(%p, %p, %p)\n",
+	       (void*)file, (const void*)comments, (const void*)images));
+
     if (!file || !comments || !images)
-        return XcursorFalse;
+        returnCode(XcursorFalse);
 
     _XcursorStdioFileInitialize (file, &f);
-    return XcursorXcFileSave (&f, comments, images) && fflush (file) != EOF;
+    returnCode(XcursorXcFileSave (&f, comments, images) && fflush (file) != EOF);
 }
 
 XcursorImage *
@@ -1104,15 +1222,18 @@ XcursorFilenameLoadImage (const char *file, int size)
     FILE	    *f;
     XcursorImage    *image;
 
+    enterFunc((T_CALLED(XcursorFilenameLoadImage) "(\"%s\", %d)\n",
+	      NonNull(file), size));
+
     if (!file || size < 0)
-        return NULL;
+        returnAddr(NULL);
 
     f = fopen (file, "r" FOPEN_CLOEXEC);
     if (!f)
-	return NULL;
+	returnAddr(NULL);
     image = XcursorFileLoadImage (f, size);
     fclose (f);
-    return image;
+    returnAddr(image);
 }
 
 XcursorImages *
@@ -1121,15 +1242,18 @@ _XcursorFilenameLoadImages (const char *file, int size, XcursorBool resize)
     FILE	    *f;
     XcursorImages   *images;
 
+    enterFunc((T_CALLED(_XcursorFilenameLoadImages) "(\"%s\", %d, %d)\n",
+	      NonNull(file), size, resize));
+
     if (!file || size < 0)
-        return NULL;
+        returnAddr(NULL);
 
     f = fopen (file, "r" FOPEN_CLOEXEC);
     if (!f)
-	return NULL;
+	returnAddr(NULL);
     images = _XcursorFileLoadImages (f, size, resize);
     fclose (f);
-    return images;
+    returnAddr(images);
 }
 
 XcursorImages *
@@ -1138,15 +1262,18 @@ XcursorFilenameLoadImages (const char *file, int size)
     FILE	    *f;
     XcursorImages   *images;
 
+    enterFunc((T_CALLED(XcursorFilenameLoadImages) "(\"%s\", %d)\n",
+	      NonNull(file), size));
+
     if (!file || size < 0)
-        return NULL;
+        returnAddr(NULL);
 
     f = fopen (file, "r" FOPEN_CLOEXEC);
     if (!f)
-	return NULL;
+	returnAddr(NULL);
     images = XcursorFileLoadImages (f, size);
     fclose (f);
-    return images;
+    returnAddr(images);
 }
 
 XcursorImages *
@@ -1155,15 +1282,18 @@ XcursorFilenameLoadAllImages (const char *file)
     FILE	    *f;
     XcursorImages   *images;
 
+    enterFunc((T_CALLED(XcursorFilenameLoadAllImages) "(\"%s\")\n",
+	      NonNull(file)));
+
     if (!file)
-        return NULL;
+        returnAddr(NULL);
 
     f = fopen (file, "r" FOPEN_CLOEXEC);
     if (!f)
-	return NULL;
+	returnAddr(NULL);
     images = XcursorFileLoadAllImages (f);
     fclose (f);
-    return images;
+    returnAddr(images);
 }
 
 XcursorBool
@@ -1174,15 +1304,18 @@ XcursorFilenameLoad (const char		*file,
     FILE	    *f;
     XcursorBool	    ret;
 
+    enterFunc((T_CALLED() "(\"%s\", %p, %p)\n",
+	      NonNull(file), (void*)commentsp, (void*)imagesp));
+
     if (!file)
-        return XcursorFalse;
+        returnCode(XcursorFalse);
 
     f = fopen (file, "r" FOPEN_CLOEXEC);
     if (!f)
-	return 0;
+	returnCode(0);
     ret = XcursorFileLoad (f, commentsp, imagesp);
     fclose (f);
-    return ret;
+    returnCode(ret);
 }
 
 XcursorBool
@@ -1191,14 +1324,17 @@ XcursorFilenameSaveImages (const char *file, const XcursorImages *images)
     FILE	    *f;
     XcursorBool	    ret;
 
+    enterFunc((T_CALLED(XcursorFilenameSaveImages) "(\"%s\", %p)\n",
+	      NonNull(file), (const void*)images));
+
     if (!file || !images)
-        return XcursorFalse;
+        returnCode(XcursorFalse);
 
     f = fopen (file, "w" FOPEN_CLOEXEC);
     if (!f)
-	return 0;
+	returnCode(0);
     ret = XcursorFileSaveImages (f, images);
-    return fclose (f) != EOF && ret;
+    returnCode(fclose (f) != EOF && ret);
 }
 
 XcursorBool
@@ -1209,12 +1345,21 @@ XcursorFilenameSave (const char		    *file,
     FILE	    *f;
     XcursorBool	    ret;
 
-    if (!file || !comments || !images)
-        return XcursorFalse;
-
-    f = fopen (file, "w" FOPEN_CLOEXEC);
-    if (!f)
-	return 0;
-    ret = XcursorFileSave (f, comments, images);
-    return fclose (f) != EOF && ret;
+    enterFunc((T_CALLED(XcursorFilenameSave ) "(\"%s\", %p, %p)\n",
+    		NonNull(file),
+		(const void *) comments,
+		(const void *) images));
+
+    if (!file || !comments || !images) {
+        ret = XcursorFalse;
+    } else {
+	f = fopen (file, "w" FOPEN_CLOEXEC);
+	if (!f) {
+	    ret = 0;
+	} else {
+	    ret = XcursorFileSave (f, comments, images);
+	    ret = fclose (f) != EOF && ret;
+	}
+    }
+    returnCode(ret);
 }
diff --git a/src/xcursorint.h b/src/xcursorint.h
index 28b2718..2ece011 100644
--- a/src/xcursorint.h
+++ b/src/xcursorint.h
@@ -125,4 +125,27 @@ _XcursorFileLoadImages (FILE *file, int size, XcursorBool resize);
 XcursorImages *
 _XcursorFilenameLoadImages (const char *file, int size, XcursorBool resize);
 
+#ifdef DEBUG_XCURSOR
+void     _XcursorTrace(const char *fmt, ...) __attribute__((format(printf,1,2)));
+unsigned _XcursorReturnUint(unsigned code);
+int      _XcursorReturnCode(int code);
+void    *_XcursorReturnAddr(void *addr);
+void     _XcursorReturnVoid(void);
+#define T_CALLED(func) "called: { " #func
+#define T_RETURN(form) "return: } %" #form "\n"
+#define enterFunc(params) _XcursorTrace params
+#define returnUint(code) return _XcursorReturnUint(code)
+#define returnCode(code) return _XcursorReturnCode(code)
+#define returnAddr(addr) return _XcursorReturnAddr(addr)
+#define returnVoid()     do { _XcursorReturnVoid(); return; } while (0)
+#else
+#define enterFunc(params) /* nothing */
+#define returnUint(code) return (code)
+#define returnCode(code) return (code)
+#define returnAddr(addr) return (addr)
+#define returnVoid()     return
+#endif
+
+#define NonNull(p) ((p) != NULL ? (p) : "<null>")
+
 #endif /* _XCURSORINT_H_ */