Changeset 920 for libcacaTweet

Timestamp:

Apr 27, 2006, 4:15:23 PM (15 years ago)

Author:

Sam Hocevar

Message:

• Completed return value and errno handling in libcucul API.

Location:

libcaca/trunk/cucul

Files:

• cucul.h (modified) (4 diffs)
• dither.c (modified) (29 diffs)
• export.c (modified) (5 diffs)
• font.c (modified) (14 diffs)
• import.c (modified) (13 diffs)
• sprite.c (modified) (8 diffs)
• transform.c (modified) (8 diffs)

libcaca/trunk/cucul/cucul.h

@@ -113 +113 @@
  *
  *  @{ */
-void cucul_invert(cucul_canvas_t *);
-void cucul_flip(cucul_canvas_t *);
-void cucul_flop(cucul_canvas_t *);
-void cucul_rotate(cucul_canvas_t *);
+int cucul_invert(cucul_canvas_t *);
+int cucul_flip(cucul_canvas_t *);
+int cucul_flop(cucul_canvas_t *);
+int cucul_rotate(cucul_canvas_t *);
 /*  @} */
 
@@ -151 +151 @@
  *  @{ */
 unsigned int cucul_get_canvas_frame_count(cucul_canvas_t *);
-void cucul_set_canvas_frame(cucul_canvas_t *, unsigned int);
-void cucul_create_canvas_frame(cucul_canvas_t *, unsigned int);
-void cucul_free_canvas_frame(cucul_canvas_t *, unsigned int);
+int cucul_set_canvas_frame(cucul_canvas_t *, unsigned int);
+int cucul_create_canvas_frame(cucul_canvas_t *, unsigned int);
+int cucul_free_canvas_frame(cucul_canvas_t *, unsigned int);
 /*  @} */
 
@@ -166 +166 @@
                                     unsigned int, unsigned int,
                                     unsigned int, unsigned int);
-void cucul_set_dither_palette(cucul_dither_t *,
-                              unsigned int r[], unsigned int g[],
-                              unsigned int b[], unsigned int a[]);
-void cucul_set_dither_brightness(cucul_dither_t *, float);
-void cucul_set_dither_gamma(cucul_dither_t *, float);
-void cucul_set_dither_contrast(cucul_dither_t *, float);
-void cucul_set_dither_invert(cucul_dither_t *, int);
-void cucul_set_dither_antialias(cucul_dither_t *, char const *);
+int cucul_set_dither_palette(cucul_dither_t *,
+                             unsigned int r[], unsigned int g[],
+                             unsigned int b[], unsigned int a[]);
+int cucul_set_dither_brightness(cucul_dither_t *, float);
+int cucul_set_dither_gamma(cucul_dither_t *, float);
+int cucul_set_dither_contrast(cucul_dither_t *, float);
+int cucul_set_dither_invert(cucul_dither_t *, int);
+int cucul_set_dither_antialias(cucul_dither_t *, char const *);
 char const * const * cucul_get_dither_antialias_list(cucul_dither_t const *);
-void cucul_set_dither_color(cucul_dither_t *, char const *);
+int cucul_set_dither_color(cucul_dither_t *, char const *);
 char const * const * cucul_get_dither_color_list(cucul_dither_t const *);
-void cucul_set_dither_charset(cucul_dither_t *, char const *);
+int cucul_set_dither_charset(cucul_dither_t *, char const *);
 char const * const * cucul_get_dither_charset_list(cucul_dither_t const *);
-void cucul_set_dither_mode(cucul_dither_t *, char const *);
+int cucul_set_dither_mode(cucul_dither_t *, char const *);
 char const * const * cucul_get_dither_mode_list(cucul_dither_t const *);
-void cucul_dither_bitmap(cucul_canvas_t *, int, int, int, int,
+int cucul_dither_bitmap(cucul_canvas_t *, int, int, int, int,
                          cucul_dither_t const *, void *);
-void cucul_free_dither(cucul_dither_t *);
+int cucul_free_dither(cucul_dither_t *);
 /*  @} */
 
@@ -196 +196 @@
 unsigned int cucul_get_font_width(cucul_font_t *);
 unsigned int cucul_get_font_height(cucul_font_t *);
-void cucul_render_canvas(cucul_canvas_t *, cucul_font_t *, void *,
+int cucul_render_canvas(cucul_canvas_t *, cucul_font_t *, void *,
                          unsigned int, unsigned int, unsigned int);
-void cucul_free_font(cucul_font_t *);
+int cucul_free_font(cucul_font_t *);
 /*  @} */
 

libcaca/trunk/cucul/dither.c

@@ -27 +27 @@
 #   include <limits.h>
 #   include <string.h>
+#   if defined(HAVE_ERRNO_H)
+#       include <errno.h>
+#   endif
 #endif
 
@@ -237 +240 @@
  *  pixel, a zero alpha mask causes the alpha values to be ignored.
  *
+ *  If an error occurs, NULL is returned and \b errno is set accordingly:
+ *  - \c EINVAL Requested width, height, pitch or bits per pixel value was
+ *    invalid.
+ *  - \c ENOMEM Not enough memory to allocate dither structure.
+ *
  *  \param bpp Bitmap depth in bits per pixel.
  *  \param w Bitmap width in pixels.
@@ -245 +253 @@
  *  \param bmask Bitmask for blue values.
  *  \param amask Bitmask for alpha values.
- *  \return Dither object, or NULL upon error.
+ *  \return Dither object upon success, NULL if an error occurred.
  */
 cucul_dither_t *cucul_create_dither(unsigned int bpp, unsigned int w,
@@ -257 +265 @@
     /* Minor sanity test */
     if(!w || !h || !pitch || bpp > 32 || bpp < 8)
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = EINVAL;
+#endif
         return NULL;
+    }
 
     d = malloc(sizeof(cucul_dither_t));
     if(!d)
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = ENOMEM;
+#endif
         return NULL;
+    }
 
     d->bpp = bpp;
@@ -326 +344 @@
  *  0 and 4095 (0xfff).
  *
+ *  If an error occurs, -1 is returned and \b errno is set accordingly:
+ *  - \c EINVAL Dither bits per pixel value is not 8, or one of the pixel
+ *   values was outside the range 0 - 4095.
+ *
  *  \param d Dither object.
  *  \param red Array of 256 red values.
@@ -331 +353 @@
  *  \param blue Array of 256 blue values.
  *  \param alpha Array of 256 alpha values.
- */
-void cucul_set_dither_palette(cucul_dither_t *d,
-                              unsigned int red[], unsigned int green[],
-                              unsigned int blue[], unsigned int alpha[])
+ *  \return 0 in case of success, -1 if an error occurred.
+ */
+int cucul_set_dither_palette(cucul_dither_t *d,
+                             unsigned int red[], unsigned int green[],
+                             unsigned int blue[], unsigned int alpha[])
 {
     int i, has_alpha = 0;
 
     if(d->bpp != 8)
-        return;
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = EINVAL;
+#endif
+        return -1;
+    }
 
     for(i = 0; i < 256; i++)
     {
-        if(red[i] >= 0 && red[i] < 0x1000 &&
-           green[i] >= 0 && green[i] < 0x1000 &&
-           blue[i] >= 0 && blue[i] < 0x1000 &&
-           alpha[i] >= 0 && alpha[i] < 0x1000)
+        if((red[i] | green[i] | blue[i] | alpha[i]) >= 0x1000)
         {
-            d->red[i] = red[i];
-            d->green[i] = green[i];
-            d->blue[i] = blue[i];
-            if(alpha[i])
-            {
-                d->alpha[i] = alpha[i];
-                has_alpha = 1;
-            }
+#if defined(HAVE_ERRNO_H)
+            errno = EINVAL;
+#endif
+            return -1;
         }
     }
 
+    for(i = 0; i < 256; i++)
+    {
+        d->red[i] = red[i];
+        d->green[i] = green[i];
+        d->blue[i] = blue[i];
+        if(alpha[i])
+        {
+            d->alpha[i] = alpha[i];
+            has_alpha = 1;
+        }
+    }
+
     d->has_alpha = has_alpha;
+
+    return 0;
 }
 
@@ -365 +400 @@
  *
  *  Set the brightness of dither.
+ *
+ *  If an error occurs, -1 is returned and \b errno is set accordingly:
+ *  - \c EINVAL Brightness value was out of range.
  *
  *  \param d Dither object.
  *  \param brightness brightness value.
- */
-void cucul_set_dither_brightness(cucul_dither_t *d, float brightness)
+ *  \return 0 in case of success, -1 if an error occurred.
+ */
+int cucul_set_dither_brightness(cucul_dither_t *d, float brightness)
 {
     /* FIXME */
+    return 0;
 }
 
@@ -377 +417 @@
  *
  *  Set the gamma of dither.
+ *
+ *  If an error occurs, -1 is returned and \b errno is set accordingly:
+ *  - \c EINVAL Gamma value was out of range.
  *
  *  \param d Dither object.
  *  \param gamma Gamma value.
- */
-void cucul_set_dither_gamma(cucul_dither_t *d, float gamma)
-{
-    /* FIXME: we don't need 4096 calls to gammapow(), we can just compute
+ *  \return 0 in case of success, -1 if an error occurred.
+ */
+int cucul_set_dither_gamma(cucul_dither_t *d, float gamma)
+{
+    /* FIXME: we don't need 4096 calls to gammapow(), we could just compute
      * 128 of them and do linear interpolation for the rest. This will
      * probably speed up things a lot. */
@@ -389 +433 @@
 
     if(gamma <= 0.0)
-        return;
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = EINVAL;
+#endif
+        return -1;
+    }
 
     d->gamma = gamma;
@@ -395 +444 @@
     for(i = 0; i < 4096; i++)
         d->gammatab[i] = 4096.0 * gammapow((float)i / 4096.0, 1.0 / gamma);
+
+    return 0;
 }
 
 /** \brief Invert colors of dither
  *
- *  Invert colors of dither
+ *  Invert colors of dither.
+ *
+ *  This function never fails.
  *
  *  \param d Dither object.
  *  \param value 0 for normal behaviour, 1 for invert
- */
-void cucul_set_dither_invert(cucul_dither_t *d, int value)
+ *  \return This function always returns 0.
+ */
+int cucul_set_dither_invert(cucul_dither_t *d, int value)
 {
     d->invert = value ? 1 : 0;
+
+    return 0;
 }
 
@@ -412 +468 @@
  *
  *  Set the contrast of dither.
+ *
+ *  If an error occurs, -1 is returned and \b errno is set accordingly:
+ *  - \c EINVAL Contrast value was out of range.
  *
  *  \param d Dither object.
  *  \param contrast contrast value.
- */
-void cucul_set_dither_contrast(cucul_dither_t *d, float contrast)
+ *  \return 0 in case of success, -1 if an error occurred.
+ */
+int cucul_set_dither_contrast(cucul_dither_t *d, float contrast)
 {
     /* FIXME */
+    return 0;
 }
 
@@ -428 +489 @@
  *  \li \c "none": no antialiasing.
  *
- *  \li \c "prefilter": simple prefilter antialiasing. This is the default
- *      value.
+ *  \li \c "prefilter" or \c "default": simple prefilter antialiasing. This
+ *      is the default value.
+ *
+ *  If an error occurs, -1 is returned and \b errno is set accordingly:
+ *  - \c EINVAL Invalid antialiasing mode.
  *
  *  \param d Dither object.
  *  \param str A string describing the antialiasing method that will be used
  *         for the dithering.
- */
-void cucul_set_dither_antialias(cucul_dither_t *d, char const *str)
+ *  \return 0 in case of success, -1 if an error occurred.
+ */
+int cucul_set_dither_antialias(cucul_dither_t *d, char const *str)
 {
     if(!strcasecmp(str, "none"))
         d->antialias = 0;
-    else /* "prefilter" is the default */
+    else if(!strcasecmp(str, "prefilter") || !strcasecmp(str, "default"))
         d->antialias = 1;
+    else
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = EINVAL;
+#endif
+        return -1;
+    }
+
+    return 0;
 }
 
