mirror of
https://gitlab.freedesktop.org/xorg/lib/libxcursor.git
synced 2025-12-20 05:50:14 +01:00
add debug-logging for file.c, to help with analysis
Signed-off-by: Thomas E. Dickey <dickey@invisible-island.net>
This commit is contained in:
Thomas E. Dickey
parent
8a1de72216
commit
fbfe95e05f
2 changed files with 318 additions and 150 deletions
445
src/file.c
445
src/file.c
|
|
@ -25,33 +25,84 @@
|
|||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifdef DEBUG_XCURSOR
|
||||
#include <stdarg.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
void _XcursorTrace(const char *fmt, ...)
|
||||
{
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
unsigned _XcursorReturnUint(unsigned code)
|
||||
{
|
||||
_XcursorTrace(T_RETURN(u), code);
|
||||
return code;
|
||||
}
|
||||
|
||||
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;
|
||||
XcursorImage *image = NULL;
|
||||
|
||||
if (width < 0 || height < 0)
|
||||
return NULL;
|
||||
if (width > XCURSOR_IMAGE_MAX_SIZE || height > XCURSOR_IMAGE_MAX_SIZE)
|
||||
return NULL;
|
||||
enterFunc((T_CALLED(XcursorImageCreate) "(%d, %d)\n", width, height));
|
||||
|
||||
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;
|
||||
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;
|
||||
if (images && name) {
|
||||
char *new = strdup (name);
|
||||
|
||||
new = strdup (name);
|
||||
if (new) {
|
||||
if (images->name)
|
||||
free (images->name);
|
||||
images->name = new;
|
||||
}
|
||||
}
|
||||
|
||||
if (!new)
|
||||
return;
|
||||
|
||||
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)
|
||||
{
|
||||
if (!image)
|
||||
return 0;
|
||||
enterFunc((T_CALLED(_XcursorImageLength) "(%p)\n", (void*)image));
|
||||
|
||||
return XCURSOR_IMAGE_HEADER_LEN + (image->width * image->height) * 4;
|
||||
if (!image)
|
||||
returnUint(0);
|
||||
|
||||
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;
|
||||
enterFunc((T_CALLED(XcursorFilenameSave ) "(\"%s\", %p, %p)\n",
|
||||
NonNull(file),
|
||||
(const void *) comments,
|
||||
(const void *) images));
|
||||
|
||||
f = fopen (file, "w" FOPEN_CLOEXEC);
|
||||
if (!f)
|
||||
return 0;
|
||||
ret = XcursorFileSave (f, comments, images);
|
||||
return fclose (f) != EOF && ret;
|
||||
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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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_ */
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue