src/patches/slang-debian-utf8.patch

   1 --- slang-1.4.4.orig/src/slinclud.h
   2 +++ slang-1.4.4/src/slinclud.h
   3 @@ -23,4 +23,12 @@
   4  # include <memory.h>
   5  #endif
   6
   7 +#define UTF8 1
   8 +
   9 +#ifdef UTF8
  10 +#include <wchar.h>
  11 +#include <limits.h>
  12 +#endif /* UTF8 */
  13 +
  14 +
  15  #endif                                /* _SLANG_INCLUDE_H_ */
  16 --- slang-1.4.4.orig/src/slang.h
  17 +++ slang-1.4.4/src/slang.h
  18 @@ -1239,10 +1239,20 @@
  19  extern int SLtt_Msdos_Cheap_Video;
  20  #endif
  21
  22 +#define UTF8 1
  23 +
  24 +#ifdef UTF8
  25 +typedef int SLsmg_Char_Type;
  26 +#define SLSMG_EXTRACT_CHAR(x) ((x) & 0xFFFFFF)
  27 +#define SLSMG_EXTRACT_COLOR(x) (((x)>>24)&0xFF)
  28 +#define SLSMG_BUILD_CHAR(ch,color) (((SLsmg_Char_Type)(wchar_t)(ch))|((color)<<24))
  29 +#define SLSMG_NOCHAR 1
  30 +#else
  31  typedef unsigned short SLsmg_Char_Type;
  32  #define SLSMG_EXTRACT_CHAR(x) ((x) & 0xFF)
  33  #define SLSMG_EXTRACT_COLOR(x) (((x)>>8)&0xFF)
  34  #define SLSMG_BUILD_CHAR(ch,color) (((SLsmg_Char_Type)(unsigned char)(ch))|((color)<<8))
  35 +#endif /* UTF8 */
  36
  37  extern int SLtt_flush_output (void);
  38  extern void SLtt_set_scroll_region(int, int);
  39 @@ -1334,7 +1342,11 @@
  40
  41  /*{{{ SLsmg Screen Management Functions */
  42
  43 +#ifdef UTF8
  44 +extern void SLsmg_fill_region (int, int, unsigned int, unsigned int, wchar_t);
  45 +#else
  46  extern void SLsmg_fill_region (int, int, unsigned int, unsigned int, unsigned char);
  47 +#endif /* UTF8 */
  48  extern void SLsmg_set_char_set (int);
  49  #ifndef IBMPC_SYSTEM
  50  extern int SLsmg_Scroll_Hash_Border;
  51 @@ -1351,7 +1363,12 @@
  52  extern void SLsmg_vprintf (char *, va_list);
  53  extern void SLsmg_write_string (char *);
  54  extern void SLsmg_write_nstring (char *, unsigned int);
  55 +#ifdef UTF8
  56 +extern void SLsmg_write_char (wchar_t);
  57 +extern void SLsmg_write_nwchars (wchar_t *, unsigned int);
  58 +#else
  59  extern void SLsmg_write_char (char);
  60 +#endif /* UTF8 */
  61  extern void SLsmg_write_nchars (char *, unsigned int);
  62  extern void SLsmg_write_wrapped_string (char *, int, int, unsigned int, unsigned int, int);
  63  extern void SLsmg_cls (void);
  64 --- slang-1.4.4.orig/src/slcurses.c
  65 +++ slang-1.4.4/src/slcurses.c
  66 @@ -440,20 +440,130 @@
  67
  68  static int do_newline (SLcurses_Window_Type *w)
  69  {
  70 -   w->_curx = 0;
  71 +   /* w->_curx = 0; */
  72     w->_cury += 1;
  73     if (w->_cury >= w->scroll_max)
  74       {
  75         w->_cury = w->scroll_max - 1;
  76 -       if (w->scroll_ok)
  77 +       if (w->scroll_ok) {
  78 +         w->_curx = 0;
  79           SLcurses_wscrl (w, 1);
  80 +       }
  81       }
  82 +   else
  83 +     w->_curx = 0;
  84 +
  85 +   return 0;
  86 +}
  87 +
  88 +#ifdef UTF8
  89 +static int SLcurses_waddch1 (SLcurses_Window_Type *win,
  90 +                            wchar_t ch, int color)
  91 +{
  92 +   SLsmg_Char_Type *b, *bmin, *bmax, *c;
  93 +   int k;
  94 +
  95 +   if (win == NULL) return -1;
  96 +
  97 +   if (win->_cury >= win->nrows)
  98 +     {
  99 +       /* Curses seems to move current postion to top of window. */
 100 +       win->_cury = win->_curx = 0;
 101 +       return -1;
 102 +     }
 103 +
 104 +   win->modified = 1;
 105 +
 106 +   if (ch < ' ')
 107 +     {
 108 +       if (ch == '\n')
 109 +         {
 110 +            SLcurses_wclrtoeol (win);
 111 +            return do_newline (win);
 112 +         }
 113 +
 114 +       if (ch == '\r')
 115 +         {
 116 +            win->_curx = 0;
 117 +            return 0;
 118 +         }
 119 +
 120 +       if (ch == '\b')
 121 +         {
 122 +            if (win->_curx > 0)
 123 +              win->_curx--;
 124 +
 125 +            return 0;
 126 +         }
 127 +
 128 +       /* HACK HACK!!!! */
 129 +       if (ch == '\t') ch = ' ';
 130 +     }
 131 +
 132 +   k = wcwidth(ch);
 133 +
 134 +   if (!k)
 135 +     return 0; /* ignore combining characters for now */
 136 +
 137 +   if (k > win->ncols)
 138 +     return 0; /* character wider than window */
 139 +
 140 +   if (win->_curx + k > win->ncols) {
 141 +     if (win->_curx < win->ncols)
 142 +       SLcurses_wclrtoeol(win);
 143 +     do_newline (win);
 144 +   }
 145 +
 146 +   bmin = win->lines[win->_cury];
 147 +   b = bmin + win->_curx;
 148 +   bmax = bmin + win->ncols;
 149 +
 150 +   /* Remove overwritten chars to left */
 151 +   if (*b == SLSMG_NOCHAR) {
 152 +     for (c = b - 1; c >= bmin && *c == SLSMG_NOCHAR; c--)
 153 +       *c = SLSMG_BUILD_CHAR(' ',SLSMG_EXTRACT_COLOR(*c));
 154 +     if (c >= bmin)
 155 +       *c = SLSMG_BUILD_CHAR(' ',SLSMG_EXTRACT_COLOR(*c));
 156 +   }
 157 +
 158 +   *b = SLSMG_BUILD_CHAR(ch,color);
 159 +   win->_curx += k;
 160 +   while (--k > 0)
 161 +     *++b = SLSMG_NOCHAR;
 162 +
 163 +   /* Remove overwritten chars to right */
 164 +   for (c = b + 1; c < bmax && *c == SLSMG_NOCHAR; c++)
 165 +     *c = SLSMG_BUILD_CHAR(' ',SLSMG_EXTRACT_COLOR(*c));
 166
 167     return 0;
 168  }
 169
 170  int SLcurses_waddch (SLcurses_Window_Type *win, SLtt_Char_Type attr)
 171  {
 172 +   SLsmg_Char_Type ch, color;
 173 +
 174 +   if (win == NULL) return -1;
 175 +
 176 +   ch = SLSMG_EXTRACT_CHAR(attr);
 177 +
 178 +   if (attr == ch)
 179 +     color = win->color;
 180 +   else
 181 +     {
 182 +       /* hack to pick up the default color for graphics chars */
 183 +       if (((attr & A_COLOR) == 0) && ((attr & A_ALTCHARSET) != 0))
 184 +         {
 185 +            /* FIXME: priority=medium: Use SLSMG_?? instead of << */
 186 +            attr |= win->color << 8;
 187 +         }
 188 +       color = map_attr_to_object (attr);
 189 +     }
 190 +
 191 +   return SLcurses_waddch1 (win, ch, color);
 192 +}
 193 +#else
 194 +int SLcurses_waddch (SLcurses_Window_Type *win, SLtt_Char_Type attr)
 195 +{
 196     SLsmg_Char_Type *b, ch;
 197     SLsmg_Char_Type color;
 198
 199 @@ -518,6 +628,7 @@
 200
 201     return 0;
 202  }
 203 +#endif /* UTF8 */
 204
 205  int SLcurses_wnoutrefresh (SLcurses_Window_Type *w)
 206  {
 207 @@ -577,7 +688,11 @@
 208
 209  int SLcurses_wclrtoeol (SLcurses_Window_Type *w)
 210  {
 211 +#ifdef UTF8
 212 +   SLsmg_Char_Type *b, *bmin, *bmax, *c;
 213 +#else
 214     SLsmg_Char_Type *b, *bmax;
 215 +#endif /* UTF8 */
 216     SLsmg_Char_Type blank;
 217
 218     if (w == NULL) return -1;
 219 @@ -588,9 +703,23 @@
 220
 221     blank = SLSMG_BUILD_CHAR(' ',w->color);
 222
 223 +#ifdef UTF8
 224 +   bmin = w->lines[w->_cury];
 225 +   b = bmin + w->_curx;
 226 +   bmax = bmin + w->ncols;
 227 +
 228 +   /* Remove overwritten chars to left */
 229 +   if (b < bmax && *b == SLSMG_NOCHAR) {
 230 +     for (c = b - 1; c >= bmin && *c == SLSMG_NOCHAR; c--)
 231 +       *c = SLSMG_BUILD_CHAR(' ',SLSMG_EXTRACT_COLOR(*c));
 232 +     if (c >= bmin)
 233 +       *c = SLSMG_BUILD_CHAR(' ',SLSMG_EXTRACT_COLOR(*c));
 234 +   }
 235 +#else
 236     b = w->lines[w->_cury];
 237     bmax = b + w->ncols;
 238     b += w->_curx;
 239 +#endif /* UTF8 */
 240
 241     while (b < bmax) *b++ = blank;
 242     return 0;
 243 @@ -677,6 +806,34 @@
 244     return 0;
 245  }
 246
 247 +#ifdef UTF8
 248 +/* Note: if len is < 0, entire string will be used.
 249 + */
 250 +int SLcurses_waddnstr (SLcurses_Window_Type *w, char *str, int len)
 251 +{
 252 +   size_t k;
 253 +   wchar_t wc;
 254 +   mbstate_t mbstate;
 255 +
 256 +   if ((w == NULL)
 257 +       || (str == NULL))
 258 +     return -1;
 259 +
 260 +   if (len < 0)
 261 +     len = (char *)(-1) - str;
 262 +
 263 +   memset (&mbstate, 0, sizeof (mbstate));
 264 +   while ((k = mbrtowc (&wc, str, len, &mbstate)) &&
 265 +         k != (size_t)(-1) &&
 266 +         k != (size_t)(-2))
 267 +     {
 268 +       SLcurses_waddch1 (w, wc, w->color);
 269 +       str += k;
 270 +       len -= k;
 271 +     }
 272 +   return k;
 273 +}
 274 +#else
 275  /* Note: if len is < 0, entire string will be used.
 276   */
 277  int SLcurses_waddnstr (SLcurses_Window_Type *w, char *str, int len)
 278 @@ -758,6 +915,7 @@
 279
 280     return 0;
 281  }
 282 +#endif /* UTF8 */
 283
 284  /* This routine IS NOT CORRECT.  It needs to compute the proper overlap
 285   * and copy accordingly.  Here, I just assume windows are same size.
 286 @@ -852,12 +1010,36 @@
 287
 288  int SLcurses_wdelch (SLcurses_Window_Type *w)
 289  {
 290 +#ifdef UTF8
 291 +   SLsmg_Char_Type *p, *p1, *pmin, *pmax, *q;
 292 +#else
 293     SLsmg_Char_Type *p, *p1, *pmax;
 294 +#endif /* UTF8 */
 295
 296 +#ifdef UTF8
 297 +   pmin = w->lines[w->_cury];
 298 +   p = pmin + w->_curx;
 299 +   pmax = pmin + w->ncols;
 300 +
 301 +   /* Remove overwritten chars to left */
 302 +   if (p < pmax && *p == SLSMG_NOCHAR) {
 303 +     for (q = p - 1; q >= pmin && *q == SLSMG_NOCHAR; q--)
 304 +       *q = SLSMG_BUILD_CHAR(' ',SLSMG_EXTRACT_COLOR(*q));
 305 +     if (q >= pmin)
 306 +       *q = SLSMG_BUILD_CHAR(' ',SLSMG_EXTRACT_COLOR(*q));
 307 +   }
 308 +
 309 +   /* Remove overwritten chars to right */
 310 +   for (q = p + 1; q < pmax && *q == SLSMG_NOCHAR; q++)
 311 +     *q = SLSMG_BUILD_CHAR(' ',SLSMG_EXTRACT_COLOR(*q));
 312 +
 313 +   p1 = p + 1;
 314 +#else
 315     p = w->lines[w->_cury];
 316     pmax = p + w->ncols;
 317     p += w->_curx;
 318     p1 = p + 1;
 319 +#endif /* UTF8 */
 320
 321     while (p1 < pmax)
 322       {
 323 @@ -884,12 +1066,12 @@
 324
 325     while (pmax > p)
 326       {
 327 -       *pmax = *p1;
 328 +       *pmax = *p1; /* Doesn't this assign beyond the end of the line? */
 329         pmax = p1;
 330         p1--;
 331       }
 332
 333 -   if (p < pmax)
 334 +   if (p < pmax) /* How could it be? */
 335       *p = SLSMG_BUILD_CHAR(ch, w->color);
 336
 337     w->modified = 1;
 338 --- slang-1.4.4.orig/src/slsmg.c
 339 +++ slang-1.4.4/src/slsmg.c
 340 @@ -225,6 +225,38 @@
 341     SLsmg_write_nchars (str, strlen (str));
 342  }
 343
 344 +#ifdef UTF8
 345 +void SLsmg_write_nstring (char *str, unsigned int n)
 346 +{
 347 +   char blank = ' ';
 348 +   mbstate_t mbstate;
 349 +
 350 +   /* Avoid a problem if a user accidently passes a negative value */
 351 +   if ((int) n < 0)
 352 +     return;
 353 +
 354 +   if (str != NULL)
 355 +     {
 356 +       wchar_t wc;
 357 +       size_t k;
 358 +       int w;
 359 +
 360 +       memset (&mbstate, 0, sizeof (mbstate));
 361 +        while ((k = mbrtowc (&wc, str, MB_LEN_MAX, &mbstate)) &&
 362 +              k != (size_t)(-1) &&
 363 +              k != (size_t)(-2))
 364 +         {
 365 +            w = wcwidth(wc);
 366 +            if (w < 0 || w > n)
 367 +              break;
 368 +            SLsmg_write_nwchars (&wc, 1);
 369 +            str += k;
 370 +            n -= w;
 371 +         }
 372 +     }
 373 +   while (n-- > 0) SLsmg_write_nchars (&blank, 1);
 374 +}
 375 +#else
 376  void SLsmg_write_nstring (char *str, unsigned int n)
 377  {
 378     unsigned int width;
 379 @@ -243,7 +275,11 @@
 380       }
 381     while (width++ < n) SLsmg_write_nchars (&blank, 1);
 382  }
 383 +#endif /* UTF8 */
 384
 385 +#ifdef UTF8
 386 +/* FIXME: This function not UTF8'd yet - Edmund */
 387 +#endif /* UTF8 */
 388  void SLsmg_write_wrapped_string (char *s, int r, int c,
 389                                  unsigned int dr, unsigned int dc,
 390                                  int fill)
 391 @@ -302,6 +338,123 @@
 392  int SLsmg_Display_Eight_Bit = 128;
 393  #endif
 394
 395 +#ifdef UTF8
 396 +void SLsmg_write_nwchars (wchar_t *str, unsigned int n)
 397 +{
 398 +  SLsmg_Char_Type *p, *prev, *q;
 399 +  int len, max_len, w, i;
 400 +  wchar_t ch;
 401 +
 402 +#ifndef IBMPC_SYSTEM
 403 +   int alt_char_set_flag;
 404 +
 405 +   alt_char_set_flag = ((This_Color & ALT_CHAR_FLAG)
 406 +                       && ((tt_Use_Blink_For_ACS == NULL)
 407 +                           || (*tt_Use_Blink_For_ACS == 0)));
 408 +#endif
 409 +
 410 +  if (Smg_Inited == 0)
 411 +    return;
 412 +  if (This_Row < Start_Row || This_Row >= Start_Row + Screen_Rows)
 413 +    return;
 414 +
 415 +  max_len = Start_Col + Screen_Cols;
 416 +  len = This_Col;
 417 +  p = SL_Screen[This_Row - Start_Row].neew + len - Start_Col;
 418 +  prev = 0;
 419 +
 420 +  for (i = 0; i < n; i++, str) {
 421 +    ch = *str++;
 422 +#ifndef IBMPC_SYSTEM
 423 +    if (alt_char_set_flag)
 424 +      ch = Alt_Char_Set[ch & 0x7F];
 425 +#endif
 426 +    w = wcwidth(ch);
 427 +
 428 +    if (w > 0) {
 429 +      if (len + w <= max_len) {
 430 +       if (!prev) {
 431 +         for (q = p; *q == SLSMG_NOCHAR; q--)
 432 +           *q = SLSMG_BUILD_CHAR(' ', SLSMG_EXTRACT_COLOR(*q));
 433 +         *q = SLSMG_BUILD_CHAR(' ', SLSMG_EXTRACT_COLOR(*q));
 434 +       }
 435 +       prev = p;
 436 +       *p++ = SLSMG_BUILD_CHAR(ch, This_Color), ++len;
 437 +       for (; --w; len++, p++)
 438 +         *p = SLSMG_NOCHAR;
 439 +      }
 440 +      else if (len < max_len) {
 441 +       for (; len < max_len; len++, p++)
 442 +         *p = SLSMG_BUILD_CHAR(' ', SLSMG_EXTRACT_COLOR(*p));
 443 +       prev = 0;
 444 +      }
 445 +    }
 446 +    else if (ch == '\n' &&
 447 +            SLsmg_Newline_Behavior != SLSMG_NEWLINE_PRINTABLE) {
 448 +      SL_Screen[This_Row - Start_Row].flags |= TOUCHED;
 449 +      for (; len < max_len && *p == SLSMG_NOCHAR; len++, p++)
 450 +       *p = SLSMG_BUILD_CHAR(' ', SLSMG_EXTRACT_COLOR(*p));
 451 +      if (!SLsmg_Newline_Behavior)
 452 +       break;
 453 +      ++This_Row;
 454 +      len = 0;
 455 +      if (This_Row == Start_Row + Screen_Rows) {
 456 +       if (SLsmg_Newline_Behavior == SLSMG_NEWLINE_SCROLLS)
 457 +         scroll_up();
 458 +       else
 459 +         break;
 460 +      }
 461 +      p = SL_Screen[This_Row - Start_Row].neew;
 462 +      prev = 0;
 463 +    }
 464 +    else if (ch == '\t' && (SLsmg_Tab_Width > 0)) {
 465 +      while (len < max_len) {
 466 +       *p = SLSMG_BUILD_CHAR(' ', SLSMG_EXTRACT_COLOR(*p));
 467 +       ++p, ++len;
 468 +       if (len % SLsmg_Tab_Width == 0)
 469 +         break;
 470 +      }
 471 +    }
 472 +    else if ((ch == 0x8) && SLsmg_Backspace_Moves) {
 473 +      /* not implemented */
 474 +    }
 475 +    else if (!w && ch) {
 476 +      /* we could handle combining characters here, using prev */
 477 +    }
 478 +    else {
 479 +      /* we should convert control characters to printable form here */
 480 +    }
 481 +  }
 482 +  This_Col = len;
 483 +  if (i == n) {
 484 +    SL_Screen[This_Row - Start_Row].flags |= TOUCHED;
 485 +    for (; len < max_len && *p == SLSMG_NOCHAR; len++, p++)
 486 +      *p = SLSMG_BUILD_CHAR(' ', SLSMG_EXTRACT_COLOR(*p));
 487 +  }
 488 +}
 489 +
 490 +void SLsmg_write_char (wchar_t wc)
 491 +{
 492 +   SLsmg_write_nwchars (&wc, 1);
 493 +}
 494 +
 495 +void SLsmg_write_nchars (char *str, unsigned int n)
 496 +{
 497 +   wchar_t wc;
 498 +   size_t k;
 499 +   mbstate_t mbstate;
 500 +
 501 +   memset (&mbstate, 0, sizeof (mbstate));
 502 +   while ((k = mbrtowc (&wc, str, n, &mbstate)) &&
 503 +         k != (size_t)(-1) &&
 504 +         k != (size_t)(-2))
 505 +     {
 506 +        SLsmg_write_nwchars (&wc, 1);
 507 +       str += k;
 508 +       n -= k;
 509 +     }
 510 +}
 511 +#else
 512  void SLsmg_write_nchars (char *str, unsigned int n)
 513  {
 514     register SLsmg_Char_Type *p, old, neew, color;
 515 @@ -475,6 +628,7 @@
 516  {
 517     SLsmg_write_nchars (&ch, 1);
 518  }
 519 +#endif /* UTF8 */
 520
 521  static int Cls_Flag;
 522
 523 @@ -891,6 +1045,10 @@
 524              This_Color = color;
 525           }
 526
 527 +#ifdef UTF8
 528 +       /* FIXME: We should convert broken wide characters to spaces
 529 +          before calling smart_puts */
 530 +#endif /* UTF8 */
 531         SL_Screen[i].old[Screen_Cols] = 0;
 532         SL_Screen[i].neew[Screen_Cols] = 0;
 533
 534 @@ -1334,9 +1492,16 @@
 535     This_Row = r; This_Col = c;
 536  }
 537
 538 +#ifdef UTF8
 539 +void SLsmg_fill_region (int r, int c, unsigned int dr, unsigned int dc, wchar_t ch)
 540 +{
 541 +   static wchar_t hbuf[16];
 542 +   int i;
 543 +#else
 544  void SLsmg_fill_region (int r, int c, unsigned int dr, unsigned int dc, unsigned char ch)
 545  {
 546     static unsigned char hbuf[16];
 547 +#endif /* UTF8 */
 548     int count;
 549     int dcmax, rmax;
 550
 551 @@ -1357,16 +1522,30 @@
 552  #if 0
 553     ch = Alt_Char_Set[ch];
 554  #endif
 555 +#ifdef UTF8
 556 +   if (ch != hbuf[0])
 557 +     for (i = 0; i < 16; i++)
 558 +       hbuf[i] = ch;
 559 +#else
 560     if (ch != hbuf[0]) SLMEMSET ((char *) hbuf, (char) ch, 16);
 561 +#endif /* UTF8 */
 562
 563     for (This_Row = r; This_Row < rmax; This_Row++)
 564       {
 565         This_Col = c;
 566         count = dc / 16;
 567 +#ifdef UTF8
 568 +       SLsmg_write_nwchars (hbuf, dc % 16);
 569 +#else
 570         SLsmg_write_nchars ((char *) hbuf, dc % 16);
 571 +#endif /* UTF8 */
 572         while (count-- > 0)
 573           {
 574 +#ifdef UTF8
 575 +            SLsmg_write_nwchars (hbuf, 16);
 576 +#else
 577              SLsmg_write_nchars ((char *) hbuf, 16);
 578 +#endif /* UTF8 */
 579           }
 580       }
 581
 582 @@ -1381,14 +1560,22 @@
 583  void SLsmg_write_color_chars (SLsmg_Char_Type *s, unsigned int len)
 584  {
 585     SLsmg_Char_Type *smax, sh;
 586 +#ifdef UTF8
 587 +   wchar_t buf[32], *b, *bmax;
 588 +#else
 589     char buf[32], *b, *bmax;
 590 +#endif /* UTF8 */
 591     int color, save_color;
 592
 593     if (Smg_Inited == 0) return;
 594
 595     smax = s + len;
 596     b = buf;
 597 +#ifdef UTF8
 598 +   bmax = b + sizeof (buf) / sizeof (SLsmg_Char_Type);
 599 +#else
 600     bmax = b + sizeof (buf);
 601 +#endif /* UTF8 */
 602
 603     save_color = This_Color;
 604
 605 @@ -1412,16 +1599,28 @@
 606           {
 607              if (b != buf)
 608                {
 609 +#ifdef UTF8
 610 +                 SLsmg_write_nwchars (buf, (int) (b - buf));
 611 +#else
 612                   SLsmg_write_nchars (buf, (int) (b - buf));
 613 +#endif /* UTF8 */
 614                   b = buf;
 615                }
 616              This_Color = color;
 617           }
 618 +#ifdef UTF8
 619 +       *b++ = SLSMG_EXTRACT_CHAR(sh);
 620 +#else
 621         *b++ = (char) SLSMG_EXTRACT_CHAR(sh);
 622 +#endif /* UTF8 */
 623       }
 624
 625     if (b != buf)
 626 +#ifdef UTF8
 627 +     SLsmg_write_nwchars (buf, (unsigned int) (b - buf));
 628 +#else
 629       SLsmg_write_nchars (buf, (unsigned int) (b - buf));
 630 +#endif /* UTF8 */
 631
 632     This_Color = save_color;
 633  }
 634 @@ -1473,7 +1672,11 @@
 635  SLsmg_set_color_in_region (int color, int r, int c, unsigned int dr, unsigned int dc)
 636  {
 637     int cmax, rmax;
 638 +#ifdef UTF8
 639 +   int color_mask;
 640 +#else
 641     SLsmg_Char_Type char_mask;
 642 +#endif /* UTF8 */
 643
 644     if (Smg_Inited == 0) return;
 645
 646 @@ -1498,14 +1701,22 @@
 647           color = ((color & 0x7F) + Bce_Color_Offset) & 0x7F;
 648       }
 649  #endif
 650 +#ifdef UTF8
 651 +   color_mask = 0;
 652 +#else
 653     color = color << 8;
 654
 655     char_mask = 0xFF;
 656 +#endif /* UTF8 */
 657
 658  #ifndef IBMPC_SYSTEM
 659     if ((tt_Use_Blink_For_ACS == NULL)
 660         || (0 == *tt_Use_Blink_For_ACS))
 661 +#ifdef UTF8
 662 +     color_mask = 0x80;
 663 +#else
 664       char_mask = 0x80FF;
 665 +#endif /* UTF8 */
 666  #endif
 667
 668     while (r < rmax)
 669 @@ -1519,7 +1730,13 @@
 670
 671         while (s < smax)
 672           {
 673 +#ifdef UTF8
 674 +            *s = SLSMG_BUILD_CHAR(SLSMG_EXTRACT_CHAR(*s),
 675 +                                  (SLSMG_EXTRACT_COLOR(*s) & color_mask)
 676 +                                  | color);
 677 +#else
 678              *s = (*s & char_mask) | color;
 679 +#endif /* UTF8 */
 680              s++;
 681           }
 682         r++;
 683 --- slang-1.4.5/src/Makefile.in.foo     2002-06-12 19:30:09.000000000 -0400
 684 +++ slang-1.4.5/src/Makefile.in 2002-06-12 19:31:13.000000000 -0400
 685 @@ -67,7 +67,7 @@
 686  #---------------------------------------------------------------------------
 687  # There should be no need to change anything below here.
 688  #---------------------------------------------------------------------------
 689 -THIS_LIB               = slang#
 690 +THIS_LIB               = slang-utf8#
 691  OTHERSTUFF             =
 692  THIS_LIB_DEFINES       = -DSLANG
 693  ELF_MAJOR_VERSION      = @slang_major_version@#
 694 --- slang-1.4.9/src/sldisply.c.orig     2003-10-27 17:24:15.000000000 -0500
 695 +++ slang-1.4.9/src/sldisply.c  2003-10-27 17:56:25.000000000 -0500
 696 @@ -9,6 +9,7 @@
 697
 698  #include <time.h>
 699  #include <ctype.h>
 700 +#include <limits.h>
 701
 702  #if !defined(VMS) || (__VMS_VER >= 70000000)
 703  # include <sys/time.h>
 704 @@ -1426,14 +1427,25 @@
 705
 706  /* Highest bit represents the character set. */
 707  #define COLOR_MASK 0x7F00
 708 +#ifdef UTF8
 709 +# define COLOR_OF(x) (SLSMG_EXTRACT_COLOR(x) & 0x7F)
 710 +#else
 711  #define COLOR_OF(x) (((x)&COLOR_MASK)>>8)
 712 +#endif
 713  #define CHAR_OF(x) ((x)&0x80FF)
 714
 715  #if SLTT_HAS_NON_BCE_SUPPORT
 716 +#ifdef UTF8
 717 +static int bce_color_eqs (SLsmg_Char_Type a, SLsmg_Char_Type b)
 718 +{
 719 +   a = SLSMG_EXTRACT_COLOR(a) & 0x7F;
 720 +   b = SLSMG_EXTRACT_COLOR(b) & 0x7F;
 721 +#else
 722  static int bce_color_eqs (unsigned int a, unsigned int b)
 723  {
 724     a = COLOR_OF(a);
 725     b = COLOR_OF(b);
 726 +#endif
 727
 728     if (a == b)
 729       return 1;
 730 @@ -1459,8 +1471,14 @@
 731      :  (Ansi_Color_Map[COLOR_OF(a)].mono == Ansi_Color_Map[COLOR_OF(b)].mono))
 732  #endif
 733
 734 +#ifdef UTF8
 735 +#define CHAR_EQS(a, b) ((a) == (b)\
 736 +                       || (SLSMG_EXTRACT_CHAR(a) == SLSMG_EXTRACT_CHAR(b)\
 737 +                           && COLOR_EQS((a), (b))))
 738 +#else
 739  #define CHAR_EQS(a, b) (((a) == (b))\
 740                         || ((CHAR_OF(a)==CHAR_OF(b)) && COLOR_EQS(a,b)))
 741 +#endif
 742
 743  /* The whole point of this routine is to prevent writing to the last column
 744   * and last row on terminals with automatic margins.
 745 @@ -1488,9 +1506,58 @@
 746     tt_write (str, len);
 747  }
 748
 749 +#ifdef UTF8
 750 +/* FIXME: This duplicates the function above
 751 + */
 752 +static void write_wstring_with_care (SLsmg_Char_Type *str, unsigned int len)
 753 +{
 754 +   mbstate_t mbstate;
 755 +
 756 +   if (str == NULL) return;
 757 +
 758 +   if (Automatic_Margins && (Cursor_r + 1 == SLtt_Screen_Rows))
 759 +     {
 760 +       if (len + (unsigned int) Cursor_c >= (unsigned int) SLtt_Screen_Cols)
 761 +         {
 762 +            /* For now, just do not write there.  Later, something more
 763 +             * sophisticated will be implemented.
 764 +             */
 765 +            if (SLtt_Screen_Cols > Cursor_c)
 766 +              {
 767 +                 len = SLtt_Screen_Cols - Cursor_c - 1;
 768 +                 while (len > 0 && str[len] == SLSMG_NOCHAR)
 769 +                   --len;
 770 +              }
 771 +            else len = 0;
 772 +         }
 773 +     }
 774 +
 775 +   memset (&mbstate, 0, sizeof (mbstate));
 776 +   while (len--)
 777 +     {
 778 +        SLsmg_Char_Type c = *str++;
 779 +       char buf[MB_LEN_MAX];
 780 +       size_t n;
 781 +
 782 +       if (c == SLSMG_NOCHAR)
 783 +         continue;
 784 +
 785 +       n = wcrtomb (buf, c, &mbstate);
 786 +       if (n == (size_t)(-1))
 787 +         break;
 788 +
 789 +       tt_write(buf, n);
 790 +     }
 791 +}
 792 +#endif /* UTF8 */
 793 +
 794  static void send_attr_str (SLsmg_Char_Type *s)
 795  {
 796 +#ifdef UTF8
 797 +   SLsmg_Char_Type out[SLTT_MAX_SCREEN_COLS], ch, *p;
 798 +#else
 799     unsigned char out[SLTT_MAX_SCREEN_COLS], ch, *p;
 800 +#endif /* UTF8 */
 801     register SLtt_Char_Type attr;
 802     register SLsmg_Char_Type sh;
 803     int color, last_color = -1;
 804 @@ -1498,8 +1565,13 @@
 805     p = out;
 806     while (0 != (sh = *s++))
 807       {
 808 +#ifdef UTF8
 809 +       ch = SLSMG_EXTRACT_CHAR(sh);
 810 +       color = SLSMG_EXTRACT_COLOR(sh);
 811 +#else
 812         ch = sh & 0xFF;
 813         color = ((int) sh & 0xFF00) >> 8;
 814 +#endif
 815
 816  #if SLTT_HAS_NON_BCE_SUPPORT
 817         if (Bce_Color_Offset
 818 @@ -1511,8 +1583,12 @@
 819           {
 820              if (SLtt_Use_Ansi_Colors) attr = Ansi_Color_Map[color & 0x7F].fgbg;
 821              else attr = Ansi_Color_Map[color & 0x7F].mono;
 822 -
 823 +
 824 +#ifdef UTF8
 825 +            if (SLSMG_EXTRACT_COLOR(sh) & 0x80) /* alternate char set */
 826 +#else
 827              if (sh & 0x8000) /* alternate char set */
 828 +#endif
 829                {
 830                   if (SLtt_Use_Blink_For_ACS)
 831                     {
 832 @@ -1534,8 +1610,12 @@
 833                     {
 834                        if (p != out)
 835                          {
 836 +#ifdef UTF8
 837 +                           write_wstring_with_care (out, p-out);
 838 +#else
 839                             *p = 0;
 840                             write_string_with_care ((char *) out);
 841 +#endif
 842                             Cursor_c += (int) (p - out);
 843                             p = out;
 844                          }
 845 @@ -1558,8 +1638,12 @@
 846           }
 847         *p++ = ch;
 848       }
 849 +#ifdef UTF8
 850 +   if (p != out) write_wstring_with_care (out, p-out);
 851 +#else
 852     *p = 0;
 853     if (p != out) write_string_with_care ((char *) out);
 854 +#endif
 855     Cursor_c += (int) (p - out);
 856  }
 857
 858 @@ -1686,7 +1770,11 @@
 859
 860         while (qq < qmax)
 861           {
 862 +#ifdef UTF8
 863 +            if (SLSMG_EXTRACT_COLOR(*qq))
 864 +#else
 865              if (*qq & 0xFF00)
 866 +#endif
 867                {
 868                   SLtt_normal_video ();
 869                   SLtt_del_eol ();
 870 @@ -1701,7 +1789,11 @@
 871     /* Find where the last non-blank character on old/new screen is */
 872
 873     space_char = ' ';
 874 +#ifdef UTF8
 875 +   if (SLSMG_EXTRACT_CHAR(*(pmax-1)) == ' ')
 876 +#else
 877     if (CHAR_EQS(*(pmax-1), ' '))
 878 +#endif
 879       {
 880         /* If we get here, then we can erase to the end of the line to create
 881          * the final space.  However, this will only work _if_ erasing will
 882 @@ -1752,7 +1844,11 @@
 883       {
 884  #endif
 885         /* Try use use erase to bol if possible */
 886 +#ifdef UTF8
 887 +       if ((Del_Bol_Str != NULL) && (SLSMG_EXTRACT_CHAR(*neww) == ' '))
 888 +#else
 889         if ((Del_Bol_Str != NULL) && (CHAR_OF(*neww) == ' '))
 890 +#endif
 891           {
 892              SLsmg_Char_Type *p1;
 893              SLsmg_Char_Type blank;
 894 @@ -1781,7 +1877,11 @@
 895                   q = oldd + ofs;
 896                   p = p1;
 897                   SLtt_goto_rc (row, ofs - 1);
 898 +#ifdef UTF8
 899 +                 SLtt_reverse_video (SLSMG_EXTRACT_COLOR (blank));
 900 +#else
 901                   SLtt_reverse_video (COLOR_OF(blank));
 902 +#endif
 903                   tt_write_string (Del_Bol_Str);
 904                   tt_write (" ", 1);
 905                   Cursor_c += 1;
 906 @@ -1978,7 +2078,11 @@
 907
 908     if (q < qmax)
 909       {
 910 +#ifdef UTF8
 911 +       SLtt_reverse_video (SLSMG_EXTRACT_COLOR (space_char));
 912 +#else
 913         SLtt_reverse_video (COLOR_OF(space_char));
 914 +#endif
 915         del_eol ();
 916       }
 917