@@ -451 +525 @@
  *  language description for that antialiasing method.
  *
+ *  This function never fails.
+ *
  *  \param d Dither object.
  *  \return An array of strings.
@@ -486 +562 @@
  *      background.
  *
- *  \li \c "full16": use the 16 ANSI colours for both the characters and the
- *      background. This is the default value.
+ *  \li \c "full16" or \c "default": use the 16 ANSI colours for both the
+ *      characters and the background. This is the default value.
+ *
+ *  If an error occurs, -1 is returned and \b errno is set accordingly:
+ *  - \c EINVAL Invalid colour set.
  *
  *  \param d Dither object.
  *  \param str A string describing the colour set that will be used
  *         for the dithering.
- */
-void cucul_set_dither_color(cucul_dither_t *d, char const *str)
+ *  \return 0 in case of success, -1 if an error occurred.
+ */
+int cucul_set_dither_color(cucul_dither_t *d, char const *str)
 {
     if(!strcasecmp(str, "mono"))
@@ -507 +587 @@
     else if(!strcasecmp(str, "full8"))
         d->color_mode = COLOR_MODE_FULL8;
-    else /* "full16" is the default */
+    else if(!strcasecmp(str, "full16") || !strcasecmp(str, "default"))
         d->color_mode = COLOR_MODE_FULL16;
+    else
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = EINVAL;
+#endif
+        return -1;
+    }
+
+    return 0;
 }
 
