Use __func__ instead of open coded function names

We are already requiring C99, at least since the recent initial context
changes.

1 files changed, 169 insertions, 246 deletions

diff --git a/src/lib/api.c b/src/lib/api.c
index a5f2ab5..83ad2eb 100644
--- a/src/lib/api.c
+++ b/src/lib/api.c
@@ -32,7 +32,7 @@
 
 /* convenience macros */
 #define   CAST_IMAGE(im, image) (im) = (ImlibImage *)(image)
-#define   CHECK_PARAM_POINTER_RETURN(func, sparam, param, ret) \
+#define   CHECK_PARAM_POINTER_RETURN(sparam, param, ret) \
 if (!(param)) \
 { \
   fprintf(stderr, "***** Imlib2 Developer Warning ***** :\n" \
@@ -40,11 +40,11 @@ if (!(param)) \
                   "\t%s();\n\n" \
                   "\tWith the parameter:\n\n" \
                   "\t%s\n\n" \
-                  "\tbeing NULL. Please fix your program.\n", func, sparam); \
+                  "\tbeing NULL. Please fix your program.\n", __func__, sparam); \
   return ret; \
 }
 
-#define   CHECK_PARAM_POINTER(func, sparam, param) \
+#define   CHECK_PARAM_POINTER(sparam, param) \
 if (!(param)) \
 { \
   fprintf(stderr, "***** Imlib2 Developer Warning ***** :\n" \
@@ -52,7 +52,7 @@ if (!(param)) \
                   "\t%s();\n\n" \
                   "\tWith the parameter:\n\n" \
                   "\t%s\n\n" \
-                  "\tbeing NULL. Please fix your program.\n", func, sparam); \
+                  "\tbeing NULL. Please fix your program.\n", __func__, sparam); \
   return; \
 }
 
