home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 1 / 1135 < prev    next >
Internet Message Format  |  1990-12-28  |  36KB
  1. From: howard@hasse.ericsson.se (Howard Gayle)
  2. Newsgroups: alt.sources
  3. Subject: GNU Emacs 8-bit mods part 08 of 12
  4. Message-ID: <1990Apr5.134005.9052@ericsson.se>
  5. Date: 5 Apr 90 13:40:05 GMT
  6.  
  7. *** ../18.55/src/search.c    Thu Aug  3 08:05:06 1989
  8. --- src/search.c    Thu Apr  5 09:16:19 1990
  9. ***************
  10. *** 1,5 ****
  11.   /* String search routines for GNU Emacs.
  12. !    Copyright (C) 1985, 1986, 1987 Free Software Foundation, Inc.
  13.   
  14.   This file is part of GNU Emacs.
  15.   
  16. --- 1,5 ----
  17.   /* String search routines for GNU Emacs.
  18. !    Copyright (C) 1985, 1986, 1987, 1990 Free Software Foundation, Inc.
  19.   
  20.   This file is part of GNU Emacs.
  21.   
  22. ***************
  23. *** 19,60 ****
  24.   and this notice must be preserved on all copies.  */
  25.   
  26.   
  27.   #include "config.h"
  28.   #include "lisp.h"
  29.   #include "syntax.h"
  30.   #include "buffer.h"
  31.   #include "commands.h"
  32.   #include "regex.h"
  33.   
  34.   #define max(a, b) ((a) > (b) ? (a) : (b))
  35.   #define min(a, b) ((a) < (b) ? (a) : (b))
  36.   
  37. - unsigned char downcase_table[01000] = {0};    /* folds upper to lower case */
  38. -           /* A WHEEL WILL FALL OFF IF, IN A trt, CHARACTER A */
  39. -           /* TRANSLATES INTO CHARACTER B AND CHARACTER B DOES NOT */
  40. -           /* ALSO TRANSLATE INTO CHARACTER B. */ 
  41. - /* If that constraint is met, compute_trt_inverse will follow a */
  42. -  /* translation table with its inverse.  The inverse of a table */
  43. -  /* follows the table at table[0400].  The form of this is that if */
  44. -  /* table[a]=b then the chain starting at table[0400+b], linked by */
  45. -  /* link(x)=table[0400+x] and ended by b must include a. */
  46. - 
  47. - /* At present compute_trt_inverse is blinded and the inverse for this */
  48. -  /* particular table is created by a single-purpose loop. */
  49. -  /* compute_trt_inverse has been tested on the following cases: */
  50. -  /* trt[x]=x, trt[x]=(+ 3 (logand x, 0370)), trt[x]='a', and the */
  51. -  /* downcase table. */
  52. - 
  53.   /* We compile regexps into this buffer and then use it for searching. */
  54.   
  55.   struct re_pattern_buffer searchbuf;
  56.   
  57. ! char search_fastmap[0400];
  58.   
  59.   /* Last regexp we compiled */
  60. - 
  61.   Lisp_Object last_regexp;
  62.   
  63.   /* Every call to re_match, etc., must pass &search_regs as the regs argument
  64.    unless you can show it is unnecessary (i.e., if re_match is certainly going
  65.    to be called again before region-around-match can be called).  */
  66. --- 19,51 ----
  67.   and this notice must be preserved on all copies.  */
  68.   
  69.   
  70. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  71. +  *  See chartab.c for details. */
  72. + 
  73. + 
  74.   #include "config.h"
  75.   #include "lisp.h"
  76.   #include "syntax.h"
  77.   #include "buffer.h"
  78. + #include "casetab.h"
  79. + #include "chartab.h"
  80.   #include "commands.h"
  81.   #include "regex.h"
  82. + #include "sorttab.h"
  83.   
  84.   #define max(a, b) ((a) > (b) ? (a) : (b))
  85.   #define min(a, b) ((a) < (b) ? (a) : (b))
  86.   
  87.   /* We compile regexps into this buffer and then use it for searching. */
  88.   
  89.   struct re_pattern_buffer searchbuf;
  90.   
  91. ! char_t search_fastmap[0400];
  92.   
  93.   /* Last regexp we compiled */
  94.   Lisp_Object last_regexp;
  95.   
  96. + 
  97.   /* Every call to re_match, etc., must pass &search_regs as the regs argument
  98.    unless you can show it is unnecessary (i.e., if re_match is certainly going
  99.    to be called again before region-around-match can be called).  */
  100. ***************
  101. *** 67,88 ****
  102.   
  103.   /* Compile a regexp and signal a Lisp error if anything goes wrong.  */
  104.   
  105. ! compile_pattern (pattern, bufp, translate)
  106.        Lisp_Object pattern;
  107.        struct re_pattern_buffer *bufp;
  108. !      char *translate;
  109.   {
  110.     char *val;
  111.     Lisp_Object dummy;
  112.   
  113.     if (EQ (pattern, last_regexp)
  114. !       && translate == bufp->translate)
  115.       return;
  116.     last_regexp = Qnil;
  117. !   bufp->translate = translate;
  118. !   val = re_compile_pattern (XSTRING (pattern)->data,
  119. !                 XSTRING (pattern)->size,
  120. !                 bufp);
  121.     if (val)
  122.       {
  123.         dummy = build_string (val);
  124. --- 58,81 ----
  125.   
  126.   /* Compile a regexp and signal a Lisp error if anything goes wrong.  */
  127.   
  128. ! compile_pattern (pattern, bufp, sorttab)
  129.        Lisp_Object pattern;
  130.        struct re_pattern_buffer *bufp;
  131. !      struct Lisp_Sorttab *sorttab;
  132.   {
  133.     char *val;
  134.     Lisp_Object dummy;
  135.   
  136. +   /* Sort table used for last regexp compilation: */
  137. +   static struct Lisp_Sorttab *last_sort_table;
  138. + 
  139.     if (EQ (pattern, last_regexp)
  140. !       && (sorttab == last_sort_table))
  141.       return;
  142.     last_regexp = Qnil;
  143. !   val = re_compile_pattern_sort (XSTRING (pattern)->data,
  144. !                      XSTRING (pattern)->size,
  145. !                      bufp, sorttab);
  146.     if (val)
  147.       {
  148.         dummy = build_string (val);
  149. ***************
  150. *** 90,95 ****
  151. --- 83,89 ----
  152.       Fsignal (Qinvalid_regexp, Fcons (dummy, Qnil));
  153.       }
  154.     last_regexp = pattern;
  155. +   last_sort_table = sorttab;
  156.     return;
  157.   }
  158.   
  159. ***************
  160. *** 115,122 ****
  161.     register int i;
  162.   
  163.     CHECK_STRING (string, 0);
  164. !   compile_pattern (string, &searchbuf,
  165. !            !NULL (bf_cur->case_fold_search) ? (char *) downcase_table : 0);
  166.   
  167.     immediate_quit = 1;
  168.     QUIT;            /* Do a pending quit right away, to avoid paradoxical behavior */
  169. --- 109,115 ----
  170.     register int i;
  171.   
  172.     CHECK_STRING (string, 0);
  173. !   compile_pattern (string, &searchbuf, current_sort_table ());
  174.   
  175.     immediate_quit = 1;
  176.     QUIT;            /* Do a pending quit right away, to avoid paradoxical behavior */
  177. ***************
  178. *** 183,190 ****
  179.       args_out_of_range (string, start);
  180.       }
  181.   
  182. !   compile_pattern (regexp, &searchbuf,
  183. !            !NULL (bf_cur->case_fold_search) ? (char *) downcase_table : 0);
  184.     immediate_quit = 1;
  185.     val = re_search (&searchbuf, XSTRING (string)->data, XSTRING (string)->size,
  186.                      s, XSTRING (string)->size - s, &search_regs);
  187. --- 176,182 ----
  188.       args_out_of_range (string, start);
  189.       }
  190.   
  191. !   compile_pattern (regexp, &searchbuf, current_sort_table ());
  192.     immediate_quit = 1;
  193.     val = re_search (&searchbuf, XSTRING (string)->data, XSTRING (string)->size,
  194.                      s, XSTRING (string)->size - s, &search_regs);
  195. ***************
  196. *** 273,279 ****
  197.   find_next_newline (from, cnt)
  198.        register int from, cnt;
  199.   {
  200. !   return (scan_buffer ('\n', from, cnt, (int *) 0));
  201.   }
  202.   
  203.   DEFUN ("skip-chars-forward", Fskip_chars_forward, Sskip_chars_forward, 1, 2, 0,
  204. --- 265,271 ----
  205.   find_next_newline (from, cnt)
  206.        register int from, cnt;
  207.   {
  208. !   return (scan_buffer (NEWLINE, from, cnt, (int *) 0));
  209.   }
  210.   
  211.   DEFUN ("skip-chars-forward", Fskip_chars_forward, Sskip_chars_forward, 1, 2, 0,
  212. ***************
  213. *** 403,410 ****
  214.       lim = FirstCharacter;
  215.       }
  216.   
  217. !   np = search_buffer (string, point, lim, n, RE,
  218. !               !NULL (bf_cur->case_fold_search) ? downcase_table : 0);
  219.     if (np <= 0)
  220.       {
  221.         if (NULL (noerror))
  222. --- 395,401 ----
  223.       lim = FirstCharacter;
  224.       }
  225.   
  226. !   np = search_buffer (string, point, lim, n, RE);
  227.     if (np <= 0)
  228.       {
  229.         if (NULL (noerror))
  230. ***************
  231. *** 441,454 ****
  232.   /* INTERFACE CHANGE ALERT!!!!  search_buffer now returns -x if only */
  233.   /* n-x occurences are found. */
  234.   
  235. ! search_buffer (string, pos, lim, n, RE, trt)
  236.        Lisp_Object string;
  237.        int pos;
  238.        int lim;
  239.        int n;
  240.        int RE;
  241. -      register unsigned char *trt;
  242.   {
  243.     int len = XSTRING (string)->size;
  244.     unsigned char *base_pat = XSTRING (string)->data;
  245.     register int *BM_tab;
  246. --- 432,446 ----
  247.   /* INTERFACE CHANGE ALERT!!!!  search_buffer now returns -x if only */
  248.   /* n-x occurences are found. */
  249.   
  250. ! search_buffer (string, pos, lim, n, RE)
  251.        Lisp_Object string;
  252.        int pos;
  253.        int lim;
  254.        int n;
  255.        int RE;
  256.   {
  257. +   struct Lisp_Sorttab *sorttab;
  258. +   register char_t *trt; /* Equivalence class table. */
  259.     int len = XSTRING (string)->size;
  260.     unsigned char *base_pat = XSTRING (string)->data;
  261.     register int *BM_tab;
  262. ***************
  263. *** 465,472 ****
  264.     if (!len)
  265.       return (0);
  266.   
  267.     if (RE)
  268. !     compile_pattern (string, &searchbuf, (char *) trt);
  269.     
  270.     if (RE            /* Here we detect whether the */
  271.                   /* generality of an RE search is */
  272. --- 457,466 ----
  273.     if (!len)
  274.       return (0);
  275.   
  276. +   sorttab = current_sort_table ();
  277. +   trt = current_equiv_class_table ();
  278.     if (RE)
  279. !     compile_pattern (string, &searchbuf, sorttab);
  280.     
  281.     if (RE            /* Here we detect whether the */
  282.                   /* generality of an RE search is */
  283. ***************
  284. *** 476,482 ****
  285.       {
  286.         RE = 0;            /* can do straight (non RE) search */
  287.         pat = (base_pat = (unsigned char *) searchbuf.buffer + 2);
  288. !                 /* trt already applied */
  289.         len = searchbuf.used - 2;
  290.       }
  291.     else if (!RE)
  292. --- 470,476 ----
  293.       {
  294.         RE = 0;            /* can do straight (non RE) search */
  295.         pat = (base_pat = (unsigned char *) searchbuf.buffer + 2);
  296. !                 /* sorttab already applied */
  297.         len = searchbuf.used - 2;
  298.       }
  299.     else if (!RE)
  300. ***************
  301. *** 483,490 ****
  302.       {
  303.         pat = (unsigned char *) alloca (len);
  304.   
  305. !       for (i = len; i--;)        /* Copy the pattern; apply trt */
  306. !     *pat++ = (((int) trt) ? trt [*base_pat++] : *base_pat++);
  307.         pat -= len; base_pat = pat;
  308.       }
  309.   
  310. --- 477,484 ----
  311.       {
  312.         pat = (unsigned char *) alloca (len);
  313.   
  314. !       for (i = len; i--;)        /* Copy the pattern; apply sorttab */
  315. !     *pat++ = (trt ? trt[*base_pat++] : *base_pat++);
  316.         pat -= len; base_pat = pat;
  317.       }
  318.   
  319. ***************
  320. *** 596,602 ****
  321.         /* is determined only by the last character of the putative match. */
  322.         /* If that character does not match, we will stride the proper */
  323.         /* distance to propose a match that superimposes it on the last */
  324. !       /* instance of a character that matches it (per trt), or misses */
  325.         /* it entirely if there is none. */  
  326.   
  327.         dirlen = len * direction;
  328. --- 590,596 ----
  329.         /* is determined only by the last character of the putative match. */
  330.         /* If that character does not match, we will stride the proper */
  331.         /* distance to propose a match that superimposes it on the last */
  332. !       /* instance of a character that matches it (per sorttab), or misses */
  333.         /* it entirely if there is none. */  
  334.   
  335.         dirlen = len * direction;
  336. ***************
  337. *** 620,642 ****
  338.       {
  339.         j = pat[i]; i += direction;
  340.         if (i == dirlen) i = infinity;
  341. !       if ((int) trt)
  342.           {
  343. -           k = (j = trt[j]);
  344.             if (i == infinity)
  345.           stride_for_teases = BM_tab[j];
  346.             BM_tab[j] = dirlen - i;
  347. -           /* A translation table is followed by its inverse -- see */
  348. -           /* comment following downcase_table for details */ 
  349. - 
  350. -           while ((j = trt[0400+j]) != k)
  351. -         BM_tab[j] = dirlen - i;
  352.           }
  353.         else
  354.           {
  355.             if (i == infinity)
  356. !         stride_for_teases = BM_tab[j];
  357. !           BM_tab[j] = dirlen - i;
  358.           }
  359.         /* stride_for_teases tells how much to stride if we get a */
  360.         /* match on the far character but are subsequently */
  361. --- 614,635 ----
  362.       {
  363.         j = pat[i]; i += direction;
  364.         if (i == dirlen) i = infinity;
  365. !       if (sorttab == NULL_SORT_TABLE)
  366.           {
  367.             if (i == infinity)
  368.           stride_for_teases = BM_tab[j];
  369.             BM_tab[j] = dirlen - i;
  370.           }
  371.         else
  372.           {
  373. +           /* We now want to set BM_tab[x] = dirlen - 1 for
  374. +           all characters x in equivalence class j. */
  375. +           k = sorttab->srt_dope[j].ec_lo;
  376.             if (i == infinity)
  377. !         stride_for_teases = BM_tab[sorttab->srt_chars[k]];
  378. !           do
  379. !             BM_tab[sorttab->srt_chars[k++]] = dirlen - i;
  380. !           while (k <= sorttab->srt_dope[j].ec_hi);
  381.           }
  382.         /* stride_for_teases tells how much to stride if we get a */
  383.         /* match on the far character but are subsequently */
  384. ***************
  385. *** 706,712 ****
  386.               break;    /* a small overrun is genuine */
  387.             cursor -= infinity; /* large overrun = hit */
  388.             i = dirlen - direction;
  389. !           if ((int) trt)
  390.               {
  391.                 while ((i -= direction) + direction != 0)
  392.               if (pat[i] != trt[*(cursor -= direction)])
  393. --- 699,705 ----
  394.               break;    /* a small overrun is genuine */
  395.             cursor -= infinity; /* large overrun = hit */
  396.             i = dirlen - direction;
  397. !           if (trt)
  398.               {
  399.                 while ((i -= direction) + direction != 0)
  400.               if (pat[i] != trt[*(cursor -= direction)])
  401. ***************
  402. *** 768,776 ****
  403.             while ((i -= direction) + direction != 0)
  404.               {
  405.                 pos -= direction;
  406. !               if (pat[i] != (((int) trt)
  407. !                      ? trt[CharAt(pos)]
  408. !                      : CharAt (pos)))
  409.               break;
  410.               }
  411.             /* Above loop has moved POS part or all the way
  412. --- 761,767 ----
  413.             while ((i -= direction) + direction != 0)
  414.               {
  415.                 pos -= direction;
  416. !               if (pat[i] != (trt ? trt[CharAt(pos)] : CharAt (pos)))
  417.               break;
  418.               }
  419.             /* Above loop has moved POS part or all the way
  420. ***************
  421. *** 977,983 ****
  422.         /* Decide how to casify by examining the matched text. */
  423.   
  424.         last = search_regs.end[0];
  425. !       prevc = '\n';
  426.         case_action = all_caps;
  427.   
  428.         /* some_multiletter_word is set nonzero if any original word
  429. --- 968,974 ----
  430.         /* Decide how to casify by examining the matched text. */
  431.   
  432.         last = search_regs.end[0];
  433. !       prevc = NEWLINE;
  434.         case_action = all_caps;
  435.   
  436.         /* some_multiletter_word is set nonzero if any original word
  437. ***************
  438. *** 987,1014 ****
  439.         for (pos = search_regs.start[0]; pos < last; pos++)
  440.       {
  441.         c = CharAt (pos);
  442. !       if (LOWERCASEP (c))
  443. !         {
  444. !           /* Cannot be all caps if any original char is lower case */
  445. ! 
  446. !           case_action = cap_initial;
  447. !           if (SYNTAX (prevc) != Sword)
  448. !         {
  449. !           /* Cannot even be cap initials
  450. !              if some original initial is lower case */
  451. !           case_action = nochange;
  452. !           break;
  453. !         }
  454. !           else
  455. !         some_multiletter_word = 1;
  456. !         }
  457. !       else if (!NOCASEP (c))
  458.           {
  459. !           some_letter = 1;
  460. !           if (!some_multiletter_word && SYNTAX (prevc) == Sword)
  461. !         some_multiletter_word = 1;
  462.           }
  463. - 
  464.         prevc = c;
  465.       }
  466.   
  467. --- 978,1004 ----
  468.         for (pos = search_regs.start[0]; pos < last; pos++)
  469.       {
  470.         c = CharAt (pos);
  471. !       switch (LOCAL_CASE (c))
  472.           {
  473. !           case lowercase_e:
  474. !             /* Cannot be all caps if any original char is lower case */
  475. !             case_action = cap_initial;
  476. !             if (SYNTAX (prevc) != Sword)
  477. !           {
  478. !             /* Cannot even be cap initials
  479. !                if some original initial is lower case */
  480. !             case_action = nochange;
  481. !             break;
  482. !           }
  483. !             else
  484. !           some_multiletter_word = 1;
  485. !         break;
  486. !           case uppercase_e:
  487. !             some_letter = 1;
  488. !             if (!some_multiletter_word && SYNTAX (prevc) == Sword)
  489. !           some_multiletter_word = 1;
  490. !         break;
  491.           }
  492.         prevc = c;
  493.       }
  494.   
  495. ***************
  496. *** 1216,1268 ****
  497.       }
  498.     return ostr;
  499.   }
  500. ! 
  501. ! /* This code should be unzapped when there comes to be multiple */
  502. !  /* translation tables.  It has been certified on various cases. */
  503. ! /*
  504. ! void
  505. ! compute_trt_inverse (trt)
  506. !      register unsigned char *trt;
  507. ! {
  508. !   register int i = 0400;
  509. !   register unsigned char c, q;
  510. ! 
  511. !   while (i--)
  512. !     trt[0400+i] = i;
  513. !   i = 0400;
  514. !   while (i--)
  515. !     {
  516. !       if ((q = trt[i]) != (unsigned char) i)
  517. !     {
  518. !       c = trt[q + 0400];
  519. !       trt[q + 0400] = i;
  520. !       trt[0400 + i] = c;
  521. !     }
  522. !     }
  523.   }
  524. - */
  525.      
  526.   syms_of_search ()
  527.   {
  528. -   register int i;
  529. - 
  530. -   for (i = 0; i < 0400; i++)
  531. -     {
  532. -       downcase_table[i] = (i >= 'A' && i <= 'Z') ? i + 040 : i;
  533. - /* We do this instead of using compute_trt_inverse to save space. */
  534. -  /* Does it? */
  535. -       downcase_table[0400+i]
  536. -     = ((i >= 'A' && i <= 'Z')
  537. -        ? i + ('a' - 'A')
  538. -        : ((i >= 'a' && i <= 'z')
  539. -           ? i + ('A' - 'a')
  540. -           : i));
  541. -     }
  542. - /* Use this instead when there come to be multiple translation tables. 
  543. -   compute_trt_inverse (downcase_table);    */
  544. - 
  545.     searchbuf.allocated = 100;
  546. !   searchbuf.buffer = (char *) malloc (searchbuf.allocated);
  547.     searchbuf.fastmap = search_fastmap;
  548.   
  549.     Qsearch_failed = intern ("search-failed");
  550. --- 1206,1228 ----
  551.       }
  552.     return ostr;
  553.   }
  554. ! 
  555. ! DEFUN ("compile-regexp", Fcompile_regexp, Scompile_regexp, 1, 1, 0,
  556. !    "Compile regular expression.")
  557. ! (re)
  558. ! Lisp_Object re;
  559. ! {
  560. ! CHECK_STRING (re, 0);
  561. ! compile_pattern (re, &searchbuf, current_sort_table ());
  562. ! re_compile_fastmap (&searchbuf);
  563. ! return (Fcons (make_string (searchbuf.buffer, searchbuf.used),
  564. !                  make_string (search_fastmap, 256)));
  565.   }
  566.      
  567.   syms_of_search ()
  568.   {
  569.     searchbuf.allocated = 100;
  570. !   searchbuf.buffer = (char_t *) malloc (searchbuf.allocated);
  571.     searchbuf.fastmap = search_fastmap;
  572.   
  573.     Qsearch_failed = intern ("search-failed");
  574. ***************
  575. *** 1299,1302 ****
  576. --- 1259,1263 ----
  577.     defsubr (&Smatch_data);
  578.     defsubr (&Sstore_match_data);
  579.     defsubr (&Sregexp_quote);
  580. +   defsubr (&Scompile_regexp);
  581.   }
  582. *** ../18.55/src/term.c    Wed Mar 29 17:49:32 1989
  583. --- src/term.c    Wed Mar  7 09:53:29 1990
  584. ***************
  585. *** 1,5 ****
  586.   /* terminal control module for terminals described by TERMCAP
  587. !    Copyright (C) 1985, 1986, 1987 Free Software Foundation, Inc.
  588.   
  589.   This file is part of GNU Emacs.
  590.   
  591. --- 1,5 ----
  592.   /* terminal control module for terminals described by TERMCAP
  593. !    Copyright (C) 1985, 1986, 1987, 1990 Free Software Foundation, Inc.
  594.   
  595.   This file is part of GNU Emacs.
  596.   
  597. ***************
  598. *** 20,27 ****
  599. --- 20,30 ----
  600.   
  601.   
  602.   #include <stdio.h>
  603. + #undef NULL
  604.   #include <ctype.h>
  605.   #include "config.h"
  606. + #include "lisp.h"
  607. + #include "chartab.h"
  608.   #include "termhooks.h"
  609.   #include "termchar.h"
  610.   #include "termopts.h"
  611. ***************
  612. *** 60,72 ****
  613.      where one page is used for Emacs and another for all else. */
  614.   int no_redraw_on_reenter;
  615.   
  616. - /* DCICcost[n] is cost of inserting N characters.
  617. -    DCICcost[-n] is cost of deleting N characters. */
  618. - 
  619. - #define DCICcost (&DC_ICcost[MScreenWidth])
  620. - int DC_ICcost[1 + 2 * MScreenWidth];
  621. - 
  622. - 
  623.   /* Hook functions that you can set to snap out the functions in this file.
  624.      These are all extern'd in termhooks.h  */
  625.   
  626. --- 63,68 ----
  627. ***************
  628. *** 82,90 ****
  629.   int (*change_line_highlight_hook) ();
  630.   int (*reassert_line_highlight_hook) ();
  631.   
  632. ! int (*insert_chars_hook) ();
  633. ! int (*write_chars_hook) ();
  634. ! int (*delete_chars_hook) ();
  635.   
  636.   int (*ring_bell_hook) ();
  637.   
  638. --- 78,86 ----
  639.   int (*change_line_highlight_hook) ();
  640.   int (*reassert_line_highlight_hook) ();
  641.   
  642. ! int (*insert_glyfs_hook) ();
  643. ! int (*write_glyfs_hook) ();
  644. ! int (*delete_glyfs_hook) ();
  645.   
  646.   int (*ring_bell_hook) ();
  647.   
  648. ***************
  649. *** 520,527 ****
  650.   clear_end_of_line (first_unused_hpos)
  651.        int first_unused_hpos;
  652.   {
  653.     if (TN_standout_width == 0 && curX == 0 && chars_wasted[curY] != 0)
  654. !     write_chars (" ", 1);
  655.     clear_end_of_line_raw (first_unused_hpos);
  656.   }
  657.   
  658. --- 516,525 ----
  659.   clear_end_of_line (first_unused_hpos)
  660.        int first_unused_hpos;
  661.   {
  662. +   static glyf_t sg = SPACEGLYF;
  663. + 
  664.     if (TN_standout_width == 0 && curX == 0 && chars_wasted[curY] != 0)
  665. !     write_glyfs (&sg, 1);
  666.     clear_end_of_line_raw (first_unused_hpos);
  667.   }
  668.   
  669. ***************
  670. *** 564,660 ****
  671.       }
  672.   }
  673.   
  674. ! write_chars (start, len)
  675. !      register char *start;
  676. !      int len;
  677.   {
  678. !   register char *p;
  679. !   register int n;
  680. !   register char *buf;
  681. !   register int c;
  682. !   char *first_check;
  683. ! 
  684. !   if (write_chars_hook)
  685. !     {
  686. !       (*write_chars_hook) (start, len);
  687. !       return;
  688. !     }
  689. !   highlight_if_desired ();
  690. !   turn_off_insert ();
  691. ! 
  692. !   /* Don't dare write in last column of bottom line, if AutoWrap,
  693. !      since that would scroll the whole screen on some terminals.  */
  694. ! 
  695. !   if (AutoWrap && curY + 1 == screen_height
  696. !       && curX + len - (chars_wasted[curY] & 077) == screen_width)
  697. !     len --;
  698. ! 
  699. !   cmplus (len);
  700. ! 
  701. !   first_check = start;
  702. ! 
  703. !   if (RPov > len && !TF_underscore && !TF_hazeltine)
  704. !     {
  705. !       fwrite (start, 1, len, stdout);
  706. !       if (ferror (stdout))
  707. !     clearerr (stdout);
  708. !       if (termscript)
  709. !     fwrite (start, 1, len, termscript);
  710. !     }
  711. !   else
  712. !     while (--len >= 0)
  713.         {
  714. !     if (RPov + 1 < len && start >= first_check && *start == start[1])
  715. !       {
  716. !         p = start + 2;
  717. ! 
  718. !         /* Now, len is number of chars left starting at p */
  719. !         while (*p++ == *start);
  720. !         --p;
  721. !         /* n is number of identical chars in this run */
  722. !         n = p - start;
  723. !         if (n > RPov)
  724. !           {
  725. !         buf = tparam (TS_repeat, 0, 0, *start, n);
  726. !         tputs (buf, n, cmputc);
  727. !         free (buf);
  728. !         start = p;
  729. !         len -= n - 1;
  730. !         continue;
  731. !           }
  732. !         else
  733. !           /* If all N identical chars are too few,
  734. !          don't even consider the last N-1, the last N-2,...  */
  735. !           first_check = p;
  736. !       }
  737. !     c = *start++;
  738. !     if (c == '_' && TF_underscore)
  739. !       {
  740. !         if (termscript)
  741. !           fputc (' ', termscript);
  742. !         putchar (' ');
  743. !         OUTPUT (Left);
  744. !       }
  745. !     if (TF_hazeltine && c == '~')
  746. !       c = '`';
  747. !     if (termscript)
  748. !       fputc (c, termscript);
  749. !     putchar (c);
  750.         }
  751.   }
  752.   
  753. ! /* If start is zero, insert blanks instead of a string at start */
  754.   
  755. - insert_chars (start, len)
  756. -      register char *start;
  757. -      int len;
  758. - {
  759. -   register char *buf;
  760. -   register int c;
  761.   
  762. !   if (insert_chars_hook)
  763.       {
  764. !       (*insert_chars_hook) (start, len);
  765.         return;
  766.       }
  767.     highlight_if_desired ();
  768. --- 562,654 ----
  769.       }
  770.   }
  771.   
  772. ! write_glyfs (start, len)
  773. ! register glyf_t *start;
  774. ! register int len;
  775.   {
  776. ! register glyf_t g;
  777. ! 
  778. ! if (write_glyfs_hook)
  779. !    {
  780. !    (*write_glyfs_hook) (start, len);
  781. !    return;
  782. !    }
  783. ! highlight_if_desired ();
  784. ! turn_off_insert ();
  785. ! 
  786. ! /* Don't dare write in last column of bottom line, if AutoWrap,
  787. ! since that would scroll the whole screen on some terminals.  */
  788. ! if (AutoWrap && curY + 1 == screen_height
  789. !    && curX + len == screen_width)
  790. !    len--;
  791. ! cmplus (len);
  792. ! while (--len >= 0)
  793. !    {
  794. !    g = *start++;
  795. !    if (g)
  796.         {
  797. !       fwrite (glyf_str (g), 1, glyf_len (g), stdout);
  798. !       if (ferror (stdout)) clearerr (stdout);
  799. !       if (termscript) fwrite (glyf_str (g), 1, glyf_len (g), termscript);
  800.         }
  801. +    }
  802.   }
  803.   
  804. ! insert_glyfs (start, len)
  805. ! register glyf_t *start;
  806. ! register int len;
  807. ! {
  808. ! register glyf_t g;
  809. ! register int l;
  810. ! register unsigned char *cp;
  811. ! register char_t c;
  812. ! 
  813. ! highlight_if_desired ();
  814. ! turn_on_insert ();
  815. ! cmplus (len);
  816. ! if (TS_pad_inserted_char == 0 && TS_ins_char == 0)
  817. !    {
  818. !    while (--len >= 0)
  819. !       {
  820. !       g = *start++;
  821. !       if (g)
  822. !          {
  823. !          fwrite (glyf_str (g), 1, glyf_len (g), stdout);
  824. !          if (ferror (stdout)) clearerr (stdout);
  825. !          if (termscript) fwrite (glyf_str (g), 1, glyf_len (g), termscript);
  826. !          }
  827. !       }
  828. !    }
  829. ! else
  830. !    {
  831. !    while (--len >= 0)
  832. !       {
  833. !       g = *start++;
  834. !       if (g)
  835. !          {
  836. !          cp = glyf_str (g);
  837. !          for (l = glyf_len (g); 0 != l; --l)
  838. !             {
  839. !             OUTPUT1_IF (TS_ins_char);
  840. !             c = *cp++;
  841. !             if (termscript) fputc (c, termscript);
  842. !             putchar (c);
  843. !             OUTPUT1_IF (TS_pad_inserted_char);
  844. !             }
  845. !          }
  846. !       }
  847. !    }
  848. ! }
  849.   
  850.   
  851. ! insert_spaces (len)
  852. ! int len;
  853. ! {
  854. !   register char_t *buf;
  855. ! 
  856. !   if (insert_glyfs_hook)
  857.       {
  858. !       (*insert_glyfs_hook) ((glyf_t *) 0, len);
  859.         return;
  860.       }
  861.     highlight_if_desired ();
  862. ***************
  863. *** 661,671 ****
  864.   
  865.     if (TS_ins_multi_chars)
  866.       {
  867. !       buf = tparam (TS_ins_multi_chars, 0, 0, len);
  868.         OUTPUT1 (buf);
  869.         free (buf);
  870. -       if (start)
  871. -     write_chars (start, len);
  872.         return;
  873.       }
  874.   
  875. --- 655,663 ----
  876.   
  877.     if (TS_ins_multi_chars)
  878.       {
  879. !       buf = (char_t *) tparam (TS_ins_multi_chars, 0, 0, len);
  880.         OUTPUT1 (buf);
  881.         free (buf);
  882.         return;
  883.       }
  884.   
  885. ***************
  886. *** 672,712 ****
  887.     turn_on_insert ();
  888.     cmplus (len);
  889.   
  890. !   if (!TF_underscore && !TF_hazeltine && start
  891. !       && TS_pad_inserted_char == 0 && TS_ins_char == 0)
  892.       {
  893. !       fwrite (start, 1, len, stdout);
  894.         if (termscript)
  895. !     fwrite (start, 1, len, termscript);
  896.       }
  897. -   else
  898. -     while (--len >= 0)
  899. -       {
  900. -     OUTPUT1_IF (TS_ins_char);
  901. -     if (!start)
  902. -       c = ' ';
  903. -     else
  904. -       {
  905. -         c = *start++;
  906. -         if (TF_hazeltine && c == '~')
  907. -           c = '`';
  908. -       }
  909. -     if (termscript)
  910. -       fputc (c, termscript);
  911. -     putchar (c);
  912. -     OUTPUT1_IF (TS_pad_inserted_char);
  913. -     }
  914.   }
  915.   
  916. ! delete_chars (n)
  917. !      register int n;
  918.   {
  919.     char *buf;
  920.     register int i;
  921.   
  922. !   if (delete_chars_hook)
  923.       {
  924. !       (*delete_chars_hook) (n);
  925.         return;
  926.       }
  927.   
  928. --- 664,688 ----
  929.     turn_on_insert ();
  930.     cmplus (len);
  931.   
  932. !   while (--len >= 0)
  933.       {
  934. !       OUTPUT1_IF (TS_ins_char);
  935.         if (termscript)
  936. !     fputc (' ', termscript);
  937. !       putchar (' ');
  938. !       OUTPUT1_IF (TS_pad_inserted_char);
  939.       }
  940.   }
  941.   
  942. ! delete_glyfs (n)
  943. ! register int n;
  944.   {
  945.     char *buf;
  946.     register int i;
  947.   
  948. !   if (delete_glyfs_hook)
  949.       {
  950. !       (*delete_glyfs_hook) (n);
  951.         return;
  952.       }
  953.   
  954. ***************
  955. *** 854,867 ****
  956.     return cost;
  957.   }
  958.   
  959.   /* ARGSUSED */
  960.   calculate_ins_del_char_costs ()
  961.   {
  962. -   int ins_startup_cost, del_startup_cost;
  963. -   int ins_cost_per_char, del_cost_per_char;
  964. -   register int i;
  965. -   register int *p;
  966. - 
  967.     if (TS_ins_multi_chars)
  968.       {
  969.         ins_cost_per_char = 0;
  970. --- 830,843 ----
  971.     return cost;
  972.   }
  973.   
  974. + static int ins_startup_cost;
  975. + static int del_startup_cost;
  976. + static int ins_cost_per_char;
  977. + static int del_cost_per_char;
  978. + 
  979.   /* ARGSUSED */
  980.   calculate_ins_del_char_costs ()
  981.   {
  982.     if (TS_ins_multi_chars)
  983.       {
  984.         ins_cost_per_char = 0;
  985. ***************
  986. *** 898,916 ****
  987.         del_startup_cost = 9999;
  988.         del_cost_per_char = 0;
  989.       }
  990. ! 
  991. !   /* Delete costs are at negative offsets */
  992. !   p = &DCICcost[0];
  993. !   for (i = screen_width; --i >= 0;)
  994. !     *--p = (del_startup_cost += del_cost_per_char);
  995. ! 
  996. !   /* Doing nothing is free */
  997. !   p = &DCICcost[0];
  998. !   *p++ = 0;
  999. ! 
  1000. !   /* Insert costs are at positive offsets */
  1001. !   for (i = screen_width; --i >= 0;)
  1002. !     *p++ = (ins_startup_cost += ins_cost_per_char);
  1003.   }
  1004.   
  1005.   calculate_costs ()
  1006. --- 874,886 ----
  1007.         del_startup_cost = 9999;
  1008.         del_cost_per_char = 0;
  1009.       }
  1010. ! }
  1011. ! int DCICcost (n)
  1012. ! register int n;
  1013. ! {
  1014. ! if (n > 0) return (ins_startup_cost + n * ins_cost_per_char);
  1015. ! else if (n == 0) return (0);
  1016. ! else return (del_startup_cost - n * del_cost_per_char);
  1017.   }
  1018.   
  1019.   calculate_costs ()
  1020. *** ../18.55/src/termchar.h    Mon Sep 29 23:45:22 1986
  1021. --- src/termchar.h    Thu Apr  5 09:16:33 1990
  1022. ***************
  1023. *** 1,5 ****
  1024.   /* Flags and parameters describing terminal's characteristics.
  1025. !    Copyright (C) 1985, 1986 Free Software Foundation, Inc.
  1026.   
  1027.   This file is part of GNU Emacs.
  1028.   
  1029. --- 1,5 ----
  1030.   /* Flags and parameters describing terminal's characteristics.
  1031. !    Copyright (C) 1985, 1986, 1990 Free Software Foundation, Inc.
  1032.   
  1033.   This file is part of GNU Emacs.
  1034.   
  1035. ***************
  1036. *** 19,24 ****
  1037. --- 19,28 ----
  1038.   and this notice must be preserved on all copies.  */
  1039.   
  1040.   
  1041. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  1042. +  *  See chartab.c for details. */
  1043. + 
  1044. + 
  1045.   extern int baud_rate;        /* Output speed in baud */
  1046.   extern int screen_width;    /* Number of usable columns */
  1047.   extern int screen_height;    /* Number of lines */
  1048. ***************
  1049. *** 42,49 ****
  1050.      where one page is used for Emacs and another for all else. */
  1051.   extern int no_redraw_on_reenter;
  1052.   
  1053. ! /* DCICcost[n] is cost of inserting N characters.
  1054. !    DCICcost[-n] is cost of deleting N characters. */
  1055. ! 
  1056. ! #define DCICcost (&DC_ICcost[MScreenWidth])
  1057. ! extern int DC_ICcost[1 + 2 * MScreenWidth];
  1058. --- 46,51 ----
  1059.      where one page is used for Emacs and another for all else. */
  1060.   extern int no_redraw_on_reenter;
  1061.   
  1062. ! /* DCICcost(n) is cost of inserting N characters.
  1063. !    DCICcost(-n) is cost of deleting N characters. */
  1064. ! int DCICcost ();
  1065. *** ../18.55/src/termhooks.h    Mon Sep 29 23:45:32 1986
  1066. --- src/termhooks.h    Thu Apr  5 09:16:48 1990
  1067. ***************
  1068. *** 1,6 ****
  1069.   /* Hooks by which low level terminal operations
  1070.      can be made to call other routines.
  1071. !    Copyright (C) 1985, 1986 Free Software Foundation, Inc.
  1072.   
  1073.   This file is part of GNU Emacs.
  1074.   
  1075. --- 1,6 ----
  1076.   /* Hooks by which low level terminal operations
  1077.      can be made to call other routines.
  1078. !    Copyright (C) 1985, 1986, 1990 Free Software Foundation, Inc.
  1079.   
  1080.   This file is part of GNU Emacs.
  1081.   
  1082. ***************
  1083. *** 20,25 ****
  1084. --- 20,29 ----
  1085.   and this notice must be preserved on all copies.  */
  1086.   
  1087.   
  1088. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  1089. +  *  See chartab.c for details. */
  1090. + 
  1091. + 
  1092.   extern int (*topos_hook) ();
  1093.   extern int (*raw_topos_hook) ();
  1094.   
  1095. ***************
  1096. *** 32,40 ****
  1097.   extern int (*change_line_highlight_hook) ();
  1098.   extern int (*reassert_line_highlight_hook) ();
  1099.   
  1100. ! extern int (*insert_chars_hook) ();
  1101. ! extern int (*write_chars_hook) ();
  1102. ! extern int (*delete_chars_hook) ();
  1103.   
  1104.   extern int (*ring_bell_hook) ();
  1105.   
  1106. --- 36,44 ----
  1107.   extern int (*change_line_highlight_hook) ();
  1108.   extern int (*reassert_line_highlight_hook) ();
  1109.   
  1110. ! extern int (*insert_glyfs_hook) ();
  1111. ! extern int (*write_glyfs_hook) ();
  1112. ! extern int (*delete_glyfs_hook) ();
  1113.   
  1114.   extern int (*ring_bell_hook) ();
  1115.   
  1116. *** ../18.55/src/window.c    Fri Jun 10 15:07:24 1988
  1117. --- src/window.c    Thu Apr  5 09:17:01 1990
  1118. ***************
  1119. *** 1,6 ****
  1120.   /* Window creation, deletion and examination for GNU Emacs.
  1121.      Does not include redisplay.
  1122. !    Copyright (C) 1985, 1986, 1987 Free Software Foundation, Inc.
  1123.   
  1124.   This file is part of GNU Emacs.
  1125.   
  1126. --- 1,6 ----
  1127.   /* Window creation, deletion and examination for GNU Emacs.
  1128.      Does not include redisplay.
  1129. !    Copyright (C) 1985, 1986, 1987, 1990 Free Software Foundation, Inc.
  1130.   
  1131.   This file is part of GNU Emacs.
  1132.   
  1133. ***************
  1134. *** 20,28 ****
  1135. --- 20,33 ----
  1136.   and this notice must be preserved on all copies.  */
  1137.   
  1138.   
  1139. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  1140. +  *  See chartab.c for details. */
  1141. + 
  1142. + 
  1143.   #include "config.h"
  1144.   #include "lisp.h"
  1145.   #include "buffer.h"
  1146. + #include "chartab.h"
  1147.   #include "window.h"
  1148.   #include "commands.h"
  1149.   #include "indent.h"
  1150. ***************
  1151. *** 107,112 ****
  1152. --- 112,121 ----
  1153.     p->start = Fmake_marker ();
  1154.     p->pointm = Fmake_marker ();
  1155.     XFASTINT (p->use_time) = 0;
  1156. +   p->window_char_table =
  1157. +     (XTYPE (buffer_defaults.buffer_char_table) == Lisp_Chartab)
  1158. +       ? buffer_defaults.buffer_char_table
  1159. +       : Vctl_arrow_char_table;
  1160.     return val;
  1161.   }
  1162.   
  1163. ***************
  1164. *** 204,209 ****
  1165. --- 213,243 ----
  1166.     return decode_window (window)->buffer;
  1167.   }
  1168.   
  1169. + DEFUN ("window-char-table", Fwindow_char_table, Swindow_char_table, 0, 1, 0,
  1170. +   "Return the char table that WINDOW is using.")
  1171. +   (window)
  1172. +      Lisp_Object window;
  1173. + {
  1174. +   return decode_window (window)->window_char_table;
  1175. + }
  1176. + 
  1177. + DEFUN ("set-window-char-table",
  1178. +    Fset_window_char_table, Sset_window_char_table, 1, 2, 0,
  1179. +    "Use TABLE as the char table in WINDOW (default selected\n\
  1180. + window).  Returns the old char table.")
  1181. + (table, window)
  1182. + register Lisp_Object table, window;
  1183. + {
  1184. + register struct window *w;
  1185. + register Lisp_Object z; /* Return. */
  1186. + 
  1187. + table = check_char_table (table);
  1188. + w = decode_window (window);
  1189. + z = w->window_char_table;
  1190. + w->window_char_table = table;
  1191. + return (z);
  1192. + }
  1193. + 
  1194.   DEFUN ("window-height", Fwindow_height, Swindow_height, 0, 1, 0,
  1195.     "Return the number of lines in WINDOW (including its mode line).")
  1196.     (window)
  1197. ***************
  1198. *** 835,845 ****
  1199.   {
  1200.     register Lisp_Object tem;
  1201.     register struct window *w = decode_window (window);
  1202.   
  1203.     buffer = Fget_buffer (buffer);
  1204.     CHECK_BUFFER (buffer, 1);
  1205.   
  1206. !   if (NULL (XBUFFER (buffer)->name))
  1207.       error ("Attempt to display deleted buffer");
  1208.   
  1209.     tem = w->buffer;
  1210. --- 869,881 ----
  1211.   {
  1212.     register Lisp_Object tem;
  1213.     register struct window *w = decode_window (window);
  1214. +   register struct buffer *bp;
  1215.   
  1216.     buffer = Fget_buffer (buffer);
  1217.     CHECK_BUFFER (buffer, 1);
  1218. +   bp = XBUFFER (buffer);
  1219.   
  1220. !   if (NULL (bp->name))
  1221.       error ("Attempt to display deleted buffer");
  1222.   
  1223.     tem = w->buffer;
  1224. ***************
  1225. *** 848,860 ****
  1226.   
  1227.     w->buffer = buffer;
  1228.     Fset_marker (w->pointm,
  1229. !            make_number (XBUFFER (buffer) == bf_cur
  1230. !                 ? point : XBUFFER (buffer)->text.pointloc),
  1231.              buffer);
  1232. !   Fset_marker (w->start, make_number (XBUFFER (buffer)->last_window_start),
  1233.              buffer);
  1234.     w->start_at_line_beg = Qnil;
  1235.     XFASTINT (w->last_modified) = 0;
  1236.     windows_or_buffers_changed++;
  1237.     if (EQ (window, selected_window))
  1238.       Fset_buffer (buffer);
  1239. --- 884,902 ----
  1240.   
  1241.     w->buffer = buffer;
  1242.     Fset_marker (w->pointm,
  1243. !            make_number (bp == bf_cur
  1244. !                 ? point : bp->text.pointloc),
  1245.              buffer);
  1246. !   Fset_marker (w->start, make_number (bp->last_window_start),
  1247.              buffer);
  1248.     w->start_at_line_beg = Qnil;
  1249.     XFASTINT (w->last_modified) = 0;
  1250. +   if (XTYPE (bp->buffer_char_table) == Lisp_Chartab)
  1251. +      w->window_char_table = bp->buffer_char_table;
  1252. +   else if (XTYPE (buffer_defaults.buffer_char_table) == Lisp_Chartab)
  1253. +      w->window_char_table = buffer_defaults.buffer_char_table;
  1254. +   else
  1255. +      w->window_char_table = Vctl_arrow_char_table;
  1256.     windows_or_buffers_changed++;
  1257.     if (EQ (window, selected_window))
  1258.       Fset_buffer (buffer);
  1259. ***************
  1260. *** 1593,1600 ****
  1261.       Lisp_Object left, top, width, height, hscroll;
  1262.       Lisp_Object parent, prev;
  1263.       Lisp_Object start_at_line_beg;
  1264.     };
  1265. ! #define SAVED_WINDOW_VECTOR_SIZE 13 /* Arg to Fmake_vector */
  1266.   
  1267.   #define SAVED_WINDOW_N(swv,n) \
  1268.     ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
  1269. --- 1635,1643 ----
  1270.       Lisp_Object left, top, width, height, hscroll;
  1271.       Lisp_Object parent, prev;
  1272.       Lisp_Object start_at_line_beg;
  1273. +     Lisp_Object saved_char_table;
  1274.     };
  1275. ! #define SAVED_WINDOW_VECTOR_SIZE 14 /* Arg to Fmake_vector */
  1276.   
  1277.   #define SAVED_WINDOW_N(swv,n) \
  1278.     ((struct saved_window *) (XVECTOR ((swv)->contents[(n)])))
  1279. ***************
  1280. *** 1684,1689 ****
  1281. --- 1727,1733 ----
  1282.         w->height = p->height;
  1283.         w->hscroll = p->hscroll;
  1284.         XFASTINT (w->last_modified) = 0;
  1285. +       w->window_char_table = p->saved_char_table;
  1286.   
  1287.         /* Reinstall the saved buffer and pointers into it.  */
  1288.         if (NULL (p->buffer))
  1289. ***************
  1290. *** 1846,1851 ****
  1291. --- 1890,1897 ----
  1292.         else
  1293.       p->parent = XWINDOW (w->parent)->temslot;
  1294.   
  1295. +       p->saved_char_table = w->window_char_table;
  1296. + 
  1297.         if (NULL (w->prev))
  1298.       p->prev = Qnil;
  1299.         else
  1300. ***************
  1301. *** 1950,1955 ****
  1302. --- 1996,2003 ----
  1303.     defsubr (&Swindowp);
  1304.     defsubr (&Spos_visible_in_window_p);
  1305.     defsubr (&Swindow_buffer);
  1306. +   defsubr (&Swindow_char_table);
  1307. +   defsubr (&Sset_window_char_table);
  1308.     defsubr (&Swindow_height);
  1309.     defsubr (&Swindow_width);
  1310.     defsubr (&Swindow_hscroll);
  1311. *** ../18.55/src/window.h    Thu Feb 19 21:47:01 1987
  1312. --- src/window.h    Thu Apr  5 09:17:13 1990
  1313. ***************
  1314. *** 1,5 ****
  1315.   /* Window definitions for GNU Emacs.
  1316. !    Copyright (C) 1985, 1986 Free Software Foundation, Inc.
  1317.   
  1318.   This file is part of GNU Emacs.
  1319.   
  1320. --- 1,5 ----
  1321.   /* Window definitions for GNU Emacs.
  1322. !    Copyright (C) 1985, 1986, 1990 Free Software Foundation, Inc.
  1323.   
  1324.   This file is part of GNU Emacs.
  1325.   
  1326. ***************
  1327. *** 19,24 ****
  1328. --- 19,28 ----
  1329.   and this notice must be preserved on all copies.  */
  1330.   
  1331.   
  1332. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  1333. +  *  See chartab.c for details. */
  1334. + 
  1335. + 
  1336.   /* Windows are allocated as if they were vectors, but then the
  1337.   Lisp data type is changed to Lisp_Window.  They are garbage
  1338.   collected along with the vectors.
  1339. ***************
  1340. *** 118,123 ****
  1341. --- 122,129 ----
  1342.       Lisp_Object last_modified;
  1343.       /* Value of point at that time */
  1344.       Lisp_Object last_point;
  1345. +     /* The char table to use for display. */
  1346. +     Lisp_Object window_char_table;
  1347.   /* The rest are currently not used or only half used */
  1348.       /* Screen coords of point at that time */
  1349.       Lisp_Object last_point_x;
  1350.