@@ -518 +607 @@
  *  cucul_set_dither_color(), and a string containing the natural
  *  language description for that colour mode.
+ *
+ *  This function never fails.
  *
  *  \param d Dither object.
@@ -545 +636 @@
  *  dither. Valid values for \c str are:
  *
- *  \li \c "ascii": use only ASCII characters. This is the default value.
+ *  \li \c "ascii" or "default": use only ASCII characters. This is the
+ *      default value.
  *
  *  \li \c "shades": use Unicode characters "U+2591 LIGHT SHADE", "U+2592
@@ -554 +646 @@
  *      characters are only found in the Unicode set.
  *
+ *  If an error occurs, -1 is returned and \b errno is set accordingly:
+ *  - \c EINVAL Invalid character set.
+ *
  *  \param d Dither object.
  *  \param str A string describing the characters that need to be used
  *         for the dithering.
- */
-void cucul_set_dither_charset(cucul_dither_t *d, char const *str)
+ *  \return 0 in case of success, -1 if an error occurred.
+ */
+int cucul_set_dither_charset(cucul_dither_t *d, char const *str)
 {
     if(!strcasecmp(str, "shades"))
@@ -570 +666 @@
         d->glyph_count = sizeof(blocks_glyphs) / sizeof(*blocks_glyphs);
     }
-    else /* "ascii" is the default */
+    else if(!strcasecmp(str, "ascii") || !strcasecmp(str, "default"))
     {
         d->glyphs = ascii_glyphs;
         d->glyph_count = sizeof(ascii_glyphs) / sizeof(*ascii_glyphs);
     }
+    else
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = EINVAL;
+#endif
+        return -1;
+    }
+
+    return 0;
 }
 
@@ -585 +690 @@
  *  language description for that character set.
  *
+ *  This function never fails.
+ *
  *  \param d Dither object.
  *  \return An array of strings.
@@ -619 +726 @@
  *  \li \c "fstein": use Floyd-Steinberg dithering. This is the default value.
  *
+ *  If an error occurs, -1 is returned and \b errno is set accordingly:
+ *  - \c EINVAL Unknown dithering mode.
+ *
  *  \param d Dither object.
  *  \param str A string describing the method that needs to be used
  *         for the dithering.
- */
-void cucul_set_dither_mode(cucul_dither_t *d, char const *str)
+ *  \return 0 in case of success, -1 if an error occurred.
+ */
+int cucul_set_dither_mode(cucul_dither_t *d, char const *str)
 {
     if(!strcasecmp(str, "none"))
@@ -655 +766 @@
         d->increment_dither = increment_random_dither;
     }
-    else /* "fstein" is the default */
+    else if(!strcasecmp(str, "fstein") || !strcasecmp(str, "default"))
     {
         d->init_dither = init_fstein_dither;
@@ -661 +772 @@
         d->increment_dither = increment_fstein_dither;
     }
+    else
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = EINVAL;
+#endif
+        return -1;
+    }
+
+    return 0;
 }
 
@@ -670 +790 @@
  *  cucul_set_dither_dithering(), and a string containing the natural
  *  language description for that dithering method.
+ *
+ *  This function never fails.
  *
  *  \param d Dither object.
@@ -695 +817 @@
  *  and will be stretched to the text area.
  *
+ *  This function never fails.
+ *
  *  \param cv A handle to the libcucul canvas.
  *  \param x X coordinate of the upper-left corner of the drawing area.
@@ -702 +826 @@
  *  \param d Dither object to be drawn.
  *  \param pixels Bitmap's pixels.
- */
-void cucul_dither_bitmap(cucul_canvas_t *cv, int x, int y, int w, int h,
-                         cucul_dither_t const *d, void *pixels)
+ *  \return This function always returns 0.
+ */
+int cucul_dither_bitmap(cucul_canvas_t *cv, int x, int y, int w, int h,
+                        cucul_dither_t const *d, void *pixels)
 {
     int *floyd_steinberg, *fs_r, *fs_g, *fs_b;
@@ -712 +837 @@
 
     if(!d || !pixels)
-        return;
+        return 0;
 
     x1 = x; x2 = x + w - 1;
@@ -941 +1066 @@
 
     free(floyd_steinberg);
+
+    return 0;
 }
 
@@ -947 +1074 @@
  *  Free the memory allocated by cucul_create_dither().
  *
+ *  This function never fails.
+ *
  *  \param d Dither object.
- */
-void cucul_free_dither(cucul_dither_t *d)
+ *  \return This function always returns 0.
+ */
+int cucul_free_dither(cucul_dither_t *d)
 {
     if(!d)
-        return;
+        return 0;
 
     free(d);
+
+    return 0;
 }
 

libcaca/trunk/cucul/export.c

@@ -21 +21 @@
 
 #if !defined(__KERNEL__)
+#   if defined(HAVE_ERRNO_H)
+#       include <errno.h>
+#   endif
 #   include <stdlib.h>
 #   include <stdio.h>
@@ -64 +67 @@
  *  \li \c "tga": export a TGA image.
  *
+ *  If an error occurs, NULL is returned and \b errno is set accordingly:
+ *  - \c EINVAL Invalid format requested.
+ *  - \c ENOMEM Not enough memory to allocate output buffer.
+ *
  *  \param cv A libcucul canvas
  *  \param format A string describing the requested output format.
+ *  \return A libcucul buffer, or NULL in case of error.
  */
 cucul_buffer_t * cucul_export_canvas(cucul_canvas_t *cv, char const *format)
@@ -72 +80 @@
 
     ex = malloc(sizeof(cucul_buffer_t));
+    if(!ex)
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = ENOMEM;
+#endif
+        return NULL;
+    }
+
     ex->size = 0;
     ex->data = NULL;
@@ -96 +112 @@
     {
         free(ex);
+#if defined(HAVE_ERRNO_H)
+        errno = EINVAL;
+#endif
         return NULL;
     }