@@ -190,7 +190,7 @@ imlib_context_free(Imlib_Context context)
 {
    ImlibContext       *c = (ImlibContext *) context;
 
-   CHECK_PARAM_POINTER("imlib_context_free", "context", context);
+   CHECK_PARAM_POINTER("context", context);
    if (c == ctx && !contexts->below)
       return;
 
@@ -205,7 +205,7 @@ imlib_context_push(Imlib_Context context)
 {
    ImlibContextItem   *item;
 
-   CHECK_PARAM_POINTER("imlib_context_push", "context", context);
+   CHECK_PARAM_POINTER("context", context);
    ctx = (ImlibContext *) context;
 
    item = malloc(sizeof(ImlibContextItem));
@@ -1161,8 +1161,8 @@ imlib_flush_loaders(void)
 EAPI int
 imlib_get_visual_depth(Display * display, Visual * visual)
 {
-   CHECK_PARAM_POINTER_RETURN("imlib_get_visual_depth", "display", display, 0);
-   CHECK_PARAM_POINTER_RETURN("imlib_get_visual_depth", "visual", visual, 0);
+   CHECK_PARAM_POINTER_RETURN("display", display, 0);
+   CHECK_PARAM_POINTER_RETURN("visual", visual, 0);
    return __imlib_XActualDepth(display, visual);
 }
 
@@ -1180,10 +1180,8 @@ imlib_get_visual_depth(Display * display, Visual * visual)
 EAPI Visual        *
 imlib_get_best_visual(Display * display, int screen, int *depth_return)
 {
-   CHECK_PARAM_POINTER_RETURN("imlib_get_best_visual", "display", display,
-                              NULL);
-   CHECK_PARAM_POINTER_RETURN("imlib_get_best_visual", "depth_return",
-                              depth_return, NULL);
+   CHECK_PARAM_POINTER_RETURN("display", display, NULL);
+   CHECK_PARAM_POINTER_RETURN("depth_return", depth_return, NULL);
    return __imlib_BestVisual(display, screen, depth_return);
 }
 #endif
@@ -1201,7 +1199,7 @@ imlib_load_image(const char *file)
 {
    Imlib_Image         im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_load_image", "file", file, NULL);
+   CHECK_PARAM_POINTER_RETURN("file", file, NULL);
 
    im = __imlib_LoadImage(file, NULL,
                           (ImlibProgressFunction) ctx->progress_func,
@@ -1224,8 +1222,7 @@ imlib_load_image_immediately(const char *file)
 {
    Imlib_Image         im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_load_image_immediately", "file", file,
-                              NULL);
+   CHECK_PARAM_POINTER_RETURN("file", file, NULL);
 
    im = __imlib_LoadImage(file, NULL,
                           (ImlibProgressFunction) ctx->progress_func,
@@ -1246,8 +1243,7 @@ imlib_load_image_without_cache(const char *file)
 {
    Imlib_Image         im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_load_image_without_cache", "file",
-                              file, NULL);
+   CHECK_PARAM_POINTER_RETURN("file", file, NULL);
 
    im = __imlib_LoadImage(file, NULL,
                           (ImlibProgressFunction) ctx->progress_func,
@@ -1269,8 +1265,7 @@ imlib_load_image_immediately_without_cache(const char *file)
 {
    Imlib_Image         im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_load_image_immediately_without_cache",
-                              "file", file, NULL);
+   CHECK_PARAM_POINTER_RETURN("file", file, NULL);
 
    im = __imlib_LoadImage(file, NULL,
                           (ImlibProgressFunction) ctx->progress_func,
@@ -1298,7 +1293,7 @@ imlib_load_image_fd(int fd, const char *file)
    Imlib_Image         im;
    FILE               *fp;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_load_image_fd", "file", file, NULL);
+   CHECK_PARAM_POINTER_RETURN("file", file, NULL);
 
    fp = fdopen(fd, "rb");
    if (fp)
@@ -1333,8 +1328,7 @@ imlib_load_image_with_error_return(const char *file,
    Imlib_Image         im;
    ImlibLoadError      er;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_load_image_with_error_return", "file",
-                              file, NULL);
+   CHECK_PARAM_POINTER_RETURN("file", file, NULL);
 
    im = __imlib_LoadImage(file, NULL,
                           (ImlibProgressFunction) ctx->progress_func,
@@ -1359,7 +1353,7 @@ imlib_load_image_with_error_return(const char *file,
 EAPI void
 imlib_free_image(void)
 {
-   CHECK_PARAM_POINTER("imlib_free_image", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    __imlib_FreeImage(ctx->image);
    ctx->image = NULL;
 }
@@ -1373,7 +1367,7 @@ imlib_free_image_and_decache(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_free_image_and_decache", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    SET_FLAG(im->flags, F_INVALID);
    __imlib_FreeImage(im);
@@ -1388,7 +1382,7 @@ imlib_image_get_width(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_image_get_width", "image", ctx->image, 0);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, 0);
    CAST_IMAGE(im, ctx->image);
    return im->w;
 }
@@ -1401,7 +1395,7 @@ imlib_image_get_height(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_image_get_height", "image", ctx->image, 0);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, 0);
    CAST_IMAGE(im, ctx->image);
    return im->h;
 }
@@ -1422,8 +1416,7 @@ imlib_image_get_filename(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_image_get_filename", "image", ctx->image,
-                              0);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, 0);
    CAST_IMAGE(im, ctx->image);
    /* strdup() the returned value if you want to alter it! */
    return (const char *)(im->file);
@@ -1451,8 +1444,7 @@ imlib_image_get_data(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_image_get_data", "image", ctx->image,
-                              NULL);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, NULL);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return NULL;
@@ -1473,8 +1465,7 @@ imlib_image_get_data_for_reading_only(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_image_get_data_for_reading_only",
-                              "image", ctx->image, NULL);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, NULL);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return NULL;
@@ -1494,8 +1485,8 @@ imlib_image_put_back_data(DATA32 * data)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_put_back_data", "image", ctx->image);
-   CHECK_PARAM_POINTER("imlib_image_put_back_data", "data", data);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("data", data);
    CAST_IMAGE(im, ctx->image);
    __imlib_DirtyImage(im);
    data = NULL;
@@ -1513,7 +1504,7 @@ imlib_image_has_alpha(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_image_has_alpha", "image", ctx->image, 0);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, 0);
    CAST_IMAGE(im, ctx->image);
    if (IMAGE_HAS_ALPHA(im))
       return 1;
@@ -1534,8 +1525,7 @@ imlib_image_set_changes_on_disk(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_set_never_changes_on_disk", "image",
-                       ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    SET_FLAG(im->flags, F_ALWAYS_CHECK_DISK);
 }
@@ -1555,8 +1545,8 @@ imlib_image_get_border(Imlib_Border * border)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_get_border", "image", ctx->image);
-   CHECK_PARAM_POINTER("imlib_image_get_border", "border", border);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("border", border);
    CAST_IMAGE(im, ctx->image);
    border->left = im->border.left;
    border->right = im->border.right;
@@ -1575,8 +1565,8 @@ imlib_image_set_border(Imlib_Border * border)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_set_border", "image", ctx->image);
-   CHECK_PARAM_POINTER("imlib_image_set_border", "border", border);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("border", border);
    CAST_IMAGE(im, ctx->image);
    if ((im->border.left == border->left)
        && (im->border.right == border->right)
@@ -1604,8 +1594,8 @@ imlib_image_set_format(const char *format)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_set_format", "image", ctx->image);
-   CHECK_PARAM_POINTER("imlib_image_set_format", "format", format);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("format", format);
    CAST_IMAGE(im, ctx->image);
    free(im->format);
    im->format = (format) ? strdup(format) : NULL;
@@ -1627,8 +1617,7 @@ imlib_image_set_irrelevant_format(char irrelevant)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_set_irrelevant_format", "image",
-                       ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    UPDATE_FLAG(im->flags, F_FORMAT_IRRELEVANT, irrelevant);
 }
@@ -1645,8 +1634,7 @@ imlib_image_set_irrelevant_border(char irrelevant)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_set_irrelevant_border", "image",
-                       ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    UPDATE_FLAG(im->flags, F_BORDER_IRRELEVANT, irrelevant);
 }
@@ -1664,7 +1652,7 @@ imlib_image_set_irrelevant_alpha(char irrelevant)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_set_irrelevant_alpha", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    UPDATE_FLAG(im->flags, F_ALPHA_IRRELEVANT, irrelevant);
 }
@@ -1680,7 +1668,7 @@ imlib_image_format(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_image_format", "image", ctx->image, NULL);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, NULL);
    CAST_IMAGE(im, ctx->image);
    return im->format;
 }
@@ -1696,7 +1684,7 @@ imlib_image_set_has_alpha(char has_alpha)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_set_has_alpha", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    UPDATE_FLAG(im->flags, F_HAS_ALPHA, has_alpha);
 }
@@ -1717,10 +1705,8 @@ imlib_render_pixmaps_for_whole_image(Pixmap * pixmap_return,
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_render_pixmaps_for_whole_image", "image",
-                       ctx->image);
-   CHECK_PARAM_POINTER("imlib_render_pixmaps_for_whole_image",
-                       "pixmap_return", pixmap_return);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("pixmap_return", pixmap_return);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -1751,10 +1737,8 @@ imlib_render_pixmaps_for_whole_image_at_size(Pixmap * pixmap_return,
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_render_pixmaps_for_whole_image_at_size",
-                       "image", ctx->image);
-   CHECK_PARAM_POINTER("imlib_render_pixmaps_for_whole_image_at_size",
-                       "pixmap_return", pixmap_return);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("pixmap_return", pixmap_return);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -1791,7 +1775,7 @@ imlib_render_image_on_drawable(int x, int y)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_render_image_on_drawable", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -1817,8 +1801,7 @@ imlib_render_image_on_drawable_at_size(int x, int y, int width, int height)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_render_image_on_drawable_at_size", "image",
-                       ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -1853,8 +1836,7 @@ imlib_render_image_part_on_drawable_at_size(int source_x, int source_y,
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_render_image_part_on_drawable_at_size", "image",
-                       ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -1908,9 +1890,8 @@ imlib_blend_image_onto_image(Imlib_Image source_image, char merge_alpha,
    ImlibImage         *im_src, *im_dst;
    int                 aa;
 
-   CHECK_PARAM_POINTER("imlib_blend_image_onto_image", "source_image",
-                       source_image);
-   CHECK_PARAM_POINTER("imlib_blend_image_onto_image", "image", ctx->image);
+   CHECK_PARAM_POINTER("source_image", source_image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im_src, source_image);
    CAST_IMAGE(im_dst, ctx->image);
    if (__imlib_LoadImageData(im_src))
@@ -1979,8 +1960,7 @@ imlib_create_image_using_data(int width, int height, DATA32 * data)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_create_image_using_data", "data", data,
-                              NULL);
+   CHECK_PARAM_POINTER_RETURN("data", data, NULL);
    if (!IMAGE_DIMENSIONS_OK(width, height))
       return NULL;
    im = __imlib_CreateImage(width, height, data);
@@ -2009,8 +1989,7 @@ EAPI                Imlib_Image
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER_RETURN
-      ("imlib_create_image_using_data_and_memory_function", "data", data, NULL);
+   CHECK_PARAM_POINTER_RETURN("data", data, NULL);
    if (!IMAGE_DIMENSIONS_OK(width, height))
       return NULL;
    im = __imlib_CreateImage(width, height, data);
@@ -2038,8 +2017,7 @@ imlib_create_image_using_copied_data(int width, int height, DATA32 * data)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_create_image_using_copied_data", "data",
-                              data, NULL);
+   CHECK_PARAM_POINTER_RETURN("data", data, NULL);
    if (!IMAGE_DIMENSIONS_OK(width, height))
       return NULL;
    im = __imlib_CreateImage(width, height, NULL);
@@ -2230,8 +2208,7 @@ imlib_copy_drawable_to_image(Pixmap mask, int x, int y, int width, int height,
    char                domask = 0;
    int                 pre_adj;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_copy_drawable_to_image", "image",
-                              ctx->image, 0);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, 0);
    if (mask)
      {
         domask = 1;
@@ -2302,7 +2279,7 @@ imlib_clone_image(void)
 {
    ImlibImage         *im, *im_old;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_clone_image", "image", ctx->image, NULL);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, NULL);
    CAST_IMAGE(im_old, ctx->image);
    if (__imlib_LoadImageData(im_old))
       return NULL;
@@ -2349,8 +2326,7 @@ imlib_create_cropped_image(int x, int y, int width, int height)
 {
    ImlibImage         *im, *im_old;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_create_cropped_image", "image",
-                              ctx->image, NULL);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, NULL);
    if (!IMAGE_DIMENSIONS_OK(abs(width), abs(height)))
       return NULL;
    CAST_IMAGE(im_old, ctx->image);
@@ -2404,8 +2380,7 @@ imlib_create_cropped_scaled_image(int source_x, int source_y,
 {
    ImlibImage         *im, *im_old;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_create_cropped_scaled_image", "image",
-                              ctx->image, NULL);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, NULL);
    if (!IMAGE_DIMENSIONS_OK(abs(destination_width), abs(destination_height)))
       return NULL;
    CAST_IMAGE(im_old, ctx->image);
@@ -2565,7 +2540,7 @@ imlib_updates_get_coordinates(Imlib_Updates updates, int *x_return,
 {
    ImlibUpdate        *u;
 
-   CHECK_PARAM_POINTER("imlib_updates_get_coordinates", "updates", updates);
+   CHECK_PARAM_POINTER("updates", updates);
    u = (ImlibUpdate *) updates;
    if (x_return)
       *x_return = u->x;
@@ -2592,7 +2567,7 @@ imlib_updates_set_coordinates(Imlib_Updates updates, int x, int y, int width,
 {
    ImlibUpdate        *u;
 
-   CHECK_PARAM_POINTER("imlib_updates_set_coordinates", "updates", updates);
+   CHECK_PARAM_POINTER("updates", updates);
    u = (ImlibUpdate *) updates;
    u->x = x;
    u->y = y;
@@ -2617,8 +2592,7 @@ imlib_render_image_updates_on_drawable(Imlib_Updates updates, int x, int y)
    ImlibImage         *im;
    int                 ximcs;
 
-   CHECK_PARAM_POINTER("imlib_render_image_updates_on_drawable", "image",
-                       ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    u = (ImlibUpdate *) updates;
    if (!updates)
@@ -2692,7 +2666,7 @@ imlib_image_flip_horizontal(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_flip_horizontal", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -2708,7 +2682,7 @@ imlib_image_flip_vertical(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_flip_vertical", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -2726,7 +2700,7 @@ imlib_image_flip_diagonal(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_flip_diagonal", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -2747,7 +2721,7 @@ imlib_image_orientate(int orientation)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_orientate", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -2793,7 +2767,7 @@ imlib_image_blur(int radius)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_blur", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -2813,7 +2787,7 @@ imlib_image_sharpen(int radius)
    ImlibImage         *im;
 
    CAST_IMAGE(im, ctx->image);
-   CHECK_PARAM_POINTER("imlib_image_sharpen", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    if (__imlib_LoadImageData(im))
       return;
    __imlib_DirtyImage(im);
@@ -2829,7 +2803,7 @@ imlib_image_tile_horizontal(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_tile_horizontal", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -2846,7 +2820,7 @@ imlib_image_tile_vertical(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_tile_vertical", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -2864,7 +2838,7 @@ imlib_image_tile(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_tile", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -2896,7 +2870,7 @@ imlib_load_font(const char *font_name)
 EAPI void
 imlib_free_font(void)
 {
-   CHECK_PARAM_POINTER("imlib_free_font", "font", ctx->font);
+   CHECK_PARAM_POINTER("font", ctx->font);
    imlib_remove_font_from_fallback_chain(ctx->font);
    __imlib_font_free(ctx->font);
    ctx->font = NULL;
@@ -2921,10 +2895,8 @@ imlib_free_font(void)
 EAPI int
 imlib_insert_font_into_fallback_chain(Imlib_Font font, Imlib_Font fallback_font)
 {
-   CHECK_PARAM_POINTER_RETURN("imlib_insert_font_into_fallback_chain",
-                              "font", font, 1);
-   CHECK_PARAM_POINTER_RETURN("imlib_insert_font_into_fallback_chain",
-                              "fallback_font", fallback_font, 1);
+   CHECK_PARAM_POINTER_RETURN("font", font, 1);
+   CHECK_PARAM_POINTER_RETURN("fallback_font", fallback_font, 1);
    return __imlib_font_insert_into_fallback_chain_imp(font, fallback_font);
 }
 
@@ -2941,8 +2913,7 @@ imlib_insert_font_into_fallback_chain(Imlib_Font font, Imlib_Font fallback_font)
 EAPI void
 imlib_remove_font_from_fallback_chain(Imlib_Font fallback_font)
 {
-   CHECK_PARAM_POINTER("imlib_remove_font_from_fallback_chain",
-                       "fallback_font", fallback_font);
+   CHECK_PARAM_POINTER("fallback_font", fallback_font);
    __imlib_font_remove_from_fallback_chain_imp(fallback_font);
 }
 
@@ -2952,8 +2923,7 @@ imlib_remove_font_from_fallback_chain(Imlib_Font fallback_font)
 EAPI                Imlib_Font
 imlib_get_prev_font_in_fallback_chain(Imlib_Font fn)
 {
-   CHECK_PARAM_POINTER_RETURN("imlib_get_prev_font_in_fallback_chain",
-                              "fn", fn, 0);
+   CHECK_PARAM_POINTER_RETURN("fn", fn, 0);
    return ((ImlibFont *) fn)->fallback_prev;
 }
 
@@ -2963,8 +2933,7 @@ imlib_get_prev_font_in_fallback_chain(Imlib_Font fn)
 EAPI                Imlib_Font
 imlib_get_next_font_in_fallback_chain(Imlib_Font fn)
 {
-   CHECK_PARAM_POINTER_RETURN("imlib_get_next_font_in_fallback_chain",
-                              "fn", fn, 0);
+   CHECK_PARAM_POINTER_RETURN("fn", fn, 0);
    return ((ImlibFont *) fn)->fallback_next;
 }
 
@@ -3009,11 +2978,9 @@ imlib_text_draw_with_return_metrics(int x, int y, const char *text,
    ImlibFont          *fn;
    int                 dir;
 
-   CHECK_PARAM_POINTER("imlib_text_draw_with_return_metrics", "font",
-                       ctx->font);
-   CHECK_PARAM_POINTER("imlib_text_draw_with_return_metrics", "image",
-                       ctx->image);
-   CHECK_PARAM_POINTER("imlib_text_draw_with_return_metrics", "text", text);
+   CHECK_PARAM_POINTER("font", ctx->font);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("text", text);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -3047,8 +3014,8 @@ imlib_get_text_size(const char *text, int *width_return, int *height_return)
    int                 w, h;
    int                 dir;
 
-   CHECK_PARAM_POINTER("imlib_get_text_size", "font", ctx->font);
-   CHECK_PARAM_POINTER("imlib_get_text_size", "text", text);
+   CHECK_PARAM_POINTER("font", ctx->font);
+   CHECK_PARAM_POINTER("text", text);
    fn = (ImlibFont *) ctx->font;
 
    dir = ctx->direction;
@@ -3150,8 +3117,8 @@ imlib_get_text_advance(const char *text, int *horizontal_advance_return,
    ImlibFont          *fn;
    int                 w, h;
 
-   CHECK_PARAM_POINTER("imlib_get_text_advance", "font", ctx->font);
-   CHECK_PARAM_POINTER("imlib_get_text_advance", "text", text);
+   CHECK_PARAM_POINTER("font", ctx->font);
+   CHECK_PARAM_POINTER("text", text);
    fn = (ImlibFont *) ctx->font;
    __imlib_font_query_advance(fn, text, &w, &h);
    if (horizontal_advance_return)
@@ -3173,8 +3140,8 @@ imlib_get_text_inset(const char *text)
 {
    ImlibFont          *fn;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_get_text_advance", "font", ctx->font, 0);
-   CHECK_PARAM_POINTER_RETURN("imlib_get_text_advance", "text", text, 0);
+   CHECK_PARAM_POINTER_RETURN("font", ctx->font, 0);
+   CHECK_PARAM_POINTER_RETURN("text", text, 0);
    fn = (ImlibFont *) ctx->font;
    return __imlib_font_query_inset(fn, text);
 }
@@ -3188,7 +3155,7 @@ imlib_get_text_inset(const char *text)
 EAPI void
 imlib_add_path_to_font_path(const char *path)
 {
-   CHECK_PARAM_POINTER("imlib_add_path_to_font_path", "path", path);
+   CHECK_PARAM_POINTER("path", path);
    if (!__imlib_font_path_exists(path))
       __imlib_font_add_font_path(path);
 }
@@ -3201,7 +3168,7 @@ imlib_add_path_to_font_path(const char *path)
 EAPI void
 imlib_remove_path_from_font_path(const char *path)
 {
-   CHECK_PARAM_POINTER("imlib_remove_path_from_font_path", "path", path);
+   CHECK_PARAM_POINTER("path", path);
    __imlib_font_del_font_path(path);
 }
 
@@ -3220,8 +3187,7 @@ imlib_remove_path_from_font_path(const char *path)
 EAPI char         **
 imlib_list_font_path(int *number_return)
 {
-   CHECK_PARAM_POINTER_RETURN("imlib_list_font_path", "number_return",
-                              number_return, NULL);
+   CHECK_PARAM_POINTER_RETURN("number_return", number_return, NULL);
    return __imlib_font_list_font_path(number_return);
 }
 
@@ -3253,10 +3219,8 @@ imlib_text_get_index_and_location(const char *text, int x, int y,
    int                 w, h, cx, cy, cw, ch, cp, xx, yy;
    int                 dir;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_text_get_index_and_location", "font",
-                              ctx->font, -1);
-   CHECK_PARAM_POINTER_RETURN("imlib_text_get_index_and_location", "text",
-                              text, -1);
+   CHECK_PARAM_POINTER_RETURN("font", ctx->font, -1);
+   CHECK_PARAM_POINTER_RETURN("text", text, -1);
    fn = (ImlibFont *) ctx->font;
 
    dir = ctx->direction;
@@ -3364,8 +3328,8 @@ imlib_text_get_location_at_index(const char *text, int index,
    ImlibFont          *fn;
    int                 cx, cy, cw, ch, w, h;
 
-   CHECK_PARAM_POINTER("imlib_text_get_index_and_location", "font", ctx->font);
-   CHECK_PARAM_POINTER("imlib_text_get_index_and_location", "text", text);
+   CHECK_PARAM_POINTER("font", ctx->font);
+   CHECK_PARAM_POINTER("text", text);
    fn = (ImlibFont *) ctx->font;
 
    __imlib_font_query_char_coords(fn, text, index, &cx, &cy, &cw, &ch);
@@ -3437,8 +3401,7 @@ imlib_text_get_location_at_index(const char *text, int index,
 EAPI char         **
 imlib_list_fonts(int *number_return)
 {
-   CHECK_PARAM_POINTER_RETURN("imlib_list_fonts", "number_return",
-                              number_return, NULL);
+   CHECK_PARAM_POINTER_RETURN("number_return", number_return, NULL);
    return __imlib_font_list_fonts(number_return);
 }
 
@@ -3500,7 +3463,7 @@ imlib_flush_font_cache(void)
 EAPI int
 imlib_get_font_ascent(void)
 {
-   CHECK_PARAM_POINTER_RETURN("imlib_get_font_ascent", "font", ctx->font, 0);
+   CHECK_PARAM_POINTER_RETURN("font", ctx->font, 0);
    return __imlib_font_ascent_get(ctx->font);
 }
 
@@ -3513,7 +3476,7 @@ imlib_get_font_ascent(void)
 EAPI int
 imlib_get_font_descent(void)
 {
-   CHECK_PARAM_POINTER_RETURN("imlib_get_font_ascent", "font", ctx->font, 0);
+   CHECK_PARAM_POINTER_RETURN("font", ctx->font, 0);
    return __imlib_font_descent_get(ctx->font);
 }
 
@@ -3526,7 +3489,7 @@ imlib_get_font_descent(void)
 EAPI int
 imlib_get_maximum_font_ascent(void)
 {
-   CHECK_PARAM_POINTER_RETURN("imlib_get_font_ascent", "font", ctx->font, 0);
+   CHECK_PARAM_POINTER_RETURN("font", ctx->font, 0);
    return __imlib_font_max_ascent_get(ctx->font);
 }
 
@@ -3539,7 +3502,7 @@ imlib_get_maximum_font_ascent(void)
 EAPI int
 imlib_get_maximum_font_descent(void)
 {
-   CHECK_PARAM_POINTER_RETURN("imlib_get_font_ascent", "font", ctx->font, 0);
+   CHECK_PARAM_POINTER_RETURN("font", ctx->font, 0);
    return __imlib_font_max_descent_get(ctx->font);
 }
 
@@ -3562,8 +3525,7 @@ imlib_create_color_modifier(void)
 EAPI void
 imlib_free_color_modifier(void)
 {
-   CHECK_PARAM_POINTER("imlib_free_color_modifier", "color_modifier",
-                       ctx->color_modifier);
+   CHECK_PARAM_POINTER("color_modifier", ctx->color_modifier);
    __imlib_FreeCmod((ImlibColorModifier *) ctx->color_modifier);
    ctx->color_modifier = NULL;
 }
@@ -3580,8 +3542,7 @@ imlib_free_color_modifier(void)
 EAPI void
 imlib_modify_color_modifier_gamma(double gamma_value)
 {
-   CHECK_PARAM_POINTER("imlib_modify_color_modifier_gamma", "color_modifier",
-                       ctx->color_modifier);
+   CHECK_PARAM_POINTER("color_modifier", ctx->color_modifier);
    __imlib_CmodModGamma((ImlibColorModifier *) ctx->color_modifier,
                         gamma_value);
 }
@@ -3599,8 +3560,7 @@ imlib_modify_color_modifier_gamma(double gamma_value)
 EAPI void
 imlib_modify_color_modifier_brightness(double brightness_value)
 {
-   CHECK_PARAM_POINTER("imlib_modify_color_modifier_brightness",
-                       "color_modifier", ctx->color_modifier);
+   CHECK_PARAM_POINTER("color_modifier", ctx->color_modifier);
    __imlib_CmodModBrightness((ImlibColorModifier *) ctx->color_modifier,
                              brightness_value);
 }
@@ -3616,8 +3576,7 @@ imlib_modify_color_modifier_brightness(double brightness_value)
 EAPI void
 imlib_modify_color_modifier_contrast(double contrast_value)
 {
-   CHECK_PARAM_POINTER("imlib_modify_color_modifier_contrast",
-                       "color_modifier", ctx->color_modifier);
+   CHECK_PARAM_POINTER("color_modifier", ctx->color_modifier);
    __imlib_CmodModContrast((ImlibColorModifier *) ctx->color_modifier,
                            contrast_value);
 }
@@ -3638,8 +3597,7 @@ EAPI void
 imlib_set_color_modifier_tables(DATA8 * red_table, DATA8 * green_table,
                                 DATA8 * blue_table, DATA8 * alpha_table)
 {
-   CHECK_PARAM_POINTER("imlib_set_color_modifier_tables", "color_modifier",
-                       ctx->color_modifier);
+   CHECK_PARAM_POINTER("color_modifier", ctx->color_modifier);
    __imlib_CmodSetTables((ImlibColorModifier *) ctx->color_modifier,
                          red_table, green_table, blue_table, alpha_table);
 }
@@ -3658,8 +3616,7 @@ EAPI void
 imlib_get_color_modifier_tables(DATA8 * red_table, DATA8 * green_table,
                                 DATA8 * blue_table, DATA8 * alpha_table)
 {
-   CHECK_PARAM_POINTER("imlib_get_color_modifier_tables", "color_modifier",
-                       ctx->color_modifier);
+   CHECK_PARAM_POINTER("color_modifier", ctx->color_modifier);
    __imlib_CmodGetTables((ImlibColorModifier *) ctx->color_modifier,
                          red_table, green_table, blue_table, alpha_table);
 }
@@ -3670,8 +3627,7 @@ imlib_get_color_modifier_tables(DATA8 * red_table, DATA8 * green_table,
 EAPI void
 imlib_reset_color_modifier(void)
 {
-   CHECK_PARAM_POINTER("imlib_rset_color_modifier", "color_modifier",
-                       ctx->color_modifier);
+   CHECK_PARAM_POINTER("color_modifier", ctx->color_modifier);
    __imlib_CmodReset((ImlibColorModifier *) ctx->color_modifier);
 }
 
@@ -3684,9 +3640,8 @@ imlib_apply_color_modifier(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_apply_color_modifier", "image", ctx->image);
-   CHECK_PARAM_POINTER("imlib_apply_color_modifier", "color_modifier",
-                       ctx->color_modifier);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("color_modifier", ctx->color_modifier);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -3709,10 +3664,8 @@ imlib_apply_color_modifier_to_rectangle(int x, int y, int width, int height)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_apply_color_modifier_to_rectangle", "image",
-                       ctx->image);
-   CHECK_PARAM_POINTER("imlib_apply_color_modifier_to_rectangle",
-                       "color_modifier", ctx->color_modifier);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("color_modifier", ctx->color_modifier);
    CAST_IMAGE(im, ctx->image);
    if (x < 0)
      {
@@ -3749,8 +3702,7 @@ imlib_image_draw_pixel(int x, int y, char make_updates)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_image_draw_pixel", "image", ctx->image,
-                              NULL);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, NULL);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return NULL;
@@ -3783,8 +3735,7 @@ imlib_image_draw_line(int x1, int y1, int x2, int y2, char make_updates)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_image_draw_line", "image", ctx->image,
-                              NULL);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, NULL);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return NULL;
@@ -3815,7 +3766,7 @@ imlib_image_draw_rectangle(int x, int y, int width, int height)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_draw_rectangle", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -3841,7 +3792,7 @@ imlib_image_fill_rectangle(int x, int y, int width, int height)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_fill_rectangle", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -3866,10 +3817,8 @@ imlib_image_copy_alpha_to_image(Imlib_Image image_source, int x, int y)
 {
    ImlibImage         *im, *im2;
 
-   CHECK_PARAM_POINTER("imlib_image_copy_alpha_to_image", "image_source",
-                       image_source);
-   CHECK_PARAM_POINTER("imlib_image_copy_alpha_to_image", "image_destination",
-                       ctx->image);
+   CHECK_PARAM_POINTER("image_source", image_source);
+   CHECK_PARAM_POINTER("image_destination", ctx->image);
    CAST_IMAGE(im, image_source);
    CAST_IMAGE(im2, ctx->image);
    if (__imlib_LoadImageData(im))
@@ -3900,10 +3849,8 @@ imlib_image_copy_alpha_rectangle_to_image(Imlib_Image image_source, int x,
 {
    ImlibImage         *im, *im2;
 
-   CHECK_PARAM_POINTER("imlib_image_copy_alpha_rectangle_to_image",
-                       "image_source", image_source);
-   CHECK_PARAM_POINTER("imlib_image_copy_alpha_rectangle_to_image",
-                       "image_destination", ctx->image);
+   CHECK_PARAM_POINTER("image_source", image_source);
+   CHECK_PARAM_POINTER("image_destination", ctx->image);
    CAST_IMAGE(im, image_source);
    CAST_IMAGE(im2, ctx->image);
    if (__imlib_LoadImageData(im))
@@ -3934,7 +3881,7 @@ imlib_image_scroll_rect(int x, int y, int width, int height, int delta_x,
    ImlibImage         *im;
    int                 xx, yy, w, h, nx, ny;
 
-   CHECK_PARAM_POINTER("imlib_image_scroll_rect", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -3983,7 +3930,7 @@ imlib_image_copy_rect(int x, int y, int width, int height, int new_x, int new_y)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_copy_rect", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -4009,8 +3956,7 @@ imlib_create_color_range(void)
 EAPI void
 imlib_free_color_range(void)
 {
-   CHECK_PARAM_POINTER("imlib_free_color_range", "color_range",
-                       ctx->color_range);
+   CHECK_PARAM_POINTER("color_range", ctx->color_range);
    __imlib_FreeRange((ImlibRange *) ctx->color_range);
    ctx->color_range = NULL;
 }
@@ -4025,8 +3971,7 @@ imlib_free_color_range(void)
 EAPI void
 imlib_add_color_to_color_range(int distance_away)
 {
-   CHECK_PARAM_POINTER("imlib_add_color_to_color_range", "color_range",
-                       ctx->color_range);
+   CHECK_PARAM_POINTER("color_range", ctx->color_range);
    __imlib_AddRangeColor((ImlibRange *) ctx->color_range, ctx->color.red,
                          ctx->color.green, ctx->color.blue, ctx->color.alpha,
                          distance_away);
@@ -4050,10 +3995,8 @@ imlib_image_fill_color_range_rectangle(int x, int y, int width, int height,
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_fill_color_range_rectangle", "image",
-                       ctx->image);
-   CHECK_PARAM_POINTER("imlib_image_fill_color_range_rectangle",
-                       "color_range", ctx->color_range);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("color_range", ctx->color_range);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -4085,10 +4028,8 @@ imlib_image_fill_hsva_color_range_rectangle(int x, int y, int width, int height,
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_fill_color_range_rectangle", "image",
-                       ctx->image);
-   CHECK_PARAM_POINTER("imlib_image_fill_color_range_rectangle",
-                       "color_range", ctx->color_range);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("color_range", ctx->color_range);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -4114,8 +4055,8 @@ imlib_image_query_pixel(int x, int y, Imlib_Color * color_return)
    ImlibImage         *im;
    DATA32             *p;
 
-   CHECK_PARAM_POINTER("imlib_image_query_pixel", "image", ctx->image);
-   CHECK_PARAM_POINTER("imlib_image_query_pixel", "color_return", color_return);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("color_return", color_return);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -4153,7 +4094,7 @@ imlib_image_query_pixel_hsva(int x, int y, float *hue, float *saturation,
    DATA32             *p;
    int                 r, g, b;
 
-   CHECK_PARAM_POINTER("imlib_image_query_pixel", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -4193,7 +4134,7 @@ imlib_image_query_pixel_hlsa(int x, int y, float *hue, float *lightness,
    DATA32             *p;
    int                 r, g, b;
 
-   CHECK_PARAM_POINTER("imlib_image_query_pixel", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -4233,7 +4174,7 @@ imlib_image_query_pixel_cmya(int x, int y, int *cyan, int *magenta, int *yellow,
    ImlibImage         *im;
    DATA32             *p;
 
-   CHECK_PARAM_POINTER("imlib_image_query_pixel", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -4270,8 +4211,8 @@ imlib_image_attach_data_value(const char *key, void *data, int value,
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_attach_data_value", "image", ctx->image);
-   CHECK_PARAM_POINTER("imlib_image_attach_data_value", "key", key);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("key", key);
    CAST_IMAGE(im, ctx->image);
    __imlib_AttachTag(im, key, value, data,
                      (ImlibDataDestructorFunction) destructor_function);
@@ -4292,10 +4233,8 @@ imlib_image_get_attached_data(const char *key)
    ImlibImageTag      *t;
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_image_get_attached_data", "image",
-                              ctx->image, NULL);
-   CHECK_PARAM_POINTER_RETURN("imlib_image_get_attached_data", "key", key,
-                              NULL);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, NULL);
+   CHECK_PARAM_POINTER_RETURN("key", key, NULL);
    CAST_IMAGE(im, ctx->image);
    t = __imlib_GetTag(im, key);
    if (t)
@@ -4317,9 +4256,8 @@ imlib_image_get_attached_value(const char *key)
    ImlibImageTag      *t;
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_image_get_attached_value", "image",
-                              ctx->image, 0);
-   CHECK_PARAM_POINTER_RETURN("imlib_image_get_attached_value", "key", key, 0);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, 0);
+   CHECK_PARAM_POINTER_RETURN("key", key, 0);
    CAST_IMAGE(im, ctx->image);
    t = __imlib_GetTag(im, key);
    if (t)
@@ -4338,9 +4276,8 @@ imlib_image_remove_attached_data_value(const char *key)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_remove_attached_data_value", "image",
-                       ctx->image);
-   CHECK_PARAM_POINTER("imlib_image_remove_attached_data_value", "key", key);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("key", key);
    CAST_IMAGE(im, ctx->image);
    __imlib_RemoveTag(im, key);
 }
@@ -4358,10 +4295,8 @@ imlib_image_remove_and_free_attached_data_value(const char *key)
    ImlibImageTag      *t;
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_remove_and_free_attached_data_value",
-                       "image", ctx->image);
-   CHECK_PARAM_POINTER("imlib_image_remove_and_free_attached_data_value",
-                       "key", key);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("key", key);
    CAST_IMAGE(im, ctx->image);
    t = __imlib_RemoveTag(im, key);
    __imlib_FreeTag(im, t);
@@ -4378,8 +4313,8 @@ imlib_save_image(const char *filename)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_save_image", "image", ctx->image);
-   CHECK_PARAM_POINTER("imlib_save_image", "filename", filename);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("filename", filename);
    CAST_IMAGE(im, ctx->image);
 
    if (__imlib_LoadImageData(im))
@@ -4402,12 +4337,9 @@ imlib_save_image_with_error_return(const char *filename,
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_save_image_with_error_return", "image",
-                       ctx->image);
-   CHECK_PARAM_POINTER("imlib_save_image_with_error_return", "filename",
-                       filename);
-   CHECK_PARAM_POINTER("imlib_save_image_with_error_return", "error_return",
-                       error_return);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("filename", filename);
+   CHECK_PARAM_POINTER("error_return", error_return);
    CAST_IMAGE(im, ctx->image);
 
    if (__imlib_LoadImageData(im))
@@ -4432,8 +4364,7 @@ imlib_create_rotated_image(double angle)
    int                 x, y, dx, dy, sz;
    double              x1, y1, d;
 
-   CHECK_PARAM_POINTER_RETURN("imlib_create_rotated_image", "image",
-                              ctx->image, NULL);
+   CHECK_PARAM_POINTER_RETURN("image", ctx->image, NULL);
    CAST_IMAGE(im_old, ctx->image);
    if (__imlib_LoadImageData(im_old))
       return NULL;
@@ -4483,12 +4414,11 @@ imlib_rotate_image_from_buffer(double angle, Imlib_Image source_image)
    double              x1, y1, d;
 
    // source image (to rotate)
-   CHECK_PARAM_POINTER("imlib_rotate_image_from_buffer", "source_image",
-                       source_image);
+   CHECK_PARAM_POINTER("source_image", source_image);
    CAST_IMAGE(im_old, source_image);
 
    // current context image
-   CHECK_PARAM_POINTER("imlib_rotate_image_from_buffer", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
 
    if (__imlib_LoadImageData(im_old))
@@ -4560,10 +4490,8 @@ imlib_blend_image_onto_image_at_angle(Imlib_Image source_image,
 {
    ImlibImage         *im_src, *im_dst;
 
-   CHECK_PARAM_POINTER("imlib_blend_image_onto_image_at_angle",
-                       "source_image", source_image);
-   CHECK_PARAM_POINTER("imlib_blend_image_onto_image_at_angle", "image",
-                       ctx->image);
+   CHECK_PARAM_POINTER("source_image", source_image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im_src, source_image);
    CAST_IMAGE(im_dst, ctx->image);
    if (__imlib_LoadImageData(im_src))
@@ -4644,10 +4572,8 @@ imlib_blend_image_onto_image_skewed(Imlib_Image source_image,
 {
    ImlibImage         *im_src, *im_dst;
 
-   CHECK_PARAM_POINTER("imlib_blend_image_onto_image_skewed", "source_image",
-                       source_image);
-   CHECK_PARAM_POINTER("imlib_blend_image_onto_image_skewed", "image",
-                       ctx->image);
+   CHECK_PARAM_POINTER("source_image", source_image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im_src, source_image);
    CAST_IMAGE(im_dst, ctx->image);
    if (__imlib_LoadImageData(im_src))
@@ -4692,8 +4618,7 @@ imlib_render_image_on_drawable_skewed(int source_x, int source_y,
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_render_image_on_drawable_skewed", "image",
-                       ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -4729,8 +4654,7 @@ imlib_render_image_on_drawable_at_angle(int source_x, int source_y,
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_render_image_on_drawable_at_angle", "image",
-                       ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -4749,8 +4673,8 @@ imlib_image_filter(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_filter", "image", ctx->image);
-   CHECK_PARAM_POINTER("imlib_image_filter", "filter", ctx->filter);
+   CHECK_PARAM_POINTER("image", ctx->image);
+   CHECK_PARAM_POINTER("filter", ctx->filter);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -4767,7 +4691,7 @@ imlib_create_filter(int initsize)
 EAPI void
 imlib_free_filter(void)
 {
-   CHECK_PARAM_POINTER("imlib_free_filter", "filter", ctx->filter);
+   CHECK_PARAM_POINTER("filter", ctx->filter);
    __imlib_FreeFilter((ImlibFilter *) ctx->filter);
    ctx->filter = NULL;
 }
@@ -4800,7 +4724,7 @@ imlib_filter_set(int xoff, int yoff, int a, int r, int g, int b)
 {
    ImlibFilter        *fil;
 
-   CHECK_PARAM_POINTER("imlib_filter_set", "filter", ctx->filter);
+   CHECK_PARAM_POINTER("filter", ctx->filter);
    fil = (ImlibFilter *) ctx->filter;
    __imlib_FilterSetColor(&fil->alpha, xoff, yoff, a, 0, 0, 0);
    __imlib_FilterSetColor(&fil->red, xoff, yoff, 0, r, 0, 0);
@@ -4813,7 +4737,7 @@ imlib_filter_set_alpha(int xoff, int yoff, int a, int r, int g, int b)
 {
    ImlibFilter        *fil;
 
-   CHECK_PARAM_POINTER("imlib_filter_set_alpha", "filter", ctx->filter);
+   CHECK_PARAM_POINTER("filter", ctx->filter);
    fil = (ImlibFilter *) ctx->filter;
    __imlib_FilterSetColor(&fil->alpha, xoff, yoff, a, r, g, b);
 }
@@ -4823,7 +4747,7 @@ imlib_filter_set_red(int xoff, int yoff, int a, int r, int g, int b)
 {
    ImlibFilter        *fil;
 
-   CHECK_PARAM_POINTER("imlib_filter_set_red", "filter", ctx->filter);
+   CHECK_PARAM_POINTER("filter", ctx->filter);
    fil = (ImlibFilter *) ctx->filter;
    __imlib_FilterSetColor(&fil->red, xoff, yoff, a, r, g, b);
 }
@@ -4833,7 +4757,7 @@ imlib_filter_set_green(int xoff, int yoff, int a, int r, int g, int b)
 {
    ImlibFilter        *fil;
 
-   CHECK_PARAM_POINTER("imlib_filter_set_green", "filter", ctx->filter);
+   CHECK_PARAM_POINTER("filter", ctx->filter);
    fil = (ImlibFilter *) ctx->filter;
    __imlib_FilterSetColor(&fil->green, xoff, yoff, a, r, g, b);
 }
@@ -4843,7 +4767,7 @@ imlib_filter_set_blue(int xoff, int yoff, int a, int r, int g, int b)
 {
    ImlibFilter        *fil;
 
-   CHECK_PARAM_POINTER("imlib_filter_set_blue", "filter", ctx->filter);
+   CHECK_PARAM_POINTER("filter", ctx->filter);
    fil = (ImlibFilter *) ctx->filter;
    __imlib_FilterSetColor(&fil->blue, xoff, yoff, a, r, g, b);
 }
@@ -4851,14 +4775,14 @@ imlib_filter_set_blue(int xoff, int yoff, int a, int r, int g, int b)
 EAPI void
 imlib_filter_constants(int a, int r, int g, int b)
 {
-   CHECK_PARAM_POINTER("imlib_filter_constants", "filter", ctx->filter);
+   CHECK_PARAM_POINTER("filter", ctx->filter);
    __imlib_FilterConstants((ImlibFilter *) ctx->filter, a, r, g, b);
 }
 
 EAPI void
 imlib_filter_divisors(int a, int r, int g, int b)
 {
-   CHECK_PARAM_POINTER("imlib_filter_divisors", "filter", ctx->filter);
+   CHECK_PARAM_POINTER("filter", ctx->filter);
    __imlib_FilterDivisors((ImlibFilter *) ctx->filter, a, r, g, b);
 }
 
@@ -4899,7 +4823,7 @@ imlib_polygon_new(void)
 EAPI void
 imlib_polygon_add_point(ImlibPolygon poly, int x, int y)
 {
-   CHECK_PARAM_POINTER("imlib_polygon_add_point", "polygon", poly);
+   CHECK_PARAM_POINTER("polygon", poly);
    __imlib_polygon_add_point((ImlibPoly) poly, x, y);
 }
 
@@ -4911,7 +4835,7 @@ imlib_polygon_add_point(ImlibPolygon poly, int x, int y)
 EAPI void
 imlib_polygon_free(ImlibPolygon poly)
 {
-   CHECK_PARAM_POINTER("imlib_polygon_free", "polygon", poly);
+   CHECK_PARAM_POINTER("polygon", poly);
    __imlib_polygon_free((ImlibPoly) poly);
 }
 
@@ -4929,7 +4853,7 @@ imlib_image_draw_polygon(ImlibPolygon poly, unsigned char closed)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_draw_polygon", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -4951,7 +4875,7 @@ imlib_image_fill_polygon(ImlibPolygon poly)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_fill_polygon", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -4977,7 +4901,7 @@ EAPI void
 imlib_polygon_get_bounds(ImlibPolygon poly, int *px1, int *py1, int *px2,
                          int *py2)
 {
-   CHECK_PARAM_POINTER("imlib_polygon_get_bounds", "polygon", poly);
+   CHECK_PARAM_POINTER("polygon", poly);
    __imlib_polygon_get_bounds((ImlibPoly) poly, px1, py1, px2, py2);
 }
 
@@ -4998,7 +4922,7 @@ imlib_image_draw_ellipse(int xc, int yc, int a, int b)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_draw_ellipse", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -5027,7 +4951,7 @@ imlib_image_fill_ellipse(int xc, int yc, int a, int b)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_fill_ellipse", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -5049,8 +4973,7 @@ imlib_image_fill_ellipse(int xc, int yc, int a, int b)
 EAPI unsigned char
 imlib_polygon_contains_point(ImlibPolygon poly, int x, int y)
 {
-   CHECK_PARAM_POINTER_RETURN("imlib_polygon_contains_point", "polygon", poly,
-                              0);
+   CHECK_PARAM_POINTER_RETURN("polygon", poly, 0);
    return __imlib_polygon_contains_point((ImlibPoly) poly, x, y);
 }
 
@@ -5059,7 +4982,7 @@ imlib_image_clear(void)
 {
    ImlibImage         *im;
 
-   CHECK_PARAM_POINTER("imlib_image_clear", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;
@@ -5074,7 +4997,7 @@ imlib_image_clear_color(int r, int g, int b, int a)
    int                 i, max;
    DATA32              col;
 
-   CHECK_PARAM_POINTER("imlib_image_clear_color", "image", ctx->image);
+   CHECK_PARAM_POINTER("image", ctx->image);
    CAST_IMAGE(im, ctx->image);
    if (__imlib_LoadImageData(im))
       return;