home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 1 / 1133 < prev    next >
Encoding:
Internet Message Format  |  1990-12-28  |  34.6 KB
  1. From: howard@hasse.ericsson.se (Howard Gayle)
  2. Newsgroups: alt.sources
  3. Subject: GNU Emacs 8-bit mods part 06 of 12
  4. Message-ID: <1990Apr5.133749.8930@ericsson.se>
  5. Date: 5 Apr 90 13:37:49 GMT
  6.  
  7. *** ../18.55/src/editfns.c    Fri Jul 21 20:21:32 1989
  8. --- src/editfns.c    Thu Apr  5 09:11:21 1990
  9. ***************
  10. *** 1,5 ****
  11.   /* Lisp functions pertaining to editing.
  12. !    Copyright (C) 1985, 1986, 1987 Free Software Foundation, Inc.
  13.   
  14.   This file is part of GNU Emacs.
  15.   
  16. --- 1,5 ----
  17.   /* Lisp functions pertaining to editing.
  18. !    Copyright (C) 1985, 1986, 1987, 1990 Free Software Foundation, Inc.
  19.   
  20.   This file is part of GNU Emacs.
  21.   
  22. ***************
  23. *** 19,28 ****
  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 <pwd.h>
  34.   #include "lisp.h"
  35. + #include "chartab.h"
  36.   #include "buffer.h"
  37. + #include "sorttab.h"
  38.   #include "window.h"
  39.   
  40.   #define min(a, b) ((a) < (b) ? (a) : (b))
  41. ***************
  42. *** 375,385 ****
  43.        point>NumCharacters)
  44.   DEFPRED ("bolp", Fbolp, Sbolp,
  45.     "Return T if point is at the beginning of a line.",
  46. !      point<=FirstCharacter || CharAt(point-1)=='\n')
  47.   DEFPRED ("eolp", Feolp, Seolp,
  48.     "Return T if point is at the end of a line.\n\
  49.   `End of a line' includes point being at the end of the buffer.",
  50. !      point>NumCharacters || CharAt(point)=='\n')
  51.   
  52.   DEFUN ("char-after", Fchar_after, Schar_after, 1, 1, 0,
  53.     "One arg, POS, a number.  Return the character in the current buffer\n\
  54. --- 381,391 ----
  55.        point>NumCharacters)
  56.   DEFPRED ("bolp", Fbolp, Sbolp,
  57.     "Return T if point is at the beginning of a line.",
  58. !      point<=FirstCharacter || CharAt(point-1)==NEWLINE)
  59.   DEFPRED ("eolp", Feolp, Seolp,
  60.     "Return T if point is at the end of a line.\n\
  61.   `End of a line' includes point being at the end of the buffer.",
  62. !      point>NumCharacters || CharAt(point)==NEWLINE)
  63.   
  64.   DEFUN ("char-after", Fchar_after, Schar_after, 1, 1, 0,
  65.     "One arg, POS, a number.  Return the character in the current buffer\n\
  66. ***************
  67. *** 955,968 ****
  68.     (c1, c2)
  69.        register Lisp_Object c1, c2;
  70.   {
  71.     CHECK_NUMBER (c1, 0);
  72.     CHECK_NUMBER (c2, 1);
  73.   
  74. !   if (!NULL (bf_cur->case_fold_search)
  75. !       ? downcase_table[0xff & XFASTINT (c1)] == downcase_table[0xff & XFASTINT (c2)]
  76. !       : XINT (c1) == XINT (c2))
  77. !     return Qt;
  78. !   return Qnil;
  79.   }
  80.   
  81.   #ifndef MAINTAIN_ENVIRONMENT /* it is done in environ.c in that case */
  82. --- 961,976 ----
  83.     (c1, c2)
  84.        register Lisp_Object c1, c2;
  85.   {
  86. +   register char_t *tt; /* Equivalence class table. */
  87.     CHECK_NUMBER (c1, 0);
  88.     CHECK_NUMBER (c2, 1);
  89.   
  90. !   tt = current_equiv_class_table ();
  91. !   if (tt)
  92. !      return ((tt[0377 & XFASTINT (c1)] == tt[0377 & XFASTINT (c2)]) ? Qt
  93. !                                                                                      : Qnil);
  94. !   else
  95. !      return ((XINT (c1) == XINT (c2)) ? Qt : Qnil);
  96.   }
  97.   
  98.   #ifndef MAINTAIN_ENVIRONMENT /* it is done in environ.c in that case */
  99. *** ../18.55/src/emacs.c    Mon Mar 13 22:41:29 1989
  100. --- src/emacs.c    Thu Apr  5 09:11:33 1990
  101. ***************
  102. *** 1,5 ****
  103.   /* Fully extensible Emacs, running on Unix, intended for GNU.
  104. !    Copyright (C) 1985, 1986, 1987 Free Software Foundation, Inc.
  105.   
  106.   This file is part of GNU Emacs.
  107.   
  108. --- 1,5 ----
  109.   /* Fully extensible Emacs, running on Unix, intended for GNU.
  110. !    Copyright (C) 1985, 1986, 1987, 1990 Free Software Foundation, Inc.
  111.   
  112.   This file is part of GNU Emacs.
  113.   
  114. ***************
  115. *** 19,24 ****
  116. --- 19,28 ----
  117.   and this notice must be preserved on all copies.  */
  118.   
  119.   
  120. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  121. +  *  See chartab.c for details. */
  122. + 
  123. + 
  124.   #include <signal.h>
  125.   #include <errno.h>
  126.   
  127. ***************
  128. *** 329,334 ****
  129. --- 333,342 ----
  130.         init_obarray ();
  131.         init_eval_once ();
  132.         init_syntax_once ();    /* Create standard syntax table.  */
  133. +       init_case_table_once ();    /* Create standard case table.  */
  134. +       init_char_table_once ();    /* Create standard char tables.  */
  135. +       init_sort_table_once ();    /* Create standard sort tables.  */
  136. +       init_trans_table_once ();    /* Create standard trans tables.  */
  137.                 /* Must be done before init_buffer */
  138.         init_buffer_once ();    /* Create buffer table and some buffers */
  139.         init_minibuf_once ();    /* Create list of minibuffers */
  140. ***************
  141. *** 387,394 ****
  142. --- 395,404 ----
  143.         syms_of_buffer ();
  144.         syms_of_bytecode ();
  145.         syms_of_callint ();
  146. +       syms_of_case_table ();
  147.         syms_of_casefiddle ();
  148.         syms_of_callproc ();
  149. +       syms_of_char_table ();
  150.         syms_of_cmds ();
  151.   #ifndef NO_DIR_LIBRARY
  152.         syms_of_dired ();
  153. ***************
  154. *** 412,418 ****
  155. --- 422,430 ----
  156.         syms_of_process ();
  157.   #endif /* subprocesses */
  158.         syms_of_search ();
  159. +       syms_of_sort_table ();
  160.         syms_of_syntax ();
  161. +       syms_of_trans_table ();
  162.         syms_of_undo ();
  163.         syms_of_window ();
  164.         syms_of_xdisp ();
  165. *** ../18.55/src/fileio.c    Wed Jul  5 03:00:25 1989
  166. --- src/fileio.c    Thu Apr  5 09:11:54 1990
  167. ***************
  168. *** 1,5 ****
  169.   /* File IO for GNU Emacs.
  170. !    Copyright (C) 1985, 1986, 1987, 1988 Free Software Foundation, Inc.
  171.   
  172.   This file is part of GNU Emacs.
  173.   
  174. --- 1,5 ----
  175.   /* File IO for GNU Emacs.
  176. !    Copyright (C) 1985, 1986, 1987, 1988, 1990 Free Software Foundation, Inc.
  177.   
  178.   This file is part of GNU Emacs.
  179.   
  180. ***************
  181. *** 19,24 ****
  182. --- 19,28 ----
  183.   and this notice must be preserved on all copies.  */
  184.   
  185.   
  186. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  187. +  *  See chartab.c for details. */
  188. + 
  189. + 
  190.   #include <sys/types.h>
  191.   #include <sys/stat.h>
  192.   #include <pwd.h>
  193. ***************
  194. *** 42,47 ****
  195. --- 46,52 ----
  196.   #include "config.h"
  197.   #include "lisp.h"
  198.   #include "buffer.h"
  199. + #include "transtab.h"
  200.   #include "window.h"
  201.   
  202.   #ifdef VMS
  203. *** ../18.55/src/fns.c    Fri Apr  7 04:25:38 1989
  204. --- src/fns.c    Thu Apr  5 09:12:06 1990
  205. ***************
  206. *** 1,5 ****
  207.   /* Random utility Lisp functions.
  208. !    Copyright (C) 1985, 1986, 1987 Free Software Foundation, Inc.
  209.   
  210.   This file is part of GNU Emacs.
  211.   
  212. --- 1,5 ----
  213.   /* Random utility Lisp functions.
  214. !    Copyright (C) 1985, 1986, 1987, 1990 Free Software Foundation, Inc.
  215.   
  216.   This file is part of GNU Emacs.
  217.   
  218. ***************
  219. *** 19,24 ****
  220. --- 19,28 ----
  221.   and this notice must be preserved on all copies.  */
  222.   
  223.   
  224. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  225. +  *  See chartab.c for details. */
  226. + 
  227. + 
  228.   #include "config.h"
  229.   
  230.   #ifdef LOAD_AVE_TYPE
  231. ***************
  232. *** 61,71 ****
  233.   #undef NULL
  234.   #endif
  235.   #include "lisp.h"
  236. - #include "commands.h"
  237. - 
  238. - #ifdef lint
  239.   #include "buffer.h"
  240. ! #endif /* lint */
  241.   
  242.   Lisp_Object Qstring_lessp;
  243.   
  244. --- 65,73 ----
  245.   #undef NULL
  246.   #endif
  247.   #include "lisp.h"
  248.   #include "buffer.h"
  249. ! #include "commands.h"
  250. ! #include "transtab.h"
  251.   
  252.   Lisp_Object Qstring_lessp;
  253.   
  254. ***************
  255. *** 181,186 ****
  256. --- 183,189 ----
  257.       }
  258.     return i < XSTRING (s2)->size ? Qt : Qnil;
  259.   }
  260. + 
  261.   
  262.   static Lisp_Object concat ();
  263.   
  264. *** ../18.55/src/indent.c    Tue Aug 16 04:51:14 1988
  265. --- src/indent.c    Thu Apr  5 09:13:35 1990
  266. ***************
  267. *** 1,5 ****
  268.   /* Indentation functions.
  269. !    Copyright (C) 1985, 1986, 1987, 1988 Free Software Foundation, Inc.
  270.   
  271.   This file is part of GNU Emacs.
  272.   
  273. --- 1,5 ----
  274.   /* Indentation functions.
  275. !    Copyright (C) 1985, 1986, 1987, 1988, 1990 Free Software Foundation, Inc.
  276.   
  277.   This file is part of GNU Emacs.
  278.   
  279. ***************
  280. *** 19,34 ****
  281.   and this notice must be preserved on all copies.  */
  282.   
  283.   
  284.   #include "config.h"
  285.   #include "lisp.h"
  286.   #include "buffer.h"
  287.   #include "indent.h"
  288.   #include "window.h"
  289.   #include "termchar.h"
  290.   #include "termopts.h"
  291.   
  292. - #define CR '\015'
  293. - 
  294.   /* Indentation can insert tabs if this is non-zero;
  295.      otherwise always uses spaces */
  296.   int indent_tabs_mode;
  297. --- 19,37 ----
  298.   and this notice must be preserved on all copies.  */
  299.   
  300.   
  301. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  302. +  *  See chartab.c for details. */
  303. + 
  304. + 
  305.   #include "config.h"
  306.   #include "lisp.h"
  307.   #include "buffer.h"
  308. + #include "chartab.h"
  309.   #include "indent.h"
  310.   #include "window.h"
  311.   #include "termchar.h"
  312.   #include "termopts.h"
  313.   
  314.   /* Indentation can insert tabs if this is non-zero;
  315.      otherwise always uses spaces */
  316.   int indent_tabs_mode;
  317. ***************
  318. *** 52,61 ****
  319.     "Return the horizontal position of point.  Beginning of line is column 0.\n\
  320.   This is calculated by adding together the widths of all the displayed\n\
  321.   representations of the character between the start of the previous line\n\
  322. ! and point.  (eg control characters will have a width of 2 or 4, tabs\n\
  323. ! will have a variable width)\n\
  324. ! Ignores finite width of screen, which means that this function may return\n\
  325. ! values greater than (screen-width).\n\
  326.   Whether the line is visible (if `selective-display' is t) has no effect.",
  327.     Lisp_Int, XSETINT, current_column ())
  328.   
  329. --- 55,62 ----
  330.     "Return the horizontal position of point.  Beginning of line is column 0.\n\
  331.   This is calculated by adding together the widths of all the displayed\n\
  332.   representations of the character between the start of the previous line\n\
  333. ! and point.  Ignores finite width of screen, which means that\n\
  334. ! this function may return values greater than (screen-width).\n\
  335.   Whether the line is visible (if `selective-display' is t) has no effect.",
  336.     Lisp_Int, XSETINT, current_column ())
  337.   
  338. ***************
  339. *** 63,73 ****
  340.   current_column ()
  341.   {
  342.     register int col;
  343. !   register unsigned char *ptr, *stop, c;
  344.     register int tab_seen;
  345.     register int post_tab;
  346.     register int tab_width = XINT (bf_cur->tab_width);
  347. !   int ctl_arrow = !NULL (bf_cur->ctl_arrow);
  348.   
  349.     if (point == last_known_column_point
  350.         && bf_modified == last_known_column_modified)
  351. --- 64,75 ----
  352.   current_column ()
  353.   {
  354.     register int col;
  355. !   register unsigned char *ptr, *stop;
  356. !   register char_t c;
  357.     register int tab_seen;
  358.     register int post_tab;
  359.     register int tab_width = XINT (bf_cur->tab_width);
  360. !   register struct Lisp_Chartab *cp;
  361.   
  362.     if (point == last_known_column_point
  363.         && bf_modified == last_known_column_modified)
  364. ***************
  365. *** 78,83 ****
  366. --- 80,86 ----
  367.     if (tab_width <= 0 || tab_width > 20) tab_width = 8;
  368.   
  369.     col = 0, tab_seen = 0, post_tab = 0;
  370. +   cp = SELECTED_CHAR_TABLE;
  371.   
  372.     while (1)
  373.       {
  374. ***************
  375. *** 91,105 ****
  376.       }
  377.   
  378.         c = *--ptr;
  379. !       if (c >= 040 && c < 0177)
  380. !     {
  381. !       col++;
  382. !     }
  383. !       else if (c == '\n')
  384.       break;
  385. !       else if (c == '\r' && EQ (bf_cur->selective_display, Qt))
  386.       break;
  387. !       else if (c == '\t')
  388.       {
  389.         if (tab_seen)
  390.           col = ((col + tab_width) / tab_width) * tab_width;
  391. --- 94,104 ----
  392.       }
  393.   
  394.         c = *--ptr;
  395. !       if (c == NEWLINE)
  396.       break;
  397. !       else if (c == cp->ct_invisc && EQ (bf_cur->selective_display, Qt))
  398.       break;
  399. !       else if (c == HTAB)
  400.       {
  401.         if (tab_seen)
  402.           col = ((col + tab_width) / tab_width) * tab_width;
  403. ***************
  404. *** 109,115 ****
  405.         tab_seen = 1;
  406.       }
  407.         else
  408. !     col += (ctl_arrow && c < 0200) ? 2 : 4;
  409.       }
  410.   
  411.     if (tab_seen)
  412. --- 108,114 ----
  413.         tab_seen = 1;
  414.       }
  415.         else
  416. !     col += ROPE_LEN (c, cp);
  417.       }
  418.   
  419.     if (tab_seen)
  420. ***************
  421. *** 200,206 ****
  422.        register int pos;
  423.   {
  424.     register int col = 0;
  425. !   register int c;
  426.     register int end = NumCharacters + 1;
  427.     register int tab_width = XINT (bf_cur->tab_width);
  428.   
  429. --- 199,205 ----
  430.        register int pos;
  431.   {
  432.     register int col = 0;
  433. !   register char_t c;
  434.     register int end = NumCharacters + 1;
  435.     register int tab_width = XINT (bf_cur->tab_width);
  436.   
  437. ***************
  438. *** 208,215 ****
  439.   
  440.     while (pos < end &&
  441.        (c = CharAt (pos),
  442. !       c == '\t' ? (col += tab_width - col % tab_width)
  443. !         : (c == ' ' ? ++col : 0)))
  444.       pos++;
  445.   
  446.     return col;
  447. --- 207,214 ----
  448.   
  449.     while (pos < end &&
  450.        (c = CharAt (pos),
  451. !       c == HTAB ? (col += tab_width - col % tab_width)
  452. !         : (c == SPACE ? ++col : 0)))
  453.       pos++;
  454.   
  455.     return col;
  456. ***************
  457. *** 219,228 ****
  458.     "Move point to column COLUMN in the current line.\n\
  459.   COLUMN is calculated by adding together the widths of all the displayed\n\
  460.   representations of the character between the start of the previous line\n\
  461. ! and point.  (eg control characters will have a width of 2 or 4, tabs\n\
  462. ! will have a variable width)\n\
  463. ! Ignores finite width of screen, which means that this function may be\n\
  464. ! passed values greater than (screen-width)")
  465.     (column)
  466.        Lisp_Object column;
  467.   {
  468. --- 218,225 ----
  469.     "Move point to column COLUMN in the current line.\n\
  470.   COLUMN is calculated by adding together the widths of all the displayed\n\
  471.   representations of the character between the start of the previous line\n\
  472. ! and point.  Ignores finite width of screen, which means that\n\
  473. ! this function may be passed values greater than (screen-width)")
  474.     (column)
  475.        Lisp_Object column;
  476.   {
  477. ***************
  478. *** 231,237 ****
  479.     register int goal;
  480.     register int end = NumCharacters;
  481.     register int tab_width = XINT (bf_cur->tab_width);
  482. !   register int ctl_arrow = !NULL (bf_cur->ctl_arrow);
  483.   
  484.     Lisp_Object val;
  485.   
  486. --- 228,234 ----
  487.     register int goal;
  488.     register int end = NumCharacters;
  489.     register int tab_width = XINT (bf_cur->tab_width);
  490. !   register struct Lisp_Chartab *cp = SELECTED_CHAR_TABLE;
  491.   
  492.     Lisp_Object val;
  493.   
  494. ***************
  495. *** 247,267 ****
  496.     while (col < goal && pos <= end)
  497.       {
  498.         int c = CharAt (pos);
  499. !       if (c == '\n')
  500.       break;
  501. !       if (c == '\r' && EQ (bf_cur->selective_display, Qt))
  502.       break;
  503.         pos++;
  504. !       col++;
  505. !       if (c == '\t')
  506.       {
  507. !       col += tab_width - 1;
  508.         col = col / tab_width * tab_width;
  509.       }
  510. !       else if (ctl_arrow && (c < 040 || c == 0177))
  511. !         col++;
  512. !       else if (c < 040 || c >= 0177)
  513. !         col += 3;
  514.       }
  515.   
  516.     SetPoint (pos);
  517. --- 244,261 ----
  518.     while (col < goal && pos <= end)
  519.       {
  520.         int c = CharAt (pos);
  521. !       if (c == NEWLINE)
  522.       break;
  523. !       if (c == cp->ct_invisc && EQ (bf_cur->selective_display, Qt))
  524.       break;
  525.         pos++;
  526. !       if (c == HTAB)
  527.       {
  528. !       col += tab_width;
  529.         col = col / tab_width * tab_width;
  530.       }
  531. !       else
  532. !     col += ROPE_LEN (c, cp);
  533.       }
  534.   
  535.     SetPoint (pos);
  536. ***************
  537. *** 304,312 ****
  538.       int cpos = fromhpos + (fromvpos << SHORTBITS);
  539.     register int target = tohpos + (tovpos << SHORTBITS);
  540.     register int pos;
  541. !   register int c;
  542.     register int tab_width = XFASTINT (bf_cur->tab_width);
  543. !   register int ctl_arrow = !NULL (bf_cur->ctl_arrow);
  544.     int selective
  545.       = XTYPE (bf_cur->selective_display) == Lisp_Int
  546.         ? XINT (bf_cur->selective_display)
  547. --- 298,306 ----
  548.       int cpos = fromhpos + (fromvpos << SHORTBITS);
  549.     register int target = tohpos + (tovpos << SHORTBITS);
  550.     register int pos;
  551. !   register char_t c;
  552.     register int tab_width = XFASTINT (bf_cur->tab_width);
  553. !   register struct Lisp_Chartab *cp = SELECTED_CHAR_TABLE;
  554.     int selective
  555.       = XTYPE (bf_cur->selective_display) == Lisp_Int
  556.         ? XINT (bf_cur->selective_display)
  557. ***************
  558. *** 318,326 ****
  559.       {
  560.         prevpos = cpos;
  561.         c = CharAt (pos);
  562. !       if (c >= 040 && c < 0177)
  563. !     cpos++;
  564. !       else if (c == '\t')
  565.       {
  566.         cpos += tab_width
  567.           - HPOS (cpos + tab_offset + hscroll - (hscroll > 0)
  568. --- 312,318 ----
  569.       {
  570.         prevpos = cpos;
  571.         c = CharAt (pos);
  572. !       if (c == HTAB)
  573.       {
  574.         cpos += tab_width
  575.           - HPOS (cpos + tab_offset + hscroll - (hscroll > 0)
  576. ***************
  577. *** 330,336 ****
  578.               + tab_width)
  579.             % tab_width;
  580.       }
  581. !       else if (c == '\n')
  582.       {
  583.         if (selective > 0 && position_indentation (pos + 1) >= selective)
  584.           {
  585. --- 322,328 ----
  586.               + tab_width)
  587.             % tab_width;
  588.       }
  589. !       else if (c == NEWLINE)
  590.       {
  591.         if (selective > 0 && position_indentation (pos + 1) >= selective)
  592.           {
  593. ***************
  594. *** 337,353 ****
  595.             /* Skip any number of invisible lines all at once */
  596.             do
  597.           {
  598. !           while (++pos < to && CharAt(pos) != '\n');
  599.           }
  600.             while (selective > 0 && position_indentation (pos + 1) >= selective);
  601.             pos--;
  602. !           /* Allow for the " ..." that is displayed for them. */
  603. !           if (!NULL (bf_cur->selective_display_ellipses))
  604. !         {
  605. !           cpos += 4;
  606. !           if (HPOS (cpos) >= width)
  607. !             cpos -= HPOS (cpos) - width;
  608. !         }
  609.           }
  610.         else
  611.           cpos += (1 << SHORTBITS) - HPOS (cpos);
  612. --- 329,341 ----
  613.             /* Skip any number of invisible lines all at once */
  614.             do
  615.           {
  616. !           while (++pos < to && CharAt(pos) != NEWLINE);
  617.           }
  618.             while (selective > 0 && position_indentation (pos + 1) >= selective);
  619.             pos--;
  620. !           cpos += cp->ct_invisr.r_len;
  621. !           if (HPOS (cpos) >= width)
  622. !         cpos -= HPOS (cpos) - width;
  623.           }
  624.         else
  625.           cpos += (1 << SHORTBITS) - HPOS (cpos);
  626. ***************
  627. *** 355,381 ****
  628.         if (hscroll > 0) cpos++; /* Count the ! on column 0 */
  629.         tab_offset = 0;
  630.       }
  631. !       else if (c == CR && selective < 0)
  632.       {
  633.         /* In selective display mode,
  634.            everything from a ^M to the end of the line is invisible */
  635. !       while (pos < to && CharAt(pos) != '\n') pos++;
  636.         pos--;
  637. !       /* Allow for the " ..." that is displayed for them. */
  638. !       if (!NULL (bf_cur->selective_display_ellipses))
  639. !         {
  640. !           cpos += 4;
  641. !           if (HPOS (cpos) >= width)
  642. !         cpos -= HPOS (cpos) - width;
  643. !         }
  644.       }
  645.         else
  646. !     cpos += (ctl_arrow && c < 0200) ? 2 : 4;
  647.   
  648.         if (HPOS (cpos) >= width
  649.         && (HPOS (cpos) > width
  650.             || (pos < NumCharacters
  651. !           && CharAt (pos + 1) != '\n')))
  652.       {
  653.         if (cpos >= target)
  654.           break;
  655. --- 343,365 ----
  656.         if (hscroll > 0) cpos++; /* Count the ! on column 0 */
  657.         tab_offset = 0;
  658.       }
  659. !       else if (c == cp->ct_invisc && selective < 0)
  660.       {
  661.         /* In selective display mode,
  662.            everything from a ^M to the end of the line is invisible */
  663. !       while (pos < to && CharAt(pos) != NEWLINE) pos++;
  664.         pos--;
  665. !       cpos += cp->ct_invisr.r_len;
  666. !       if (HPOS (cpos) >= width)
  667. !         cpos -= HPOS (cpos) - width;
  668.       }
  669.         else
  670. !     cpos += ROPE_LEN (c, cp);
  671.   
  672.         if (HPOS (cpos) >= width
  673.         && (HPOS (cpos) > width
  674.             || (pos < NumCharacters
  675. !           && CharAt (pos + 1) != NEWLINE)))
  676.       {
  677.         if (cpos >= target)
  678.           break;
  679. ***************
  680. *** 384,390 ****
  681.             && width + 1 < screen_width)
  682.             || !NULL (bf_cur->truncate_lines))
  683.           {
  684. !           while (pos < to && CharAt(pos) != '\n') pos++;
  685.             pos--;
  686.           }
  687.         else
  688. --- 368,374 ----
  689.             && width + 1 < screen_width)
  690.             || !NULL (bf_cur->truncate_lines))
  691.           {
  692. !           while (pos < to && CharAt(pos) != NEWLINE) pos++;
  693.             pos--;
  694.           }
  695.         else
  696. ***************
  697. *** 405,411 ****
  698.     val_compute_motion.contin
  699.       = pos != from
  700.         && (val_compute_motion.vpos != VPOS (prevpos))
  701. !       && c != '\n';
  702.   
  703.     return &val_compute_motion;
  704.   }
  705. --- 389,395 ----
  706.     val_compute_motion.contin
  707.       = pos != from
  708.         && (val_compute_motion.vpos != VPOS (prevpos))
  709. !       && c != NEWLINE;
  710.   
  711.     return &val_compute_motion;
  712.   }
  713. ***************
  714. *** 420,426 ****
  715.     int opoint = point;
  716.     int col;
  717.   
  718. !   if (pos == FirstCharacter || CharAt (pos - 1) == '\n')
  719.       return 0;
  720.     SetPoint (pos);
  721.     col = current_column ();
  722. --- 404,410 ----
  723.     int opoint = point;
  724.     int col;
  725.   
  726. !   if (pos == FirstCharacter || CharAt (pos - 1) == NEWLINE)
  727.       return 0;
  728.     SetPoint (pos);
  729.     col = current_column ();
  730. ***************
  731. *** 457,463 ****
  732.       {
  733.         /* Moving downward is simple, but must calculate from beg of line 
  734.        to determine hpos of starting point */
  735. !       if (from > FirstCharacter && CharAt (from - 1) != '\n')
  736.       {
  737.         prevline = find_next_newline (from, -1);
  738.         while (selective > 0
  739. --- 441,447 ----
  740.       {
  741.         /* Moving downward is simple, but must calculate from beg of line 
  742.        to determine hpos of starting point */
  743. !       if (from > FirstCharacter && CharAt (from - 1) != NEWLINE)
  744.       {
  745.         prevline = find_next_newline (from, -1);
  746.         while (selective > 0
  747. *** ../18.55/src/keyboard.c    Thu Jul 20 07:32:59 1989
  748. --- src/keyboard.c    Thu Apr  5 09:12:26 1990
  749. ***************
  750. *** 1,5 ****
  751.   /* Keyboard input; editor command loop.
  752. !    Copyright (C) 1985, 1986, 1987, 1988 Free Software Foundation, Inc.
  753.   
  754.   This file is part of GNU Emacs.
  755.   
  756. --- 1,5 ----
  757.   /* Keyboard input; editor command loop.
  758. !    Copyright (C) 1985, 1986, 1987, 1988, 1990 Free Software Foundation, Inc.
  759.   
  760.   This file is part of GNU Emacs.
  761.   
  762. ***************
  763. *** 18,23 ****
  764. --- 18,27 ----
  765.   file named COPYING.  Among other things, the copyright notice
  766.   and this notice must be preserved on all copies.  */
  767.   
  768. + 
  769. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  770. +  *  See chartab.c for details. */
  771. + 
  772.   /*** For version 19, can simplify this by making interrupt_input 1 on VMS.  */
  773.   
  774.   /* Allow config.h to undefine symbols found here.  */
  775. ***************
  776. *** 32,39 ****
  777. --- 36,46 ----
  778.   #include "lisp.h"
  779.   #include "macros.h"
  780.   #include "window.h"
  781. + #include "casetab.h"
  782. + #include "chartab.h"
  783.   #include "commands.h"
  784.   #include "buffer.h"
  785. + #include "transtab.h"
  786.   #include <setjmp.h>
  787.   #include <errno.h>
  788.   
  789. ***************
  790. *** 591,599 ****
  791.           {
  792.             if (EQ (cmd, Qforward_char) && point <= NumCharacters)
  793.           {
  794.             lose = CharAt (point);
  795.             SetPoint (point + 1);
  796. !           if (lose >= ' ' && lose < 0177
  797.                 && (XFASTINT (XWINDOW (selected_window)->last_modified)
  798.                 >= bf_modified)
  799.                 && (XFASTINT (XWINDOW (selected_window)->last_point)
  800. --- 598,608 ----
  801.           {
  802.             if (EQ (cmd, Qforward_char) && point <= NumCharacters)
  803.           {
  804. +                   register struct Lisp_Chartab *cp = SELECTED_CHAR_TABLE;
  805. + 
  806.             lose = CharAt (point);
  807.             SetPoint (point + 1);
  808. !           if (1 == ROPE_LEN (lose, cp)
  809.                 && (XFASTINT (XWINDOW (selected_window)->last_modified)
  810.                 >= bf_modified)
  811.                 && (XFASTINT (XWINDOW (selected_window)->last_point)
  812. ***************
  813. *** 607,615 ****
  814.           }
  815.             else if (EQ (cmd, Qbackward_char) && point > FirstCharacter)
  816.           {
  817.             SetPoint (point - 1);
  818.             lose = CharAt (point);
  819. !           if (lose >= ' ' && lose < 0177
  820.                 && (XFASTINT (XWINDOW (selected_window)->last_modified)
  821.                 >= bf_modified)
  822.                 && (XFASTINT (XWINDOW (selected_window)->last_point)
  823. --- 616,626 ----
  824.           }
  825.             else if (EQ (cmd, Qbackward_char) && point > FirstCharacter)
  826.           {
  827. +                   register struct Lisp_Chartab *cp = SELECTED_CHAR_TABLE;
  828. + 
  829.             SetPoint (point - 1);
  830.             lose = CharAt (point);
  831. !           if (1 == ROPE_LEN (lose, cp)
  832.                 && (XFASTINT (XWINDOW (selected_window)->last_modified)
  833.                 >= bf_modified)
  834.                 && (XFASTINT (XWINDOW (selected_window)->last_point)
  835. ***************
  836. *** 647,658 ****
  837.                 lose = 1;
  838.                 nonundocount = 0;
  839.               }
  840. !           if (!lose
  841. !               && (point == NumCharacters + 1 || CharAt (point) == '\n')
  842. !               && last_command_char >= ' '
  843. !               && last_command_char < 0177)
  844. !             no_redisplay
  845. !               = direct_output_for_insert (last_command_char);
  846.             goto directly_done;
  847.           }
  848.           }
  849. --- 658,674 ----
  850.                 lose = 1;
  851.                 nonundocount = 0;
  852.               }
  853. !           if (!lose &&
  854. !               (point == NumCharacters + 1
  855. !               || CharAt (point) == NEWLINE))
  856. !             {
  857. !               register rope_t *rp =
  858. !                   &SELECTED_CHAR_TABLE->ct_dispr[last_command_char];
  859. ! 
  860. !               if (1 == rp->r_len)
  861. !                 no_redisplay =
  862. !               direct_output_for_insert (rp->r_glyfs[0]);
  863. !             }
  864.             goto directly_done;
  865.           }
  866.           }
  867. *** ../18.55/src/lisp.h    Wed Mar 30 08:42:49 1988
  868. --- src/lisp.h    Thu Apr  5 09:13:49 1990
  869. ***************
  870. *** 1,5 ****
  871.   /* Fundamental definitions for GNU Emacs Lisp interpreter.
  872. !    Copyright (C) 1985, 1986, 1987 Free Software Foundation, Inc.
  873.   
  874.   This file is part of GNU Emacs.
  875.   
  876. --- 1,5 ----
  877.   /* Fundamental definitions for GNU Emacs Lisp interpreter.
  878. !    Copyright (C) 1985, 1986, 1987, 1990 Free Software Foundation, Inc.
  879.   
  880.   This file is part of GNU Emacs.
  881.   
  882. ***************
  883. *** 19,24 ****
  884. --- 19,28 ----
  885.   and this notice must be preserved on all copies.  */
  886.   
  887.   
  888. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  889. +  *  See chartab.c for details. */
  890. + 
  891. + 
  892.   /* Define the fundamental Lisp data structures */
  893.   
  894.   /* This is the set of Lisp data types */
  895. ***************
  896. *** 45,61 ****
  897.       /* Cons.  object.v.cons points to a struct Lisp_Cons. */
  898.       Lisp_Cons,
  899.   
  900. !     /* >>> No longer used */
  901. !     Lisp_Object_Unused_1,
  902. ! #if 0
  903. !     was...
  904. !     /* Treated like vector in GC, except do not set its mark bit.
  905. !        Used for internal data blocks that will be explicitly freed
  906. !        but which, while active, are reached by GC mark exactly once
  907. !        and should be marked through like a vector.  */
  908. !     Lisp_Temp_Vector,
  909. ! #endif 0
  910. ! 
  911.       /* Editor buffer.  obj.v.buffer points to a struct buffer.
  912.          No buffer is ever truly freed; they can be "killed", but this
  913.          just marks them as dead. */
  914. --- 49,57 ----
  915.       /* Cons.  object.v.cons points to a struct Lisp_Cons. */
  916.       Lisp_Cons,
  917.   
  918. !     /* A character table. */
  919. !     Lisp_Chartab,
  920. !     
  921.       /* Editor buffer.  obj.v.buffer points to a struct buffer.
  922.          No buffer is ever truly freed; they can be "killed", but this
  923.          just marks them as dead. */
  924. ***************
  925. *** 151,157 ****
  926.       Lisp_Window,
  927.   
  928.       /* Used by save,set,restore-window-configuration */
  929. !     Lisp_Window_Configuration
  930.     };
  931.   
  932.   #ifndef NO_UNION_TYPE
  933. --- 147,162 ----
  934.       Lisp_Window,
  935.   
  936.       /* Used by save,set,restore-window-configuration */
  937. !     Lisp_Window_Configuration,
  938. ! 
  939. !     /* A case table. */
  940. !     Lisp_Casetab,
  941. ! 
  942. !     /* A sort table. */
  943. !     Lisp_Sorttab,
  944. ! 
  945. !     /* A trans table. */
  946. !     Lisp_Transtab
  947.     };
  948.   
  949.   #ifndef NO_UNION_TYPE
  950. ***************
  951. *** 396,401 ****
  952. --- 401,411 ----
  953.   #define XINTPTR(a) ((int *) XPNTR(a))
  954.   #define XWINDOW(a) ((struct window *) XPNTR(a))
  955.   #define XPROCESS(a) ((struct Lisp_Process *) XPNTR(a))
  956. + #define XCASETAB(a) ((struct Lisp_Casetab *) XPNTR(a))
  957. + #define XCHARTAB(a) ((struct Lisp_Chartab *) XPNTR(a))
  958. + #define XETCTAB(a) ((struct Lisp_Etctab *) XPNTR(a))
  959. + #define XSORTTAB(a) ((struct Lisp_Sorttab *) XPNTR(a))
  960. + #define XTRANSTAB(a) ((struct Lisp_Transtab *) XPNTR(a))
  961.   
  962.   #define XSETCONS(a, b) XSETPNTR(a, (int) (b))
  963.   #define XSETBUFFER(a, b) XSETPNTR(a, (int) (b))
  964. ***************
  965. *** 409,414 ****
  966. --- 419,425 ----
  967.   #define XSETINTPTR(a, b) XSETPNTR(a, (int) (b))
  968.   #define XSETWINDOW(a, b) XSETPNTR(a, (int) (b))
  969.   #define XSETPROCESS(a, b) XSETPNTR(a, (int) (b))
  970. + #define XSETCHARTAB(a, b) XSETPNTR(a, (int) (b))
  971.   
  972.   /* In a cons, the markbit of the car is the gc mark bit */
  973.   
  974. ***************
  975. *** 472,477 ****
  976. --- 483,581 ----
  977.       int modified;
  978.     };
  979.   
  980. + /* Characters, glyfs, ropes, case, character, sort and translate tables. */
  981. + 
  982. + struct Lisp_Etctab /* Header for garbage-collecting various tables. */
  983. +   {
  984. +   int                      etc_ser;  /* Mark and serial number. */
  985. +   struct Lisp_Etctab *etc_next; /* Thread. */
  986. +   };
  987. + 
  988. + /* For our purposes here, every character
  989. + is assigned to one of three mutually exclusive classes:
  990. +    1) caseless,
  991. +    2) lower case, or
  992. +    3) upper case.
  993. + This is represented by the following type: */
  994. + typedef enum {nocase_e, lowercase_e, uppercase_e} case_t;
  995. + 
  996. + /* A case table gives case information about the characters in
  997. + a character set. */
  998. + struct Lisp_Casetab
  999. +   {
  1000. +     int                     cas_mark;      /* Mark bit & serial number. */
  1001. +     struct Lisp_Casetab *cas_next;      /* Link for garbage collection. */
  1002. +     case_t                   cas_case[256]; /* The data. */
  1003. +   };
  1004. + 
  1005. + /* A character, declared with the following typedef, is a member
  1006. + of some character set associated with the current buffer. */
  1007. + typedef unsigned char char_t;
  1008. + 
  1009. + /* A char_t is displayed on a given terminal by means of a
  1010. + sequence of one or more glyfs.  A glyf is something that takes
  1011. + up exactly one display position on the screen: */
  1012. + typedef short unsigned glyf_t;
  1013. + 
  1014. + /* Sequences of glyfs are known as ropes, just as sequences of
  1015. + characters are known as strings.  A rope has a length and an
  1016. + array of glyfs: */
  1017. + #define MAXROPE 5 /* Max glyfs in a rope. */
  1018. + typedef struct
  1019. +    {
  1020. +    short unsigned r_len;            /* Number of glyfs in rope. */
  1021. +    glyf_t         r_glyfs[MAXROPE]; /* The glyfs. */
  1022. +    } rope_t;
  1023. + 
  1024. + /* A character table: */
  1025. + struct Lisp_Chartab
  1026. +    {
  1027. +    struct Lisp_Etctab ct_etc;
  1028. +    glyf_t             ct_frameg;     /* Window frame mark, default |. */
  1029. +    glyf_t             ct_truncg;     /* Truncation mark, default $. */
  1030. +    glyf_t             ct_wrapg;      /* Wrap-around mark, default \. */
  1031. +    char_t             ct_invisc;     /* Selective display character. */
  1032. +    rope_t             ct_invisr;     /* Selective display rope. */
  1033. +    rope_t                ct_dispr[256]; /* Display ropes for each character. */
  1034. +    };
  1035. + 
  1036. + /* A trans[late] table maps each character in a character set
  1037. + into another, possibly different character, such as its
  1038. + lower-case equivalent: */
  1039. + struct Lisp_Transtab
  1040. +   {
  1041. +     int                       trt_mark;    /* Mark bit & serial number. */
  1042. +     struct Lisp_Transtab *trt_next;    /* Link for garbage collection. */
  1043. +     char_t                    trt_to[256]; /* The table. */
  1044. +   };
  1045. + 
  1046. + /* Sort tables are used for searching and sorting.  A sort
  1047. + table is two consecutive vectors of 256 bytes each (total 512
  1048. + bytes).  Each vector is indexed by character.  The first vector
  1049. + maps characters into equivalence class numbers.  These are
  1050. + ordered for sorting.  The second vector gives the next
  1051. + character in the equivalence class, in a circular,
  1052. + singly-linked list.  For example, consider the ISO 8859/1
  1053. + character set, and suppose we want n and n-with-tilde to be in
  1054. + the same equivalence class.  Let s[] be the sort table.  We need:
  1055. +    s['n'] == s['n-with-tilde']
  1056. + and
  1057. +    s['n'               + 256] == 'n-with-tilde'
  1058. +    s['n-with-tilde' + 256] == 'n' */
  1059. + typedef struct
  1060. +   {
  1061. +     char_t ec_lo;
  1062. +     char_t ec_hi;
  1063. +   } ec_dope_t;
  1064. + 
  1065. + struct Lisp_Sorttab
  1066. +   {
  1067. +     struct Lisp_Etctab srt_etc;
  1068. +     char_t                srt_ec [256]; /* Equivalence class of each char. */
  1069. +     ec_dope_t          srt_dope[256]; /* Next char in equivalence class. */
  1070. +     char_t                srt_chars[256];
  1071. +   };
  1072. + 
  1073.   /* Data type checking */
  1074.   
  1075.   #define NULL(x)  (XFASTINT (x) == XFASTINT (Qnil))
  1076. ***************
  1077. *** 662,692 ****
  1078.   
  1079.   #define QUITP (!NULL (Vquit_flag) && NULL (Vinhibit_quit))
  1080.   
  1081. - /* 1 if CH is upper case.  */
  1082. - 
  1083. - #define UPPERCASEP(CH) (downcase_table[CH] != (CH))
  1084. - 
  1085. - /* 1 if CH is lower case.  */
  1086. - 
  1087. - #define LOWERCASEP(CH)   \
  1088. -  (downcase_table[CH] == (CH) && downcase_table[0400 + (CH)] != (CH))
  1089. - 
  1090. - /* 1 if CH is neither upper nor lower case.  */
  1091. - 
  1092. - #define NOCASEP(CH) (downcase_table[0400 + (CH)] == (CH))
  1093. - 
  1094. - /* Upcase a character, or make no change if that cannot be done.  */
  1095. - 
  1096. - #define UPCASE(CH) (downcase_table[CH] == (CH) ? UPCASE1 (CH) : (CH))
  1097. - 
  1098. - /* Upcase a character known to be not upper case.  */
  1099. - 
  1100. - #define UPCASE1(CH) downcase_table[0400 + (CH)]
  1101. - 
  1102. - /* Downcase a character, or make no change if that cannot be done. */
  1103. - 
  1104. - #define DOWNCASE(CH) downcase_table[CH]
  1105. - 
  1106.   /* number of bytes of structure consed since last GC */
  1107.   
  1108.   extern int consing_since_gc;
  1109. --- 766,771 ----
  1110. ***************
  1111. *** 890,896 ****
  1112.   extern Lisp_Object Vfundamental_mode_abbrev_table;
  1113.   
  1114.   /* defined in search.c */
  1115. - extern unsigned char downcase_table[];
  1116.   extern Lisp_Object Fstring_match ();
  1117.   extern Lisp_Object Fscan_buffer ();
  1118.   
  1119. --- 969,974 ----
  1120. *** ../18.55/src/minibuf.c    Sat Apr  1 01:50:26 1989
  1121. --- src/minibuf.c    Thu Apr  5 09:14:01 1990
  1122. ***************
  1123. *** 1,5 ****
  1124.   /* Minibuffer input and completion.
  1125. !    Copyright (C) 1985, 1986 Free Software Foundation, Inc.
  1126.   
  1127.   This file is part of GNU Emacs.
  1128.   
  1129. --- 1,5 ----
  1130.   /* Minibuffer input and completion.
  1131. !    Copyright (C) 1985, 1986, 1990 Free Software Foundation, Inc.
  1132.   
  1133.   This file is part of GNU Emacs.
  1134.   
  1135. ***************
  1136. *** 19,28 ****
  1137. --- 19,33 ----
  1138.   and this notice must be preserved on all copies.  */
  1139.   
  1140.   
  1141. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  1142. +  *  See chartab.c for details. */
  1143. + 
  1144. + 
  1145.   #include "config.h"
  1146.   #include "lisp.h"
  1147.   #include "commands.h"
  1148.   #include "buffer.h"
  1149. + #include "transtab.h"
  1150.   #include "window.h"
  1151.   #include "syntax.h"
  1152.   #include "dispextern.h"
  1153. ***************
  1154. *** 491,497 ****
  1155.   
  1156.     if (completion_ignore_case)
  1157.       {
  1158. !       while (l && downcase_table[*s1++] == downcase_table[*s2++])
  1159.       l--;
  1160.       }
  1161.     else
  1162. --- 496,502 ----
  1163.   
  1164.     if (completion_ignore_case)
  1165.       {
  1166. !       while (l && DOWNCASE (*s1++) == DOWNCASE (*s2++))
  1167.       l--;
  1168.       }
  1169.     else
  1170. *** ../18.55/src/process.c    Mon Aug  7 00:01:31 1989
  1171. --- src/process.c    Thu Apr  5 09:12:42 1990
  1172. ***************
  1173. *** 1,5 ****
  1174.   /* Asynchronous subprocess control for GNU Emacs.
  1175. !    Copyright (C) 1985, 1986, 1987, 1988 Free Software Foundation, Inc.
  1176.   
  1177.   This file is part of GNU Emacs.
  1178.   
  1179. --- 1,5 ----
  1180.   /* Asynchronous subprocess control for GNU Emacs.
  1181. !    Copyright (C) 1985, 1986, 1987, 1988, 1990 Free Software Foundation, Inc.
  1182.   
  1183.   This file is part of GNU Emacs.
  1184.   
  1185. ***************
  1186. *** 19,24 ****
  1187. --- 19,28 ----
  1188.   and this notice must be preserved on all copies.  */
  1189.   
  1190.   
  1191. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  1192. +  *  See chartab.c for details. */
  1193. + 
  1194. + 
  1195.   #include <signal.h>
  1196.   
  1197.   #include "config.h"
  1198. ***************
  1199. *** 89,94 ****
  1200. --- 93,99 ----
  1201.   #include "process.h"
  1202.   #include "termhooks.h"
  1203.   #include "termopts.h"
  1204. + #include "transtab.h"
  1205.   #include "commands.h"
  1206.   
  1207.   /* a process object is a network connection when its childp field is neither
  1208. *** ../18.55/src/print.c    Thu Jul 28 17:12:41 1988
  1209. --- src/print.c    Thu Apr  5 09:14:12 1990
  1210. ***************
  1211. *** 1,5 ****
  1212.   /* Lisp object printing and output streams.
  1213. !    Copyright (C) 1985, 1986 Free Software Foundation, Inc.
  1214.   
  1215.   This file is part of GNU Emacs.
  1216.   
  1217. --- 1,5 ----
  1218.   /* Lisp object printing and output streams.
  1219. !    Copyright (C) 1985, 1986, 1990 Free Software Foundation, Inc.
  1220.   
  1221.   This file is part of GNU Emacs.
  1222.   
  1223. ***************
  1224. *** 19,24 ****
  1225. --- 19,28 ----
  1226.   and this notice must be preserved on all copies.  */
  1227.   
  1228.   
  1229. + /* Modified 1990 for 8-bit character support by Howard Gayle.
  1230. +  *  See chartab.c for details. */
  1231. + 
  1232. + 
  1233.   #include "config.h"
  1234.   #include <stdio.h>
  1235.   #undef NULL
  1236. ***************
  1237. *** 641,646 ****
  1238. --- 645,671 ----
  1239.         strout (" in ", -1, printcharfun);
  1240.         strout (XSTRING (XMARKER (obj)->buffer->name)->data, -1, printcharfun);
  1241.       }
  1242. +       PRINTCHAR ('>');
  1243. +       break;
  1244. + 
  1245. +     case Lisp_Casetab:
  1246. +       strout ("#<case-table ", -1, printcharfun);
  1247. +       goto etc_table;
  1248. + 
  1249. +     case Lisp_Chartab:
  1250. +       strout ("#<char-table ", -1, printcharfun);
  1251. +       goto etc_table;
  1252. + 
  1253. +     case Lisp_Sorttab:
  1254. +       strout ("#<sort-table ", -1, printcharfun);
  1255. +       goto etc_table;
  1256. + 
  1257. +     case Lisp_Transtab:
  1258. +       strout ("#<trans-table ", -1, printcharfun);
  1259. + 
  1260. +     etc_table:
  1261. +       sprintf (buf, "%d", XETCTAB (obj)->etc_ser);
  1262. +       strout (buf, -1, printcharfun);
  1263.         PRINTCHAR ('>');
  1264.         break;
  1265.   #endif /* standalone */
  1266.