@@ -108 +127 @@
  *  the export format, to be used with cucul_export_canvas(), and a string
  *  containing the natural language description for that export format.
+ *
+ *  This function never fails.
  *
  *  \return An array of strings.

libcaca/trunk/cucul/font.c

@@ -27 +27 @@
 #   elif defined(HAVE_NETINET_IN_H)
 #       include <netinet/in.h>
+#   endif
+#   if defined(HAVE_ERRNO_H)
+#       include <errno.h>
 #   endif
 #   include <stdio.h>
@@ -109 +112 @@
  *  program until the font handle has been freed with cucul_free_font().
  *
+ *  If an error occurs, NULL is returned and \b errno is set accordingly:
+ *  - \c ENOENT Requested built-in font does not exist.
+ *  - \c EINVAL Invalid font data in memory area.
+ *  - \c ENOMEM Not enough memory to allocate font structure.
+ *
  *  \param data The memory area containing the font or its name.
  *  \param size The size of the memory area, or 0 if the font name is given.
@@ -127 +135 @@
 #endif
 
+#if defined(HAVE_ERRNO_H)
+        errno = ENOENT;
+#endif
         return NULL;
     }
 
     if(size < sizeof(struct font_header))
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = EINVAL;
+#endif
         return NULL;
+    }
 
     f = malloc(sizeof(cucul_font_t));
+    if(!f)
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = ENOMEM;
+#endif
+        return NULL;
+    }
+
     f->private = (void *)(uintptr_t)data;
 
@@ -153 +177 @@
     {
         free(f);
+#if defined(HAVE_ERRNO_H)
+        errno = EINVAL;
+#endif
         return NULL;
     }
 
     f->block_list = malloc(f->header.blocks * sizeof(struct block_info));
+    if(!f->block_list)
+    {
+        free(f);
+#if defined(HAVE_ERRNO_H)
+        errno = ENOMEM;
+#endif
+        return NULL;
+    }
+
     memcpy(f->block_list,
            f->private + 8 + sizeof(struct font_header),
@@ -172 +208 @@
             free(f->block_list);
             free(f);
+#if defined(HAVE_ERRNO_H)
+            errno = EINVAL;
+#endif
             return NULL;
         }
@@ -177 +216 @@
 
     f->glyph_list = malloc(f->header.glyphs * sizeof(struct glyph_info));
+    if(!f->glyph_list)
+    {
+        free(f->block_list);
+        free(f);
+#if defined(HAVE_ERRNO_H)
+        errno = ENOMEM;
+#endif
+        return NULL;
+    }
+
     memcpy(f->glyph_list,
            f->private + 8 + sizeof(struct font_header)
@@ -195 +244 @@
             free(f->block_list);
             free(f);
+#if defined(HAVE_ERRNO_H)
+            errno = EINVAL;
+#endif
             return NULL;
         }
@@ -208 +260 @@
  *  Return a list of available builtin fonts. The list is a NULL-terminated
  *  array of strings.
+ *
+ *  This function never fails.
  *
  *  \return An array of strings.
@@ -227 +281 @@
  *  This function returns the maximum value for the current font's glyphs
  *
+ *  This function never fails.
+ *
  *  \param f The font, as returned by cucul_load_font()
  *  \return The maximum glyph width.
@@ -238 +294 @@
  *
  *  This function returns the maximum value for the current font's glyphs
+ *
+ *  This function never fails.
  *
  *  \param f The font, as returned by cucul_load_font()
@@ -254 +312 @@
  *  cucul_load_font() can be freed.
  *
+ *  This function never fails.
+ *
  *  \param f The font, as returned by cucul_load_font()
- */
-void cucul_free_font(cucul_font_t *f)
+ *  \return This function always returns 0.
+ */
+int cucul_free_font(cucul_font_t *f)
 {
     free(f->glyph_list);
     free(f->block_list);
     free(f);
+
+    return 0;
 }
 
@@ -275 +338 @@
  *  Glyphs that do not fit in the image buffer are currently not rendered at
  *  all. They may be cropped instead in future versions.
+ *
+ *  This function never fails.
  *
  *  \param cv The canvas to render
@@ -282 +347 @@
  *  \param height The height (in pixels) of the image buffer
  *  \param pitch The pitch (in bytes) of an image buffer line.
- */
-void cucul_render_canvas(cucul_canvas_t *cv, cucul_font_t *f,
-                         void *buf, unsigned int width,
-                         unsigned int height, unsigned int pitch)
+ *  \return This function always returns 0.
+ */
+int cucul_render_canvas(cucul_canvas_t *cv, cucul_font_t *f,
+                        void *buf, unsigned int width,
+                        unsigned int height, unsigned int pitch)
 {
     uint8_t *glyph = NULL;
@@ -380 +446 @@
     if(f->header.bpp != 8)
         free(glyph);
+
+    return 0;
 }
 

libcaca/trunk/cucul/import.c

@@ -20 +20 @@
 
 #if !defined(__KERNEL__)
+#   if defined(HAVE_ERRNO_H)
+#       include <errno.h>
+#   endif
 #   include <stdio.h>
 #   include <stdlib.h>
@@ -44 +47 @@
 /** \brief Import a buffer into a canvas
  *
- *  This function imports a libcucul buffer (cucul_load_memory()/cucul_load_file())
- *  into an internal libcucul canvas.
+ *  This function imports a libcucul buffer as returned by cucul_load_memory()
+ *  or cucul_load_file() into an internal libcucul canvas.
  *
  *  Valid values for \c format are:
@@ -54 +57 @@
  *
  *  \li \c "caca": import native libcaca files.
+ *
+ *  If an error occurs, NULL is returned and \b errno is set accordingly:
+ *  - \c ENOMEM Not enough memory to allocate canvas.
+ *  - \c EINVAL Invalid format requested.
  *
  *  \param buffer A \e libcucul buffer containing the data to be loaded
@@ -64 +71 @@
     char const *buf = (char const*)buffer->data;
 
-    if(buffer->size == 0 || buffer->data == NULL)
-        return NULL;
-
     if(!strcasecmp("caca", format))
         return import_caca(buffer->data, buffer->size);
@@ -76 +80 @@
     /* Autodetection */
     if(!strcasecmp("", format))
