Changeset 535


Ignore:
Timestamp:
Mar 6, 2006, 8:13:01 PM (15 years ago)
Author:
Sam Hocevar
Message:
  • Use 32 bit integers for the character array. No visible difference for now because we only do ASCII, but that will let us do Unicode later.
Location:
libcaca/trunk/src
Files:
6 edited

Legend:

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

    r527 r535  
    2525#   include <inttypes.h>
    2626#else
     27typedef unsigned int uint32_t;
    2728typedef unsigned char uint8_t;
    2829#endif
  • libcaca/trunk/src/char.c

    r527 r535  
    2323#   include <inttypes.h>
    2424#else
     25typedef unsigned int uint32_t;
    2526typedef unsigned char uint8_t;
    2627#endif
     
    102103        return;
    103104
    104     qq->chars[x + y * qq->width] = c;
     105    qq->chars[x + y * qq->width] = c & 0x7f; /* FIXME: ASCII-only */
    105106    qq->attr[x + y * qq->width] = (qq->bgcolor << 4) | qq->fgcolor;
    106107}
     
    119120void cucul_putstr(cucul_t *qq, int x, int y, char const *s)
    120121{
    121     unsigned char *charbuf;
    122     unsigned char *attrbuf;
     122    uint32_t *chars;
     123    uint8_t *attr;
    123124    char const *t;
    124125    unsigned int len;
     
    146147    }
    147148
    148     charbuf = qq->chars + x + y * qq->width;
    149     attrbuf = qq->attr + x + y * qq->width;
     149    chars = qq->chars + x + y * qq->width;
     150    attr = qq->attr + x + y * qq->width;
    150151    t = s;
    151152    while(*t)
    152153    {
    153         *charbuf++ = *t++;
    154         *attrbuf++ = (qq->bgcolor << 4) | qq->fgcolor;
     154        *chars++ = *t++ & 0x7f; /* FIXME: ASCII-only */
     155        *attr++ = (qq->bgcolor << 4) | qq->fgcolor;
    155156    }
    156157}
     
    209210        {
    210211            *buffer++ = qq->attr[x + y * qq->width];
    211             *buffer++ = qq->chars[x + y * qq->width];
     212            *buffer++ = qq->chars[x + y * qq->width] & 0x7f; /* FIXME: ASCII */
    212213        }
    213214    }
  • libcaca/trunk/src/cucul.c

    r527 r535  
    2424#   include <inttypes.h>
    2525#else
     26typedef unsigned int uint32_t;
    2627typedef unsigned char uint8_t;
    2728#endif
     
    4748{
    4849    cucul_t *qq = malloc(sizeof(cucul_t));
     50    int i;
    4951
    5052    cucul_read_environment(qq);
     
    5860    qq->height = 32;
    5961
    60     qq->chars = malloc(qq->width * qq->height * sizeof(uint8_t));
     62    qq->chars = malloc(qq->width * qq->height * sizeof(uint32_t));
    6163    qq->attr = malloc(qq->width * qq->height * sizeof(uint8_t));
    6264
    63     memset(qq->chars, ' ', qq->width * qq->height * sizeof(uint8_t));
     65    for(i = qq->width * qq->height; i--; )
     66        qq->chars[i] = (uint32_t)' ';
    6467    memset(qq->attr, 0, qq->width * qq->height * sizeof(uint8_t));
    6568
     
    101104    if(new_size > old_size)
    102105    {
    103         qq->chars = realloc(qq->chars, new_size * sizeof(uint8_t));
     106        qq->chars = realloc(qq->chars, new_size * sizeof(uint32_t));
    104107        qq->attr = realloc(qq->attr, new_size * sizeof(uint8_t));
    105108    }
     
    125128
    126129            /* Zero the end of the line */
    127             memset(qq->chars + y * width + old_width, ' ',
    128                    width - old_width);
     130            for(x = width - old_width; x--; )
     131                qq->chars[y * width + old_width + x] = (uint32_t)' ';
    129132            memset(qq->attr + y * width + old_width, 0,
    130133                   width - old_width);
     
    151154    {
    152155        /* Zero the bottom of the screen */
    153         memset(qq->chars + old_height * width, ' ',
     156        for(x = (height - old_height) * width; x--; )
     157            qq->chars[old_height * width + x] = (uint32_t)' ';
     158        memset(qq->attr + old_height * width, 0,
    154159               (height - old_height) * width);
    155160    }
     
    158163    if(new_size <= old_size)
    159164    {
    160         qq->chars = realloc(qq->chars, new_size * sizeof(uint8_t));
     165        qq->chars = realloc(qq->chars, new_size * sizeof(uint32_t));
    161166        qq->attr = realloc(qq->attr, new_size * sizeof(uint8_t));
    162167    }
  • libcaca/trunk/src/cucul_internals.h

    r527 r535  
    2626    unsigned int width, height;
    2727
    28     uint8_t *chars, *attr;
     28    uint32_t *chars;
     29    uint8_t *attr;
    2930    uint8_t *empty_line, *scratch_line;
    3031
  • libcaca/trunk/src/export.c

    r527 r535  
    2323#   include <inttypes.h>
    2424#else
     25typedef unsigned int uint32_t;
    2526typedef unsigned char uint8_t;
    2627#endif
     
    7576    {
    7677        uint8_t *lineattr = qq->attr + y * qq->width;
    77         uint8_t *linechar = qq->chars + y * qq->width;
     78        uint32_t *linechar = qq->chars + y * qq->width;
    7879
    7980        for(x = 0; x < qq->width; x += len)
     
    8586                len++)
    8687            {
    87                 if(linechar[x + len] == ' ')
     88                if(linechar[x + len] == (uint32_t)' ')
    8889                    cur += sprintf(cur, "&nbsp;");
    8990                else
    90                     cur += sprintf(cur, "%c", linechar[x + len]);
     91                    cur += sprintf(cur, "%c", linechar[x + len] & 0x7f);
    9192            }
    9293            cur += sprintf(cur, "</span>");
     
    136137    {
    137138        uint8_t *lineattr = qq->attr + y * qq->width;
    138         uint8_t *linechar = qq->chars + y * qq->width;
     139        uint32_t *linechar = qq->chars + y * qq->width;
    139140
    140141        cur += sprintf(cur, "<tr>");
     
    160161            for(i = 0; i < len; i++)
    161162            {
    162                 if(linechar[x + i] == ' ')
     163                if(linechar[x + i] == (uint32_t)' ')
    163164                    cur += sprintf(cur, "&nbsp;");
    164165                else
    165                     cur += sprintf(cur, "%c", linechar[x + i]);
     166                    cur += sprintf(cur, "%c", linechar[x + i] & 0x7f);
    166167            }
    167168
     
    211212    {
    212213        uint8_t *lineattr = qq->attr + y * qq->width;
    213         uint8_t *linechar = qq->chars + y * qq->width;
     214        uint32_t *linechar = qq->chars + y * qq->width;
    214215
    215216        uint8_t prevfg = -1;
     
    220221            uint8_t fg = palette[lineattr[x] & 0x0f];
    221222            uint8_t bg = palette[lineattr[x] >> 4];
    222             uint8_t c = linechar[x];
     223            uint32_t c = linechar[x];
    223224
    224225            if(bg == prevbg)
     
    226227                if(fg == prevfg)
    227228                    ; /* Same fg/bg, do nothing */
    228                 else if(c == ' ')
     229                else if(c == (uint32_t)' ')
    229230                    fg = prevfg; /* Hackety hack */
    230231                else
    231232                {
    232233                    cur += sprintf(cur, "\x03%d", fg);
    233                     if(c >= '0' && c <= '9')
     234                    if(c >= (uint32_t)'0' && c <= (uint32_t)'9')
    234235                        cur += sprintf(cur, "\x02\x02");
    235236                }
     
    242243                    cur += sprintf(cur, "\x03%d,%d", fg, bg);
    243244
    244                 if(c >= '0' && c <= '9')
     245                if(c >= (uint32_t)'0' && c <= (uint32_t)'9')
    245246                    cur += sprintf(cur, "\x02\x02");
    246247            }
    247             *cur++ = c;
     248            *cur++ = c & 0x7f;
    248249            prevfg = fg;
    249250            prevbg = bg;
     
    290291    {
    291292        uint8_t *lineattr = qq->attr + y * qq->width;
    292         uint8_t *linechar = qq->chars + y * qq->width;
     293        uint32_t *linechar = qq->chars + y * qq->width;
    293294
    294295        uint8_t prevfg = -1;
     
    299300            uint8_t fg = palette[lineattr[x] & 0x0f];
    300301            uint8_t bg = (palette[lineattr[x] >> 4])+10;
    301             uint8_t c = linechar[x];
     302            uint32_t c = linechar[x];
    302303
    303304            if(!trailing)
     
    310311            else
    311312                cur += sprintf(cur, "0;%d;%dm",fg,bg);
    312             *cur++ = c;
     313            *cur++ = c & 0x7f;
    313314            if((c == '%') && trailing)
    314                 *cur++ = c;
     315                *cur++ = c & 0x7f;
    315316            prevfg = fg;
    316317            prevbg = bg;
  • libcaca/trunk/src/graphics.c

    r534 r535  
    5757#   include <inttypes.h>
    5858#else
     59typedef unsigned int uint32_t;
    5960typedef unsigned char uint8_t;
    6061#endif
     
    880881        int x, y;
    881882        uint8_t *attr = kk->qq->attr;
    882         uint8_t *chars = kk->qq->chars;
     883        uint32_t *chars = kk->qq->chars;
    883884        for(y = 0; y < (int)kk->qq->height; y++)
    884885        {
     
    894895                {
    895896                    SLsmg_set_color(slang_assoc[*attr++]);
    896                     SLsmg_write_char(*chars++);
     897                    SLsmg_write_char(*chars++ & 0x7f);
    897898                }
    898899                else
     
    912913#else
    913914                SLsmg_set_color(*attr++);
    914                 SLsmg_write_char(*chars++);
     915                SLsmg_write_char(*chars++ & 0x7f);
    915916#endif
    916917            }
     
    925926        int x, y;
    926927        uint8_t *attr = kk->qq->attr;
    927         uint8_t *chars = kk->qq->chars;
     928        uint32_t *chars = kk->qq->chars;
    928929        for(y = 0; y < (int)kk->qq->height; y++)
    929930        {
     
    932933            {
    933934                attrset(kk->ncurses.attr[*attr++]);
    934                 addch(*chars++);
     935                addch(*chars++ & 0x7f);
    935936            }
    936937        }
     
    945946        char *screen = kk->conio.screen;
    946947        uint8_t *attr = kk->qq->attr;
    947         uint8_t *chars = kk->qq->chars;
     948        uint32_t *chars = kk->qq->chars;
    948949        for(n = kk->qq->height * kk->qq->width; n--; )
    949950        {
    950             *screen++ = *chars++;
     951            *screen++ = *chars++ & 0x7f;
    951952            *screen++ = *attr++;
    952953        }
     
    990991            for(x = 0; x < kk->qq->width; x += len)
    991992            {
     993                char buffer[BUFSIZ]; /* FIXME: use a smaller buffer */
     994                uint32_t *chars = kk->qq->chars + x + y * kk->qq->width;
    992995                uint8_t *attr = kk->qq->attr + x + y * kk->qq->width;
    993996
     
    995998
    996999                /* Skip spaces */
    997                 if(kk->qq->chars[x + y * kk->qq->width] == ' ')
     1000                if(chars[0] == ' ')
    9981001                    continue;
     1002
     1003                buffer[0] = chars[0] & 0x7f;
    9991004
    10001005                while(x + len < kk->qq->width
    10011006                       && (attr[len] & 0xf) == (attr[0] & 0xf))
     1007                {
     1008                    buffer[len] = chars[len] & 0x7f;
    10021009                    len++;
     1010                }
    10031011
    10041012                XSetForeground(kk->x11.dpy, kk->x11.gc, kk->x11.colors[attr[0] & 0xf]);
    1005                 XDrawString(kk->x11.dpy, kk->x11.pixmap, kk->x11.gc, x * kk->x11.font_width,
     1013                XDrawString(kk->x11.dpy, kk->x11.pixmap, kk->x11.gc,
     1014                            x * kk->x11.font_width,
    10061015                            (y + 1) * kk->x11.font_height - kk->x11.font_offset,
    1007                             (char*)(kk->qq->chars + x + y * kk->qq->width), len);
     1016                            buffer, len);
    10081017            }
    10091018        }
     
    10261035        for(i = 0; i < kk->qq->width * kk->qq->height; i++)
    10271036        {
    1028             kk->win32.buffer[i].Char.AsciiChar = kk->qq->chars[i];
     1037            kk->win32.buffer[i].Char.AsciiChar = kk->qq->chars[i] & 0x7f;
    10291038            kk->win32.buffer[i].Attributes =
    10301039                    win32_fg_palette[kk->qq->attr[i] & 0xf]
     
    10811090        {
    10821091            uint8_t *attr = kk->qq->attr + line * kk->qq->width;
    1083             unsigned char *chars = kk->qq->chars + line * kk->qq->width;
     1092            uint32_t *chars = kk->qq->chars + line * kk->qq->width;
    10841093
    10851094            for(x = 0; x < kk->gl.width; x += kk->gl.font_width)
    10861095            {
    1087                 if(chars[0] != ' ')
     1096                if(*chars != (uint32_t)' ')
    10881097                {
    1089                     glBindTexture(GL_TEXTURE_2D, kk->gl.id[chars[0]-32]);
     1098                    char ch = *chars & 0x7f;
     1099
     1100                    /* FIXME: check ch bounds */
     1101                    glBindTexture(GL_TEXTURE_2D, kk->gl.id[ch - 32]);
    10901102                    glColor4bv(gl_bgpal[attr[0] & 0xf]);
    10911103                    glBegin(GL_QUADS);
Note: See TracChangeset for help on using the changeset viewer.