home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 1 / 1136 < prev    next >
Internet Message Format  |  1990-12-28  |  34KB
  1. From: howard@hasse.ericsson.se (Howard Gayle)
  2. Newsgroups: alt.sources
  3. Subject: GNU Emacs 8-bit mods part 09 of 12
  4. Message-ID: <1990Apr5.134111.9195@ericsson.se>
  5. Date: 5 Apr 90 13:41:11 GMT
  6.  
  7. *** ../18.55/src/xdisp.c    Wed Apr 26 22:13:59 1989
  8. --- src/xdisp.c    Thu Apr  5 09:17:31 1990
  9. ***************
  10. *** 1,5 ****
  11.   /* Display generation from window structure and buffer text.
  12. !    Copyright (C) 1985, 1986, 1987, 1988 Free Software Foundation, Inc.
  13.   
  14.   This file is part of GNU Emacs.
  15.   
  16. --- 1,5 ----
  17.   /* Display generation from window structure and buffer text.
  18. !    Copyright (C) 1985, 1986, 1987, 1988, 1990 Free Software Foundation, Inc.
  19.   
  20.   This file is part of GNU Emacs.
  21.   
  22. ***************
  23. *** 19,29 ****
  24. --- 19,34 ----
  25.   and this notice must be preserved on all copies.  */
  26.   
  27.   
  28. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  29. +  *  See chartab.c for details. */
  30. + 
  31. + 
  32.   #include "config.h"
  33.   #include <stdio.h>
  34.   /*#include <ctype.h>*/
  35.   #undef NULL
  36.   #include "lisp.h"
  37. + #include "chartab.h"
  38.   #include "window.h"
  39.   #include "termchar.h"
  40.   #include "dispextern.h"
  41. ***************
  42. *** 349,357 ****
  43.             && end_unchanged >= tlendpos
  44.             && bf_s2 >= tlendpos)))
  45.       {
  46. !       if (tlbufpos > FirstCharacter && CharAt (tlbufpos - 1) != '\n'
  47.         && (tlbufpos == NumCharacters + 1
  48. !           || CharAt (tlbufpos) == '\n'))
  49.       /* Former continuation line has disappeared by becoming empty */
  50.       goto cancel;
  51.         else if (XFASTINT (w->last_modified) < bf_modified
  52. --- 354,362 ----
  53.             && end_unchanged >= tlendpos
  54.             && bf_s2 >= tlendpos)))
  55.       {
  56. !       if (tlbufpos > FirstCharacter && CharAt (tlbufpos - 1) != NEWLINE
  57.         && (tlbufpos == NumCharacters + 1
  58. !           || CharAt (tlbufpos) == NEWLINE))
  59.       /* Former continuation line has disappeared by becoming empty */
  60.       goto cancel;
  61.         else if (XFASTINT (w->last_modified) < bf_modified
  62. ***************
  63. *** 689,695 ****
  64.        but no longer is, find a new starting point.  */
  65.     else if (!NULL (w->start_at_line_beg)
  66.          && !(startp == FirstCharacter
  67. !         || CharAt (startp - 1) == '\n'))
  68.       {
  69.         goto recenter;
  70.       }
  71. --- 694,700 ----
  72.        but no longer is, find a new starting point.  */
  73.     else if (!NULL (w->start_at_line_beg)
  74.          && !(startp == FirstCharacter
  75. !         || CharAt (startp - 1) == NEWLINE))
  76.       {
  77.         goto recenter;
  78.       }
  79. ***************
  80. *** 764,770 ****
  81.   
  82.     startp = marker_position (w->start);
  83.     w->start_at_line_beg = 
  84. !     (startp == FirstCharacter || CharAt (startp - 1) == '\n') ? Qt : Qnil;
  85.   
  86.   done:
  87.     /* If window not full width, must redo its mode line
  88. --- 769,775 ----
  89.   
  90.     startp = marker_position (w->start);
  91.     w->start_at_line_beg = 
  92. !     (startp == FirstCharacter || CharAt (startp - 1) == NEWLINE) ? Qt : Qnil;
  93.   
  94.   done:
  95.     /* If window not full width, must redo its mode line
  96. ***************
  97. *** 811,817 ****
  98.         if (pos != val.bufpos)
  99.       last_text_vpos
  100.         /* Next line, unless prev line ended in end of buffer with no cr */
  101. !       = vpos - (val.vpos && CharAt (val.bufpos - 1) != '\n');
  102.         pos = val.bufpos;
  103.       }
  104.   
  105. --- 816,822 ----
  106.         if (pos != val.bufpos)
  107.       last_text_vpos
  108.         /* Next line, unless prev line ended in end of buffer with no cr */
  109. !       = vpos - (val.vpos && CharAt (val.bufpos - 1) != NEWLINE);
  110.         pos = val.bufpos;
  111.       }
  112.   
  113. ***************
  114. *** 930,936 ****
  115.        newline before it, so the following line must be redrawn. */
  116.     if (stop_vpos == ep.vpos
  117.         && (ep.bufpos == FirstCharacter
  118. !       || CharAt (ep.bufpos - 1) != '\n'
  119.         || ep.bufpos == bf_s1 + bf_s2 + 1 - end_unchanged))
  120.       stop_vpos = ep.vpos + 1;
  121.   
  122. --- 935,941 ----
  123.        newline before it, so the following line must be redrawn. */
  124.     if (stop_vpos == ep.vpos
  125.         && (ep.bufpos == FirstCharacter
  126. !       || CharAt (ep.bufpos - 1) != NEWLINE
  127.         || ep.bufpos == bf_s1 + bf_s2 + 1 - end_unchanged))
  128.       stop_vpos = ep.vpos + 1;
  129.   
  130. ***************
  131. *** 952,958 ****
  132.         for (i = ep.bufpos; i < xp.bufpos; i++)
  133.       {
  134.         tem = CharAt (i);
  135. !       if (tem != ' ' && tem != '\n' && tem != '\t')
  136.           break;
  137.       }
  138.         if (i == xp.bufpos)
  139. --- 957,963 ----
  140.         for (i = ep.bufpos; i < xp.bufpos; i++)
  141.       {
  142.         tem = CharAt (i);
  143. !       if (tem != SPACE && tem != NEWLINE && tem != HTAB)
  144.           break;
  145.       }
  146.         if (i == xp.bufpos)
  147. ***************
  148. *** 1063,1069 ****
  149.         if (pos != val.bufpos)
  150.       last_text_vpos
  151.         /* Next line, unless prev line ended in end of buffer with no cr */
  152. !         = vpos - (val.vpos && CharAt (val.bufpos - 1) != '\n');
  153.         pos = val.bufpos;
  154.       }
  155.   
  156. --- 1068,1074 ----
  157.         if (pos != val.bufpos)
  158.       last_text_vpos
  159.         /* Next line, unless prev line ended in end of buffer with no cr */
  160. !         = vpos - (val.vpos && CharAt (val.bufpos - 1) != NEWLINE);
  161.         pos = val.bufpos;
  162.       }
  163.   
  164. ***************
  165. *** 1167,1172 ****
  166. --- 1172,1194 ----
  167.     return 1;
  168.   }
  169.   
  170. + glyf_t *copy_rope (t, s, r)
  171. + register glyf_t *t; /* Copy to here. */
  172. + register glyf_t *s; /* Starting point. */
  173. + register rope_t *r; /* Copy from here. */
  174. + {
  175. + register int     n = r->r_len;   /* Number of glyfs in rope. */
  176. + register glyf_t *f = r->r_glyfs; /* Step through glyfs in rope. */
  177. + 
  178. + while (n--)
  179. +    {
  180. +    if (t >= s) *t = *f;
  181. +    ++t;
  182. +    ++f;
  183. +    }
  184. + return (t);
  185. + }
  186. + 
  187.   /* Display one line of window w, starting at position `start' in w's buffer.
  188.    Display starting at horizontal position `hpos',
  189.     which is normally zero or negative.
  190. ***************
  191. *** 1193,1209 ****
  192.        int taboffset;
  193.   {
  194.     register int pos = start;
  195. !   register int c;
  196. !   register char *p1;
  197.     int end;
  198.     register int pause;
  199. !   register unsigned char *p;
  200. !   char *endp;
  201. !   register char *startp;
  202. !   register char *p1prev;
  203.     register struct display_line *line;
  204.     int tab_width = XINT (bf_cur->tab_width);
  205. -   int ctl_arrow = !NULL (bf_cur->ctl_arrow);
  206.     int width = XFASTINT (w->width) - 1
  207.       - (XFASTINT (w->width) + XFASTINT (w->left) != screen_width);
  208.     struct position val;
  209. --- 1215,1230 ----
  210.        int taboffset;
  211.   {
  212.     register int pos = start;
  213. !   register char_t c;
  214. !   register glyf_t *p1;
  215.     int end;
  216.     register int pause;
  217. !   register char_t *p;
  218. !   glyf_t *endp;
  219. !   register glyf_t *startp;
  220. !   register glyf_t *p1prev;
  221.     register struct display_line *line;
  222.     int tab_width = XINT (bf_cur->tab_width);
  223.     int width = XFASTINT (w->width) - 1
  224.       - (XFASTINT (w->width) + XFASTINT (w->left) != screen_width);
  225.     struct position val;
  226. ***************
  227. *** 1218,1224 ****
  228.       = XTYPE (bf_cur->selective_display) == Lisp_Int
  229.         ? XINT (bf_cur->selective_display)
  230.       : !NULL (bf_cur->selective_display) ? -1 : 0;
  231. !   int selective_e = selective && !NULL (bf_cur->selective_display_ellipses);
  232.   
  233.     hpos += XFASTINT (w->left);
  234.     line = get_display_line (vpos, XFASTINT (w->left));
  235. --- 1239,1246 ----
  236.       = XTYPE (bf_cur->selective_display) == Lisp_Int
  237.         ? XINT (bf_cur->selective_display)
  238.       : !NULL (bf_cur->selective_display) ? -1 : 0;
  239. !   register struct Lisp_Chartab *cp = WINDOW_CHAR_TABLE (w);
  240. !   int selective_rlen = selective ? cp->ct_invisr.r_len : 0;
  241.   
  242.     hpos += XFASTINT (w->left);
  243.     line = get_display_line (vpos, XFASTINT (w->left));
  244. ***************
  245. *** 1229,1235 ****
  246.       {
  247.         if (minibuf_prompt)
  248.       hpos = display_string (w, line, minibuf_prompt, hpos,
  249. !                    !truncate ? '\\' : '$', -1, -1);
  250.         minibuf_prompt_width = hpos;
  251.       }
  252.   
  253. --- 1251,1258 ----
  254.       {
  255.         if (minibuf_prompt)
  256.       hpos = display_string (w, line, minibuf_prompt, hpos,
  257. !                    truncate ? cp->ct_truncg : cp->ct_wrapg,
  258. !                    -1, -1);
  259.         minibuf_prompt_width = hpos;
  260.       }
  261.   
  262. ***************
  263. *** 1267,1279 ****
  264.         p = &CharAt (pos);
  265.       }
  266.         c = *p++;
  267. !       if (c >= 040 && c < 0177)
  268. !     {
  269. !       if (p1 >= startp)
  270. !         *p1 = c;
  271. !       p1++;
  272. !     }
  273. !       else if (c == '\n')
  274.       {
  275.         invis = 0;
  276.         while (pos < end
  277. --- 1290,1296 ----
  278.         p = &CharAt (pos);
  279.       }
  280.         c = *p++;
  281. !       if (c == NEWLINE)
  282.       {
  283.         invis = 0;
  284.         while (pos < end
  285. ***************
  286. *** 1282,1348 ****
  287.           {
  288.             invis = 1;
  289.             pos = find_next_newline (pos + 1, 1);
  290. !           if (CharAt (pos - 1) == '\n')
  291.           pos--;
  292.           }
  293. !       if (invis && selective_e)
  294.           {
  295. !           p1 += 4;
  296.             if (p1 - startp > width)
  297.           p1 = endp;
  298. !           strncpy (p1prev, " ...", p1 - p1prev);
  299.           }
  300.         break;
  301.       }
  302. !       else if (c == '\t')
  303.       {
  304.         do
  305.           {
  306.             if (p1 >= startp)
  307. !         *p1 = ' ';
  308.             p1++;
  309.           }
  310.         while ((p1 - startp + taboffset + hscroll - (hscroll > 0))
  311.            % tab_width);
  312.       }
  313. !       else if (c == Ctl('M') && selective == -1)
  314.       {
  315.         pos = find_next_newline (pos, 1);
  316. !       if (CharAt (pos - 1) == '\n')
  317.           pos--;
  318. !       if (selective_e)
  319.           {
  320. !           p1 += 4;
  321.             if (p1 - startp > width)
  322.           p1 = endp;
  323. !           strncpy (p1prev, " ...", p1 - p1prev);
  324.           }
  325.         break;
  326.       }
  327. !       else if (c < 0200 && ctl_arrow)
  328. !     {
  329. !       if (p1 >= startp)
  330. !         *p1 = '^';
  331. !       p1++;
  332. !       if (p1 >= startp)
  333. !         *p1 = c ^ 0100;
  334. !       p1++;
  335. !     }
  336. !       else
  337. !     {
  338. !       if (p1 >= startp)
  339. !         *p1 = '\\';
  340. !       p1++;
  341. !       if (p1 >= startp)
  342. !         *p1 = (c >> 6) + '0';
  343. !       p1++;
  344. !       if (p1 >= startp)
  345. !         *p1 = (7 & (c >> 3)) + '0';
  346. !       p1++;
  347. !       if (p1 >= startp)
  348. !         *p1 = (7 & c) + '0';
  349. !       p1++;
  350. !     }
  351.         pos++;
  352.       }
  353.   
  354. --- 1299,1345 ----
  355.           {
  356.             invis = 1;
  357.             pos = find_next_newline (pos + 1, 1);
  358. !           if (CharAt (pos - 1) == NEWLINE)
  359.           pos--;
  360.           }
  361. !       if (invis && selective_rlen)
  362.           {
  363. !           p1 += selective_rlen;
  364.             if (p1 - startp > width)
  365.           p1 = endp;
  366. !           bcopy (cp->ct_invisr.r_glyfs, p1prev,
  367. !                      (p1 - p1prev) * sizeof (glyf_t));
  368.           }
  369.         break;
  370.       }
  371. !       else if (c == HTAB)
  372.       {
  373.         do
  374.           {
  375.             if (p1 >= startp)
  376. !         *p1 = SPACEGLYF;
  377.             p1++;
  378.           }
  379.         while ((p1 - startp + taboffset + hscroll - (hscroll > 0))
  380.            % tab_width);
  381.       }
  382. !       else if (c == cp->ct_invisc && selective == -1)
  383.       {
  384.         pos = find_next_newline (pos, 1);
  385. !       if (CharAt (pos - 1) == NEWLINE)
  386.           pos--;
  387. !       if (selective_rlen)
  388.           {
  389. !           p1 += selective_rlen;
  390.             if (p1 - startp > width)
  391.           p1 = endp;
  392. !           bcopy (cp->ct_invisr.r_glyfs, p1prev,
  393. !                      (p1 - p1prev) * sizeof (glyf_t));
  394.           }
  395.         break;
  396.       }
  397. !       else
  398. !         p1 = copy_rope (p1, startp, &cp->ct_dispr[c]);
  399.         pos++;
  400.       }
  401.   
  402. ***************
  403. *** 1373,1379 ****
  404.   
  405.     if (pos < NumCharacters + 1)
  406.       {
  407. !       if (CharAt (pos) == '\n')
  408.       /* If stopped due to a newline, start next line after it */
  409.       pos++;
  410.         else
  411. --- 1370,1376 ----
  412.   
  413.     if (pos < NumCharacters + 1)
  414.       {
  415. !       if (CharAt (pos) == NEWLINE)
  416.       /* If stopped due to a newline, start next line after it */
  417.       pos++;
  418.         else
  419. ***************
  420. *** 1381,1387 ****
  421.       {
  422.         if (truncate)
  423.           {
  424. !           *p1++ = '$';
  425.             /* Truncating => start next line after next newline,
  426.            and point is on this line if it is before the newline,
  427.            and skip none of first char of next line */
  428. --- 1378,1384 ----
  429.       {
  430.         if (truncate)
  431.           {
  432. !           *p1++ = cp->ct_truncg;
  433.             /* Truncating => start next line after next newline,
  434.            and point is on this line if it is before the newline,
  435.            and skip none of first char of next line */
  436. ***************
  437. *** 1388,1398 ****
  438.             pos = find_next_newline (pos, 1);
  439.             val.hpos = XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0;
  440.   
  441. !           lastpos = pos - (CharAt (pos - 1) == '\n');
  442.           }
  443.         else
  444.           {
  445. !           *p1++ = '\\';
  446.             val.vpos = 0;
  447.             lastpos--;
  448.           }
  449. --- 1385,1395 ----
  450.             pos = find_next_newline (pos, 1);
  451.             val.hpos = XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0;
  452.   
  453. !           lastpos = pos - (CharAt (pos - 1) == NEWLINE);
  454.           }
  455.         else
  456.           {
  457. !           *p1++ = cp->ct_wrapg;
  458.             val.vpos = 0;
  459.             lastpos--;
  460.           }
  461. ***************
  462. *** 1436,1442 ****
  463.     /* If hscroll and line not empty, insert truncation-at-left marker */
  464.     if (hscroll && lastpos != start)
  465.       {
  466. !       *startp = '$';
  467.         if (p1 <= startp)
  468.       p1 = startp + 1;
  469.       }
  470. --- 1433,1439 ----
  471.     /* If hscroll and line not empty, insert truncation-at-left marker */
  472.     if (hscroll && lastpos != start)
  473.       {
  474. !       *startp = cp->ct_truncg;
  475.         if (p1 <= startp)
  476.       p1 = startp + 1;
  477.       }
  478. ***************
  479. *** 1445,1452 ****
  480.       {
  481.         endp++;
  482.         if (p1 < startp) p1 = startp;
  483. !       while (p1 < endp) *p1++ = ' ';
  484. !       *p1++ = '|';
  485.       }
  486.     line->length = max (line->length, p1 - line->body);
  487.     line->body[line->length] = 0;
  488. --- 1442,1449 ----
  489.       {
  490.         endp++;
  491.         if (p1 < startp) p1 = startp;
  492. !       while (p1 < endp) *p1++ = SPACEGLYF;
  493. !       *p1++ = cp->ct_frameg;
  494.       }
  495.     line->length = max (line->length, p1 - line->body);
  496.     line->body[line->length] = 0;
  497. ***************
  498. *** 1717,1723 ****
  499.   {
  500.     register char *bp = buf;
  501.     register long len;
  502. !     
  503.     len = strlen (str);
  504.     if (width && width < len)
  505.       {
  506. --- 1714,1720 ----
  507.   {
  508.     register char *bp = buf;
  509.     register long len;
  510. ! 
  511.     len = strlen (str);
  512.     if (width && width < len)
  513.       {
  514. ***************
  515. *** 1856,1862 ****
  516.      been obtained by get_display_line (vpos, hpos)
  517.      or in some suitable manner.
  518.   
  519. !   TRUNCATE is character to display at end if truncated.  Zero for none.
  520.   
  521.     MINCOL is the first column ok to end at.  (Pad with spaces to this col.)
  522.     MAXCOL is the last column ok to end at.  Truncate here.
  523. --- 1853,1859 ----
  524.      been obtained by get_display_line (vpos, hpos)
  525.      or in some suitable manner.
  526.   
  527. !   TRUNCATE is glyf to display at end if truncated.  Zero for none.
  528.   
  529.     MINCOL is the first column ok to end at.  (Pad with spaces to this col.)
  530.     MAXCOL is the last column ok to end at.  Truncate here.
  531. ***************
  532. *** 1872,1900 ****
  533.        register struct display_line *line;
  534.        unsigned char *string;
  535.        int hpos;
  536. !      char truncate;
  537.        int mincol, maxcol;
  538.   {
  539. !   register int c;
  540. !   register unsigned char *p1;
  541.     int hscroll = XINT (w->hscroll);
  542.     int tab_width = XINT (bf_cur->tab_width);
  543. !   register unsigned char *start;
  544. !   register unsigned char *end;
  545. !   unsigned char *p1start = (unsigned char *) line->body + hpos;
  546.     int window_width = XFASTINT (w->width);
  547.   
  548.     if (tab_width <= 0 || tab_width > 20) tab_width = 8;
  549.   
  550.     p1 = p1start;
  551. !   start = (unsigned char *) line->body + XFASTINT (w->left);
  552.     end = start + window_width - (truncate != 0);
  553.   
  554.     if ((window_width + XFASTINT (w->left)) != screen_width)
  555. !     *end-- = '|';
  556.   
  557. !   if (maxcol >= 0 && end - (unsigned char *) line->body > maxcol)
  558. !     end = (unsigned char *) line->body + maxcol;
  559.     if (maxcol >= 0 && mincol > maxcol)
  560.       mincol = maxcol;
  561.   
  562. --- 1869,1898 ----
  563.        register struct display_line *line;
  564.        unsigned char *string;
  565.        int hpos;
  566. !      glyf_t truncate;
  567.        int mincol, maxcol;
  568.   {
  569. !   register char_t c;
  570. !   register glyf_t *p1;
  571.     int hscroll = XINT (w->hscroll);
  572.     int tab_width = XINT (bf_cur->tab_width);
  573. !   register glyf_t *start;
  574. !   register glyf_t *end;
  575. !   glyf_t *p1start = line->body + hpos;
  576.     int window_width = XFASTINT (w->width);
  577. +   register struct Lisp_Chartab *cp = WINDOW_CHAR_TABLE (w);
  578.   
  579.     if (tab_width <= 0 || tab_width > 20) tab_width = 8;
  580.   
  581.     p1 = p1start;
  582. !   start = line->body + XFASTINT (w->left);
  583.     end = start + window_width - (truncate != 0);
  584.   
  585.     if ((window_width + XFASTINT (w->left)) != screen_width)
  586. !     *end-- = cp->ct_frameg;
  587.   
  588. !   if (maxcol >= 0 && end - line->body > maxcol)
  589. !     end = line->body + maxcol;
  590.     if (maxcol >= 0 && mincol > maxcol)
  591.       mincol = maxcol;
  592.   
  593. ***************
  594. *** 1902,1947 ****
  595.       {
  596.         c = *string++;
  597.         if (!c) break;
  598. !       if (c >= 040 && c < 0177)
  599. !     {
  600. !       if (p1 >= start)
  601. !         *p1 = c;
  602. !       p1++;
  603. !     }
  604. !       else if (c == '\t')
  605.       {
  606.         do
  607.           {
  608.             if (p1 >= start)
  609. !         *p1 = ' ';
  610.             p1++;
  611.           }
  612.         while ((p1 - start + hscroll - (hscroll > 0)) % tab_width);
  613.       }
  614. !       else if (c < 0200 && buffer_defaults.ctl_arrow)
  615. !     {
  616. !       if (p1 >= start)
  617. !         *p1 = '^';
  618. !       p1++;
  619. !       if (p1 >= start)
  620. !         *p1 = c ^ 0100;
  621. !       p1++;
  622. !     }
  623. !       else
  624. !     {
  625. !       if (p1 >= start)
  626. !         *p1 = '\\';
  627. !       p1++;
  628. !       if (p1 >= start)
  629. !         *p1 = (c >> 6) + '0';
  630. !       p1++;
  631. !       if (p1 >= start)
  632. !         *p1 = (7 & (c >> 3)) + '0';
  633. !       p1++;
  634. !       if (p1 >= start)
  635. !         *p1 = (7 & c) + '0';
  636. !       p1++;
  637. !     }
  638.       }
  639.   
  640.     if (c)
  641. --- 1900,1917 ----
  642.       {
  643.         c = *string++;
  644.         if (!c) break;
  645. !       if (c == HTAB)
  646.       {
  647.         do
  648.           {
  649.             if (p1 >= start)
  650. !         *p1 = SPACEGLYF;
  651.             p1++;
  652.           }
  653.         while ((p1 - start + hscroll - (hscroll > 0)) % tab_width);
  654.       }
  655. !       else
  656. !         p1 = copy_rope (p1, start, &cp->ct_dispr[c]);
  657.       }
  658.   
  659.     if (c)
  660. ***************
  661. *** 1951,1963 ****
  662.       }
  663.     else if (mincol >= 0)
  664.       {
  665. !       end = (unsigned char *) line->body + mincol;
  666.         while (p1 < end)
  667. !     *p1++ = ' ';
  668.       }
  669.   
  670.     {
  671. !     register int len = p1 - (unsigned char *) line->body;
  672.       if (len > line->length)
  673.         line->length = len;
  674.       line->body[line->length] = 0;
  675. --- 1921,1933 ----
  676.       }
  677.     else if (mincol >= 0)
  678.       {
  679. !       end = line->body + mincol;
  680.         while (p1 < end)
  681. !     *p1++ = SPACEGLYF;
  682.       }
  683.   
  684.     {
  685. !     register int len = p1 - line->body;
  686.       if (len > line->length)
  687.         line->length = len;
  688.       line->body[line->length] = 0;
  689. *** ../18.55/src/x11term.c    Thu Aug  3 04:56:42 1989
  690. --- src/x11term.c    Thu Apr  5 09:18:47 1990
  691. ***************
  692. *** 1,5 ****
  693.   /* X Communication module for terminals which understand the X protocol.
  694. !    Copyright (C) 1988 Free Software Foundation, Inc.
  695.   
  696.   This file is part of GNU Emacs.
  697.   
  698. --- 1,5 ----
  699.   /* X Communication module for terminals which understand the X protocol.
  700. !    Copyright (C) 1988, 1990 Free Software Foundation, Inc.
  701.   
  702.   This file is part of GNU Emacs.
  703.   
  704. ***************
  705. *** 29,34 ****
  706. --- 29,38 ----
  707.    *    $Header: x11term.c,v 1.12 88/02/29 14:11:07 rfrench Exp $
  708.    */
  709.   
  710. + 
  711. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  712. +  *  See chartab.c for details. */
  713. + 
  714.   #ifndef lint
  715.   static char *rcsid_xterm_c = "$Header: x11term.c,v 1.12 88/02/29 14:11:07 rfrench Exp $";
  716.   #endif    lint
  717. ***************
  718. *** 49,54 ****
  719. --- 53,59 ----
  720.   #ifdef HAVE_X_WINDOWS
  721.   
  722.   #include "lisp.h"
  723. + #include "chartab.h"
  724.   #undef NULL
  725.   
  726.   /* Allow m- file to inhibit use of interrupt-driven input.  */
  727. ***************
  728. *** 457,467 ****
  729.       UNBLOCK_INPUT ();
  730.   }
  731.   
  732.   /* used by dumprectangle which is usually invoked upon Expose
  733.    * events which come from bit blt's or moving an obscuring opaque window
  734.    */
  735.   
  736. ! dumpchars (ActiveScreen, numcols, tempX, tempY, tempHL)
  737.        register struct display_line **ActiveScreen;
  738.        register int numcols;
  739.        register int tempX, tempY, tempHL;
  740. --- 462,490 ----
  741.       UNBLOCK_INPUT ();
  742.   }
  743.   
  744. + /* Display a sequence of glyfs. */
  745. + static void drawglyfs (gc, x, y, gp, n)
  746. + GC               gc; /* Graphic context.*/
  747. + int                x;  /* Horizontal glyf position. */
  748. + int                y;  /* Vertical glyf position. */
  749. + register glyf_t *gp; /* Points to first glyf. */
  750. + int              n;  /* Number of glyfs to display. */
  751. + {
  752. + register char *cp;                /* Steps through buf[]. */
  753. + register int   i;                 /* Counts glyfs.*/
  754. + char             buf[MScreenWidth]; /* Holds characters to be displayed. */
  755. + 
  756. + cp = buf;
  757. + for (i = n; 0 != i; --i)
  758. +    *cp++ = 0377 & *gp++;
  759. + XDrawImageString (XXdisplay, XXwindow, gc, x, y, buf, n);
  760. + }
  761. + 
  762.   /* used by dumprectangle which is usually invoked upon Expose
  763.    * events which come from bit blt's or moving an obscuring opaque window
  764.    */
  765.   
  766. ! dumpglyfs (ActiveScreen, numcols, tempX, tempY, tempHL)
  767.        register struct display_line **ActiveScreen;
  768.        register int numcols;
  769.        register int tempX, tempY, tempHL;
  770. ***************
  771. *** 476,492 ****
  772.           tempY < 0 || tempY >= screen_height)
  773.           return;
  774.   
  775. !     XDrawImageString(XXdisplay, XXwindow, tempHL ? XXgc_rev : XXgc_norm,
  776. !              tempX*XXfontw+XXInternalBorder,
  777. !              tempY*XXfonth+XXInternalBorder+XXbase,
  778. !              &ActiveScreen[tempY+1]->body[tempX],
  779. !              numcols);
  780.   }
  781.   
  782.   /* When a line has been changed this function is called.  Due to various
  783.    * bits of braindamage on the parts of both X11 and Emacs, the new
  784.    * version of the line is simply output if this function is invoked while
  785. !  * in UpDate.  Sometimes writechars can be invoked when not in update if
  786.    * text is to be output at the end of the line.  In this case the whole
  787.    * line is not output.  Simply the new text at the current cursor
  788.    * position given by VisibleX,Y.  The cursor is moved to the end of the
  789. --- 499,515 ----
  790.           tempY < 0 || tempY >= screen_height)
  791.           return;
  792.   
  793. !     drawglyfs(tempHL ? XXgc_rev : XXgc_norm,
  794. !           tempX*XXfontw+XXInternalBorder,
  795. !           tempY*XXfonth+XXInternalBorder+XXbase,
  796. !           &ActiveScreen[tempY+1]->body[tempX],
  797. !           numcols);
  798.   }
  799.   
  800.   /* When a line has been changed this function is called.  Due to various
  801.    * bits of braindamage on the parts of both X11 and Emacs, the new
  802.    * version of the line is simply output if this function is invoked while
  803. !  * in UpDate.  Sometimes writeglyfs can be invoked when not in update if
  804.    * text is to be output at the end of the line.  In this case the whole
  805.    * line is not output.  Simply the new text at the current cursor
  806.    * position given by VisibleX,Y.  The cursor is moved to the end of the
  807. ***************
  808. *** 518,529 ****
  809.       else
  810.           temp_length = 0;
  811.       if (temp_length > 0) {
  812. !         XDrawImageString (XXdisplay, XXwindow,
  813. !                   CurHL ? XXgc_rev : XXgc_norm,
  814. !                   first*XXfontw+XXInternalBorder,
  815. !                   cursY*XXfonth+XXInternalBorder+XXbase,
  816. !                   &DesiredScreen[cursY + 1]->body[first],
  817. !                   temp_length);
  818.           if (temp_length < screen_width)
  819.               x_clear_end_of_line (temp_length);
  820.           XTtopos (cursY, temp_length);
  821. --- 541,551 ----
  822.       else
  823.           temp_length = 0;
  824.       if (temp_length > 0) {
  825. !         drawglyfs (CurHL ? XXgc_rev : XXgc_norm,
  826. !                first*XXfontw+XXInternalBorder,
  827. !                cursY*XXfonth+XXInternalBorder+XXbase,
  828. !                &DesiredScreen[cursY + 1]->body[first],
  829. !                temp_length);
  830.           if (temp_length < screen_width)
  831.               x_clear_end_of_line (temp_length);
  832.           XTtopos (cursY, temp_length);
  833. ***************
  834. *** 535,547 ****
  835.       UNBLOCK_INPUT ();
  836.   }
  837.   
  838. ! writechars (start, end)
  839. !     register char *start, *end;
  840.   {
  841.     BLOCK_INPUT_DECLARE ();
  842.   
  843.   #ifdef XDEBUG
  844. !   fprintf(stderr, "writechars (cursX %d temp_len %d InUpd %d)\n",
  845.         cursX, end-start+1, InUpdate);
  846.   #endif XDEBUG
  847.   
  848. --- 557,569 ----
  849.       UNBLOCK_INPUT ();
  850.   }
  851.   
  852. ! writeglyfs (start, end)
  853. !     register glyf_t *start, *end;
  854.   {
  855.     BLOCK_INPUT_DECLARE ();
  856.   
  857.   #ifdef XDEBUG
  858. !   fprintf(stderr, "writeglyfs (cursX %d temp_len %d InUpd %d)\n",
  859.         cursX, end-start+1, InUpdate);
  860.   #endif XDEBUG
  861.   
  862. ***************
  863. *** 559,570 ****
  864.   
  865.     if (InUpdate)
  866.       {
  867. !       XDrawImageString (XXdisplay, XXwindow,
  868. !             CurHL ? XXgc_rev : XXgc_norm,
  869. !             cursX*XXfontw+XXInternalBorder,
  870. !             cursY*XXfonth+XXInternalBorder+XXbase,
  871. !             start,
  872. !             (end - start) + 1);
  873.         XTtopos (cursY, (end - start) + 1);
  874.   
  875.         UNBLOCK_INPUT ();
  876. --- 581,591 ----
  877.   
  878.     if (InUpdate)
  879.       {
  880. !       drawglyfs (CurHL ? XXgc_rev : XXgc_norm,
  881. !          cursX*XXfontw+XXInternalBorder,
  882. !          cursY*XXfonth+XXInternalBorder+XXbase,
  883. !          start,
  884. !          (end - start) + 1);
  885.         XTtopos (cursY, (end - start) + 1);
  886.   
  887.         UNBLOCK_INPUT ();
  888. ***************
  889. *** 582,593 ****
  890.     if (((end - start) + VisibleX) >= screen_width)
  891.       end = start + (screen_width - (VisibleX + 1));
  892.     if (end >= start) {
  893. !     XDrawImageString (XXdisplay, XXwindow,
  894. !               CurHL ? XXgc_rev : XXgc_norm,
  895. !               (VisibleX * XXfontw+XXInternalBorder),
  896. !               VisibleY * XXfonth+XXInternalBorder+XXbase,
  897. !               start,
  898. !               ((end - start) + 1));
  899.       VisibleX = VisibleX + (end - start) + 1;
  900.     }
  901.     if (!CursorExists)
  902. --- 603,613 ----
  903.     if (((end - start) + VisibleX) >= screen_width)
  904.       end = start + (screen_width - (VisibleX + 1));
  905.     if (end >= start) {
  906. !     drawglyfs (CurHL ? XXgc_rev : XXgc_norm,
  907. !            VisibleX * XXfontw+XXInternalBorder,
  908. !            VisibleY * XXfonth+XXInternalBorder+XXbase,
  909. !            start,
  910. !            ((end - start) + 1));
  911.       VisibleX = VisibleX + (end - start) + 1;
  912.     }
  913.     if (!CursorExists)
  914. ***************
  915. *** 596,610 ****
  916.   }
  917.   
  918.   static
  919. ! XTwrite_chars (start, len)
  920. !      register char *start;
  921.        register int len;
  922.   {
  923.   #ifdef XDEBUG
  924. !     fprintf (stderr, "XTwrite_chars (len %d)\n",len);
  925.   #endif
  926.   
  927. !     writechars (start, start+len-1);
  928.   }
  929.   
  930.   XTflash ()
  931. --- 616,630 ----
  932.   }
  933.   
  934.   static
  935. ! XTwrite_glyfs (start, len)
  936. !      register glyf_t *start;
  937.        register int len;
  938.   {
  939.   #ifdef XDEBUG
  940. !     fprintf (stderr, "XTwrite_glyfs (len %d)\n",len);
  941.   #endif
  942.   
  943. !     writeglyfs (start, start+len-1);
  944.   }
  945.   
  946.   XTflash ()
  947. ***************
  948. *** 669,674 ****
  949. --- 689,695 ----
  950.   CursorToggle ()
  951.   {
  952.       register struct display_line **ActiveScreen;
  953. +         static   glyf_t                sg = SPACEGLYF;
  954.   
  955.       if (!WindowMapped) {
  956.           CursorExists = 0;
  957. ***************
  958. *** 692,718 ****
  959.       if (ActiveScreen && ActiveScreen[VisibleY+1] &&
  960.           VisibleX < ActiveScreen[VisibleY+1]->length) {
  961.           if (CursorExists)
  962. !             XDrawImageString(XXdisplay, XXwindow, XXgc_norm,
  963. !                     VisibleX*XXfontw+XXInternalBorder,
  964. !                     VisibleY*XXfonth+XXInternalBorder+XXbase,
  965. !                     &ActiveScreen[VisibleY+1]->body[VisibleX],
  966. !                     1);
  967.           else if (CursorOutline) {
  968. !             XDrawImageString(XXdisplay, XXwindow, XXgc_norm,
  969. !                     VisibleX*XXfontw+XXInternalBorder,
  970. !                     VisibleY*XXfonth+XXInternalBorder+XXbase,
  971. !                     &ActiveScreen[VisibleY+1]->body[VisibleX],
  972. !                     1);
  973.               XDrawRectangle (XXdisplay, XXwindow, XXgc_norm,
  974.                       VisibleX*XXfontw+XXInternalBorder,
  975.                       VisibleY*XXfonth+XXInternalBorder,
  976.                       XXfontw - 1, XXfonth - 1);
  977.           } else
  978. !             XDrawImageString(XXdisplay, XXwindow, XXgc_curs,
  979. !                     VisibleX*XXfontw+XXInternalBorder,
  980. !                     VisibleY*XXfonth+XXInternalBorder+XXbase,
  981. !                     &ActiveScreen[VisibleY+1]->body[VisibleX],
  982. !                     1);
  983.             }
  984.       else {
  985.           if (CursorExists)
  986. --- 713,739 ----
  987.       if (ActiveScreen && ActiveScreen[VisibleY+1] &&
  988.           VisibleX < ActiveScreen[VisibleY+1]->length) {
  989.           if (CursorExists)
  990. !             drawglyfs(XXgc_norm,
  991. !                   VisibleX*XXfontw+XXInternalBorder,
  992. !                   VisibleY*XXfonth+XXInternalBorder+XXbase,
  993. !                   &ActiveScreen[VisibleY+1]->body[VisibleX],
  994. !                   1);
  995.           else if (CursorOutline) {
  996. !             drawglyfs(XXgc_norm,
  997. !                   VisibleX*XXfontw+XXInternalBorder,
  998. !                   VisibleY*XXfonth+XXInternalBorder+XXbase,
  999. !                   &ActiveScreen[VisibleY+1]->body[VisibleX],
  1000. !                   1);
  1001.               XDrawRectangle (XXdisplay, XXwindow, XXgc_norm,
  1002.                       VisibleX*XXfontw+XXInternalBorder,
  1003.                       VisibleY*XXfonth+XXInternalBorder,
  1004.                       XXfontw - 1, XXfonth - 1);
  1005.           } else
  1006. !             drawglyfs(XXgc_curs,
  1007. !                   VisibleX*XXfontw+XXInternalBorder,
  1008. !                   VisibleY*XXfonth+XXInternalBorder+XXbase,
  1009. !                   &ActiveScreen[VisibleY+1]->body[VisibleX],
  1010. !                   1);
  1011.             }
  1012.       else {
  1013.           if (CursorExists)
  1014. ***************
  1015. *** 726,735 ****
  1016.                       VisibleY*XXfonth+XXInternalBorder,
  1017.                       XXfontw - 1, XXfonth - 1);
  1018.           else
  1019. !             XDrawImageString(XXdisplay, XXwindow, XXgc_curs,
  1020. !                     VisibleX*XXfontw+XXInternalBorder,
  1021. !                     VisibleY*XXfonth+XXInternalBorder+XXbase,
  1022. !                     " ", 1);
  1023.             }
  1024.   
  1025.       CursorExists = !CursorExists;
  1026. --- 747,756 ----
  1027.                       VisibleY*XXfonth+XXInternalBorder,
  1028.                       XXfontw - 1, XXfonth - 1);
  1029.           else
  1030. !             drawglyfs(XXgc_curs,
  1031. !                   VisibleX*XXfontw+XXInternalBorder,
  1032. !                   VisibleY*XXfonth+XXInternalBorder+XXbase,
  1033. !                   &sg, 1);
  1034.             }
  1035.   
  1036.       CursorExists = !CursorExists;
  1037. ***************
  1038. *** 892,898 ****
  1039.               continue;
  1040.           localX = left;
  1041.           localHL = ActiveScreen[localY+1]->highlighted;
  1042. !         dumpchars (ActiveScreen,
  1043.                  min (cols,
  1044.                   ActiveScreen[localY+1]->length-localX),
  1045.                  localX, localY, localHL);
  1046. --- 913,919 ----
  1047.               continue;
  1048.           localX = left;
  1049.           localHL = ActiveScreen[localY+1]->highlighted;
  1050. !         dumpglyfs (ActiveScreen,
  1051.                  min (cols,
  1052.                   ActiveScreen[localY+1]->length-localX),
  1053.                  localX, localY, localHL);
  1054. ***************
  1055. *** 937,948 ****
  1056.   }
  1057.   
  1058.   static
  1059. ! XTinsert_chars (start, len)
  1060. !      register char *start;
  1061.        register int len;
  1062.   {
  1063.   #ifdef XDEBUG
  1064. !     fprintf (stderr, "XTinsert_chars\n");
  1065.   #endif
  1066.   
  1067.       updateline (0);
  1068. --- 958,969 ----
  1069.   }
  1070.   
  1071.   static
  1072. ! XTinsert_glyfs (start, len)
  1073. !      register glyf_t *start;
  1074.        register int len;
  1075.   {
  1076.   #ifdef XDEBUG
  1077. !     fprintf (stderr, "XTinsert_glyfs\n");
  1078.   #endif
  1079.   
  1080.       updateline (0);
  1081. ***************
  1082. *** 949,961 ****
  1083.   }
  1084.   
  1085.   static
  1086. ! XTdelete_chars (n)
  1087.        register int n;
  1088.   {
  1089.       char *msg = "Major foobars!  This shouldn't show up!";
  1090.       
  1091.   #ifdef XDEBUG
  1092. !     fprintf (stderr, "XTdelete_chars (num %d cursX %d)\n",n,cursX);
  1093.   #endif
  1094.   
  1095.       updateline (0);
  1096. --- 970,982 ----
  1097.   }
  1098.   
  1099.   static
  1100. ! XTdelete_glyfs (n)
  1101.        register int n;
  1102.   {
  1103.       char *msg = "Major foobars!  This shouldn't show up!";
  1104.       
  1105.   #ifdef XDEBUG
  1106. !     fprintf (stderr, "XTdelete_glyfs (num %d cursX %d)\n",n,cursX);
  1107.   #endif
  1108.   
  1109.       updateline (0);
  1110. ***************
  1111. *** 1067,1147 ****
  1112.   {
  1113.       switch (keycode) {
  1114.       case XK_L1:
  1115. !         return("192");
  1116.       case XK_L2:
  1117. !         return("193");
  1118.       case XK_L3:
  1119. !         return("194");
  1120.       case XK_L4:
  1121. !         return("195");
  1122.       case XK_L5:
  1123. !         return("196");
  1124.       case XK_L6:
  1125. !         return("197");
  1126.       case XK_L7:
  1127. !         return("198");
  1128.       case XK_L8:
  1129. !         return("199");
  1130.       case XK_L9:
  1131. !         return("200");
  1132.       case XK_L10:
  1133. !         return("201");
  1134.   
  1135.       case XK_R1:
  1136. !         return("208");
  1137.       case XK_R2:
  1138. !         return("209");
  1139.       case XK_R3:
  1140. !         return("210");
  1141.       case XK_R4:
  1142. !         return("211");
  1143.       case XK_R5:
  1144. !         return("212");
  1145.       case XK_R6:
  1146. !         return("213");
  1147.       case XK_R7:
  1148. !         return("214");
  1149.       case XK_R8:
  1150. !         return("215");
  1151.       case XK_R9:
  1152. !         return("216");
  1153.       case XK_R10:
  1154. !         return("217");
  1155.       case XK_R11:
  1156. !         return("218");
  1157.       case XK_R12:
  1158. !         return("219");
  1159.       case XK_R13:
  1160. !         return("220");
  1161.       case XK_R14:
  1162. !         return("221");
  1163.       case XK_R15:
  1164. !         return("222");
  1165.   
  1166.       case XK_Break:            /* Sun3 "Alternate" key */
  1167. !         return("223");
  1168.   
  1169.       case XK_F1:
  1170. !         return("224");
  1171.       case XK_F2:
  1172. !         return("225");
  1173.       case XK_F3:
  1174. !         return("226");
  1175.       case XK_F4:
  1176. !         return("227");
  1177.       case XK_F5:
  1178. !         return("228");
  1179.       case XK_F6:
  1180. !         return("229");
  1181.       case XK_F7:
  1182. !         return("230");
  1183.       case XK_F8:
  1184. !         return("231");
  1185.       case XK_F9:
  1186. !         return("232");
  1187.   
  1188.       default:
  1189. !         return("-1");
  1190.       }
  1191.   }
  1192.   #else
  1193. --- 1088,1168 ----
  1194.   {
  1195.       switch (keycode) {
  1196.       case XK_L1:
  1197. !         return("\033[192z");
  1198.       case XK_L2:
  1199. !         return("\033[193z");
  1200.       case XK_L3:
  1201. !         return("\033[194z");
  1202.       case XK_L4:
  1203. !         return("\033[195z");
  1204.       case XK_L5:
  1205. !         return("\033[196z");
  1206.       case XK_L6:
  1207. !         return("\033[197z");
  1208.       case XK_L7:
  1209. !         return("\033[198z");
  1210.       case XK_L8:
  1211. !         return("\033[199z");
  1212.       case XK_L9:
  1213. !         return("\033[200z");
  1214.       case XK_L10:
  1215. !         return("\033[201z");
  1216.   
  1217.       case XK_R1:
  1218. !         return("\021305");
  1219.       case XK_R2:
  1220. !         return("\021304");
  1221.       case XK_R3:
  1222. !         return("\021326");
  1223.       case XK_R4:
  1224. !         return("\021345");
  1225.       case XK_R5:
  1226. !         return("\021344");
  1227.       case XK_R6:
  1228. !         return("\021366");
  1229.       case XK_R7:
  1230. !         return("\033[214z");
  1231.       case XK_R8:
  1232. !         return("\033[215z");
  1233.       case XK_R9:
  1234. !         return("\033[216z");
  1235.       case XK_R10:
  1236. !         return("\033[217z");
  1237.       case XK_R11:
  1238. !         return("\033[218z");
  1239.       case XK_R12:
  1240. !         return("\033[219z");
  1241.       case XK_R13:
  1242. !         return("\033[220z");
  1243.       case XK_R14:
  1244. !         return("\033[221z");
  1245.       case XK_R15:
  1246. !         return("\033[222z");
  1247.   
  1248.       case XK_Break:            /* Sun3 "Alternate" key */
  1249. !         return("\033[223z");
  1250.   
  1251.       case XK_F1:
  1252. !         return("\033[224z");
  1253.       case XK_F2:
  1254. !         return("\033[225z");
  1255.       case XK_F3:
  1256. !         return("\033[226z");
  1257.       case XK_F4:
  1258. !         return("\033[227z");
  1259.       case XK_F5:
  1260. !         return("\033[228z");
  1261.       case XK_F6:
  1262. !         return("\033[229z");
  1263.       case XK_F7:
  1264. !         return("\033[230z");
  1265.       case XK_F8:
  1266. !         return("\033[231z");
  1267.       case XK_F9:
  1268. !         return("\033[232z");
  1269.   
  1270.       default:
  1271. !         return("\033[-1z");
  1272.       }
  1273.   }
  1274.   #else
  1275. ***************
  1276. *** 1335,1345 ****
  1277.        will have already given us the string we want. */
  1278.         if (IsFunctionKey(keysym) ||
  1279.         IsMiscFunctionKey(keysym)) {
  1280. -     strcpy(mapping_buf,"[");
  1281. -     strcat(mapping_buf,stringFuncVal(keysym));
  1282.   #ifdef sun
  1283. !     strcat(mapping_buf,"z");
  1284.   #else
  1285.       strcat(mapping_buf,"~");
  1286.   #endif /* sun */
  1287.       nbytes = strlen(mapping_buf);
  1288. --- 1356,1366 ----
  1289.        will have already given us the string we want. */
  1290.         if (IsFunctionKey(keysym) ||
  1291.         IsMiscFunctionKey(keysym)) {
  1292.   #ifdef sun
  1293. !     strcpy(mapping_buf,stringFuncVal(keysym));
  1294.   #else
  1295. +     strcpy(mapping_buf,"[");
  1296. +     strcat(mapping_buf,stringFuncVal(keysym));
  1297.       strcat(mapping_buf,"~");
  1298.   #endif /* sun */
  1299.       nbytes = strlen(mapping_buf);
  1300. ***************
  1301. *** 1559,1567 ****
  1302.       clear_end_of_line_hook = XTclear_end_of_line;
  1303.       ins_del_lines_hook = XTins_del_lines;
  1304.       change_line_highlight_hook = XTchange_line_highlight;
  1305. !     insert_chars_hook = XTinsert_chars;
  1306. !     write_chars_hook = XTwrite_chars;
  1307. !     delete_chars_hook = XTdelete_chars;
  1308.       ring_bell_hook = XTfeep;
  1309.       reset_terminal_modes_hook = XTreset_terminal_modes;
  1310.       set_terminal_modes_hook = XTset_terminal_modes;
  1311. --- 1580,1588 ----
  1312.       clear_end_of_line_hook = XTclear_end_of_line;
  1313.       ins_del_lines_hook = XTins_del_lines;
  1314.       change_line_highlight_hook = XTchange_line_highlight;
  1315. !     insert_glyfs_hook = XTinsert_glyfs;
  1316. !     write_glyfs_hook = XTwrite_glyfs;
  1317. !     delete_glyfs_hook = XTdelete_glyfs;
  1318.       ring_bell_hook = XTfeep;
  1319.       reset_terminal_modes_hook = XTreset_terminal_modes;
  1320.       set_terminal_modes_hook = XTset_terminal_modes;
  1321. ***************
  1322. *** 1884,1890 ****
  1323. --- 1905,1914 ----
  1324.   #ifndef CANNOT_DUMP
  1325.       if (initialized)
  1326.   #endif /* CANNOT_DUMP */
  1327. +                 {
  1328.           Vxterm = Qt;
  1329. +                 init_char_table_x();
  1330. +                 }
  1331.   
  1332.       Fset (intern ("window-system-version"), make_number (11));
  1333.   
  1334.