-        {
-            unsigned int i=0;
-            /* if 4 first letters are CACA */
-            if(buffer->size >= 4 &&
-               buf[0] == 'C' && buf[1] == 'A' && buf[2] == 'C' && buf[3] != 'A')
-                return import_caca(buffer->data, buffer->size);
-
-            /* If we find ESC[ argv, we guess it's an ANSI file */
-            while(i < buffer->size - 1)
-                {
-                    if((buf[i] == 0x1b) && (buf[i+1] == '['))
-                        return import_ansi(buffer->data, buffer->size);
-                    i++;
-                }
-
-            /* Otherwise, import it as text */
-            return import_text(buffer->data, buffer->size);
-        }
+    {
+        unsigned int i;
+
+        /* If 4 first letters are CACA */
+        if(buffer->size >= 4 &&
+           buf[0] == 'C' && buf[1] == 'A' && buf[2] == 'C' && buf[3] != 'A')
+            return import_caca(buffer->data, buffer->size);
+
+        /* If we find ESC[ argv, we guess it's an ANSI file */
+        for(i = 0; i < buffer->size - 1; i++)
+            if((buf[i] == 0x1b) && (buf[i + 1] == '['))
+                return import_ansi(buffer->data, buffer->size);
+
+        /* Otherwise, import it as text */
+        return import_text(buffer->data, buffer->size);
+    }
+
+#if defined(HAVE_ERRNO_H)
+    errno = EINVAL;
+#endif
     return NULL;
 }
@@ -103 +109 @@
  *  the import format, to be used with cucul_import_canvas(), and a string
  *  containing the natural language description for that import format.
+ *
+ *  This function never fails.
  *
  *  \return An array of strings.
@@ -131 +139 @@
 
     if(size < 16)
-        return NULL;
+        goto invalid_caca;
 
     if(buf[0] != 'C' || buf[1] != 'A' || buf[2] != 'C' || buf[3] != 'A')
-        return NULL;
+        goto invalid_caca;
 
     if(buf[4] != 'C' || buf[5] != 'A' || buf[6] != 'N' || buf[7] != 'V')
-        return NULL;
+        goto invalid_caca;
 
     width = ((uint32_t)buf[8] << 24) | ((uint32_t)buf[9] << 16)
@@ -145 +153 @@
 
     if(!width || !height)
+        goto invalid_caca;
+
+    if(size != 16 + width * height * 8)
+        goto invalid_caca;
+
+    cv = cucul_create_canvas(width, height);
+
+    if(!cv)
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = ENOMEM;
+#endif
         return NULL;
-
-    if(size != 16 + width * height * 8)
-        return NULL;
-
-    cv = cucul_create_canvas(width, height);
-
-    if(!cv)
-        return NULL;
+    }
 
     for(n = height * width; n--; )
@@ -168 +181 @@
 
     return cv;
+
+invalid_caca:
+#if defined(HAVE_ERRNO_H)
+    errno = EINVAL;
+#endif
+    return NULL;
 }
 
@@ -177 +196 @@
 
     cv = cucul_create_canvas(width, height);
+    if(!cv)
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = ENOMEM;
+#endif
+        return NULL;
+    }
+
     cucul_set_color(cv, CUCUL_COLOR_DEFAULT, CUCUL_COLOR_TRANSPARENT);
 
     for(i = 0; i < size; i++)
-        {
-            unsigned char ch = *text++;
-
-            if(ch == '\r')
-                continue;
-
-            if(ch == '\n')
-                {
-                    x = 0;
-                    y++;
-                    continue;
-                }
-
-            if(x >= width || y >= height)
-                {
-                    if(x >= width)
-                        width = x + 1;
-
-                    if(y >= height)
-                        height = y + 1;
-
-                    cucul_set_canvas_size(cv, width, height);
-                }
-
-            cucul_putchar(cv, x, y, ch);
-            x++;
-        }
+    {
+        unsigned char ch = *text++;
+
+        if(ch == '\r')
+            continue;
+
+        if(ch == '\n')
+        {
+            x = 0;
+            y++;
+            continue;
+        }
+
+        if(x >= width || y >= height)
+        {
+            if(x >= width)
+                width = x + 1;
+
+            if(y >= height)
+                height = y + 1;
+
+            cucul_set_canvas_size(cv, width, height);
+        }
+
+        cucul_putchar(cv, x, y, ch);
+        x++;
+    }
 
     return cv;
@@ -221 +248 @@
 
     cv = cucul_create_canvas(width, height);
+    if(!cv)
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = ENOMEM;
+#endif
+        return NULL;
+    }
+
     ansi_parse_grcm(cv, &grcm, 1, &dummy);
 
     for(i = 0; i < size; i += skip)
