Changeset 962 for libcaca


Ignore:
Timestamp:
May 19, 2006, 6:53:48 AM (14 years ago)
Author:
Sam Hocevar
Message:
  • Export the UTF-8 / UTF-32 / CP437 character conversions to applications.
Location:
libcaca/trunk
Files:
13 edited

Legend:

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

    r929 r962  
    491491    int bytes;
    492492
    493     bytes = _cucul_utf32_to_utf8(buf, ch);
     493    bytes = cucul_utf32_to_utf8(buf, ch);
    494494    buf[bytes] = '\0';
    495495    addstr(buf);
  • libcaca/trunk/caca/driver_slang.c

    r929 r962  
    396396    int bytes;
    397397
    398     bytes = _cucul_utf32_to_utf8(buf, ch);
     398    bytes = cucul_utf32_to_utf8(buf, ch);
    399399    buf[bytes] = '\0';
    400400    SLsmg_write_string(buf);
  • libcaca/trunk/cucul/box.c

    r958 r962  
    156156    if(y2 > ymax) y2 = ymax;
    157157
    158     ch = _cucul_utf8_to_utf32(str);
     158    ch = cucul_utf8_to_utf32(str);
    159159
    160160    for(y = y1; y <= y2; y++)
  • libcaca/trunk/cucul/canvas.c

    r958 r962  
    117117    while(len)
    118118    {
    119         *chars++ = _cucul_utf8_to_utf32(s);
     119        *chars++ = cucul_utf8_to_utf32(s);
    120120        *attr++ = (cv->bgcolor << 16) | cv->fgcolor;
    121121
  • libcaca/trunk/cucul/charset.c

    r927 r962  
    2727#include "cucul_internals.h"
    2828
     29/*
     30 * UTF-8 handling
     31 */
     32
    2933static char const trailing[256] =
    3034{
     
    4448    0x03C82080UL, 0xFA082080UL, 0x82082080UL
    4549};
    46 
    47 unsigned int _cucul_strlen_utf8(char const *s)
    48 {
    49     int len = 0;
    50     char const *parser = s;
    51 
    52     while(*parser)
    53     {
    54         int i;
    55         int bytes = 1 + trailing[(int)(unsigned char)*parser];
    56 
    57         for(i = 1; i < bytes; i++)
    58             if(!parser[i])
    59                 return len;
    60         parser += bytes;
    61         len++;
    62     }
    63 
    64     return len;
    65 }
    66 
    67 char const *_cucul_skip_utf8(char const *s, unsigned int x)
    68 {
    69     char const *parser = s;
    70 
    71     while(x)
    72     {
    73         int i;
    74         int bytes = 1 + trailing[(int)(unsigned char)*parser];
    75 
    76         for(i = 1; i < bytes; i++)
    77             if(!parser[i])
    78                 return parser;
    79         parser += bytes;
    80         x--;
    81     }
    82 
    83     return parser;
    84 }
    85 
    86 uint32_t _cucul_utf8_to_utf32(char const *s)
    87 {
    88     int bytes = trailing[(int)(unsigned char)*s];
    89     uint32_t ret = 0;
    90 
    91     switch(bytes)
    92     {
    93         /* FIXME: do something for invalid sequences (4 and 5) */
    94         case 3: ret += (uint8_t)*s++; ret <<= 6;
    95         case 2: ret += (uint8_t)*s++; ret <<= 6;
    96         case 1: ret += (uint8_t)*s++; ret <<= 6;
    97         case 0: ret += (uint8_t)*s++;
    98     }
    99 
    100     ret -= offsets[bytes];
    101 
    102     return ret;
    103 }
    104 
    105 unsigned int _cucul_utf32_to_utf8(void *buf, uint32_t ch)
    106 {
    107     static const uint8_t mark[7] =
    108     {
    109         0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
    110     };
    111 
    112     char *parser = buf;
    113     int bytes;
    114 
    115     if(ch < 0x80)
    116     {
    117         *parser++ = ch;
    118         return 1;
    119     }
    120 
    121     bytes = (ch < 0x800) ? 2 : (ch < 0x10000) ? 3 : 4;
    122     parser += bytes;
    123 
    124     switch(bytes)
    125     {
    126         case 4: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
    127         case 3: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
    128         case 2: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
    129     }
    130     *--parser = ch | mark[bytes];
    131 
    132     return bytes;
    133 }
    13450
    13551/*
     
    17793};
    17894
    179 uint8_t _cucul_utf32_to_cp437(uint32_t ch)
     95unsigned long int cucul_utf8_to_utf32(char const *s)
     96{
     97    int bytes = trailing[(int)(unsigned char)*s];
     98    uint32_t ret = 0;
     99
     100    switch(bytes)
     101    {
     102        /* FIXME: do something for invalid sequences (4 and 5) */
     103        case 3: ret += (uint8_t)*s++; ret <<= 6;
     104        case 2: ret += (uint8_t)*s++; ret <<= 6;
     105        case 1: ret += (uint8_t)*s++; ret <<= 6;
     106        case 0: ret += (uint8_t)*s++;
     107    }
     108
     109    ret -= offsets[bytes];
     110
     111    return ret;
     112}
     113
     114unsigned int cucul_utf32_to_utf8(char *buf, unsigned long int ch)
     115{
     116    static const uint8_t mark[7] =
     117    {
     118        0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
     119    };
     120
     121    char *parser = buf;
     122    int bytes;
     123
     124    if(ch < 0x80)
     125    {
     126        *parser++ = ch;
     127        return 1;
     128    }
     129
     130    bytes = (ch < 0x800) ? 2 : (ch < 0x10000) ? 3 : 4;
     131    parser += bytes;
     132
     133    switch(bytes)
     134    {
     135        case 4: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
     136        case 3: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
     137        case 2: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
     138    }
     139    *--parser = ch | mark[bytes];
     140
     141    return bytes;
     142}
     143
     144unsigned char cucul_utf32_to_cp437(unsigned long int ch)
    180145{
    181146    unsigned int i;
     
    198163}
    199164
    200 uint32_t _cucul_cp437_to_utf32(uint8_t ch)
     165unsigned long int cucul_cp437_to_utf32(unsigned char ch)
    201166{
    202167    if(ch > 0x7f)
     
    212177}
    213178
     179unsigned int _cucul_strlen_utf8(char const *s)
     180{
     181    int len = 0;
     182    char const *parser = s;
     183
     184    while(*parser)
     185    {
     186        int i;
     187        int bytes = 1 + trailing[(int)(unsigned char)*parser];
     188
     189        for(i = 1; i < bytes; i++)
     190            if(!parser[i])
     191                return len;
     192        parser += bytes;
     193        len++;
     194    }
     195
     196    return len;
     197}
     198
     199char const *_cucul_skip_utf8(char const *s, unsigned int x)
     200{
     201    char const *parser = s;
     202
     203    while(x)
     204    {
     205        int i;
     206        int bytes = 1 + trailing[(int)(unsigned char)*parser];
     207
     208        for(i = 1; i < bytes; i++)
     209            if(!parser[i])
     210                return parser;
     211        parser += bytes;
     212        x--;
     213    }
     214
     215    return parser;
     216}
     217
  • libcaca/trunk/cucul/conic.c

    r958 r962  
    4444{
    4545    int test, dx, dy;
    46     uint32_t ch = _cucul_utf8_to_utf32(str);
     46    uint32_t ch = cucul_utf8_to_utf32(str);
    4747
    4848    /* Optimized Bresenham. Kick ass. */
     
    139139    int y = b;
    140140    int d1 = b*b - (a*a*b) + (a*a/4);
    141     uint32_t ch = _cucul_utf8_to_utf32(str);
     141    uint32_t ch = cucul_utf8_to_utf32(str);
    142142
    143143    ellipsepoints(cv, xo, yo, x, y, ch);
  • libcaca/trunk/cucul/cucul.h

    r958 r962  
    117117int cucul_flop(cucul_canvas_t *);
    118118int cucul_rotate(cucul_canvas_t *);
     119/*  @} */
     120
     121/** \defgroup charset libcucul character set conversions
     122 *
     123 *  These functions perform conversions between usual character sets.
     124 *
     125 *  @{ */
     126extern unsigned long int cucul_utf8_to_utf32(char const *);
     127extern unsigned int cucul_utf32_to_utf8(char *, unsigned long int);
     128extern unsigned char cucul_utf32_to_cp437(unsigned long int);
     129extern unsigned long int cucul_cp437_to_utf32(unsigned char);
    119130/*  @} */
    120131
  • libcaca/trunk/cucul/cucul_internals.h

    r958 r962  
    5757extern unsigned int _cucul_strlen_utf8(char const *);
    5858extern char const *_cucul_skip_utf8(char const *, unsigned int);
    59 extern uint32_t _cucul_utf8_to_utf32(char const *);
    60 extern unsigned int _cucul_utf32_to_utf8(void *, uint32_t);
    61 extern uint8_t _cucul_utf32_to_cp437(uint32_t);
    62 extern uint32_t _cucul_cp437_to_utf32(uint8_t);
    6359
    6460/* Colour functions */
  • libcaca/trunk/cucul/export.c

    r952 r962  
    250250            }
    251251
    252             cur += _cucul_utf32_to_utf8(cur, ch);
     252            cur += cucul_utf32_to_utf8(cur, ch);
    253253
    254254            prevfg = fg;
     
    314314            }
    315315
    316             *cur++ = _cucul_utf32_to_cp437(ch);
     316            *cur++ = cucul_utf32_to_cp437(ch);
    317317
    318318            prevfg = fg;
     
    716716                *cur++ = '?';
    717717            else if(ch > 0x0000007f)
    718                 cur += _cucul_utf32_to_utf8(cur, ch);
     718                cur += cucul_utf32_to_utf8(cur, ch);
    719719            else switch((uint8_t)ch)
    720720            {
  • libcaca/trunk/cucul/import.c

    r958 r962  
    406406
    407407        /* Now paste our character */
    408         cucul_putchar(cv, x, y, _cucul_cp437_to_utf32(buffer[i]));
     408        cucul_putchar(cv, x, y, cucul_cp437_to_utf32(buffer[i]));
    409409        x++;
    410410    }
  • libcaca/trunk/cucul/line.c

    r958 r962  
    6262    s.x2 = x2;
    6363    s.y2 = y2;
    64     s.ch = _cucul_utf8_to_utf32(str);
     64    s.ch = cucul_utf8_to_utf32(str);
    6565    s.draw = draw_solid_line;
    6666    clip_line(cv, &s);
     
    9090    int i;
    9191    struct line s;
    92     s.ch = _cucul_utf8_to_utf32(str);
     92    s.ch = cucul_utf8_to_utf32(str);
    9393    s.draw = draw_solid_line;
    9494
  • libcaca/trunk/cucul/triangle.c

    r958 r962  
    110110    ymax = cv->height - 1;
    111111
    112     ch = _cucul_utf8_to_utf32(str);
     112    ch = cucul_utf8_to_utf32(str);
    113113
    114114    /* Rasterize our triangle */
  • libcaca/trunk/tools/makefont.c

    r960 r962  
    2929
    3030#include "cucul.h"
    31 #include "cucul_internals.h"
    3231
    3332#include <pango/pango.h>
     
    222221
    223222            gtab[n].unicode = i;
    224             bytes = _cucul_utf32_to_utf8(gtab[n].buf, gtab[n].unicode);
     223            bytes = cucul_utf32_to_utf8(gtab[n].buf, gtab[n].unicode);
    225224            gtab[n].buf[bytes] = '\0';
    226225
Note: See TracChangeset for help on using the changeset viewer.