Changeset 1362


Ignore:
Timestamp:
Nov 12, 2006, 4:26:13 PM (13 years ago)
Author:
Sam Hocevar
Message:
  • Got rid of HAVE_ERRNO_H ifdefs by defining seterrno()/geterrno() functions.
  • More debugging information in the import/export and font functions.
Location:
libcaca/trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/caca/caca.c

    r1208 r1362  
    2525#   include <string.h>
    2626#   include <stdio.h>
    27 #   if defined(HAVE_ERRNO_H)
    28 #       include <errno.h>
    29 #   endif
    3027#   if defined(USE_PLUGINS)
    3128#       if defined(HAVE_DLFCN_H)
     
    7067    if(!dp)
    7168    {
    72 #if defined(HAVE_ERRNO_H)
    73         errno = ENOMEM;
    74 #endif
     69        seterrno(ENOMEM);
    7570        return NULL;
    7671    }
     
    8883#endif
    8984        free(dp);
    90 #if defined(HAVE_ERRNO_H)
    91         errno = ENODEV;
    92 #endif
     85        seterrno(ENODEV);
    9386        return NULL;
    9487    }
     
    10194#endif
    10295        free(dp);
    103 #if defined(HAVE_ERRNO_H)
    104         errno = ENODEV;
    105 #endif
     96        seterrno(ENODEV);
    10697        return NULL;
    10798    }
  • libcaca/trunk/caca/graphics.c

    r1231 r1362  
    1919#include "common.h"
    2020
    21 #if !defined(__KERNEL__)
    22 #   if defined(HAVE_ERRNO_H)
    23 #       include <errno.h>
    24 #   endif
    25 #endif
    26 
    2721#include "caca.h"
    2822#include "caca_internals.h"
     
    4640    int ret = dp->drv.set_display_title(dp, title);
    4741
    48 #if defined(HAVE_ERRNO_H)
    4942    if(ret)
    50         errno = ENOSYS;
    51 #endif
     43        seterrno(ENOSYS);
    5244
    5345    return ret;
     
    196188    if(!dp->drv.set_mouse)
    197189    {
    198 #if defined(HAVE_ERRNO_H)
    199         errno = ENOSYS;
    200 #endif
     190        seterrno(ENOSYS);
    201191        return -1;
    202192    }
  • libcaca/trunk/common.h

    r1360 r1362  
    1818 */
    1919
     20/* C99 types */
    2021#if defined HAVE_INTTYPES_H && !defined __KERNEL__
    2122#   include <inttypes.h>
     
    3334#endif
    3435
     36/* errno handling */
     37#if defined HAVE_ERRNO_H && !defined __KERNEL__
     38#   include <errno.h>
     39static inline void seterrno(int e) { errno = e; }
     40static inline int geterrno(void) { return errno; }
     41#else
     42#   define seterrno(x) do {} while(0)
     43#   define geterrno(x) 0
     44#endif
     45
     46/* debug messages */
    3547#if defined DEBUG && !defined __KERNEL__
    3648#   include <stdio.h>
    3749#   include <stdarg.h>
    38 #   if defined(HAVE_ERRNO_H)
    39 #       include <errno.h>
    40 #   endif
    4150static inline void debug(const char *format, ...)
    4251{
    43 #   if defined(HAVE_ERRNO_H)
    44     int saved_errno = errno;
    45 #   endif
     52    int saved_errno = geterrno();
    4653    va_list args;
    4754    va_start(args, format);
     
    5057    fprintf(stderr, "\n");
    5158    va_end(args);
    52 #   if defined(HAVE_ERRNO_H)
    53     errno = saved_errno;
    54 #   endif
     59    seterrno(saved_errno);
    5560}
    5661#else
     
    5863#endif
    5964
     65/* hton16() and hton32() */
    6066#if defined HAVE_HTONS
    6167#   if defined __KERNEL__
     
    102108#endif
    103109
    104 #if defined __KERNEL__
    105 #   undef HAVE_ERRNO_H
    106 #endif
    107 
  • libcaca/trunk/cucul/attr.c

    r1347 r1362  
    1919#include "config.h"
    2020#include "common.h"
    21 
    22 #if defined(HAVE_ERRNO_H)
    23 #   include <errno.h>
    24 #endif
    2521
    2622#include "cucul.h"
     
    9086    if(sizeof(unsigned long int) > sizeof(uint32_t) && attr > 0xffffffff)
    9187    {
    92 #if defined(HAVE_ERRNO_H)
    93         errno = EINVAL;
    94 #endif
     88        seterrno(EINVAL);
    9589        return -1;
    9690    }
     
    132126    if(sizeof(unsigned long int) > sizeof(uint32_t) && attr > 0xffffffff)
    133127    {
    134 #if defined(HAVE_ERRNO_H)
    135         errno = EINVAL;
    136 #endif
     128        seterrno(EINVAL);
    137129        return -1;
    138130    }
     
    178170    if(fg > 0x20 || bg > 0x20)
    179171    {
    180 #if defined(HAVE_ERRNO_H)
    181         errno = EINVAL;
    182 #endif
     172        seterrno(EINVAL);
    183173        return -1;
    184174    }
     
    214204    if(fg > 0xffff || bg > 0xffff)
    215205    {
    216 #if defined(HAVE_ERRNO_H)
    217         errno = EINVAL;
    218 #endif
     206        seterrno(EINVAL);
    219207        return -1;
    220208    }
  • libcaca/trunk/cucul/canvas.c

    r1347 r1362  
    2525#   include <stdlib.h>
    2626#   include <stdarg.h>
    27 #   if defined(HAVE_ERRNO_H)
    28 #       include <errno.h>
    29 #   endif
    3027#   if defined(HAVE_UNISTD_H)
    3128#       include <unistd.h>
     
    385382    if(mask && (src->width != mask->width || src->height != mask->height))
    386383    {
    387 #if defined(HAVE_ERRNO_H)
    388         errno = EINVAL;
    389 #endif
     384        seterrno(EINVAL);
    390385        return -1;
    391386    }
     
    472467    if(cv->refcount)
    473468    {
    474 #if defined(HAVE_ERRNO_H)
    475         errno = EBUSY;
    476 #endif
     469        seterrno(EBUSY);
    477470        return -1;
    478471    }
  • libcaca/trunk/cucul/cucul.c

    r1342 r1362  
    2525#   include <string.h>
    2626#   include <time.h>
    27 #   if defined(HAVE_ERRNO_H)
    28 #       include <errno.h>
    29 #   endif
    3027#   include <sys/types.h>
    3128#   if defined(HAVE_UNISTD_H)
     
    8885    if(_cucul_set_canvas_size(cv, width, height) < 0)
    8986    {
    90 #if defined(HAVE_ERRNO_H)
    91         int saved_errno = errno;
    92 #endif
     87        int saved_errno = geterrno();
    9388        free(cv->frames);
    9489        free(cv);
    95 #if defined(HAVE_ERRNO_H)
    96         errno = saved_errno;
    97 #endif
     90        seterrno(saved_errno);
    9891        return NULL;
    9992    }
     
    10295
    10396nomem:
    104 #if defined(HAVE_ERRNO_H)
    105     errno = ENOMEM;
    106 #endif
     97    seterrno(ENOMEM);
    10798    return NULL;
    10899}
     
    138129    if(cv->refcount)
    139130    {
    140 #if defined(HAVE_ERRNO_H)
    141         errno = EBUSY;
    142 #endif
     131        seterrno(EBUSY);
    143132        return -1;
    144133    }
     
    193182    if(cv->refcount)
    194183    {
    195 #if defined(HAVE_ERRNO_H)
    196         errno = EBUSY;
    197 #endif
     184        seterrno(EBUSY);
    198185        return -1;
    199186    }
     
    263250            if(new_size && (!cv->frames[f].chars || !cv->frames[f].attrs))
    264251            {
    265 #if defined(HAVE_ERRNO_H)
    266                 errno = ENOMEM;
    267 #endif
     252                seterrno(ENOMEM);
    268253                return -1;
    269254            }
     
    357342            if(new_size && (!cv->frames[f].chars || !cv->frames[f].attrs))
    358343            {
    359 #if defined(HAVE_ERRNO_H)
    360                 errno = ENOMEM;
    361 #endif
     344                seterrno(ENOMEM);
    362345                return -1;
    363346            }
  • libcaca/trunk/cucul/dither.c

    r1347 r1362  
    2727#   include <limits.h>
    2828#   include <string.h>
    29 #   if defined(HAVE_ERRNO_H)
    30 #       include <errno.h>
    31 #   endif
    3229#endif
    3330
     
    272269    if(!w || !h || !pitch || bpp > 32 || bpp < 8)
    273270    {
    274 #if defined(HAVE_ERRNO_H)
    275         errno = EINVAL;
    276 #endif
     271        seterrno(EINVAL);
    277272        return NULL;
    278273    }
     
    281276    if(!d)
    282277    {
    283 #if defined(HAVE_ERRNO_H)
    284         errno = ENOMEM;
    285 #endif
     278        seterrno(ENOMEM);
    286279        return NULL;
    287280    }
     
    378371    if(d->bpp != 8)
    379372    {
    380 #if defined(HAVE_ERRNO_H)
    381         errno = EINVAL;
    382 #endif
     373        seterrno(EINVAL);
    383374        return -1;
    384375    }
     
    388379        if((red[i] | green[i] | blue[i] | alpha[i]) >= 0x1000)
    389380        {
    390 #if defined(HAVE_ERRNO_H)
    391             errno = EINVAL;
    392 #endif
     381            seterrno(EINVAL);
    393382            return -1;
    394383        }
     
    449438    if(gamma <= 0.0)
    450439    {
    451 #if defined(HAVE_ERRNO_H)
    452         errno = EINVAL;
    453 #endif
     440        seterrno(EINVAL);
    454441        return -1;
    455442    }
     
    521508    else
    522509    {
    523 #if defined(HAVE_ERRNO_H)
    524         errno = EINVAL;
    525 #endif
     510        seterrno(EINVAL);
    526511        return -1;
    527512    }
     
    597582    else
    598583    {
    599 #if defined(HAVE_ERRNO_H)
    600         errno = EINVAL;
    601 #endif
     584        seterrno(EINVAL);
    602585        return -1;
    603586    }
     
    676659    else
    677660    {
    678 #if defined(HAVE_ERRNO_H)
    679         errno = EINVAL;
    680 #endif
     661        seterrno(EINVAL);
    681662        return -1;
    682663    }
     
    771752    else
    772753    {
    773 #if defined(HAVE_ERRNO_H)
    774         errno = EINVAL;
    775 #endif
     754        seterrno(EINVAL);
    776755        return -1;
    777756    }
  • libcaca/trunk/cucul/export.c

    r1360 r1362  
    2121
    2222#if !defined(__KERNEL__)
    23 #   if defined(HAVE_ERRNO_H)
    24 #       include <errno.h>
    25 #   endif
    2623#   include <stdlib.h>
    2724#   include <stdio.h>
     
    118115        return export_tga(cv, bytes);
    119116
    120 #if defined(HAVE_ERRNO_H)
    121     errno = EINVAL;
    122 #endif
     117    seterrno(EINVAL);
    123118    return NULL;
    124119}
     
    277272
    278273    /* Crop to really used size */
    279     debug("utf8 export: alloc %li bytes, realloc %li\n",
    280           (long int)*bytes, (long int)(uintptr_t)(cur - data));
     274    debug("utf8 export: alloc %lu bytes, realloc %lu",
     275          (unsigned long int)*bytes, (unsigned long int)(cur - data));
    281276    *bytes = (uintptr_t)(cur - data);
    282277    data = realloc(data, *bytes);
     
    357352
    358353    /* Crop to really used size */
    359     debug("ansi export: alloc %li bytes, realloc %li\n",
    360           (long int)*bytes, (long int)(uintptr_t)(cur - data));
     354    debug("ansi export: alloc %lu bytes, realloc %lu",
     355          (unsigned long int)*bytes, (unsigned long int)(cur - data));
    361356    *bytes = (uintptr_t)(cur - data);
    362357    data = realloc(data, *bytes);
     
    433428
    434429    /* Crop to really used size */
    435     debug("html export: alloc %li bytes, realloc %li\n",
    436           (long int)*bytes, (long int)(uintptr_t)(cur - data));
     430    debug("html export: alloc %lu bytes, realloc %lu",
     431          (unsigned long int)*bytes, (unsigned long int)(cur - data));
    437432    *bytes = (uintptr_t)(cur - data);
    438433    data = realloc(data, *bytes);
     
    528523
    529524    /* Crop to really used size */
    530     debug("html3 export: alloc %li bytes, realloc %li\n",
    531           (long int)*bytes, (long int)(uintptr_t)(cur - data));
     525    debug("html3 export: alloc %lu bytes, realloc %lu",
     526          (unsigned long int)*bytes, (unsigned long int)(cur - data));
    532527    *bytes = (uintptr_t)(cur - data);
    533528    data = realloc(data, *bytes);
     
    635630
    636631    /* Crop to really used size */
    637     debug("IRC export: alloc %li bytes, realloc %li\n",
    638           (long int)*bytes, (long int)(uintptr_t)(cur - data));
     632    debug("IRC export: alloc %lu bytes, realloc %lu",
     633          (unsigned long int)*bytes, (unsigned long int)(cur - data));
    639634    *bytes = (uintptr_t)(cur - data);
    640635    data = realloc(data, *bytes);
     
    744739
    745740    /* Crop to really used size */
    746     debug("PS export: alloc %li bytes, realloc %li\n",
    747           (long int)*bytes, (long int)(uintptr_t)(cur - data));
     741    debug("PS export: alloc %lu bytes, realloc %lu",
     742          (unsigned long int)*bytes, (unsigned long int)(cur - data));
    748743    *bytes = (uintptr_t)(cur - data);
    749744    data = realloc(data, *bytes);
     
    830825
    831826    /* Crop to really used size */
    832     debug("SVG export: alloc %li bytes, realloc %li\n",
    833           (long int)*bytes, (long int)(uintptr_t)(cur - data));
     827    debug("SVG export: alloc %lu bytes, realloc %lu",
     828          (unsigned long int)*bytes, (unsigned long int)(cur - data));
    834829    *bytes = (uintptr_t)(cur - data);
    835830    data = realloc(data, *bytes);
     
    849844    if(!fontlist[0])
    850845    {
    851 #if defined(HAVE_ERRNO_H)
    852         errno = EINVAL;
    853 #endif
     846        seterrno(EINVAL);
    854847        return NULL;
    855848    }
  • libcaca/trunk/cucul/font.c

    r1359 r1362  
    2222#   if defined(HAVE_ENDIAN_H)
    2323#       include <endian.h>
    24 #   endif
    25 #   if defined(HAVE_ERRNO_H)
    26 #       include <errno.h>
    2724#   endif
    2825#   include <stdio.h>
     
    127124            return cucul_load_font((char *)&monobold12_data, monobold12_size);
    128125
    129 #if defined(HAVE_ERRNO_H)
    130         errno = ENOENT;
    131 #endif
     126        seterrno(ENOENT);
    132127        return NULL;
    133128    }
     
    135130    if(size < sizeof(struct font_header))
    136131    {
    137 #if defined(HAVE_ERRNO_H)
    138         errno = EINVAL;
    139 #endif
     132        debug("font error: data size %i < header size %i",
     133              size, (int)sizeof(struct font_header));
     134        seterrno(EINVAL);
    140135        return NULL;
    141136    }
     
    144139    if(!f)
    145140    {
    146 #if defined(HAVE_ERRNO_H)
    147         errno = ENOMEM;
    148 #endif
     141        seterrno(ENOMEM);
    149142        return NULL;
    150143    }
     
    168161        || (f->header.flags & 1) == 0)
    169162    {
     163#if defined DEBUG
     164        if(size != 4 + f->header.control_size + f->header.data_size)
     165            debug("font error: data size %i < expected size %i",
     166                  size, 4 + f->header.control_size + f->header.data_size);
     167        else if(f->header.bpp != 8 && f->header.bpp != 4 &&
     168                f->header.bpp != 2 && f->header.bpp != 1)
     169            debug("font error: invalid bpp %i", f->header.bpp);
     170        else if((f->header.flags & 1) == 0)
     171            debug("font error: invalid flags %.04x", f->header.flags);
     172#endif
    170173        free(f);
    171 #if defined(HAVE_ERRNO_H)
    172         errno = EINVAL;
    173 #endif
     174        seterrno(EINVAL);
    174175        return NULL;
    175176    }
     
    179180    {
    180181        free(f);
    181 #if defined(HAVE_ERRNO_H)
    182         errno = ENOMEM;
    183 #endif
     182        seterrno(ENOMEM);
    184183        return NULL;
    185184    }
     
    191190        free(f->block_list);
    192191        free(f);
    193 #if defined(HAVE_ERRNO_H)
    194         errno = ENOMEM;
    195 #endif
     192        seterrno(ENOMEM);
    196193        return NULL;
    197194    }
     
    210207            || f->block_list[i].index >= f->header.glyphs)
    211208        {
     209#if defined DEBUG
     210            if(f->block_list[i].start > f->block_list[i].stop)
     211                debug("font error: block %i has start %i > stop %i",
     212                      i, f->block_list[i].start, f->block_list[i].stop);
     213            else if(i > 0 && f->block_list[i].start < f->block_list[i - 1].stop)
     214                debug("font error: block %i has start %i < previous stop %i",
     215                      f->block_list[i].start, f->block_list[i - 1].stop);
     216            else if(f->block_list[i].index >= f->header.glyphs)
     217                debug("font error: block %i has index >= glyph count %i",
     218                      f->block_list[i].index, f->header.glyphs);
     219#endif
    212220            free(f->user_block_list);
    213221            free(f->block_list);
    214222            free(f);
    215 #if defined(HAVE_ERRNO_H)
    216             errno = EINVAL;
    217 #endif
     223            seterrno(EINVAL);
    218224            return NULL;
    219225        }
     
    232238        free(f->block_list);
    233239        free(f);
    234 #if defined(HAVE_ERRNO_H)
    235         errno = ENOMEM;
    236 #endif
     240        seterrno(ENOMEM);
    237241        return NULL;
    238242    }
     
    253257                   f->header.bpp + 7) / 8 > f->header.data_size)
    254258        {
     259#if defined DEBUG
     260            if(f->glyph_list[i].data_offset >= f->header.data_size)
     261                debug("font error: glyph %i has data start %i > "
     262                      "data end %i",
     263                      f->glyph_list[i].data_offset, f->header.data_size);
     264            else if(f->glyph_list[i].data_offset
     265                     + (f->glyph_list[i].width * f->glyph_list[i].height *
     266                        f->header.bpp + 7) / 8 > f->header.data_size)
     267                debug("font error: glyph %i has data end %i > "
     268                      "data end %i", f->glyph_list[i].data_offset
     269                       + (f->glyph_list[i].width * f->glyph_list[i].height *
     270                          f->header.bpp + 7) / 8, f->header.data_size);
     271#endif
    255272            free(f->glyph_list);
    256273            free(f->user_block_list);
    257274            free(f->block_list);
    258275            free(f);
    259 #if defined(HAVE_ERRNO_H)
    260             errno = EINVAL;
    261 #endif
     276            seterrno(EINVAL);
    262277            return NULL;
    263278        }
  • libcaca/trunk/cucul/frame.c

    r1357 r1362  
    2323#   include <stdlib.h>
    2424#   include <string.h>
    25 #   if defined(HAVE_ERRNO_H)
    26 #       include <errno.h>
    27 #   endif
    2825#endif
    2926
     
    6764    if(frame >= cv->framecount)
    6865    {
    69 #if defined(HAVE_ERRNO_H)
    70         errno = EINVAL;
    71 #endif
     66        seterrno(EINVAL);
    7267        return -1;
    7368    }
     
    161156    if(id >= cv->framecount)
    162157    {
    163 #if defined(HAVE_ERRNO_H)
    164         errno = EINVAL;
    165 #endif
     158        seterrno(EINVAL);
    166159        return -1;
    167160    }
     
    169162    if(cv->framecount == 1)
    170163    {
    171 #if defined(HAVE_ERRNO_H)
    172         errno = EINVAL;
    173 #endif
     164        seterrno(EINVAL);
    174165        return -1;
    175166    }
  • libcaca/trunk/cucul/import.c

    r1349 r1362  
    2020
    2121#if !defined __KERNEL__
    22 #   if defined HAVE_ERRNO_H
    23 #       include <errno.h>
    24 #   endif
    2522#   include <stdio.h>
    2623#   include <stdlib.h>
     
    119116    }
    120117
    121 #if defined HAVE_ERRNO_H
    122     errno = EINVAL;
    123 #endif
     118    seterrno(EINVAL);
    124119    return -1;
    125120}
     
    158153{
    159154#if defined __KERNEL__
    160 #   if defined HAVE_ERRNO_H
    161     errno = ENOSYS;
    162 #   endif
     155    seterrno(ENOSYS);
    163156    return -1;
    164157#else
     
    179172    {
    180173        fclose(fp);
    181 #   if defined HAVE_ERRNO_H
    182         errno = ENOMEM;
    183 #   endif
     174        seterrno(ENOMEM);
    184175        return -1;
    185176    }
     
    237228
    238229    if(buf[0] != 0xca || buf[1] != 0xca || buf[2] != 'C' || buf[3] != 'V')
     230    {
     231        debug("caca import error: expected \\xca\\xcaCV header");
    239232        goto invalid_caca;
     233    }
    240234
    241235    control_size = sscanu32(buf + 4);
     
    249243
    250244    if(control_size < 16 + frames * 32)
     245    {
     246        debug("caca import error: control size %lu < expected %lu",
     247              (unsigned long int)control_size, 16 + frames * 32);
    251248        goto invalid_caca;
     249    }
    252250
    253251    for(expected_size = 0, f = 0; f < frames; f++)
     
    270268
    271269    if(expected_size != data_size)
     270    {
     271        debug("caca import error: data size %lu < expected %lu",
     272              (unsigned long int)data_size, (unsigned long int)expected_size);
    272273        goto invalid_caca;
     274    }
    273275
    274276    /* FIXME: read all frames, not only the first one */
     
    294296
    295297invalid_caca:
    296 #if defined HAVE_ERRNO_H
    297     errno = EINVAL;
    298 #endif
     298    seterrno(EINVAL);
    299299    return -1;
    300300}
  • libcaca/trunk/cucul/legacy.c

    r1347 r1362  
    2121
    2222#if !defined(__KERNEL__)
    23 #   if defined(HAVE_ERRNO_H)
    24 #       include <errno.h>
    25 #   endif
    2623#   include <stdio.h>
    2724#   include <stdlib.h>
     
    8986    if(!ex)
    9087    {
    91 #if defined(HAVE_ERRNO_H)
    92         errno = ENOMEM;
    93 #endif
     88        seterrno(ENOMEM);
    9489        return NULL;
    9590    }
Note: See TracChangeset for help on using the changeset viewer.