-        {
-            skip = 1;
-
-            /* Wrap long lines */
-            if((unsigned int)x >= width)
+    {
+        skip = 1;
+
+        /* Wrap long lines */
+        if((unsigned int)x >= width)
+        {
+            x = 0;
+            y++;
+        }
+
+        if(buffer[i] == '\x1a' && size - i >= 8
+           && !memcmp(buffer + i + 1, "SAUCE00", 7))
+            break; /* End before SAUCE data */
+
+        if(buffer[i] == '\r')
+            continue; /* DOS sucks */
+
+        if(buffer[i] == '\n')
+        {
+            x = 0;
+            y++;
+            continue;
+        }
+
+        /* Interpret escape commands, as per Standard ECMA-48 "Control
+         * Functions for Coded Character Sets", 5.4. Control sequences. */
+        if(buffer[i] == '\x1b' && buffer[i + 1] == '[')
+        {
+            unsigned int argc = 0, argv[101];
+            unsigned int param, inter, final;
+
+        /* Compute offsets to parameter bytes, intermediate bytes and
+         * to the final byte. Only the final byte is mandatory, there
+         * can be zero of the others.
+         * 0  param=2             inter                 final           final+1
+         * +-----+------------------+---------------------+-----------------+
+         * | CSI | parameter bytes  | intermediate bytes  |   final byte    |
+         * |     |   0x30 - 0x3f    |    0x20 - 0x2f      |   0x40 - 0x7e   |
+         * | ^[[ | 0123456789:;<=>? | SPC !"#$%&'()*+,-./ | azAZ@[\]^_`{|}~ |
+         * +-----+------------------+---------------------+-----------------+
+         */
+            param = 2;
+
+            for(inter = param; i + inter < size; inter++)
+                if(buffer[i + inter] < 0x30 || buffer[i + inter] > 0x3f)
+                    break;
+
+            for(final = inter; i + final < size; final++)
+                if(buffer[i + final] < 0x20 || buffer[i + final] > 0x2f)
+                    break;
+
+            if(buffer[i + final] < 0x40 || buffer[i + final] > 0x7e)
+                break; /* Invalid Final Byte */
+
+            skip += final;
+
+            /* Sanity checks */
+            if(param < inter && buffer[i + param] >= 0x3c)
+            {
+                fprintf(stderr, "private sequence \"^[[%.*s\"\n",
+                        final - param + 1, buffer + i + param);
+                continue; /* Private sequence, skip it entirely */
+            }
+
+            if(final - param > 100)
+                continue; /* Suspiciously long sequence, skip it */
+
+            /* Parse parameter bytes as per ECMA-48 5.4.2: Parameter string
+             * format */
+            if(param < inter)
+            {
+                argv[0] = 0;
+                for(j = param; j < inter; j++)
                 {
+                    if(buffer[i + j] == ';')
+                        argv[++argc] = 0;
+                    else if(buffer[i + j] >= '0' && buffer[i + j] <= '9')
+                        argv[argc] = 10 * argv[argc] + (buffer[i + j] - '0');
+                }
+                argc++;
+            }
+
+            /* Interpret final byte. The code representations are given in
+             * ECMA-48 5.4: Control sequences, and the code definitions are
+             * given in ECMA-48 8.3: Definition of control functions. */
+            switch(buffer[i + final])
+            {
+            case 'f': /* CUP - Cursor Position */
+            case 'H': /* HVP - Character And Line Position */
+                x = (argc > 1) ? argv[1] - 1 : 0;
+                y = (argc > 0) ? argv[0] - 1 : 0;
+                break;
+            case 'A': /* CUU - Cursor Up */
+                y -= argc ? argv[0] : 1;
+                if(y < 0)
+                    y = 0;
+                break;
+            case 'B': /* CUD - Cursor Down */
+                y += argc ? argv[0] : 1;
+                break;
+            case 'C': /* CUF - Cursor Right */
+                x += argc ? argv[0] : 1;
+                break;
+            case 'D': /* CUB - Cursor Left */
+                x -= argc ? argv[0] : 1;
+                if(x < 0)
                     x = 0;
-                    y++;
-                }
-
-            if(buffer[i] == '\x1a' && size - i >= 8
-               && !memcmp(buffer + i + 1, "SAUCE00", 7))
-                break; /* End before SAUCE data */
-
-            if(buffer[i] == '\r')
-                continue; /* DOS sucks */
-
-            if(buffer[i] == '\n')
-                {
-                    x = 0;
-                    y++;
-                    continue;
-                }
-
-            /* Interpret escape commands, as per Standard ECMA-48 "Control
-             * Functions for Coded Character Sets", 5.4. Control sequences. */
-            if(buffer[i] == '\x1b' && buffer[i + 1] == '[')
-                {
-                    unsigned int argc = 0, argv[101];
-                    unsigned int param, inter, final;
-
-                    /* Compute offsets to parameter bytes, intermediate bytes and
-                     * to the final byte. Only the final byte is mandatory, there
-                     * can be zero of the others.
-                     * 0  param=2             inter                 final           final+1
-                     * +-----+------------------+---------------------+-----------------+
-                     * | CSI | parameter bytes  | intermediate bytes  |   final byte    |
-                     * |     |   0x30 - 0x3f    |    0x20 - 0x2f      |   0x40 - 0x7e   |
-                     * | ^[[ | 0123456789:;<=>? | SPC !"#$%&'()*+,-./ | azAZ@[\]^_`{|}~ |
-                     * +-----+------------------+---------------------+-----------------+
-                     */
-                    param = 2;
-
-                    for(inter = param; i + inter < size; inter++)
-                        if(buffer[i + inter] < 0x30 || buffer[i + inter] > 0x3f)
-                            break;
-
-                    for(final = inter; i + final < size; final++)
-                        if(buffer[i + final] < 0x20 || buffer[i + final] > 0x2f)
-                            break;
-
-                    if(buffer[i + final] < 0x40 || buffer[i + final] > 0x7e)
-                        break; /* Invalid Final Byte */
-
-                    skip += final;
-
-                    /* Sanity checks */
-                    if(param < inter && buffer[i + param] >= 0x3c)
-                        {
-                            fprintf(stderr, "private sequence \"^[[%.*s\"\n",
-                                    final - param + 1, buffer + i + param);
-                            continue; /* Private sequence, skip it entirely */
-                        }
-
-                    if(final - param > 100)
-                        continue; /* Suspiciously long sequence, skip it */
-
-                    /* Parse parameter bytes as per ECMA-48 5.4.2: Parameter string
-                     * format */
-                    if(param < inter)
-                        {
-                            argv[0] = 0;
-                            for(j = param; j < inter; j++)
-                                {
-                                    if(buffer[i + j] == ';')
-                                        argv[++argc] = 0;
-                                    else if(buffer[i + j] >= '0' && buffer[i + j] <= '9')
-                                        argv[argc] = 10 * argv[argc] + (buffer[i + j] - '0');
-                                }
-                            argc++;
-                        }
-
-                    /* Interpret final byte. The code representations are given in
-                     * ECMA-48 5.4: Control sequences, and the code definitions are
-                     * given in ECMA-48 8.3: Definition of control functions. */
-                    switch(buffer[i + final])
-                        {
-                        case 'f': /* CUP - Cursor Position */
-                        case 'H': /* HVP - Character And Line Position */
-                            x = (argc > 1) ? argv[1] - 1 : 0;
-                            y = (argc > 0) ? argv[0] - 1 : 0;
-                            break;
-                        case 'A': /* CUU - Cursor Up */
-                            y -= argc ? argv[0] : 1;
-                            if(y < 0)
-                                y = 0;
-                            break;
-                        case 'B': /* CUD - Cursor Down */
-                            y += argc ? argv[0] : 1;
-                            break;
-                        case 'C': /* CUF - Cursor Right */
-                            x += argc ? argv[0] : 1;
-                            break;
-                        case 'D': /* CUB - Cursor Left */
-                            x -= argc ? argv[0] : 1;
-                            if(x < 0)
-                                x = 0;
-                            break;
-                        case 's': /* Private (save cursor position) */
-                            save_x = x;
-                            save_y = y;
-                            break;
-                        case 'u': /* Private (reload cursor positin) */
-                            x = save_x;
-                            y = save_y;
-                            break;
-                        case 'J': /* ED - Erase In Page */
-                            if(argv[0] == 2)
-                                x = y = 0;
-                            break;
-                        case 'K': /* EL - Erase In Line */
-                            for(j = x; j < width; j++)
-                                _cucul_putchar32(cv, j, y, (uint32_t)' ');
-                            x = width;
-                            break;
-                        case 'm': /* SGR - Select Graphic Rendition */
-                            ansi_parse_grcm(cv, &grcm, argc, argv);
-                            break;
-                        default:
-                            fprintf(stderr, "unknown command %c\n", buffer[i + final]);
-                            break;
-                        }
-
-                    continue;
-                }
-
-            /* We're going to paste a character. First make sure the canvas
-             * is big enough. */
-            if((unsigned int)y >= height)
-                {
-                    height = y + 1;
-                    cucul_set_canvas_size(cv, width, height);
-                }
-
-            /* Now paste our character */
-            _cucul_putchar32(cv, x, y, _cucul_cp437_to_utf32(buffer[i]));
-            x++;
-        }
+                break;
+            case 's': /* Private (save cursor position) */
+                save_x = x;
+                save_y = y;
+                break;
+            case 'u': /* Private (reload cursor positin) */
+                x = save_x;
+                y = save_y;
+                break;
+            case 'J': /* ED - Erase In Page */
+                if(argv[0] == 2)
+                    x = y = 0;
+                break;
+            case 'K': /* EL - Erase In Line */
+                for(j = x; j < width; j++)
+                    _cucul_putchar32(cv, j, y, (uint32_t)' ');
+                x = width;
+                break;
+            case 'm': /* SGR - Select Graphic Rendition */
+                ansi_parse_grcm(cv, &grcm, argc, argv);
+                break;
+            default:
+                fprintf(stderr, "unknown command %c\n", buffer[i + final]);
+                break;
+            }
+
+            continue;
+        }
+
+        /* We're going to paste a character. First make sure the canvas
+         * is big enough. */
+        if((unsigned int)y >= height)
+        {
+            height = y + 1;
+            cucul_set_canvas_size(cv, width, height);
+        }
+
+        /* Now paste our character */
+        _cucul_putchar32(cv, x, y, _cucul_cp437_to_utf32(buffer[i]));
+        x++;
+    }
 
     return cv;
