Changeset 920


Ignore:
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:
7 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/cucul/cucul.h

    r896 r920  
    113113 *
    114114 *  @{ */
    115 void cucul_invert(cucul_canvas_t *);
    116 void cucul_flip(cucul_canvas_t *);
    117 void cucul_flop(cucul_canvas_t *);
    118 void cucul_rotate(cucul_canvas_t *);
     115int cucul_invert(cucul_canvas_t *);
     116int cucul_flip(cucul_canvas_t *);
     117int cucul_flop(cucul_canvas_t *);
     118int cucul_rotate(cucul_canvas_t *);
    119119/*  @} */
    120120
     
    151151 *  @{ */
    152152unsigned int cucul_get_canvas_frame_count(cucul_canvas_t *);
    153 void cucul_set_canvas_frame(cucul_canvas_t *, unsigned int);
    154 void cucul_create_canvas_frame(cucul_canvas_t *, unsigned int);
    155 void cucul_free_canvas_frame(cucul_canvas_t *, unsigned int);
     153int cucul_set_canvas_frame(cucul_canvas_t *, unsigned int);
     154int cucul_create_canvas_frame(cucul_canvas_t *, unsigned int);
     155int cucul_free_canvas_frame(cucul_canvas_t *, unsigned int);
    156156/*  @} */
    157157
     
    166166                                    unsigned int, unsigned int,
    167167                                    unsigned int, unsigned int);
    168 void cucul_set_dither_palette(cucul_dither_t *,
    169                               unsigned int r[], unsigned int g[],
    170                               unsigned int b[], unsigned int a[]);
    171 void cucul_set_dither_brightness(cucul_dither_t *, float);
    172 void cucul_set_dither_gamma(cucul_dither_t *, float);
    173 void cucul_set_dither_contrast(cucul_dither_t *, float);
    174 void cucul_set_dither_invert(cucul_dither_t *, int);
    175 void cucul_set_dither_antialias(cucul_dither_t *, char const *);
     168int cucul_set_dither_palette(cucul_dither_t *,
     169                             unsigned int r[], unsigned int g[],
     170                             unsigned int b[], unsigned int a[]);
     171int cucul_set_dither_brightness(cucul_dither_t *, float);
     172int cucul_set_dither_gamma(cucul_dither_t *, float);
     173int cucul_set_dither_contrast(cucul_dither_t *, float);
     174int cucul_set_dither_invert(cucul_dither_t *, int);
     175int cucul_set_dither_antialias(cucul_dither_t *, char const *);
    176176char const * const * cucul_get_dither_antialias_list(cucul_dither_t const *);
    177 void cucul_set_dither_color(cucul_dither_t *, char const *);
     177int cucul_set_dither_color(cucul_dither_t *, char const *);
    178178char const * const * cucul_get_dither_color_list(cucul_dither_t const *);
    179 void cucul_set_dither_charset(cucul_dither_t *, char const *);
     179int cucul_set_dither_charset(cucul_dither_t *, char const *);
    180180char const * const * cucul_get_dither_charset_list(cucul_dither_t const *);
    181 void cucul_set_dither_mode(cucul_dither_t *, char const *);
     181int cucul_set_dither_mode(cucul_dither_t *, char const *);
    182182char const * const * cucul_get_dither_mode_list(cucul_dither_t const *);
    183 void cucul_dither_bitmap(cucul_canvas_t *, int, int, int, int,
     183int cucul_dither_bitmap(cucul_canvas_t *, int, int, int, int,
    184184                         cucul_dither_t const *, void *);
    185 void cucul_free_dither(cucul_dither_t *);
     185int cucul_free_dither(cucul_dither_t *);
    186186/*  @} */
    187187
     
    196196unsigned int cucul_get_font_width(cucul_font_t *);
    197197unsigned int cucul_get_font_height(cucul_font_t *);
    198 void cucul_render_canvas(cucul_canvas_t *, cucul_font_t *, void *,
     198int cucul_render_canvas(cucul_canvas_t *, cucul_font_t *, void *,
    199199                         unsigned int, unsigned int, unsigned int);
    200 void cucul_free_font(cucul_font_t *);
     200int cucul_free_font(cucul_font_t *);
    201201/*  @} */
    202202
  • libcaca/trunk/cucul/dither.c

    r859 r920  
    2727#   include <limits.h>
    2828#   include <string.h>
     29#   if defined(HAVE_ERRNO_H)
     30#       include <errno.h>
     31#   endif
    2932#endif
    3033
     
    237240 *  pixel, a zero alpha mask causes the alpha values to be ignored.
    238241 *
     242 *  If an error occurs, NULL is returned and \b errno is set accordingly:
     243 *  - \c EINVAL Requested width, height, pitch or bits per pixel value was
     244 *    invalid.
     245 *  - \c ENOMEM Not enough memory to allocate dither structure.
     246 *
    239247 *  \param bpp Bitmap depth in bits per pixel.
    240248 *  \param w Bitmap width in pixels.
     
    245253 *  \param bmask Bitmask for blue values.
    246254 *  \param amask Bitmask for alpha values.
    247  *  \return Dither object, or NULL upon error.
     255 *  \return Dither object upon success, NULL if an error occurred.
    248256 */
    249257cucul_dither_t *cucul_create_dither(unsigned int bpp, unsigned int w,
     
    257265    /* Minor sanity test */
    258266    if(!w || !h || !pitch || bpp > 32 || bpp < 8)
     267    {
     268#if defined(HAVE_ERRNO_H)
     269        errno = EINVAL;
     270#endif
    259271        return NULL;
     272    }
    260273
    261274    d = malloc(sizeof(cucul_dither_t));
    262275    if(!d)
     276    {
     277#if defined(HAVE_ERRNO_H)
     278        errno = ENOMEM;
     279#endif
    263280        return NULL;
     281    }
    264282
    265283    d->bpp = bpp;
     
    326344 *  0 and 4095 (0xfff).
    327345 *
     346 *  If an error occurs, -1 is returned and \b errno is set accordingly:
     347 *  - \c EINVAL Dither bits per pixel value is not 8, or one of the pixel
     348 *   values was outside the range 0 - 4095.
     349 *
    328350 *  \param d Dither object.
    329351 *  \param red Array of 256 red values.
     
    331353 *  \param blue Array of 256 blue values.
    332354 *  \param alpha Array of 256 alpha values.
    333  */
    334 void cucul_set_dither_palette(cucul_dither_t *d,
    335                               unsigned int red[], unsigned int green[],
    336                               unsigned int blue[], unsigned int alpha[])
     355 *  \return 0 in case of success, -1 if an error occurred.
     356 */
     357int cucul_set_dither_palette(cucul_dither_t *d,
     358                             unsigned int red[], unsigned int green[],
     359                             unsigned int blue[], unsigned int alpha[])
    337360{
    338361    int i, has_alpha = 0;
    339362
    340363    if(d->bpp != 8)
    341         return;
     364    {
     365#if defined(HAVE_ERRNO_H)
     366        errno = EINVAL;
     367#endif
     368        return -1;
     369    }
    342370
    343371    for(i = 0; i < 256; i++)
    344372    {
    345         if(red[i] >= 0 && red[i] < 0x1000 &&
    346            green[i] >= 0 && green[i] < 0x1000 &&
    347            blue[i] >= 0 && blue[i] < 0x1000 &&
    348            alpha[i] >= 0 && alpha[i] < 0x1000)
     373        if((red[i] | green[i] | blue[i] | alpha[i]) >= 0x1000)
    349374        {
    350             d->red[i] = red[i];
    351             d->green[i] = green[i];
    352             d->blue[i] = blue[i];
    353             if(alpha[i])
    354             {
    355                 d->alpha[i] = alpha[i];
    356                 has_alpha = 1;
    357             }
     375#if defined(HAVE_ERRNO_H)
     376            errno = EINVAL;
     377#endif
     378            return -1;
    358379        }
    359380    }
    360381
     382    for(i = 0; i < 256; i++)
     383    {
     384        d->red[i] = red[i];
     385        d->green[i] = green[i];
     386        d->blue[i] = blue[i];
     387        if(alpha[i])
     388        {
     389            d->alpha[i] = alpha[i];
     390            has_alpha = 1;
     391        }
     392    }
     393
    361394    d->has_alpha = has_alpha;
     395
     396    return 0;
    362397}
    363398
     
    365400 *
    366401 *  Set the brightness of dither.
     402 *
     403 *  If an error occurs, -1 is returned and \b errno is set accordingly:
     404 *  - \c EINVAL Brightness value was out of range.
    367405 *
    368406 *  \param d Dither object.
    369407 *  \param brightness brightness value.
    370  */
    371 void cucul_set_dither_brightness(cucul_dither_t *d, float brightness)
     408 *  \return 0 in case of success, -1 if an error occurred.
     409 */
     410int cucul_set_dither_brightness(cucul_dither_t *d, float brightness)
    372411{
    373412    /* FIXME */
     413    return 0;
    374414}
    375415
     
    377417 *
    378418 *  Set the gamma of dither.
     419 *
     420 *  If an error occurs, -1 is returned and \b errno is set accordingly:
     421 *  - \c EINVAL Gamma value was out of range.
    379422 *
    380423 *  \param d Dither object.
    381424 *  \param gamma Gamma value.
    382  */
    383 void cucul_set_dither_gamma(cucul_dither_t *d, float gamma)
    384 {
    385     /* FIXME: we don't need 4096 calls to gammapow(), we can just compute
     425 *  \return 0 in case of success, -1 if an error occurred.
     426 */
     427int cucul_set_dither_gamma(cucul_dither_t *d, float gamma)
     428{
     429    /* FIXME: we don't need 4096 calls to gammapow(), we could just compute
    386430     * 128 of them and do linear interpolation for the rest. This will
    387431     * probably speed up things a lot. */
     
    389433
    390434    if(gamma <= 0.0)
    391         return;
     435    {
     436#if defined(HAVE_ERRNO_H)
     437        errno = EINVAL;
     438#endif
     439        return -1;
     440    }
    392441
    393442    d->gamma = gamma;
     
    395444    for(i = 0; i < 4096; i++)
    396445        d->gammatab[i] = 4096.0 * gammapow((float)i / 4096.0, 1.0 / gamma);
     446
     447    return 0;
    397448}
    398449
    399450/** \brief Invert colors of dither
    400451 *
    401  *  Invert colors of dither
     452 *  Invert colors of dither.
     453 *
     454 *  This function never fails.
    402455 *
    403456 *  \param d Dither object.
    404457 *  \param value 0 for normal behaviour, 1 for invert
    405  */
    406 void cucul_set_dither_invert(cucul_dither_t *d, int value)
     458 *  \return This function always returns 0.
     459 */
     460int cucul_set_dither_invert(cucul_dither_t *d, int value)
    407461{
    408462    d->invert = value ? 1 : 0;
     463
     464    return 0;
    409465}
    410466
     
    412468 *
    413469 *  Set the contrast of dither.
     470 *
     471 *  If an error occurs, -1 is returned and \b errno is set accordingly:
     472 *  - \c EINVAL Contrast value was out of range.
    414473 *
    415474 *  \param d Dither object.
    416475 *  \param contrast contrast value.
    417  */
    418 void cucul_set_dither_contrast(cucul_dither_t *d, float contrast)
     476 *  \return 0 in case of success, -1 if an error occurred.
     477 */
     478int cucul_set_dither_contrast(cucul_dither_t *d, float contrast)
    419479{
    420480    /* FIXME */
     481    return 0;
    421482}
    422483
     
    428489 *  \li \c "none": no antialiasing.
    429490 *
    430  *  \li \c "prefilter": simple prefilter antialiasing. This is the default
    431  *      value.
     491 *  \li \c "prefilter" or \c "default": simple prefilter antialiasing. This
     492 *      is the default value.
     493 *
     494 *  If an error occurs, -1 is returned and \b errno is set accordingly:
     495 *  - \c EINVAL Invalid antialiasing mode.
    432496 *
    433497 *  \param d Dither object.
    434498 *  \param str A string describing the antialiasing method that will be used
    435499 *         for the dithering.
    436  */
    437 void cucul_set_dither_antialias(cucul_dither_t *d, char const *str)
     500 *  \return 0 in case of success, -1 if an error occurred.
     501 */
     502int cucul_set_dither_antialias(cucul_dither_t *d, char const *str)
    438503{
    439504    if(!strcasecmp(str, "none"))
    440505        d->antialias = 0;
    441     else /* "prefilter" is the default */
     506    else if(!strcasecmp(str, "prefilter") || !strcasecmp(str, "default"))
    442507        d->antialias = 1;
     508    else
     509    {
     510#if defined(HAVE_ERRNO_H)
     511        errno = EINVAL;
     512#endif
     513        return -1;
     514    }
     515
     516    return 0;
    443517}
    444518
     
    451525 *  language description for that antialiasing method.
    452526 *
     527 *  This function never fails.
     528 *
    453529 *  \param d Dither object.
    454530 *  \return An array of strings.
     
    486562 *      background.
    487563 *
    488  *  \li \c "full16": use the 16 ANSI colours for both the characters and the
    489  *      background. This is the default value.
     564 *  \li \c "full16" or \c "default": use the 16 ANSI colours for both the
     565 *      characters and the background. This is the default value.
     566 *
     567 *  If an error occurs, -1 is returned and \b errno is set accordingly:
     568 *  - \c EINVAL Invalid colour set.
    490569 *
    491570 *  \param d Dither object.
    492571 *  \param str A string describing the colour set that will be used
    493572 *         for the dithering.
    494  */
    495 void cucul_set_dither_color(cucul_dither_t *d, char const *str)
     573 *  \return 0 in case of success, -1 if an error occurred.
     574 */
     575int cucul_set_dither_color(cucul_dither_t *d, char const *str)
    496576{
    497577    if(!strcasecmp(str, "mono"))
     
    507587    else if(!strcasecmp(str, "full8"))
    508588        d->color_mode = COLOR_MODE_FULL8;
    509     else /* "full16" is the default */
     589    else if(!strcasecmp(str, "full16") || !strcasecmp(str, "default"))
    510590        d->color_mode = COLOR_MODE_FULL16;
     591    else
     592    {
     593#if defined(HAVE_ERRNO_H)
     594        errno = EINVAL;
     595#endif
     596        return -1;
     597    }
     598
     599    return 0;
    511600}
    512601
     
    518607 *  cucul_set_dither_color(), and a string containing the natural
    519608 *  language description for that colour mode.
     609 *
     610 *  This function never fails.
    520611 *
    521612 *  \param d Dither object.
     
    545636 *  dither. Valid values for \c str are:
    546637 *
    547  *  \li \c "ascii": use only ASCII characters. This is the default value.
     638 *  \li \c "ascii" or "default": use only ASCII characters. This is the
     639 *      default value.
    548640 *
    549641 *  \li \c "shades": use Unicode characters "U+2591 LIGHT SHADE", "U+2592
     
    554646 *      characters are only found in the Unicode set.
    555647 *
     648 *  If an error occurs, -1 is returned and \b errno is set accordingly:
     649 *  - \c EINVAL Invalid character set.
     650 *
    556651 *  \param d Dither object.
    557652 *  \param str A string describing the characters that need to be used
    558653 *         for the dithering.
    559  */
    560 void cucul_set_dither_charset(cucul_dither_t *d, char const *str)
     654 *  \return 0 in case of success, -1 if an error occurred.
     655 */
     656int cucul_set_dither_charset(cucul_dither_t *d, char const *str)
    561657{
    562658    if(!strcasecmp(str, "shades"))
     
    570666        d->glyph_count = sizeof(blocks_glyphs) / sizeof(*blocks_glyphs);
    571667    }
    572     else /* "ascii" is the default */
     668    else if(!strcasecmp(str, "ascii") || !strcasecmp(str, "default"))
    573669    {
    574670        d->glyphs = ascii_glyphs;
    575671        d->glyph_count = sizeof(ascii_glyphs) / sizeof(*ascii_glyphs);
    576672    }
     673    else
     674    {
     675#if defined(HAVE_ERRNO_H)
     676        errno = EINVAL;
     677#endif
     678        return -1;
     679    }
     680
     681    return 0;
    577682}
    578683
     
    585690 *  language description for that character set.
    586691 *
     692 *  This function never fails.
     693 *
    587694 *  \param d Dither object.
    588695 *  \return An array of strings.
     
    619726 *  \li \c "fstein": use Floyd-Steinberg dithering. This is the default value.
    620727 *
     728 *  If an error occurs, -1 is returned and \b errno is set accordingly:
     729 *  - \c EINVAL Unknown dithering mode.
     730 *
    621731 *  \param d Dither object.
    622732 *  \param str A string describing the method that needs to be used
    623733 *         for the dithering.
    624  */
    625 void cucul_set_dither_mode(cucul_dither_t *d, char const *str)
     734 *  \return 0 in case of success, -1 if an error occurred.
     735 */
     736int cucul_set_dither_mode(cucul_dither_t *d, char const *str)
    626737{
    627738    if(!strcasecmp(str, "none"))
     
    655766        d->increment_dither = increment_random_dither;
    656767    }
    657     else /* "fstein" is the default */
     768    else if(!strcasecmp(str, "fstein") || !strcasecmp(str, "default"))
    658769    {
    659770        d->init_dither = init_fstein_dither;
     
    661772        d->increment_dither = increment_fstein_dither;
    662773    }
     774    else
     775    {
     776#if defined(HAVE_ERRNO_H)
     777        errno = EINVAL;
     778#endif
     779        return -1;
     780    }
     781
     782    return 0;
    663783}
    664784
     
    670790 *  cucul_set_dither_dithering(), and a string containing the natural
    671791 *  language description for that dithering method.
     792 *
     793 *  This function never fails.
    672794 *
    673795 *  \param d Dither object.
     
    695817 *  and will be stretched to the text area.
    696818 *
     819 *  This function never fails.
     820 *
    697821 *  \param cv A handle to the libcucul canvas.
    698822 *  \param x X coordinate of the upper-left corner of the drawing area.
     
    702826 *  \param d Dither object to be drawn.
    703827 *  \param pixels Bitmap's pixels.
    704  */
    705 void cucul_dither_bitmap(cucul_canvas_t *cv, int x, int y, int w, int h,
    706                          cucul_dither_t const *d, void *pixels)
     828 *  \return This function always returns 0.
     829 */
     830int cucul_dither_bitmap(cucul_canvas_t *cv, int x, int y, int w, int h,
     831                        cucul_dither_t const *d, void *pixels)
    707832{
    708833    int *floyd_steinberg, *fs_r, *fs_g, *fs_b;
     
    712837
    713838    if(!d || !pixels)
    714         return;
     839        return 0;
    715840
    716841    x1 = x; x2 = x + w - 1;
     
    9411066
    9421067    free(floyd_steinberg);
     1068
     1069    return 0;
    9431070}
    9441071
     
    9471074 *  Free the memory allocated by cucul_create_dither().
    9481075 *
     1076 *  This function never fails.
     1077 *
    9491078 *  \param d Dither object.
    950  */
    951 void cucul_free_dither(cucul_dither_t *d)
     1079 *  \return This function always returns 0.
     1080 */
     1081int cucul_free_dither(cucul_dither_t *d)
    9521082{
    9531083    if(!d)
    954         return;
     1084        return 0;
    9551085
    9561086    free(d);
     1087
     1088    return 0;
    9571089}
    9581090
  • libcaca/trunk/cucul/export.c

    r896 r920  
    2121
    2222#if !defined(__KERNEL__)
     23#   if defined(HAVE_ERRNO_H)
     24#       include <errno.h>
     25#   endif
    2326#   include <stdlib.h>
    2427#   include <stdio.h>
     
    6467 *  \li \c "tga": export a TGA image.
    6568 *
     69 *  If an error occurs, NULL is returned and \b errno is set accordingly:
     70 *  - \c EINVAL Invalid format requested.
     71 *  - \c ENOMEM Not enough memory to allocate output buffer.
     72 *
    6673 *  \param cv A libcucul canvas
    6774 *  \param format A string describing the requested output format.
     75 *  \return A libcucul buffer, or NULL in case of error.
    6876 */
    6977cucul_buffer_t * cucul_export_canvas(cucul_canvas_t *cv, char const *format)
     
    7280
    7381    ex = malloc(sizeof(cucul_buffer_t));
     82    if(!ex)
     83    {
     84#if defined(HAVE_ERRNO_H)
     85        errno = ENOMEM;
     86#endif
     87        return NULL;
     88    }
     89
    7490    ex->size = 0;
    7591    ex->data = NULL;
     
    96112    {
    97113        free(ex);
     114#if defined(HAVE_ERRNO_H)
     115        errno = EINVAL;
     116#endif
    98117        return NULL;
    99118    }
     
    108127 *  the export format, to be used with cucul_export_canvas(), and a string
    109128 *  containing the natural language description for that export format.
     129 *
     130 *  This function never fails.
    110131 *
    111132 *  \return An array of strings.
  • libcaca/trunk/cucul/font.c

    r865 r920  
    2727#   elif defined(HAVE_NETINET_IN_H)
    2828#       include <netinet/in.h>
     29#   endif
     30#   if defined(HAVE_ERRNO_H)
     31#       include <errno.h>
    2932#   endif
    3033#   include <stdio.h>
     
    109112 *  program until the font handle has been freed with cucul_free_font().
    110113 *
     114 *  If an error occurs, NULL is returned and \b errno is set accordingly:
     115 *  - \c ENOENT Requested built-in font does not exist.
     116 *  - \c EINVAL Invalid font data in memory area.
     117 *  - \c ENOMEM Not enough memory to allocate font structure.
     118 *
    111119 *  \param data The memory area containing the font or its name.
    112120 *  \param size The size of the memory area, or 0 if the font name is given.
     
    127135#endif
    128136
     137#if defined(HAVE_ERRNO_H)
     138        errno = ENOENT;
     139#endif
    129140        return NULL;
    130141    }
    131142
    132143    if(size < sizeof(struct font_header))
     144    {
     145#if defined(HAVE_ERRNO_H)
     146        errno = EINVAL;
     147#endif
    133148        return NULL;
     149    }
    134150
    135151    f = malloc(sizeof(cucul_font_t));
     152    if(!f)
     153    {
     154#if defined(HAVE_ERRNO_H)
     155        errno = ENOMEM;
     156#endif
     157        return NULL;
     158    }
     159
    136160    f->private = (void *)(uintptr_t)data;
    137161
     
    153177    {
    154178        free(f);
     179#if defined(HAVE_ERRNO_H)
     180        errno = EINVAL;
     181#endif
    155182        return NULL;
    156183    }
    157184
    158185    f->block_list = malloc(f->header.blocks * sizeof(struct block_info));
     186    if(!f->block_list)
     187    {
     188        free(f);
     189#if defined(HAVE_ERRNO_H)
     190        errno = ENOMEM;
     191#endif
     192        return NULL;
     193    }
     194
    159195    memcpy(f->block_list,
    160196           f->private + 8 + sizeof(struct font_header),
     
    172208            free(f->block_list);
    173209            free(f);
     210#if defined(HAVE_ERRNO_H)
     211            errno = EINVAL;
     212#endif
    174213            return NULL;
    175214        }
     
    177216
    178217    f->glyph_list = malloc(f->header.glyphs * sizeof(struct glyph_info));
     218    if(!f->glyph_list)
     219    {
     220        free(f->block_list);
     221        free(f);
     222#if defined(HAVE_ERRNO_H)
     223        errno = ENOMEM;
     224#endif
     225        return NULL;
     226    }
     227
    179228    memcpy(f->glyph_list,
    180229           f->private + 8 + sizeof(struct font_header)
     
    195244            free(f->block_list);
    196245            free(f);
     246#if defined(HAVE_ERRNO_H)
     247            errno = EINVAL;
     248#endif
    197249            return NULL;
    198250        }
     
    208260 *  Return a list of available builtin fonts. The list is a NULL-terminated
    209261 *  array of strings.
     262 *
     263 *  This function never fails.
    210264 *
    211265 *  \return An array of strings.
     
    227281 *  This function returns the maximum value for the current font's glyphs
    228282 *
     283 *  This function never fails.
     284 *
    229285 *  \param f The font, as returned by cucul_load_font()
    230286 *  \return The maximum glyph width.
     
    238294 *
    239295 *  This function returns the maximum value for the current font's glyphs
     296 *
     297 *  This function never fails.
    240298 *
    241299 *  \param f The font, as returned by cucul_load_font()
     
    254312 *  cucul_load_font() can be freed.
    255313 *
     314 *  This function never fails.
     315 *
    256316 *  \param f The font, as returned by cucul_load_font()
    257  */
    258 void cucul_free_font(cucul_font_t *f)
     317 *  \return This function always returns 0.
     318 */
     319int cucul_free_font(cucul_font_t *f)
    259320{
    260321    free(f->glyph_list);
    261322    free(f->block_list);
    262323    free(f);
     324
     325    return 0;
    263326}
    264327
     
    275338 *  Glyphs that do not fit in the image buffer are currently not rendered at
    276339 *  all. They may be cropped instead in future versions.
     340 *
     341 *  This function never fails.
    277342 *
    278343 *  \param cv The canvas to render
     
    282347 *  \param height The height (in pixels) of the image buffer
    283348 *  \param pitch The pitch (in bytes) of an image buffer line.
    284  */
    285 void cucul_render_canvas(cucul_canvas_t *cv, cucul_font_t *f,
    286                          void *buf, unsigned int width,
    287                          unsigned int height, unsigned int pitch)
     349 *  \return This function always returns 0.
     350 */
     351int cucul_render_canvas(cucul_canvas_t *cv, cucul_font_t *f,
     352                        void *buf, unsigned int width,
     353                        unsigned int height, unsigned int pitch)
    288354{
    289355    uint8_t *glyph = NULL;
     
    380446    if(f->header.bpp != 8)
    381447        free(glyph);
     448
     449    return 0;
    382450}
    383451
  • libcaca/trunk/cucul/import.c

    r918 r920  
    2020
    2121#if !defined(__KERNEL__)
     22#   if defined(HAVE_ERRNO_H)
     23#       include <errno.h>
     24#   endif
    2225#   include <stdio.h>
    2326#   include <stdlib.h>
     
    4447/** \brief Import a buffer into a canvas
    4548 *
    46  *  This function imports a libcucul buffer (cucul_load_memory()/cucul_load_file())
    47  *  into an internal libcucul canvas.
     49 *  This function imports a libcucul buffer as returned by cucul_load_memory()
     50 *  or cucul_load_file() into an internal libcucul canvas.
    4851 *
    4952 *  Valid values for \c format are:
     
    5457 *
    5558 *  \li \c "caca": import native libcaca files.
     59 *
     60 *  If an error occurs, NULL is returned and \b errno is set accordingly:
     61 *  - \c ENOMEM Not enough memory to allocate canvas.
     62 *  - \c EINVAL Invalid format requested.
    5663 *
    5764 *  \param buffer A \e libcucul buffer containing the data to be loaded
     
    6471    char const *buf = (char const*)buffer->data;
    6572
    66     if(buffer->size == 0 || buffer->data == NULL)
    67         return NULL;
    68 
    6973    if(!strcasecmp("caca", format))
    7074        return import_caca(buffer->data, buffer->size);
     
    7680    /* Autodetection */
    7781    if(!strcasecmp("", format))
    78         {
    79             unsigned int i=0;
    80             /* if 4 first letters are CACA */
    81             if(buffer->size >= 4 &&
    82                buf[0] == 'C' && buf[1] == 'A' && buf[2] == 'C' && buf[3] != 'A')
    83                 return import_caca(buffer->data, buffer->size);
    84 
    85             /* If we find ESC[ argv, we guess it's an ANSI file */
    86             while(i < buffer->size - 1)
    87                 {
    88                     if((buf[i] == 0x1b) && (buf[i+1] == '['))
    89                         return import_ansi(buffer->data, buffer->size);
    90                     i++;
    91                 }
    92 
    93             /* Otherwise, import it as text */
    94             return import_text(buffer->data, buffer->size);
    95         }
     82    {
     83        unsigned int i;
     84
     85        /* If 4 first letters are CACA */
     86        if(buffer->size >= 4 &&
     87           buf[0] == 'C' && buf[1] == 'A' && buf[2] == 'C' && buf[3] != 'A')
     88            return import_caca(buffer->data, buffer->size);
     89
     90        /* If we find ESC[ argv, we guess it's an ANSI file */
     91        for(i = 0; i < buffer->size - 1; i++)
     92            if((buf[i] == 0x1b) && (buf[i + 1] == '['))
     93                return import_ansi(buffer->data, buffer->size);
     94
     95        /* Otherwise, import it as text */
     96        return import_text(buffer->data, buffer->size);
     97    }
     98
     99#if defined(HAVE_ERRNO_H)
     100    errno = EINVAL;
     101#endif
    96102    return NULL;
    97103}
     
    103109 *  the import format, to be used with cucul_import_canvas(), and a string
    104110 *  containing the natural language description for that import format.
     111 *
     112 *  This function never fails.
    105113 *
    106114 *  \return An array of strings.
     
    131139
    132140    if(size < 16)
    133         return NULL;
     141        goto invalid_caca;
    134142
    135143    if(buf[0] != 'C' || buf[1] != 'A' || buf[2] != 'C' || buf[3] != 'A')
    136         return NULL;
     144        goto invalid_caca;
    137145
    138146    if(buf[4] != 'C' || buf[5] != 'A' || buf[6] != 'N' || buf[7] != 'V')
    139         return NULL;
     147        goto invalid_caca;
    140148
    141149    width = ((uint32_t)buf[8] << 24) | ((uint32_t)buf[9] << 16)
     
    145153
    146154    if(!width || !height)
     155        goto invalid_caca;
     156
     157    if(size != 16 + width * height * 8)
     158        goto invalid_caca;
     159
     160    cv = cucul_create_canvas(width, height);
     161
     162    if(!cv)
     163    {
     164#if defined(HAVE_ERRNO_H)
     165        errno = ENOMEM;
     166#endif
    147167        return NULL;
    148 
    149     if(size != 16 + width * height * 8)
    150         return NULL;
    151 
    152     cv = cucul_create_canvas(width, height);
    153 
    154     if(!cv)
    155         return NULL;
     168    }
    156169
    157170    for(n = height * width; n--; )
     
    168181
    169182    return cv;
     183
     184invalid_caca:
     185#if defined(HAVE_ERRNO_H)
     186    errno = EINVAL;
     187#endif
     188    return NULL;
    170189}
    171190
     
    177196
    178197    cv = cucul_create_canvas(width, height);
     198    if(!cv)
     199    {
     200#if defined(HAVE_ERRNO_H)
     201        errno = ENOMEM;
     202#endif
     203        return NULL;
     204    }
     205
    179206    cucul_set_color(cv, CUCUL_COLOR_DEFAULT, CUCUL_COLOR_TRANSPARENT);
    180207
    181208    for(i = 0; i < size; i++)
    182         {
    183             unsigned char ch = *text++;
    184 
    185             if(ch == '\r')
    186                 continue;
    187 
    188             if(ch == '\n')
    189                 {
    190                     x = 0;
    191                     y++;
    192                     continue;
    193                 }
    194 
    195             if(x >= width || y >= height)
    196                 {
    197                     if(x >= width)
    198                         width = x + 1;
    199 
    200                     if(y >= height)
    201                         height = y + 1;
    202 
    203                     cucul_set_canvas_size(cv, width, height);
    204                 }
    205 
    206             cucul_putchar(cv, x, y, ch);
    207             x++;
    208         }
     209    {
     210        unsigned char ch = *text++;
     211
     212        if(ch == '\r')
     213            continue;
     214
     215        if(ch == '\n')
     216        {
     217            x = 0;
     218            y++;
     219            continue;
     220        }
     221
     222        if(x >= width || y >= height)
     223        {
     224            if(x >= width)
     225                width = x + 1;
     226
     227            if(y >= height)
     228                height = y + 1;
     229
     230            cucul_set_canvas_size(cv, width, height);
     231        }
     232
     233        cucul_putchar(cv, x, y, ch);
     234        x++;
     235    }
    209236
    210237    return cv;
     
    221248
    222249    cv = cucul_create_canvas(width, height);
     250    if(!cv)
     251    {
     252#if defined(HAVE_ERRNO_H)
     253        errno = ENOMEM;
     254#endif
     255        return NULL;
     256    }
     257
    223258    ansi_parse_grcm(cv, &grcm, 1, &dummy);
    224259
    225260    for(i = 0; i < size; i += skip)
    226         {
    227             skip = 1;
    228 
    229             /* Wrap long lines */
    230             if((unsigned int)x >= width)
     261    {
     262        skip = 1;
     263
     264        /* Wrap long lines */
     265        if((unsigned int)x >= width)
     266        {
     267            x = 0;
     268            y++;
     269        }
     270
     271        if(buffer[i] == '\x1a' && size - i >= 8
     272           && !memcmp(buffer + i + 1, "SAUCE00", 7))
     273            break; /* End before SAUCE data */
     274
     275        if(buffer[i] == '\r')
     276            continue; /* DOS sucks */
     277
     278        if(buffer[i] == '\n')
     279        {
     280            x = 0;
     281            y++;
     282            continue;
     283        }
     284
     285        /* Interpret escape commands, as per Standard ECMA-48 "Control
     286         * Functions for Coded Character Sets", 5.4. Control sequences. */
     287        if(buffer[i] == '\x1b' && buffer[i + 1] == '[')
     288        {
     289            unsigned int argc = 0, argv[101];
     290            unsigned int param, inter, final;
     291
     292        /* Compute offsets to parameter bytes, intermediate bytes and
     293         * to the final byte. Only the final byte is mandatory, there
     294         * can be zero of the others.
     295         * 0  param=2             inter                 final           final+1
     296         * +-----+------------------+---------------------+-----------------+
     297         * | CSI | parameter bytes  | intermediate bytes  |   final byte    |
     298         * |     |   0x30 - 0x3f    |    0x20 - 0x2f      |   0x40 - 0x7e   |
     299         * | ^[[ | 0123456789:;<=>? | SPC !"#$%&'()*+,-./ | azAZ@[\]^_`{|}~ |
     300         * +-----+------------------+---------------------+-----------------+
     301         */
     302            param = 2;
     303
     304            for(inter = param; i + inter < size; inter++)
     305                if(buffer[i + inter] < 0x30 || buffer[i + inter] > 0x3f)
     306                    break;
     307
     308            for(final = inter; i + final < size; final++)
     309                if(buffer[i + final] < 0x20 || buffer[i + final] > 0x2f)
     310                    break;
     311
     312            if(buffer[i + final] < 0x40 || buffer[i + final] > 0x7e)
     313                break; /* Invalid Final Byte */
     314
     315            skip += final;
     316
     317            /* Sanity checks */
     318            if(param < inter && buffer[i + param] >= 0x3c)
     319            {
     320                fprintf(stderr, "private sequence \"^[[%.*s\"\n",
     321                        final - param + 1, buffer + i + param);
     322                continue; /* Private sequence, skip it entirely */
     323            }
     324
     325            if(final - param > 100)
     326                continue; /* Suspiciously long sequence, skip it */
     327
     328            /* Parse parameter bytes as per ECMA-48 5.4.2: Parameter string
     329             * format */
     330            if(param < inter)
     331            {
     332                argv[0] = 0;
     333                for(j = param; j < inter; j++)
    231334                {
     335                    if(buffer[i + j] == ';')
     336                        argv[++argc] = 0;
     337                    else if(buffer[i + j] >= '0' && buffer[i + j] <= '9')
     338                        argv[argc] = 10 * argv[argc] + (buffer[i + j] - '0');
     339                }
     340                argc++;
     341            }
     342
     343            /* Interpret final byte. The code representations are given in
     344             * ECMA-48 5.4: Control sequences, and the code definitions are
     345             * given in ECMA-48 8.3: Definition of control functions. */
     346            switch(buffer[i + final])
     347            {
     348            case 'f': /* CUP - Cursor Position */
     349            case 'H': /* HVP - Character And Line Position */
     350                x = (argc > 1) ? argv[1] - 1 : 0;
     351                y = (argc > 0) ? argv[0] - 1 : 0;
     352                break;
     353            case 'A': /* CUU - Cursor Up */
     354                y -= argc ? argv[0] : 1;
     355                if(y < 0)
     356                    y = 0;
     357                break;
     358            case 'B': /* CUD - Cursor Down */
     359                y += argc ? argv[0] : 1;
     360                break;
     361            case 'C': /* CUF - Cursor Right */
     362                x += argc ? argv[0] : 1;
     363                break;
     364            case 'D': /* CUB - Cursor Left */
     365                x -= argc ? argv[0] : 1;
     366                if(x < 0)
    232367                    x = 0;
    233                     y++;
    234                 }
    235 
    236             if(buffer[i] == '\x1a' && size - i >= 8
    237                && !memcmp(buffer + i + 1, "SAUCE00", 7))
    238                 break; /* End before SAUCE data */
    239 
    240             if(buffer[i] == '\r')
    241                 continue; /* DOS sucks */
    242 
    243             if(buffer[i] == '\n')
    244                 {
    245                     x = 0;
    246                     y++;
    247                     continue;
    248                 }
    249 
    250             /* Interpret escape commands, as per Standard ECMA-48 "Control
    251              * Functions for Coded Character Sets", 5.4. Control sequences. */
    252             if(buffer[i] == '\x1b' && buffer[i + 1] == '[')
    253                 {
    254                     unsigned int argc = 0, argv[101];
    255                     unsigned int param, inter, final;
    256 
    257                     /* Compute offsets to parameter bytes, intermediate bytes and
    258                      * to the final byte. Only the final byte is mandatory, there
    259                      * can be zero of the others.
    260                      * 0  param=2             inter                 final           final+1
    261                      * +-----+------------------+---------------------+-----------------+
    262                      * | CSI | parameter bytes  | intermediate bytes  |   final byte    |
    263                      * |     |   0x30 - 0x3f    |    0x20 - 0x2f      |   0x40 - 0x7e   |
    264                      * | ^[[ | 0123456789:;<=>? | SPC !"#$%&'()*+,-./ | azAZ@[\]^_`{|}~ |
    265                      * +-----+------------------+---------------------+-----------------+
    266                      */
    267                     param = 2;
    268 
    269                     for(inter = param; i + inter < size; inter++)
    270                         if(buffer[i + inter] < 0x30 || buffer[i + inter] > 0x3f)
    271                             break;
    272 
    273                     for(final = inter; i + final < size; final++)
    274                         if(buffer[i + final] < 0x20 || buffer[i + final] > 0x2f)
    275                             break;
    276 
    277                     if(buffer[i + final] < 0x40 || buffer[i + final] > 0x7e)
    278                         break; /* Invalid Final Byte */
    279 
    280                     skip += final;
    281 
    282                     /* Sanity checks */
    283                     if(param < inter && buffer[i + param] >= 0x3c)
    284                         {
    285                             fprintf(stderr, "private sequence \"^[[%.*s\"\n",
    286                                     final - param + 1, buffer + i + param);
    287                             continue; /* Private sequence, skip it entirely */
    288                         }
    289 
    290                     if(final - param > 100)
    291                         continue; /* Suspiciously long sequence, skip it */
    292 
    293                     /* Parse parameter bytes as per ECMA-48 5.4.2: Parameter string
    294                      * format */
    295                     if(param < inter)
    296                         {
    297                             argv[0] = 0;
    298                             for(j = param; j < inter; j++)
    299                                 {
    300                                     if(buffer[i + j] == ';')
    301                                         argv[++argc] = 0;
    302                                     else if(buffer[i + j] >= '0' && buffer[i + j] <= '9')
    303                                         argv[argc] = 10 * argv[argc] + (buffer[i + j] - '0');
    304                                 }
    305                             argc++;
    306                         }
    307 
    308                     /* Interpret final byte. The code representations are given in
    309                      * ECMA-48 5.4: Control sequences, and the code definitions are
    310                      * given in ECMA-48 8.3: Definition of control functions. */
    311                     switch(buffer[i + final])
    312                         {
    313                         case 'f': /* CUP - Cursor Position */
    314                         case 'H': /* HVP - Character And Line Position */
    315                             x = (argc > 1) ? argv[1] - 1 : 0;
    316                             y = (argc > 0) ? argv[0] - 1 : 0;
    317                             break;
    318                         case 'A': /* CUU - Cursor Up */
    319                             y -= argc ? argv[0] : 1;
    320                             if(y < 0)
    321                                 y = 0;
    322                             break;
    323                         case 'B': /* CUD - Cursor Down */
    324                             y += argc ? argv[0] : 1;
    325                             break;
    326                         case 'C': /* CUF - Cursor Right */
    327                             x += argc ? argv[0] : 1;
    328                             break;
    329                         case 'D': /* CUB - Cursor Left */
    330                             x -= argc ? argv[0] : 1;
    331                             if(x < 0)
    332                                 x = 0;
    333                             break;
    334                         case 's': /* Private (save cursor position) */
    335                             save_x = x;
    336                             save_y = y;
    337                             break;
    338                         case 'u': /* Private (reload cursor positin) */
    339                             x = save_x;
    340                             y = save_y;
    341                             break;
    342                         case 'J': /* ED - Erase In Page */
    343                             if(argv[0] == 2)
    344                                 x = y = 0;
    345                             break;
    346                         case 'K': /* EL - Erase In Line */
    347                             for(j = x; j < width; j++)
    348                                 _cucul_putchar32(cv, j, y, (uint32_t)' ');
    349                             x = width;
    350                             break;
    351                         case 'm': /* SGR - Select Graphic Rendition */
    352                             ansi_parse_grcm(cv, &grcm, argc, argv);
    353                             break;
    354                         default:
    355                             fprintf(stderr, "unknown command %c\n", buffer[i + final]);
    356                             break;
    357                         }
    358 
    359                     continue;
    360                 }
    361 
    362             /* We're going to paste a character. First make sure the canvas
    363              * is big enough. */
    364             if((unsigned int)y >= height)
    365                 {
    366                     height = y + 1;
    367                     cucul_set_canvas_size(cv, width, height);
    368                 }
    369 
    370             /* Now paste our character */
    371             _cucul_putchar32(cv, x, y, _cucul_cp437_to_utf32(buffer[i]));
    372             x++;
    373         }
     368                break;
     369            case 's': /* Private (save cursor position) */
     370                save_x = x;
     371                save_y = y;
     372                break;
     373            case 'u': /* Private (reload cursor positin) */
     374                x = save_x;
     375                y = save_y;
     376                break;
     377            case 'J': /* ED - Erase In Page */
     378                if(argv[0] == 2)
     379                    x = y = 0;
     380                break;
     381            case 'K': /* EL - Erase In Line */
     382                for(j = x; j < width; j++)
     383                    _cucul_putchar32(cv, j, y, (uint32_t)' ');
     384                x = width;
     385                break;
     386            case 'm': /* SGR - Select Graphic Rendition */
     387                ansi_parse_grcm(cv, &grcm, argc, argv);
     388                break;
     389            default:
     390                fprintf(stderr, "unknown command %c\n", buffer[i + final]);
     391                break;
     392            }
     393
     394            continue;
     395        }
     396
     397        /* We're going to paste a character. First make sure the canvas
     398         * is big enough. */
     399        if((unsigned int)y >= height)
     400        {
     401            height = y + 1;
     402            cucul_set_canvas_size(cv, width, height);
     403        }
     404
     405        /* Now paste our character */
     406        _cucul_putchar32(cv, x, y, _cucul_cp437_to_utf32(buffer[i]));
     407        x++;
     408    }
    374409
    375410    return cv;
     
    382417{
    383418    static uint8_t const ansi2cucul[] =
    384         {
    385             CUCUL_COLOR_BLACK, CUCUL_COLOR_RED,
    386             CUCUL_COLOR_GREEN, CUCUL_COLOR_BROWN,
    387             CUCUL_COLOR_BLUE, CUCUL_COLOR_MAGENTA,
    388             CUCUL_COLOR_CYAN, CUCUL_COLOR_LIGHTGRAY
    389         };
     419    {
     420        CUCUL_COLOR_BLACK, CUCUL_COLOR_RED,
     421        CUCUL_COLOR_GREEN, CUCUL_COLOR_BROWN,
     422        CUCUL_COLOR_BLUE, CUCUL_COLOR_MAGENTA,
     423        CUCUL_COLOR_CYAN, CUCUL_COLOR_LIGHTGRAY
     424    };
    390425
    391426    unsigned int j;
     
    393428
    394429    for(j = 0; j < argc; j++)
    395         {
    396             /* Defined in ECMA-48 8.3.117: SGR - SELECT GRAPHIC RENDITION */
    397             if(argv[j] >= 30 && argv[j] <= 37)
    398                 g->fg = ansi2cucul[argv[j] - 30];
    399             else if(argv[j] >= 40 && argv[j] <= 47)
    400                 g->bg = ansi2cucul[argv[j] - 40];
    401             else if(argv[j] >= 90 && argv[j] <= 97)
    402                 g->fg = ansi2cucul[argv[j] - 90] + 8;
    403             else if(argv[j] >= 100 && argv[j] <= 107)
    404                 g->bg = ansi2cucul[argv[j] - 100] + 8;
    405             else switch(argv[j])
    406                 {
    407                 case 0: /* default rendition */
    408                     g->fg = CUCUL_COLOR_DEFAULT;
    409                     g->bg = CUCUL_COLOR_DEFAULT;
    410                     g->bold = g->negative = g->concealed = 0;
    411                     break;
    412                 case 1: /* bold or increased intensity */
    413                     g->bold = 1;
    414                     break;
    415                 case 4: /* singly underlined */
    416                     break;
    417                 case 5: /* slowly blinking (less then 150 per minute) */
    418                     break;
    419                 case 7: /* negative image */
    420                     g->negative = 1;
    421                     break;
    422                 case 8: /* concealed characters */
    423                     g->concealed = 1;
    424                     break;
    425                 case 22: /* normal colour or normal intensity (neither bold nor faint) */
    426                     g->bold = 0;
    427                     break;
    428                 case 28: /* revealed characters */
    429                     g->concealed = 0;
    430                     break;
    431                 case 39: /* default display colour (implementation-defined) */
    432                     g->fg = CUCUL_COLOR_DEFAULT;
    433                     break;
    434                 case 49: /* default background colour (implementation-defined) */
    435                     g->bg = CUCUL_COLOR_DEFAULT;
    436                     break;
    437                 default:
    438                     fprintf(stderr, "unknown sgr %i\n", argv[j]);
    439                     break;
    440                 }
    441         }
     430    {
     431        /* Defined in ECMA-48 8.3.117: SGR - SELECT GRAPHIC RENDITION */
     432        if(argv[j] >= 30 && argv[j] <= 37)
     433            g->fg = ansi2cucul[argv[j] - 30];
     434        else if(argv[j] >= 40 && argv[j] <= 47)
     435            g->bg = ansi2cucul[argv[j] - 40];
     436        else if(argv[j] >= 90 && argv[j] <= 97)
     437            g->fg = ansi2cucul[argv[j] - 90] + 8;
     438        else if(argv[j] >= 100 && argv[j] <= 107)
     439            g->bg = ansi2cucul[argv[j] - 100] + 8;
     440        else switch(argv[j])
     441        {
     442        case 0: /* default rendition */
     443            g->fg = CUCUL_COLOR_DEFAULT;
     444            g->bg = CUCUL_COLOR_DEFAULT;
     445            g->bold = g->negative = g->concealed = 0;
     446            break;
     447        case 1: /* bold or increased intensity */
     448            g->bold = 1;
     449            break;
     450        case 4: /* singly underlined */
     451            break;
     452        case 5: /* slowly blinking (less then 150 per minute) */
     453            break;
     454        case 7: /* negative image */
     455            g->negative = 1;
     456            break;
     457        case 8: /* concealed characters */
     458            g->concealed = 1;
     459            break;
     460        case 22: /* normal colour or normal intensity (neither bold nor faint) */
     461            g->bold = 0;
     462            break;
     463        case 28: /* revealed characters */
     464            g->concealed = 0;
     465            break;
     466        case 39: /* default display colour (implementation-defined) */
     467            g->fg = CUCUL_COLOR_DEFAULT;
     468            break;
     469        case 49: /* default background colour (implementation-defined) */
     470            g->bg = CUCUL_COLOR_DEFAULT;
     471            break;
     472        default:
     473            fprintf(stderr, "unknown sgr %i\n", argv[j]);
     474            break;
     475        }
     476    }
    442477
    443478    if(g->concealed)
    444         {
    445             myfg = mybg = CUCUL_COLOR_TRANSPARENT;
    446         }
     479    {
     480        myfg = mybg = CUCUL_COLOR_TRANSPARENT;
     481    }
    447482    else
    448         {
    449             myfg = g->negative ? g->bg : g->fg;
    450             mybg = g->negative ? g->fg : g->bg;
    451 
    452             if(g->bold)
    453                 {
    454                     if(myfg < 8)
    455                         myfg += 8;
    456                     else if(myfg == CUCUL_COLOR_DEFAULT)
    457                         myfg = CUCUL_COLOR_WHITE;
    458                 }
    459         }
     483    {
     484        myfg = g->negative ? g->bg : g->fg;
     485        mybg = g->negative ? g->fg : g->bg;
     486
     487        if(g->bold)
     488        {
     489            if(myfg < 8)
     490                myfg += 8;
     491            else if(myfg == CUCUL_COLOR_DEFAULT)
     492                myfg = CUCUL_COLOR_WHITE;
     493        }
     494    }
    460495
    461496    cucul_set_color(cv, myfg, mybg);
  • libcaca/trunk/cucul/sprite.c

    r859 r920  
    2323#   include <stdlib.h>
    2424#   include <string.h>
     25#   if defined(HAVE_ERRNO_H)
     26#       include <errno.h>
     27#   endif
    2528#endif
    2629
     
    3134 *
    3235 *  This function returns the current canvas frame count.
     36 *
     37 *  This function never fails.
    3338 *
    3439 *  \param cv A libcucul canvas
     
    4853 *  If the frame index is outside the canvas' frame range, nothing happens.
    4954 *
     55 *  If an error occurs, -1 is returned and \b errno is set accordingly:
     56 *  - \c EINVAL Requested frame is out of range.
     57 *
    5058 *  \param cv A libcucul canvas
    5159 *  \param frame The canvas frame to activate
     60 *  \return 0 in case of success, -1 if an error occurred.
    5261 */
    53 void cucul_set_canvas_frame(cucul_canvas_t *cv, unsigned int frame)
     62int cucul_set_canvas_frame(cucul_canvas_t *cv, unsigned int frame)
    5463{
    5564    if(frame >= cv->framecount)
    56         return;
     65    {
     66#if defined(HAVE_ERRNO_H)
     67        errno = EINVAL;
     68#endif
     69        return -1;
     70    }
    5771
    5872    cv->frame = frame;
     
    6074    cv->chars = cv->allchars[cv->frame];
    6175    cv->attr = cv->allattr[cv->frame];
     76
     77    return 0;
    6278}
    6379
     
    7591 *  to the insertion.
    7692 *
     93 *  If an error occurs, -1 is returned and \b errno is set accordingly:
     94 *  - \c ENOMEM Not enough memory to allocate new frame.
     95 *
    7796 *  \param cv A libcucul canvas
    7897 *  \param frame The index where to insert the new frame
     98 *  \return 0 in case of success, -1 if an error occurred.
    7999 */
    80 void cucul_create_canvas_frame(cucul_canvas_t *cv, unsigned int frame)
     100int cucul_create_canvas_frame(cucul_canvas_t *cv, unsigned int frame)
    81101{
    82102    unsigned int size = cv->width * cv->height * sizeof(uint32_t);
     
    106126    cv->chars = cv->allchars[cv->frame];
    107127    cv->attr = cv->allattr[cv->frame];
     128
     129    return 0;
    108130}
    109131
     
    124146 *  renumbered due to the deletion.
    125147 *
     148 *  If an error occurs, -1 is returned and \b errno is set accordingly:
     149 *  - \c EINVAL Requested frame is out of range, or attempt to delete the
     150 *    last frame of the canvas.
     151 *
    126152 *  \param cv A libcucul canvas
    127153 *  \param frame The index of the frame to delete
     154 *  \return 0 in case of success, -1 if an error occurred.
    128155 */
    129 void cucul_free_canvas_frame(cucul_canvas_t *cv, unsigned int frame)
     156int cucul_free_canvas_frame(cucul_canvas_t *cv, unsigned int frame)
    130157{
    131158    unsigned int f;
    132159
    133160    if(frame >= cv->framecount)
    134         return;
     161    {
     162#if defined(HAVE_ERRNO_H)
     163        errno = EINVAL;
     164#endif
     165        return -1;
     166    }
    135167
    136168    if(cv->framecount == 1)
    137         return;
     169    {
     170#if defined(HAVE_ERRNO_H)
     171        errno = EINVAL;
     172#endif
     173        return -1;
     174    }
    138175
    139176    free(cv->allchars[frame]);
     
    157194    cv->chars = cv->allchars[cv->frame];
    158195    cv->attr = cv->allattr[cv->frame];
     196
     197    return 0;
    159198}
    160199
  • libcaca/trunk/cucul/transform.c

    r859 r920  
    3434 *  becomes cyan, etc.) without changing the characters in it.
    3535 *
     36 *  This function never fails.
     37 *
    3638 *  \param cv The canvas to invert.
    37  */
    38 void cucul_invert(cucul_canvas_t *cv)
     39 *  \return This function always returns 0.
     40 */
     41int cucul_invert(cucul_canvas_t *cv)
    3942{
    4043    uint32_t *attr = cv->attr;
     
    4649        attr++;
    4750    }
     51
     52    return 0;
    4853}
    4954
     
    5358 *  look like the mirrored version wherever possible.
    5459 *
     60 *  This function never fails.
     61 *
    5562 *  \param cv The canvas to flip.
    56  */
    57 void cucul_flip(cucul_canvas_t *cv)
     63 *  \return This function always returns 0.
     64 */
     65int cucul_flip(cucul_canvas_t *cv)
    5866{
    5967    unsigned int y;
     
    8391            *cleft = flipchar(*cleft);
    8492    }
     93
     94    return 0;
    8595}
    8696
     
    90100 *  look like the mirrored version wherever possible.
    91101 *
     102 *  This function never fails.
     103 *
    92104 *  \param cv The canvas to flop.
    93  */
    94 void cucul_flop(cucul_canvas_t *cv)
     105 *  \return This function always returns 0.
     106 */
     107int cucul_flop(cucul_canvas_t *cv)
    95108{
    96109    unsigned int x;
     
    121134            *ctop = flopchar(*ctop);
    122135    }
     136
     137    return 0;
    123138}
    124139
     
    129144 *  possible.
    130145 *
     146 *  This function never fails.
     147 *
    131148 *  \param cv The canvas to rotate.
    132  */
    133 void cucul_rotate(cucul_canvas_t *cv)
     149 *  \return This function always returns 0.
     150 */
     151int cucul_rotate(cucul_canvas_t *cv)
    134152{
    135153    uint32_t *cbegin = cv->chars;
     
    154172    if(cbegin == cend)
    155173        *cbegin = rotatechar(*cbegin);
     174
     175    return 0;
    156176}
    157177
Note: See TracChangeset for help on using the changeset viewer.