@@ -382 +417 @@
 {
     static uint8_t const ansi2cucul[] =
-        {
-            CUCUL_COLOR_BLACK, CUCUL_COLOR_RED,
-            CUCUL_COLOR_GREEN, CUCUL_COLOR_BROWN,
-            CUCUL_COLOR_BLUE, CUCUL_COLOR_MAGENTA,
-            CUCUL_COLOR_CYAN, CUCUL_COLOR_LIGHTGRAY
-        };
+    {
+        CUCUL_COLOR_BLACK, CUCUL_COLOR_RED,
+        CUCUL_COLOR_GREEN, CUCUL_COLOR_BROWN,
+        CUCUL_COLOR_BLUE, CUCUL_COLOR_MAGENTA,
+        CUCUL_COLOR_CYAN, CUCUL_COLOR_LIGHTGRAY
+    };
 
     unsigned int j;
@@ -393 +428 @@
 
     for(j = 0; j < argc; j++)
-        {
-            /* Defined in ECMA-48 8.3.117: SGR - SELECT GRAPHIC RENDITION */
-            if(argv[j] >= 30 && argv[j] <= 37)
-                g->fg = ansi2cucul[argv[j] - 30];
-            else if(argv[j] >= 40 && argv[j] <= 47)
-                g->bg = ansi2cucul[argv[j] - 40];
-            else if(argv[j] >= 90 && argv[j] <= 97)
-                g->fg = ansi2cucul[argv[j] - 90] + 8;
-            else if(argv[j] >= 100 && argv[j] <= 107)
-                g->bg = ansi2cucul[argv[j] - 100] + 8;
-            else switch(argv[j])
-                {
-                case 0: /* default rendition */
-                    g->fg = CUCUL_COLOR_DEFAULT;
-                    g->bg = CUCUL_COLOR_DEFAULT;
-                    g->bold = g->negative = g->concealed = 0;
-                    break;
-                case 1: /* bold or increased intensity */
-                    g->bold = 1;
-                    break;
-                case 4: /* singly underlined */
-                    break;
-                case 5: /* slowly blinking (less then 150 per minute) */
-                    break;
-                case 7: /* negative image */
-                    g->negative = 1;
-                    break;
-                case 8: /* concealed characters */
-                    g->concealed = 1;
-                    break;
-                case 22: /* normal colour or normal intensity (neither bold nor faint) */
-                    g->bold = 0;
-                    break;
-                case 28: /* revealed characters */
-                    g->concealed = 0;
-                    break;
-                case 39: /* default display colour (implementation-defined) */
-                    g->fg = CUCUL_COLOR_DEFAULT;
-                    break;
-                case 49: /* default background colour (implementation-defined) */
-                    g->bg = CUCUL_COLOR_DEFAULT;
-                    break;
-                default:
-                    fprintf(stderr, "unknown sgr %i\n", argv[j]);
-                    break;
-                }
-        }
+    {
+        /* Defined in ECMA-48 8.3.117: SGR - SELECT GRAPHIC RENDITION */
+        if(argv[j] >= 30 && argv[j] <= 37)
+            g->fg = ansi2cucul[argv[j] - 30];
+        else if(argv[j] >= 40 && argv[j] <= 47)
+            g->bg = ansi2cucul[argv[j] - 40];
+        else if(argv[j] >= 90 && argv[j] <= 97)
+            g->fg = ansi2cucul[argv[j] - 90] + 8;
+        else if(argv[j] >= 100 && argv[j] <= 107)
+            g->bg = ansi2cucul[argv[j] - 100] + 8;
+        else switch(argv[j])
+        {
+        case 0: /* default rendition */
+            g->fg = CUCUL_COLOR_DEFAULT;
+            g->bg = CUCUL_COLOR_DEFAULT;
+            g->bold = g->negative = g->concealed = 0;
+            break;
+        case 1: /* bold or increased intensity */
+            g->bold = 1;
+            break;
+        case 4: /* singly underlined */
+            break;
+        case 5: /* slowly blinking (less then 150 per minute) */
+            break;
+        case 7: /* negative image */
+            g->negative = 1;
+            break;
+        case 8: /* concealed characters */
+            g->concealed = 1;
+            break;
+        case 22: /* normal colour or normal intensity (neither bold nor faint) */
+            g->bold = 0;
+            break;
+        case 28: /* revealed characters */
+            g->concealed = 0;
+            break;
+        case 39: /* default display colour (implementation-defined) */
+            g->fg = CUCUL_COLOR_DEFAULT;
+            break;
+        case 49: /* default background colour (implementation-defined) */
+            g->bg = CUCUL_COLOR_DEFAULT;
+            break;
+        default:
+            fprintf(stderr, "unknown sgr %i\n", argv[j]);
+            break;
+        }
+    }
 
     if(g->concealed)
-        {
-            myfg = mybg = CUCUL_COLOR_TRANSPARENT;
-        }
+    {
+        myfg = mybg = CUCUL_COLOR_TRANSPARENT;
+    }
     else
-        {
-            myfg = g->negative ? g->bg : g->fg;
-            mybg = g->negative ? g->fg : g->bg;
-
-            if(g->bold)
-                {
-                    if(myfg < 8)
-                        myfg += 8;
-                    else if(myfg == CUCUL_COLOR_DEFAULT)
-                        myfg = CUCUL_COLOR_WHITE;
-                }
-        }
+    {
+        myfg = g->negative ? g->bg : g->fg;
+        mybg = g->negative ? g->fg : g->bg;
+
+        if(g->bold)
+        {
+            if(myfg < 8)
+                myfg += 8;
+            else if(myfg == CUCUL_COLOR_DEFAULT)
+                myfg = CUCUL_COLOR_WHITE;
+        }
+    }
 
     cucul_set_color(cv, myfg, mybg);

libcaca/trunk/cucul/sprite.c

@@ -23 +23 @@
 #   include <stdlib.h>
 #   include <string.h>
+#   if defined(HAVE_ERRNO_H)
+#       include <errno.h>
+#   endif
 #endif
 
@@ -31 +34 @@
  *
  *  This function returns the current canvas frame count.
+ *
+ *  This function never fails.
  *
  *  \param cv A libcucul canvas
@@ -48 +53 @@
  *  If the frame index is outside the canvas' frame range, nothing happens.
  *
+ *  If an error occurs, -1 is returned and \b errno is set accordingly:
+ *  - \c EINVAL Requested frame is out of range.
+ *
  *  \param cv A libcucul canvas
  *  \param frame The canvas frame to activate
+ *  \return 0 in case of success, -1 if an error occurred.
  */
-void cucul_set_canvas_frame(cucul_canvas_t *cv, unsigned int frame)
+int cucul_set_canvas_frame(cucul_canvas_t *cv, unsigned int frame)
 {
     if(frame >= cv->framecount)
-        return;
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = EINVAL;
+#endif
+        return -1;
+    }
 
     cv->frame = frame;
@@ -60 +74 @@
     cv->chars = cv->allchars[cv->frame];
     cv->attr = cv->allattr[cv->frame];
+
+    return 0;
 }
 
@@ -75 +91 @@
  *  to the insertion.
  *
+ *  If an error occurs, -1 is returned and \b errno is set accordingly:
+ *  - \c ENOMEM Not enough memory to allocate new frame.
+ *
  *  \param cv A libcucul canvas
  *  \param frame The index where to insert the new frame
+ *  \return 0 in case of success, -1 if an error occurred.
  */
-void cucul_create_canvas_frame(cucul_canvas_t *cv, unsigned int frame)
+int cucul_create_canvas_frame(cucul_canvas_t *cv, unsigned int frame)
 {
     unsigned int size = cv->width * cv->height * sizeof(uint32_t);
@@ -106 +126 @@
     cv->chars = cv->allchars[cv->frame];
     cv->attr = cv->allattr[cv->frame];
+
+    return 0;
 }
 
@@ -124 +146 @@
  *  renumbered due to the deletion.
  *
+ *  If an error occurs, -1 is returned and \b errno is set accordingly:
+ *  - \c EINVAL Requested frame is out of range, or attempt to delete the
+ *    last frame of the canvas.
+ *
  *  \param cv A libcucul canvas
  *  \param frame The index of the frame to delete
+ *  \return 0 in case of success, -1 if an error occurred.
  */
-void cucul_free_canvas_frame(cucul_canvas_t *cv, unsigned int frame)
+int cucul_free_canvas_frame(cucul_canvas_t *cv, unsigned int frame)
 {
     unsigned int f;
 
     if(frame >= cv->framecount)
-        return;
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = EINVAL;
+#endif
+        return -1;
+    }
 
     if(cv->framecount == 1)
-        return;
+    {
+#if defined(HAVE_ERRNO_H)
+        errno = EINVAL;
+#endif
+        return -1;
+    }
 
     free(cv->allchars[frame]);
@@ -157 +194 @@
     cv->chars = cv->allchars[cv->frame];
     cv->attr = cv->allattr[cv->frame];
+
+    return 0;
 }
 

libcaca/trunk/cucul/transform.c

@@ -34 +34 @@
  *  becomes cyan, etc.) without changing the characters in it.
  *
+ *  This function never fails.
+ *
  *  \param cv The canvas to invert.
- */
-void cucul_invert(cucul_canvas_t *cv)
+ *  \return This function always returns 0.
+ */
+int cucul_invert(cucul_canvas_t *cv)
 {
     uint32_t *attr = cv->attr;
@@ -46 +49 @@
         attr++;
     }
+
+    return 0;
 }
 
@@ -53 +58 @@
  *  look like the mirrored version wherever possible.
  *
+ *  This function never fails.
+ *
  *  \param cv The canvas to flip.
- */
-void cucul_flip(cucul_canvas_t *cv)
+ *  \return This function always returns 0.
+ */
+int cucul_flip(cucul_canvas_t *cv)
 {
     unsigned int y;
@@ -83 +91 @@
             *cleft = flipchar(*cleft);
     }
+
+    return 0;
 }
 
@@ -90 +100 @@
  *  look like the mirrored version wherever possible.
  *
+ *  This function never fails.
+ *
  *  \param cv The canvas to flop.
- */
-void cucul_flop(cucul_canvas_t *cv)
+ *  \return This function always returns 0.
+ */
+int cucul_flop(cucul_canvas_t *cv)
 {
     unsigned int x;
@@ -121 +134 @@
             *ctop = flopchar(*ctop);
     }
+
+    return 0;
 }
 
@@ -129 +144 @@
  *  possible.
  *
+ *  This function never fails.
+ *
  *  \param cv The canvas to rotate.
- */
-void cucul_rotate(cucul_canvas_t *cv)
+ *  \return This function always returns 0.
+ */
+int cucul_rotate(cucul_canvas_t *cv)
 {
     uint32_t *cbegin = cv->chars;
@@ -154 +172 @@
     if(cbegin == cend)
         *cbegin = rotatechar(*cbegin);
+
+    return 0;
 }