home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume16 / psterm / part04 < prev    next >
Encoding:
Internet Message Format  |  1988-11-01  |  54.4 KB
  1. Subject:  v16i051:  Terminal emulator for NeWS window system, Part04/04
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rsalz@uunet.UU.NET
  5.  
  6. Submitted-by: hoptoad!gnu (John Gilmore)
  7. Posting-number: Volume 16, Issue 51
  8. Archive-name: psterm/part04
  9.  
  10. : psterm part 4 of 4
  11. : To unbundle, sh this file
  12. echo tcap.cps
  13. cat >tcap.cps <<'@@@ Fin de tcap.cps'
  14. %
  15. % This file is a product of Sun Microsystems, Inc. and is provided for
  16. % unrestricted use provided that this legend is included on all tape
  17. % media and as a part of the software program in whole or part.
  18. % Users may copy, modify or distribute this file at will.
  19. % 
  20. % THIS FILE IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  21. % WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  22. % PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  23. % 
  24. % This file is provided with no support and without any obligation on the
  25. % part of Sun Microsystems, Inc. to assist in its use, correction,
  26. % modification or enhancement.
  27. % 
  28. % SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  29. % INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THIS FILE
  30. % OR ANY PART THEREOF.
  31. % 
  32. % In no event will Sun Microsystems, Inc. be liable for any lost revenue
  33. % or profits or other special, indirect and consequential damages, even
  34. % if Sun has been advised of the possibility of such damages.
  35. % 
  36. % Sun Microsystems, Inc.
  37. % 2550 Garcia Avenue
  38. % Mountain View, California  94043
  39. %
  40. % Modifications to the original Sun Microsystems, Inc. source code
  41. % made by the Grasshopper Group are in the Public Domain.
  42. %
  43. % Extensions to this file by Eric Messick of the Grasshopper Group.
  44. %
  45. % Grasshopper Group
  46. % 212 Clayton St
  47. % San Francisco, CA 94117
  48. %
  49. %
  50. %
  51. % "@(#)tcap.cps 9.5 88/01/19 SMI
  52. % "@(#)$Header: tcap.cps,v 2.2 88/10/04 05:59:57 gnu Release $
  53. %
  54. % Copyright (c) 1985 by Sun Microsystems, Inc.
  55. %/
  56.  
  57. cdef PSDefs(reload)
  58.     systemdict /LoadingPSTerm known {
  59.         createevent dup begin
  60.             /Name [/PSTimer /PSTermLoaded] def
  61.         end expressinterest
  62.         createevent dup begin
  63.             /Name /PSTimer def
  64.             /TimeStamp currenttime .5 add def
  65.         end sendevent awaitevent pop
  66.     } if pause
  67.     systemdict /PSTermDict known not reload 0 ne or {
  68.         systemdict /LoadingPSTerm true put
  69.         systemdict /PSTermDict undef
  70.         (psterm.ps) LoadFile pop
  71.     } if pause
  72.  
  73. cdef PSInitCode(string userinit)
  74.     PSTermDict /UserCodeLoaded known not {
  75.         (.pstermrc) LoadFile pop
  76.         PSTermDict /UserCodeLoaded true put
  77.         systemdict /LoadingPSTerm undef
  78.         createevent dup begin
  79.             /Name /PSTermLoaded def
  80.             /TimeStamp currenttime def
  81.         end sendevent
  82.     } if pause
  83.     userdict end PSTermDict begin begin        
  84.              % PSTermDict begin dictstackexch
  85.     PSTermInit
  86.     PSTermDict userinit known { userinit cvx exec } if
  87.  
  88. cdef CreateWindow(x, y, fs, col, lines, string framelabel,
  89.     string iconlabel, string initialfont, starticonic, iconx, icony)
  90.         x y fs col lines
  91.           framelabel iconlabel initialfont starticonic iconx icony
  92.           createwindow
  93.  
  94. cdef StartInput() startinput
  95. cdef ReInitialize() resetscale
  96.  
  97. cdef CursorUp(x,y,cstring c) c x y CU
  98. cdef CursorDown(x,y,cstring c) c x y CD
  99.  
  100. cdef PaintUnderRev(cstring s)    s UR
  101. cdef PaintUnderNor(cstring s)    s UN
  102. cdef PaintRev(cstring s)    s PR
  103. cdef PaintNor(cstring s)    s PN
  104. cdef MoveTo(x, y)        x y MT
  105. cdef ClearToEndOfLine()        CE
  106. cdef CopyLines(yfrom, yby, w, nl) yby w yfrom nl CL
  107.  
  108. cdef BeginRepair() BRP
  109. cdef EndRepair() ERP
  110. cdef EndRefresh() EOR
  111.  
  112. cdef SetFrameLabel(string str) str SL
  113. cdef SetSelContents(r, s, l, cstring str)    str s l r setselcontents
  114. cdef RingBell() VB        % no audible bell as yet
  115. cdef VisibleBell() VB
  116. cdef SetPageMode(onoff) onoff PM
  117. cdef SetAutoMargins(onoff) onoff AM
  118.  
  119. cdef StartHiLighting(strokeit) strokeit [
  120. cdef HiLightLine(length) length
  121. cdef EndHiLighting(endcol, startcol, startrow) endcol ] startcol startrow HL
  122. cdef ClearSelectionPath() clearselectionpath
  123. cdef RePaintHiLight() PaintHiLight
  124. cdef StrHiLightLine(cstring s) s
  125. cdef StrEndHiLighting(cstring ends, cstring starts,
  126.     startrow) ends ] starts startrow HL
  127. cdef TakeDownOutline() takedownoutline
  128. cdef StartSavingSelection() startselset
  129. cdef SaveSelectionPiece(cstring s) s extsel
  130. cdef FinishSavingSelection() finishselset
  131. cdef HiLightRect(startcol, startrow, endcol, endrow, strokeit)
  132.     strokeit startcol startrow endcol endrow HiLightRect
  133.  
  134. cdef ToggleScrollBar(len) len TSB
  135. cdef SetScrollBarValue(len, pos) len pos SSBV
  136.  
  137. cdef PopMsg(string str)
  138.     gsave framebuffer setcanvas currentcursorlocation str popmsg grestore
  139. @@@ Fin de tcap.cps
  140. echo tcap_ops.c
  141. cat >tcap_ops.c <<'@@@ Fin de tcap_ops.c'
  142. /*
  143.  * This file is a product of Sun Microsystems, Inc. and is provided for
  144.  * unrestricted use provided that this legend is included on all tape
  145.  * media and as a part of the software program in whole or part.
  146.  * Users may copy, modify or distribute this file at will.
  147.  * 
  148.  * THIS FILE IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  149.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  150.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  151.  * 
  152.  * This file is provided with no support and without any obligation on the
  153.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  154.  * modification or enhancement.
  155.  * 
  156.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  157.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THIS FILE
  158.  * OR ANY PART THEREOF.
  159.  * 
  160.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  161.  * or profits or other special, indirect and consequential damages, even
  162.  * if Sun has been advised of the possibility of such damages.
  163.  * 
  164.  * Sun Microsystems, Inc.
  165.  * 2550 Garcia Avenue
  166.  * Mountain View, California  94043
  167.  *
  168.  * Modifications to the original Sun Microsystems, Inc. source code
  169.  * made by the Grasshopper Group are in the Public Domain.
  170.  *
  171.  * Extensions to this file by Eric Messick of the Grasshopper Group.
  172.  *
  173.  * Grasshopper Group
  174.  * 212 Clayton St
  175.  * San Francisco, CA 94117
  176.  *
  177.  */
  178.  
  179. #ifndef lint
  180. static    char sccsid[] = "@(#)tcap_ops.c 9.6 88/01/19 Copyright 1985 Sun Micro";
  181. static    char RCSid[] =
  182.     "@(#)$Header: tcap_ops.c,v 2.3 88/10/04 05:59:59 gnu Release $";
  183. #endif
  184.  
  185. /*
  186.  * Copyright (c) 1985 by Sun Microsystems, Inc.
  187.  */
  188.  
  189. /*-
  190.     tcap_ops.c
  191.  
  192.     tcap_ops.c, Mon Mar 24 11:52:31 1986
  193.  
  194.         David Rosenthal,
  195.         Sun Microsystems
  196.  */
  197.  
  198.  
  199. #include    <stdio.h>
  200. #include    <sys/types.h>
  201. #ifdef REF
  202. #include    <ref/config.h>
  203. #endif
  204. #include    "termcap.h"
  205. #include    "tcap.h"
  206.  
  207. /*
  208.  * Termcap operations module.
  209.  *
  210.  *    The external interface of this module is the array T[] and its
  211.  *    number of elements Ts,  plus the initialization routine:
  212.  *    tc_init_ops()
  213.  */
  214.  
  215. #include    "screen.h"
  216. extern    int CharsPerLine;
  217. extern    int LinesPerScreen;
  218. extern    struct pair Dot;
  219. extern    struct tcap T[];
  220. extern    int Ts;
  221. extern    char *malloc();
  222. #ifndef bcopy
  223. extern    void bcopy();
  224. #endif
  225. #ifndef bzero
  226. extern    void bzero();
  227. #endif
  228. extern    char *strncpy();
  229. static    struct tcap *tc_lookup();
  230.  
  231. static    u_short TopLineOfScrollRegion, BottomLineOfScrollRegion;
  232. static    struct pair SavedCursor;
  233. static    u_short ScrollNLKludge = 0;
  234. struct    tcap *CheckCR = 0;
  235. struct    tcap *CheckNL = 0;
  236. struct    tcap *CheckBS = 0;
  237. struct    tcap *CheckTAB = 0;
  238.  
  239. static unsigned int PermanentModes = 0,  TemporaryModes = 0;
  240.  
  241. static    char *FrameLabel;
  242. static    u_short FLindex;
  243. static    int (*prevInput)();
  244.  
  245. struct    tcap interruptedOp = { 0 };
  246. struct    line *lastInputLine;
  247. int    PageFull = 0;
  248. static    int PrevPageMode = -1;
  249. extern    int PageMode;
  250. extern    int userLinesPerScreen;
  251. extern    int userCharsPerLine;
  252.  
  253. static int al_op(), clear_body(), ce_op(), cm_in(), cs_op();
  254. static int dc_op(), dl_op(), ic_op(), nl_op(), sf_op();
  255.  
  256. tc_init_ops()
  257. {
  258.     struct tcap *me, *tc;
  259.  
  260.     if (userLinesPerScreen > 0)
  261.     LinesPerScreen = userLinesPerScreen;
  262.     if (userCharsPerLine > 0)
  263.     CharsPerLine = userCharsPerLine;
  264.     Dot.x = 0 ;
  265.     Dot.y = LinesPerScreen - 1 ;
  266.     TopLineOfScrollRegion = 0;
  267.     BottomLineOfScrollRegion = LinesPerScreen - 1;
  268.     FrameLabel = malloc((unsigned)CharsPerLine+1);
  269.     /*
  270.      * Beware of termcap entries that define ue and/or se identical
  271.      * to me (turn off ALL attributes).  Since we just pattern
  272.      * match, it's likely we won't get me_op in normal operation,
  273.      * so force the entries here. (known for vt100)
  274.      */
  275.     me = tc_lookup("me");
  276.     if (me) {
  277.     tc = tc_lookup("ue");
  278.     if (tc && tc->t_size == me->t_size &&
  279.         bcmp(me->t_text, tc->t_text, (int)tc->t_size) == 0)
  280.         tc->t_op = me->t_op;
  281.     tc = tc_lookup("se");
  282.     if (tc && tc->t_size == me->t_size &&
  283.         bcmp(me->t_text, tc->t_text, (int)tc->t_size) == 0)
  284.         tc->t_op = me->t_op;
  285.     }
  286.     /*
  287.      * Check for sf == \n, if so we must kludge things so that
  288.      * sf_op will call nl_op as needed (exists on bitgraph).
  289.      */
  290.     tc = tc_lookup("sf");
  291.     if (tc && tc->t_size == 1 && tc->t_text[0] == '\n')
  292.     ScrollNLKludge = 1;
  293.     /*
  294.      * To minimize the number of times the regular text processing
  295.      * is stopped to invoke the pattern matcher we check the most
  296.      * strings CR, NL, BS, and TAB to see if they are \r, \n, \b,,
  297.      * and \t, respectively.  If any are, a quick check on the character
  298.      * is made before the pattern matching machinery is invoked.
  299.      */
  300.     tc = tc_lookup("cr");
  301.     if (tc && tc->t_size == 1 && tc->t_text[0] == '\r')
  302.        CheckCR = tc;
  303.     tc = tc_lookup("nl");
  304.     if (tc && tc->t_size == 1 && tc->t_text[0] == '\n')
  305.        CheckNL = tc;
  306.     tc = tc_lookup("bc");
  307.     if (tc && tc->t_size == 1 && tc->t_text[0] == '\b')
  308.        CheckBS = tc;
  309.     tc = tc_lookup("ta");
  310.     if (tc && tc->t_size == 1 && tc->t_text[0] == '\t')
  311.        CheckTAB = tc;
  312. }
  313.  
  314. tc_initmodemenu()
  315. {
  316.  
  317.     /*
  318.      * Insure menu items properly reflect initial settings.
  319.      */
  320.     SetPageMode(PageMode);
  321.     SetAutoMargins(PermanentModes & AutoMarginMode);
  322. }
  323.  
  324. static struct tcap *
  325. tc_lookup(key)
  326.     char *key;
  327. {
  328.     register struct tcap *tp;
  329.  
  330.     for (tp = T; *tp->t_key; tp++)
  331.     if (strcmp(tp->t_key, key) == 0)
  332.         return (tp);
  333.     return ((struct tcap *)0);
  334. }
  335.  
  336. /*
  337.  * scrollreset is called whenever keyboard input is seen, in order to
  338.  * do deferred scrolling and remember the last line on which the user
  339.  * typed something.
  340.  */
  341.  
  342. scrollreset(l)
  343.     int l;
  344. {
  345.     int n = PageFull;
  346.  
  347.     PageFull = 0;
  348.     lastInputLine = (l == 1) ? screen[1] : 0;
  349.     while (n-- > 0 && !PageFull)
  350.     sf_op((struct tcap *) 0);
  351.     if (lastInputLine == 0)
  352.     lastInputLine = screen[Dot.y];
  353. }
  354.  
  355. toggleautomargins()
  356. {
  357.  
  358.     PermanentModes ^= (unsigned int) AutoMarginMode;
  359.     SetAutoMargins(PermanentModes & AutoMarginMode);
  360.     FlushPostScript();
  361. }
  362.  
  363. togglepagemode()
  364. {
  365.     SetPageMode(PageMode = !PageMode);
  366.     FlushPostScript();
  367. }
  368.  
  369. resetscreensize(row, col)
  370. int row, col;
  371. {
  372.     struct tcap t;
  373.     int dotx, doty;
  374.  
  375.     dotx = Dot.x ;
  376.     if (dotx >= col) dotx = col - 1;
  377.  
  378.     doty = Dot.y - LinesPerScreen + row ;
  379.     if (doty >= row) doty = row - 1;
  380.     if (doty < 0) doty = 0 ;
  381.  
  382.     if (PageMode) {
  383.         /* no scroll stop line */
  384.         lastInputLine = screen[doty - row + LinesPerScreen];
  385.     }
  386.  
  387.     CharsPerLine = col ;
  388.     LinesPerScreen = row ;
  389.  
  390.     t.t_x = LinesPerScreen - 1 ;
  391.     t.t_y = 0 ;
  392.     cs_op(&t);    /* change scrolling region to full screen */
  393.             /* if it wasn't full screen before, then it's the
  394.              * program's responsibility to change it after
  395.              * getting the sigwinch 
  396.              * note that this trashes Dot, so we save it.
  397.              */
  398.     Dot.x = dotx ;
  399.     Dot.y = doty ;
  400. }
  401.  
  402. #ifdef notdef
  403. static
  404. trace(s, t)
  405.     register char *s;
  406.     register struct tcap *t;
  407. {
  408.     register char *q = t->t_text;
  409.  
  410.     fprintf(stderr, "%s: ", s);
  411.     fprintf(stderr, "[%s,", t->t_key);
  412.     if (q == NULL)
  413.     fprintf(stderr, "(nil)");
  414.     else while (*q) {
  415.     if (*q < ' ') {
  416.         fprintf(stderr, "^%c", *q + '@');
  417.     } else {
  418.         fprintf(stderr, "%c", *q);
  419.     }
  420.     q++;
  421.     }
  422.     fprintf(stderr, ",%d,(%d,%d)]\n", t->t_index, t->t_x, t->t_y);
  423. }
  424. #endif
  425.  
  426. #ifndef    notdef
  427. #define    trace(X, Y)    (void)(X, Y)
  428. #endif
  429. #define ChangeScreen()
  430. #define    MoveCursor()
  431.  
  432. #ifdef notdef
  433. static
  434. PrintScreen()
  435. {
  436.     register int y;
  437.  
  438.     for (y = 0; y < LinesPerScreen; y++) {
  439.     register struct line *l = screen[y];
  440.     register int x;
  441.  
  442.     if (l == NULL)
  443.         fprintf(stderr, "(nil)");
  444.     else for (x = 0; x < l->length; x++) {
  445.         if (x == Dot.x && y == Dot.y)
  446.         fprintf(stderr, "+");
  447.         else if (x == l->changeposition)
  448.         fprintf(stderr, "|");
  449.         else
  450.             fprintf(stderr, "%c", (l->body[x] == ' ' ? '.' : l->body[x]));
  451.     }
  452.     fprintf(stderr, "\n");
  453.     }
  454.     fprintf(stderr, "\n");
  455. }
  456. #endif
  457.  
  458. showc(t)
  459. struct tcap *t;
  460. {
  461.     register char *cp = t->t_text;
  462.     register struct line *l;
  463.     register int dotx, c;
  464.     register unsigned Modes = PermanentModes | TemporaryModes;
  465.     int n = t->t_size;
  466.     register char *bp;
  467.     register u_char *pp;
  468.  
  469.     trace("==", t);
  470.     TemporaryModes = 0;
  471.     dotx = Dot.x;
  472.     while (n > 0 && !PageFull) {
  473.         l = screen[Dot.y];
  474.         if (l->changeposition > dotx)
  475.             l->changeposition = dotx;
  476.         if (l->length < dotx)
  477.             l->length = dotx;
  478.         bp = &l->body[dotx] ;
  479.         pp = &l->prop[dotx] ;
  480.         if (Modes & InsertMode && l->length > dotx) {
  481.             n-- ;
  482.             c = *cp++;
  483.             if (c < ' ' || c >= 0177)
  484.                 continue;
  485.             if (l->length < CharsPerLine)
  486.                 l->length++;
  487.  
  488.             bcopy((char *)pp, (char *)pp+1,(int)(l->length-dotx-1));
  489.             bcopy(        bp,         bp+1,(int)(l->length-dotx-1));
  490.  
  491.             l->end_of_changes = CharsPerLine + 1 ;
  492.             *bp = c;
  493.             *pp = (Modes & Attributes);
  494.             if (++dotx >= CharsPerLine) {
  495.                 if (Modes & AutoMarginMode) {
  496.                     trace("cr", t);
  497.                     l->end_of_changes = CharsPerLine + 1 ;
  498.                     l->flags |= LINE_WRAPPED ;
  499.                     if (l->length < dotx)
  500.                         l->length = dotx ;
  501.                     dotx = 0;
  502.                     MoveCursor();
  503.                     nl_op(t);
  504.                     TemporaryModes |= WrapJustHappenedMode;
  505.                     }
  506.                 else    dotx = CharsPerLine - 1;
  507.                 }
  508.             }
  509.         else    {
  510.             while (n-- > 0 && !PageFull) {
  511.                 c = *cp++;
  512.                 if (c < ' ' || c >= 0177)
  513.                     continue;
  514.                 *bp++ = c;
  515.                 *pp++ = (Modes & Attributes);
  516.                 if (++dotx >= CharsPerLine) {
  517.                     if (Modes & AutoMarginMode) {
  518.                         trace("cr", t);
  519.                         l->end_of_changes =
  520.                             CharsPerLine + 1 ;
  521.                         l->flags |= LINE_WRAPPED ;
  522.                         if (l->length < dotx)
  523.                             l->length = dotx ;
  524.                         dotx = 0;
  525.                         MoveCursor();
  526.                         nl_op(t);
  527.                         TemporaryModes |=
  528.                             WrapJustHappenedMode;
  529.                         break;
  530.                         }
  531.                     else    dotx = CharsPerLine - 1;
  532.                     }
  533.                 }
  534.             }
  535.         if (l->length < dotx)
  536.             l->length = dotx ;
  537.         if (l->end_of_changes < dotx)
  538.             l->end_of_changes = dotx;
  539.         }
  540.     Dot.x = dotx;
  541.     ChangeScreen();
  542.     /*
  543.      * If we were interrupted by nl_op setting PageFull, set up
  544.      * interruptedOp with a tcap that can be used to finish this later.
  545.      */
  546.     if (PageFull && ++n > 0) {
  547.         interruptedOp = *t;
  548.         interruptedOp.t_text += (t->t_size - n);
  549.         interruptedOp.t_size = n;
  550.         }
  551.     else    interruptedOp.t_op = 0;
  552. }
  553.  
  554. static int
  555. AL_op(t)    /* add multiple blank lines */
  556.     struct tcap *t;
  557. {
  558.     trace("AL", t);
  559.     /* cheat for now */
  560.     while (t->t_y-- > 0)
  561.     al_op(t);
  562.     ChangeScreen();
  563. }
  564.  
  565. static int
  566. DC_op(t)
  567.     struct tcap *t;
  568. {
  569.     trace("DC", t);
  570.     /* cheat for now */
  571.     while (t->t_y-- > 0)
  572.     dc_op(t);
  573.     ChangeScreen();
  574. }
  575.  
  576. static int
  577. DL_op(t)    /* delete multiple lines */
  578.     struct tcap *t;
  579. {
  580.     trace("DL", t);
  581.     /* cheat for now */
  582.     while (t->t_y-- > 0)
  583.     dl_op(t);
  584.     ChangeScreen();
  585. }
  586.  
  587. static int
  588. DO_in(t)    /* move cursor down n lines */
  589.     struct tcap *t;
  590. {
  591.     trace("DO", t);
  592.     return (cm_in(t));    /* Neat!  It might even work */
  593. }
  594.  
  595. static int
  596. DO_op(t)    /* move cursor down n lines */
  597.     register struct tcap *t;
  598. {
  599.     trace("DO", t);
  600.     if (t->t_y >= 0 && (Dot.y + t->t_y) < LinesPerScreen)
  601.         Dot.y += t->t_y;
  602.     MoveCursor();
  603. }
  604.  
  605. static int
  606. IC_op(t)
  607.     struct tcap *t;
  608. {
  609.     trace("IC", t);
  610.     /* cheat for now */
  611.     while (t->t_y-- > 0)
  612.     ic_op(t);
  613.     ChangeScreen();
  614. }
  615.  
  616. static int
  617. LE_in(t)    /* move cursor left n characters */
  618.     struct tcap *t;
  619. {
  620.     trace("LE", t);
  621.     return (cm_in(t));    /* Neat!  It might even work */
  622. }
  623.  
  624. static int
  625. LE_op(t)    /* move cursor left n characters */
  626.     register struct tcap *t;
  627. {
  628.     trace("LE", t);
  629.     if ((Dot.x - t->t_y) >= 0)
  630.         Dot.x -= t->t_y;
  631.     MoveCursor();
  632. }
  633.  
  634. static int
  635. RI_in(t)    /* move cursor right n characters */
  636.     struct tcap *t;
  637. {
  638.     trace("RI", t);
  639.     return (cm_in(t));    /* Neat!  It might even work */
  640. }
  641.  
  642. static int
  643. RI_op(t)    /* move cursor right n characters */
  644.     register struct tcap *t;
  645. {
  646.     trace("RI", t);
  647.     if (t->t_y >= 0 && (Dot.x + t->t_y) <= CharsPerLine)
  648.         Dot.x += t->t_y;
  649.     MoveCursor();
  650. }
  651.  
  652. static int
  653. UP_in(t)    /* move cursor up n lines */
  654.     struct tcap *t;
  655. {
  656.     trace("UP", t);
  657.     return (cm_in(t));    /* Neat!  It might even work */
  658. }
  659.  
  660. static int
  661. UP_op(t)    /* move cursor up n lines */
  662.     register struct tcap *t;
  663. {
  664.     trace("UP", t);
  665.     if ((Dot.y - t->t_y) >= 0)
  666.         Dot.y -= t->t_y;
  667.     MoveCursor();
  668. }
  669.  
  670. static int
  671. al_op(t)    /* Add new blank line */
  672.     struct tcap *t;
  673. {
  674.     register struct line **p, **current;
  675.     register struct line *old;
  676.  
  677.     trace("al", t);
  678.     current = &screen[Dot.y];
  679.     p = &screen[BottomLineOfScrollRegion];
  680.     old = *p;
  681.     for (; p > current; p--)
  682.     *p = *(p-1);
  683.     *p = old;
  684.     clear_body(old, 0);
  685.     old->length = 0;
  686.     old->changeposition = 0;
  687.     old->end_of_changes = CharsPerLine;
  688.     old->usedtobe = LinesPerScreen;
  689.     ChangeScreen();
  690. }
  691.  
  692. static int
  693. am_in(t)    /* Has auto-margins */
  694.     struct tcap *t;
  695. {
  696.     trace("am", t);
  697.     if (t->t_x) PermanentModes |= AutoMarginMode;
  698.     return (0);
  699. }
  700.  
  701. static int
  702. bc_op(t)    /* back-character */
  703.     struct tcap *t;
  704. {
  705.     trace("bc", t);
  706.     if (Dot.x > 0)
  707.     Dot.x--;
  708.     MoveCursor();
  709. }
  710.  
  711. static int
  712. bl_op(t)    /* Bell character */
  713.     struct tcap *t;
  714. {
  715.     trace("bl", t);
  716.     RingBell();
  717. }
  718.  
  719. /*
  720.  * Clearing the whole line body for the clear ops may be excessive
  721.  * but nothing short of it seems to work for programs which do a lot
  722.  * of cursor manipulation, such as rogue or hack.
  723.  */
  724. static int
  725. clear_body(l, x)
  726.     struct line *l;
  727.     int x;
  728. {
  729.     register int len = l->buffer_length - x;
  730.     register char *cp;
  731.  
  732.     bzero((char *)&l->prop[x], len);
  733.     l->flags = 0 ;
  734.     for (cp = &l->body[x]; len-- > 0;)
  735.      *cp++ = ' ';
  736. }
  737.  
  738. static int
  739. cd_op(t)    /* Clear to end of display */
  740.     struct tcap *t;
  741. {
  742.     register struct line **p, **last;
  743.     register struct line *l;
  744.  
  745.     trace("cd", t);
  746.     ce_op(t);
  747.     last = &screen[LinesPerScreen];
  748.     for (p = &screen[Dot.y+1]; p < last; p++) {
  749.     (l = *p)->length = 0;
  750.     l->changeposition = 0;
  751.     l->end_of_changes = CharsPerLine ;
  752.     clear_body(l, 0);
  753.     }
  754.     ChangeScreen();
  755. }
  756.  
  757. static int
  758. ce_op(t)    /* Clear to end of line */
  759.     struct tcap *t;
  760. {
  761.     register struct line *l = screen[Dot.y];
  762.  
  763.     trace("ce", t);
  764.     l->length = Dot.x;
  765.     if (l->changeposition > Dot.x)
  766.     l->changeposition = Dot.x;
  767.     l->end_of_changes = CharsPerLine ;
  768.     clear_body(l, (int)l->length);
  769.     ChangeScreen();
  770. }
  771.  
  772. static int
  773. cl_op(t)    /* Clear screen */
  774.     struct tcap *t;
  775. {
  776.     register struct line **p, **last;
  777.     register struct line *l;
  778.  
  779.     trace("cl", t);
  780.     Dot.x = Dot.y = 0;
  781.     last = &screen[LinesPerScreen];
  782.     for (p = &screen[0]; p < last; p++) {
  783.     (l = *p)->length = 0;
  784.     l->changeposition = 0;
  785.     l->end_of_changes = CharsPerLine ;
  786.     clear_body(l, 0);
  787.     }
  788.     ChangeScreen();
  789.     if (PageMode)
  790.     lastInputLine = screen[Dot.y];    /* no scroll stop line */
  791. }
  792.  
  793. #ifdef    HAVE_TERMCAP
  794. static int
  795. cm_in(t)    /* Cursor motion */
  796.     register struct tcap *t;
  797. {
  798.     register u_char c;
  799.     char        buf[128];
  800.     register    char *cp = t->t_text, *bp = buf;
  801.  
  802.     trace("cm", t);
  803.  
  804.     if (cp == NULL)
  805.     return(0);
  806.     /* Pre-process out parts of the % escapes */
  807.     while ((c = *cp++) != '\0') {
  808.     if (c == '%') {
  809.         register u_char c2 = *cp++;
  810.  
  811.         switch (c2) {
  812.         case '+':        /* Subtract next then %. */
  813.         switch (t->t_2nd + t->t_pc_r) {
  814.         case 0:
  815.         case 2:
  816.             t->t_yi = *cp++;
  817.             break;
  818.         case 1:
  819.             t->t_xi = *cp++;
  820.             break;
  821.         }
  822.         c2 = '.';
  823.         goto percent_dot;
  824.         case '>':
  825.         switch (t->t_2nd + t->t_pc_r) {
  826.         case 1:
  827.             t->t_xilim = *cp++;
  828.             t->t_xi = *cp++;
  829.             t->t_xilim += t->t_xi + 1;
  830.             break;
  831.         case 0:
  832.         case 2:
  833.             t->t_yilim = *cp++;
  834.             t->t_yi = *cp++;
  835.             t->t_yilim += t->t_yi + 1;
  836.             break;
  837.         }
  838.         t->t_2nd = !t->t_2nd;
  839.         break;
  840.         case 'r':
  841.         t->t_pc_r = 1;
  842.         break;
  843.         case 'i':
  844.         t->t_xi++;
  845.         t->t_yi++;
  846.         break;
  847.         case 'n':
  848.         t->t_pc_n = 1;
  849.         break;
  850.         case 'B':
  851.         t->t_pc_B = 1;
  852.         break;
  853.         case 'D':
  854.         t->t_pc_D = 1;
  855.         break;
  856.         /* The following ones will be interpreted on the fly */
  857.         case 'd':        /* series of decimal digits */
  858.         case '2':        /* two decimal digits */
  859.         case '3':        /* three decimal digits */
  860.         case '.':        /* binary character */
  861.     percent_dot:
  862.         case '%':
  863.         *bp++ = c;
  864.         *bp++ = c2;
  865.         t->t_2nd = !t->t_2nd;
  866.         break;
  867.         default:        /* Bad % escape */
  868.         return (1);
  869.         }
  870.     }
  871.     else {
  872.         *bp++ = c;
  873.     }
  874.     }
  875.     *bp++ = '\0';
  876.     if (bp-buf > 1) {
  877.     if ((t->t_text = malloc((unsigned)(bp-buf+1))) == NULL)
  878.         return (2);
  879.     strncpy(t->t_text, buf, bp-buf);
  880.     t->t_size = bp-buf - 1;
  881.     } else {
  882.     t->t_text = NULL;
  883.     }
  884.     t->t_2nd = 0;
  885.     return (0);
  886. }
  887.  
  888. #else    /* !HAVE_TERMCAP */
  889.  
  890. static int
  891. cm_in(t)    /* Cursor motion */
  892.     register struct tcap *t;
  893. {
  894.     register u_char c;
  895.     char        buf[128];
  896.     register    char *cp = t->t_text, *bp = buf;
  897.  
  898.     trace("cm", t);
  899.  
  900.     if (cp == NULL)
  901.     return(0);
  902.     /* Pre-process out parts of the % escapes */
  903.     while ((c = *cp++) != '\0') {
  904.     static int    seen1 = 0;
  905.  
  906.     if (c == '%') {
  907.         register u_char c2 = *cp++;
  908.  
  909.         switch (c2) {
  910.         case 'p':
  911.         switch (*cp++) {
  912.         case '1':
  913.             seen1++;
  914.             t->t_2nd = 0;
  915.             break;
  916.         case '2':
  917.             if (!seen1)
  918.                 t->t_pc_r = 1;
  919.             t->t_2nd = 1;
  920.             break;
  921.         /*
  922.          * This capability is not available in termcap so we will
  923.          * assume that it is not present in terminfo either. This
  924.          * means that terminal that send more than two pieces of
  925.          * variable data with the "cm" directive will not work.
  926.          * Currently for "cm" only two variables are defined.
  927.          */
  928.         case '3':
  929.         case '4':
  930.         case '5':
  931.         case '6':
  932.         case '7':
  933.         case '8':
  934.         case '9':
  935.            return(1);
  936.         }
  937.         break;
  938.  
  939.         case '\'':        /* store constant for future operator */
  940.         switch (t->t_2nd + t->t_pc_r) {
  941.         case 0:
  942.         case 2:
  943.             t->t_yi = *cp++;
  944.             break;
  945.         case 1:
  946.             t->t_xi = *cp++;
  947.             break;
  948.         }
  949.         if (*cp == '\'')
  950.             cp++;        /* blow past the trailing '\'' */
  951.         else
  952.             return(1);
  953.         break;
  954.         case '{':        /* store decimal constant for future operator */
  955.         switch (t->t_2nd + t->t_pc_r) {
  956.         case 0:
  957.         case 2:
  958.             t->t_yi = ((*cp++) * 10) + (*cp++);
  959.             break;
  960.         case 1:
  961.             t->t_xi = ((*cp++) * 10) + (*cp++);
  962.             break;
  963.         }
  964.         if (*cp == '}')
  965.             cp++;        /* blow past trailing '}' */
  966.         else
  967.             return(1);
  968.         break;
  969.         /* the following will  not work do to the simplifications here */
  970.         case '?':        /* if */
  971.         case 't':        /* then */
  972.         case 'e':        /* else */
  973.         return(1);    /* lets not delude ourselves, the data
  974.                  *  structures were set up to deal with termcap
  975.                  *  not the complexities of terminfo.
  976.                  */
  977.         case 'i':
  978.         t->t_xi++;
  979.         t->t_yi++;
  980.         break;
  981.         case '+':
  982.         if (*cp++ != '%')
  983.             return(1);
  984.         if (*cp++ != 'c')
  985.             return(1);
  986.         *bp++ = '%';        /* make it look like termcap */
  987.         *bp++ = '.';
  988.         break;
  989.         /* use the simpified model of termcap so some of this
  990.          * stuff is not valid
  991.          */
  992.         case '\b':        /* flags in format string */
  993.         case ':':        /* needed for '-' and '+' flags */
  994.         case '#':        /* flags in format string */
  995.         case '.':        /* if only fract part of precision */
  996.         return(1);
  997.         /* just leave a 'd' */
  998.         case '0':        /* numeric part of precision */
  999.         case '1':        /* numeric part of precision */
  1000.         case '4':        /* numeric part of precision */
  1001.         case '5':        /* numeric part of precision */
  1002.         case '6':        /* numeric part of precision */
  1003.         case '7':        /* numeric part of precision */
  1004.         case '8':        /* numeric part of precision */
  1005.         case '9':        /* numeric part of precision */
  1006.         /* skip past the end of this definition, leave %d in its place*/
  1007.         while (*cp != 'd' && *cp != 'o' && *cp != 'x'
  1008.                 && *cp != 'X' && *cp != 's')
  1009.             cp++;
  1010.         /* don't support anything but 'd' */
  1011.         if (*cp != 'd')
  1012.             return(1);
  1013.         *bp++ = c;        /* '%' */
  1014.         *bp++ = *cp++;        /* 'd' */
  1015.         /* The following ones will be interpreted on the fly. */
  1016.         case '2':        /* numeric part of precision */
  1017.         case '3':        /* numeric part of precision */
  1018.         /* remove %[23]->[doxXs], put %[23] in bp */
  1019.         *bp++ = c;
  1020.         *bp++ = c2;
  1021.         /* skip any factional part of the precision */
  1022.         while (*cp != 'd' && *cp != 'o' && *cp != 'x'
  1023.                 && *cp != 'X' && *cp != 's')
  1024.             cp++;
  1025.         /* don't support anything but 'd' */
  1026.         if (*cp != 'd')
  1027.             return(1);
  1028.         *cp++;        /* get rid of the 'd' */
  1029.         break;
  1030.         /* not suported by termcap, so not supported here */
  1031.         case 'o':        /* octal: no other formating is present */
  1032.         case 'x':        /* hex: no other formating is present */
  1033.         case 'X':        /* HEX: no other formating is present */
  1034.         case 's':        /* String: no other formating is present */
  1035.         case 'c':        /* binary character */
  1036.         case 'l':        /* strlen() operator */
  1037.         case '=':        /* equal operator */ 
  1038.         case '>':        /* greater than operator */
  1039.         case '<':        /* less than operator */
  1040.         case '-':        /* subtract operator */
  1041.         case '*':        /* multiply operator */
  1042.         case '/':        /* divide operator */
  1043.         case 'm':        /* modula operator */
  1044.         case '&':        /* bitwise and operator */
  1045.         case '|':        /* bitwise or operator */
  1046.         case '^':        /* bitwise xor operator */
  1047.         case '~':        /* bitwise not operator */
  1048.         case 'A':        /* logical and operator */
  1049.         case 'O':        /* logical or operator */
  1050.         case '!':        /* logical not operator */
  1051.         return(1);
  1052.         /* include the string "%A" where A = one of the following cases */
  1053.         case 'd':        /* decimal: no other formating is present */
  1054.         case '%':
  1055.         *bp++ = c;
  1056.         *bp++ = c2;
  1057.         break;
  1058.         default:        /* Bad % escape */
  1059.         return (1);
  1060.         }
  1061.     }
  1062.     else {
  1063.         *bp++ = c;
  1064.     }
  1065.     }
  1066.     *bp++ = '\0';
  1067.     if (bp-buf > 1) {
  1068.     if ((t->t_text = malloc(bp-buf+1)) == NULL)
  1069.         return (2);
  1070.     strncpy(t->t_text, buf, bp-buf);
  1071.     t->t_size = bp-buf - 1;
  1072.     } else {
  1073.     t->t_text = NULL;
  1074.     }
  1075.     t->t_2nd = 0;
  1076.     return (0);
  1077. }
  1078. #endif    /* !HAVE_TERMCAP */
  1079.  
  1080. static int
  1081. cm_op(t)    /* Cursor motion */
  1082.     register struct tcap *t;
  1083. {
  1084.  
  1085.     trace("cm", t);
  1086.     lastInputLine = 0;            /* no scroll stop line */
  1087.     if (t->t_x >= 0 && t->t_x < CharsPerLine)
  1088.     Dot.x = t->t_x;
  1089.     if (t->t_y >= 0 && t->t_y < LinesPerScreen)
  1090.     Dot.y = t->t_y;
  1091.     MoveCursor();
  1092. }
  1093.  
  1094. static int
  1095. co_in(t)    /* number of columns */
  1096.     struct tcap *t;
  1097. {
  1098.     trace("co", t);
  1099.     if (userCharsPerLine < 1)
  1100.     CharsPerLine = t->t_x;
  1101.     return (0);
  1102. }
  1103.  
  1104. static int
  1105. cr_op(t)    /* carriage return */
  1106.     struct tcap *t;
  1107. {
  1108.     trace("cr", t);
  1109.     Dot.x = 0;
  1110.     MoveCursor();
  1111. }
  1112.  
  1113. static int
  1114. cs_in(t)    /* change scroll region */
  1115.     struct tcap *t;
  1116. {
  1117.     trace("cs", t);
  1118.     return (cm_in(t));    /* Neat!  It might even work */
  1119. }
  1120.  
  1121. static int
  1122. cs_op(t)    /* change scroll region */
  1123.     register struct tcap *t;
  1124. {
  1125.     trace("cs", t);
  1126.     if (t->t_y >= t->t_x || t->t_x >= LinesPerScreen)
  1127.     return;
  1128.     Dot.x = 0;
  1129.     Dot.y = t->t_y;
  1130.     TopLineOfScrollRegion = t->t_y;
  1131.     BottomLineOfScrollRegion = t->t_x;
  1132.     lastInputLine = 0;            /* no scroll stop line */
  1133.     MoveCursor();
  1134. }
  1135.  
  1136. static int
  1137. dc_op(t)    /* delete character */
  1138.     struct tcap *t;
  1139. {
  1140.     register struct line *l = screen[Dot.y];
  1141.     register int dotx = Dot.x;
  1142.     int len;
  1143.  
  1144.     trace("dc", t);
  1145.     if (l->changeposition > dotx)
  1146.     l->changeposition = dotx;
  1147.     if (dotx < l->length) {
  1148.     l->length--;
  1149.     len = l->length - dotx;
  1150.     bcopy((char *)&l->prop[dotx+1], (char *)&l->prop[dotx], len);
  1151.     l->prop[l->length] = 0 ;
  1152.     bcopy(&l->body[dotx+1], &l->body[dotx], len);
  1153.     l->body[l->length] = ' ' ;
  1154.     }
  1155.     l->end_of_changes = CharsPerLine ;
  1156.     ChangeScreen();
  1157. }
  1158.  
  1159. static int
  1160. dl_op(t)    /* delete line */
  1161.     struct tcap *t;
  1162. {
  1163.     register struct line **p, **bottom;
  1164.     register struct line *old = screen[Dot.y];
  1165.  
  1166.     trace("dl", t);
  1167.     lastInputLine = 0;            /* no scroll stop line */
  1168.     bottom = &screen[BottomLineOfScrollRegion];
  1169.     for (p = &screen[Dot.y]; p < bottom; p++)
  1170.     *p = *(p+1);
  1171.     *p = old;
  1172.     clear_body(old, 0);
  1173.     old->length = 0;
  1174.     old->changeposition = 0;
  1175.     old->end_of_changes = CharsPerLine ;
  1176.     old->usedtobe = LinesPerScreen ;
  1177.     ChangeScreen();
  1178. }
  1179.  
  1180. static int
  1181. do_op(t)    /* down one line */
  1182.     struct tcap *t;
  1183. {
  1184.     trace("do", t);
  1185.     if (PermanentModes & IgnoreNewlineAfterWrapMode) {
  1186.     if (TemporaryModes & WrapJustHappenedMode) {
  1187.         TemporaryModes &= ~WrapJustHappenedMode;
  1188.         return;
  1189.     }
  1190.     }
  1191.     if (Dot.y < LinesPerScreen - 1)
  1192.     Dot.y++;
  1193.     else {
  1194.     sf_op(t);
  1195.     }
  1196.     MoveCursor();
  1197. }
  1198.  
  1199. static int
  1200. ei_op(t)    /* end insert mode */
  1201.     struct tcap *t;
  1202. {
  1203.     trace("ei", t);
  1204.     PermanentModes &= ~InsertMode;
  1205. }
  1206.  
  1207. static int
  1208. el_op(t)    /* end frame label definition mode */
  1209.     struct tcap *t;
  1210. {
  1211.     if (FrameLabel) {
  1212.     FrameLabel[FLindex] = '\0';
  1213.     SetFrameLabel(FrameLabel);
  1214.     }
  1215.     t = T+Ts;
  1216.     t->t_op = prevInput;
  1217. }
  1218.  
  1219. static int
  1220. ke_op(t)    /* leave keyboard transmit mode */
  1221.     struct tcap *t;
  1222. {
  1223.     trace("ke", t);
  1224. }
  1225.  
  1226. static int
  1227. ks_op(t)    /* enter keyboard transmit mode */
  1228.     struct tcap *t;
  1229. {
  1230.     trace("ks", t);
  1231. }
  1232.  
  1233. static int
  1234. ho_op(t)    /* home cursor */
  1235.     struct tcap *t;
  1236. {
  1237.  
  1238.     trace("ho", t);
  1239.     lastInputLine = 0;            /* no scroll stop line */
  1240.     Dot.x = Dot.y = 0;
  1241.     MoveCursor();
  1242. }
  1243.  
  1244. static int
  1245. ic_op(t)    /* insert character */
  1246.     struct tcap *t;
  1247. {
  1248.     trace("ic", t);
  1249.     TemporaryModes |= InsertMode;
  1250. }
  1251.  
  1252. static int
  1253. im_op(t)    /* enter insert mode */
  1254.     struct tcap *t;
  1255. {
  1256.     trace("im", t);
  1257.     PermanentModes |= InsertMode;
  1258. }
  1259.  
  1260. static int
  1261. le_op(t)    /* cursor left */
  1262.     struct tcap *t;
  1263. {
  1264.     trace("le", t);
  1265.     if (Dot.x > 0)
  1266.     Dot.x--;
  1267.     MoveCursor();
  1268. }
  1269.  
  1270. static int
  1271. li_in(t)    /* number of lines */
  1272.     struct tcap *t;
  1273. {
  1274.     trace("li", t);
  1275.     if (userLinesPerScreen < 1)
  1276.     LinesPerScreen = t->t_x;
  1277.     return (0);
  1278. }
  1279.  
  1280. static int
  1281. ll_op(t)    /* last line first column */
  1282.     struct tcap *t;
  1283. {
  1284.     trace("ll", t);
  1285.     Dot.x = 0;
  1286.     Dot.y = LinesPerScreen - 1;
  1287.     MoveCursor();
  1288. }
  1289.  
  1290. static int
  1291. lm_op(t)    /* label mode input */
  1292.     register struct tcap *t;
  1293. {
  1294.     trace("lm", t);
  1295.     if (FLindex + t->t_size >= CharsPerLine)
  1296.     t->t_size = CharsPerLine - FLindex;
  1297.     if (t->t_size > 0) {
  1298.     if (FrameLabel)
  1299.         strncpy(&FrameLabel[FLindex], t->t_text, (int)t->t_size);
  1300.     FLindex += t->t_size;
  1301.     }
  1302. }
  1303.  
  1304. static int
  1305. mb_op(t)    /* enable blink */
  1306.     struct tcap *t;
  1307. {
  1308.     trace("mb", t);
  1309.     PermanentModes |= BlinkMode;
  1310. }
  1311.  
  1312. static int
  1313. md_op(t)    /* enter bold mode */
  1314.     struct tcap *t;
  1315. {
  1316.     trace("md", t);
  1317.     PermanentModes |= BoldMode;
  1318. }
  1319.  
  1320. static int
  1321. me_op(t)    /* turn off attributes */
  1322.     struct tcap *t;
  1323. {
  1324.     trace("me", t);
  1325.     PermanentModes &= ~(Attributes);
  1326. }
  1327.  
  1328. static int
  1329. mr_op(t)    /* enter reverse video */
  1330.     struct tcap *t;
  1331. {
  1332.     trace("mr", t);
  1333.     PermanentModes |= ReverseVideoMode;
  1334. }
  1335.  
  1336. static int
  1337. nd_op(t)    /* cursor right */
  1338.     struct tcap *t;
  1339. {
  1340.     trace("nd", t);
  1341.     if (Dot.x < (CharsPerLine - 1))
  1342.     Dot.x++;
  1343.     MoveCursor();
  1344. }
  1345.  
  1346. static int
  1347. nl_op(t)    /* newline */
  1348.     struct tcap *t;
  1349. {
  1350.     trace("nl", t);
  1351.     if (PermanentModes & IgnoreNewlineAfterWrapMode) {
  1352.     if (TemporaryModes & WrapJustHappenedMode) {
  1353.         TemporaryModes &= ~WrapJustHappenedMode;
  1354.         return;
  1355.     }
  1356.     }
  1357.     if (Dot.y < LinesPerScreen - 1)
  1358.     Dot.y++;
  1359.     else {
  1360.     sf_op(t);
  1361.     }
  1362.     MoveCursor();
  1363. }
  1364.  
  1365. static int
  1366. rc_op(t)    /* restore cursor */
  1367.     struct tcap *t;
  1368. {
  1369.     trace("rc", t);
  1370.     Dot = SavedCursor;
  1371.     MoveCursor();
  1372. }
  1373.  
  1374. static int
  1375. sc_op(t)    /* save cursor */
  1376.     struct tcap *t;
  1377. {
  1378.     trace("sc", t);
  1379.     SavedCursor = Dot;
  1380.     MoveCursor();
  1381. }
  1382.  
  1383. static int
  1384. se_op(t)    /* leave stand-out */
  1385.     struct tcap *t;
  1386. {
  1387.     trace("se", t);
  1388.     PermanentModes &= ~StandOutMode;
  1389. }
  1390.  
  1391. static int
  1392. so_op(t)    /* enter stand-out */
  1393.     struct tcap *t;
  1394. {
  1395.     trace("so", t);
  1396.     PermanentModes |= StandOutMode;
  1397. }
  1398.  
  1399. static int
  1400. sf_op(t)    /* scroll forwards */
  1401.     struct tcap *t;
  1402. {
  1403.     register struct line **p, **bottom;
  1404.     register struct line *old;
  1405.     static int SFrecur = 0;
  1406.  
  1407.     trace("sf", t);
  1408.     /*
  1409.      * When sf is "\n", nl_op won't be called, so we emulate
  1410.      * it's actions here (beware of recursion).
  1411.      */
  1412.     if (ScrollNLKludge && !SFrecur) {
  1413.     SFrecur++; nl_op(t); SFrecur--;
  1414.     return (1);            /* XXX */
  1415.     }
  1416.     p = &screen[TopLineOfScrollRegion];
  1417.     if (PageMode && *p == lastInputLine) {
  1418.     PageFull++;            /* can't scroll this line */
  1419.     return (0);
  1420.     }
  1421.     ScrollSaveLine(*p);
  1422.     bottom = &screen[BottomLineOfScrollRegion];
  1423.     p = &screen[TopLineOfScrollRegion];
  1424.     old = *p;
  1425.     for (; p < bottom; p++)
  1426.     *p = *(p+1);
  1427.     *p = old;
  1428.     clear_body(old, 0);
  1429.     old->length = 0;
  1430.     old->changeposition = 0;
  1431.     old->end_of_changes = CharsPerLine ;
  1432.     old->usedtobe = LinesPerScreen;
  1433.     ChangeScreen();
  1434.     return (1);
  1435. }
  1436.  
  1437. static int
  1438. sl_op(t)    /* start defining new frame label */
  1439.     register struct tcap *t;
  1440. {
  1441.     trace("sl", t);
  1442.     FLindex = 0;
  1443.     t = T+Ts;
  1444.     prevInput = t->t_op;
  1445.     t->t_op = lm_op;
  1446. }
  1447.  
  1448. static int
  1449. sr_op(t)    /* scroll reverse */
  1450.     struct tcap *t;
  1451. {
  1452.     register struct line **p, **top;
  1453.     register struct line *old;
  1454.  
  1455.     trace("sr", t);
  1456.     lastInputLine = 0;            /* no scroll stop line */
  1457.     top = &screen[TopLineOfScrollRegion];
  1458.     p = &screen[BottomLineOfScrollRegion];
  1459.     old = *p;
  1460.     for (; p > top; p--)
  1461.     *p = *(p-1);
  1462.     *p = old;
  1463.     clear_body(old, 0);
  1464.     old->length = 0;
  1465.     old->changeposition = 0;
  1466.     old->end_of_changes = CharsPerLine ;
  1467.     old->usedtobe = LinesPerScreen;
  1468.     ChangeScreen();
  1469. }
  1470.  
  1471. static int
  1472. ta_op(t)    /* tab */
  1473.     struct tcap *t;
  1474. {
  1475.     trace("ta", t);
  1476.     Dot.x = (Dot.x & ~07) + 010;
  1477.     if (Dot.x >= CharsPerLine - 1)
  1478.     Dot.x = CharsPerLine - 1;
  1479.     MoveCursor();
  1480. }
  1481.  
  1482. static int
  1483. te_op(t)    /* end use of termcap */
  1484.     struct tcap *t;
  1485. {
  1486.     trace("te", t);
  1487.     if (PrevPageMode != -1) {
  1488.     PageMode = PrevPageMode;
  1489.     PrevPageMode = -1;
  1490.     }
  1491. }
  1492.  
  1493. static int
  1494. ti_op(t)    /* begin use of termcap */
  1495. {
  1496.     trace("ti", t);
  1497.     /*
  1498.      * Turn off page mode when using termcap.
  1499.      */
  1500.     if (PrevPageMode == -1) {
  1501.     PrevPageMode = PageMode;
  1502.     PageMode = 0;
  1503.     }
  1504. }
  1505.  
  1506. static int
  1507. ue_op(t)    /* end underline */
  1508.     struct tcap *t;
  1509. {
  1510.     trace("ue", t);
  1511.     PermanentModes &= ~UnderlineMode;
  1512. }
  1513.  
  1514. static int
  1515. up_op(t)    /* cursor up */
  1516.     struct tcap *t;
  1517. {
  1518.     trace("up", t);
  1519.     if (Dot.y > 0)
  1520.     Dot.y--;
  1521.     else    /* vi will never do this,  but some ll caps may */
  1522.         Dot.y = LinesPerScreen - 1;
  1523.     MoveCursor();
  1524. }
  1525.  
  1526. static int
  1527. us_op(t)    /* start underline */
  1528.     struct tcap *t;
  1529. {
  1530.     trace("us", t);
  1531.     PermanentModes |= UnderlineMode;
  1532. }
  1533.  
  1534. static int
  1535. vb_op(t)    /* visibile bell */
  1536.     struct tcap *t;
  1537. {
  1538.     trace("bl", t);
  1539.     VisibleBell();
  1540. }
  1541.  
  1542. static int
  1543. xn_in(t)
  1544.     struct tcap *t;
  1545. {
  1546.     trace("xn", t);
  1547.     if (t->t_x) PermanentModes |= IgnoreNewlineAfterWrapMode;
  1548.     return (0);
  1549. }
  1550.  
  1551. /* These capabilities are numeric or boolean - they dont have ops */
  1552. #define am_op    NULL
  1553. #define    bs_op    NULL
  1554. #define    co_op    NULL
  1555. #define    li_op    NULL
  1556. #define pc_op    NULL
  1557. #define xn_op    NULL
  1558.  
  1559. /* These capabilities are strings that dont need initialization */
  1560. #define    al_in    NULL
  1561. #define    bc_in    NULL
  1562. #define    bl_in    NULL
  1563. #define    cd_in    NULL
  1564. #define    ce_in    NULL
  1565. #define    cl_in    NULL
  1566. #define    cr_in    NULL
  1567. #define    dc_in    NULL
  1568. #define    dl_in    NULL
  1569. #define    do_in    NULL
  1570. #define    ei_in    NULL
  1571. #define    ke_in    NULL
  1572. #define    ks_in    NULL
  1573. #define    ho_in    NULL
  1574. #define    ic_in    NULL
  1575. #define    im_in    NULL
  1576. #define    le_in    NULL
  1577. #define    ll_in    NULL
  1578. #define    mb_in    NULL
  1579. #define    md_in    NULL
  1580. #define    me_in    NULL
  1581. #define    mr_in    NULL
  1582. #define    nd_in    NULL
  1583. #define    nl_in    NULL
  1584. #define pc_in    NULL
  1585. #define rc_in    NULL
  1586. #define    sc_in    NULL
  1587. #define    se_in    NULL
  1588. #define    sf_in    NULL
  1589. #define    so_in    NULL
  1590. #define    sr_in    NULL
  1591. #define    ta_in    NULL
  1592. #define    ue_in    NULL
  1593. #define    up_in    NULL
  1594. #define    us_in    NULL
  1595.  
  1596. #define    s    string
  1597. #define n    num
  1598. #define b    bool
  1599.  
  1600. struct tcap T[] = {
  1601. /*
  1602.  *   key   ty op     in     text  deftx sz in tmp  tf
  1603.  *    x  xi xl y  yi yl r  n  B  D  2
  1604.  */
  1605.     {"AL", s, AL_op, cs_in, NULL,   NULL, 0, 0, NULL, 0},
  1606.     {"DL", s, DL_op, cs_in, NULL,   NULL, 0, 0, NULL, 0},
  1607.     {"DC", s, DC_op, cs_in, NULL,   NULL, 0, 0, NULL, 0},
  1608.     {"DO", s, DO_op, DO_in, NULL,   NULL, 0, 0, NULL, 0},
  1609.     {"IC", s, IC_op, cs_in, NULL,   NULL, 0, 0, NULL, 0},
  1610.     {"LE", s, LE_op, LE_in, NULL,   NULL, 0, 0, NULL, 0},
  1611.     {"RI", s, RI_op, RI_in, NULL,   NULL, 0, 0, NULL, 0},
  1612.     {"UP", s, UP_op, UP_in, NULL,   NULL, 0, 0, NULL, 0},
  1613.     {"al", s, al_op, al_in, NULL,   NULL, 0, 0, NULL, 0},
  1614.     {"am", b, am_op, am_in, NULL,   NULL, 0, 0, NULL, 0},
  1615.     {"bc", s, bc_op, bc_in, NULL,  "\10", 0, 0, NULL, 0},
  1616.     {"bl", s, bl_op, bl_in, NULL,   "\7", 0, 0, NULL, 0},
  1617.     {"cd", s, cd_op, cd_in, NULL,   NULL, 0, 0, NULL, 0},
  1618.     {"ce", s, ce_op, ce_in, NULL,   NULL, 0, 0, NULL, 0},
  1619.     {"cl", s, cl_op, cl_in, NULL,   NULL, 0, 0, NULL, 0},
  1620.     {"cm", s, cm_op, cm_in, NULL,   NULL, 0, 0, NULL, 0},
  1621.     {"co", n, co_op, co_in, NULL,   NULL, 0, 0, NULL, 0},
  1622.     {"cr", s, cr_op, cr_in, NULL, "\015", 0, 0, NULL, 0},
  1623.     {"cs", s, cs_op, cs_in, NULL,   NULL, 0, 0, NULL, 0},
  1624.     {"dc", s, dc_op, dc_in, NULL,   NULL, 0, 0, NULL, 0},
  1625.     {"dl", s, dl_op, dl_in, NULL,   NULL, 0, 0, NULL, 0},
  1626.     {"do", s, do_op, do_in, NULL,   NULL, 0, 0, NULL, 0},
  1627.     {"ei", s, ei_op, ei_in, NULL,   NULL, 0, 0, NULL, 0},
  1628.     {"el", s, el_op, NULL,  NULL,"\033\\",0, 0, NULL, 0}, /* end label */
  1629.     {"ke", s, ke_op, ke_in, NULL,   NULL, 0, 0, NULL, 0},
  1630.     {"ks", s, ks_op, ks_in, NULL,   NULL, 0, 0, NULL, 0},
  1631.     {"ho", s, ho_op, ho_in, NULL,   NULL, 0, 0, NULL, 0},
  1632.     {"ic", s, ic_op, ic_in, NULL,   NULL, 0, 0, NULL, 0},
  1633.     {"im", s, im_op, im_in, NULL,   NULL, 0, 0, NULL, 0},
  1634.     {"le", s, le_op, le_in, NULL,   NULL, 0, 0, NULL, 0},
  1635.     {"li", n, li_op, li_in, NULL,   NULL, 0, 0, NULL, 0},
  1636.     {"ll", s, ll_op, ll_in, NULL,   NULL, 0, 0, NULL, 0},
  1637.     {"lm", s, lm_op,  NULL, NULL,   NULL, 0, 0, NULL, 0}, /* label mode input */
  1638.     {"mb", s, mb_op, mb_in, NULL,   NULL, 0, 0, NULL, 0},
  1639.     {"md", s, md_op, md_in, NULL,   NULL, 0, 0, NULL, 0},
  1640.     {"me", s, me_op, me_in, NULL,   NULL, 0, 0, NULL, 0},
  1641.     {"mr", s, mr_op, mr_in, NULL,   NULL, 0, 0, NULL, 0},
  1642.     {"nd", s, nd_op, nd_in, NULL,   NULL, 0, 0, NULL, 0},
  1643.     {"nl", s, nl_op, nl_in, NULL, "\012", 0, 0, NULL, 0},
  1644.     {"pc", s, pc_op, pc_in, NULL, "\200", 0, 0, NULL, 0},
  1645.     {"rc", s, rc_op, rc_in, NULL,   NULL, 0, 0, NULL, 0},
  1646.     {"sc", s, sc_op, sc_in, NULL,   NULL, 0, 0, NULL, 0},
  1647.     {"se", s, se_op, se_in, NULL,   NULL, 0, 0, NULL, 0},
  1648.     {"sf", s, sf_op, sf_in, NULL,   NULL, 0, 0, NULL, 0},
  1649.     {"sl", s, sl_op, NULL,  NULL,"\033]l",0, 0, NULL, 0}, /* start label */
  1650.     {"so", s, so_op, so_in, NULL,   NULL, 0, 0, NULL, 0},
  1651.     {"sr", s, sr_op, sr_in, NULL,   NULL, 0, 0, NULL, 0},
  1652.     {"ta", s, ta_op, ta_in, NULL, "\011", 0, 0, NULL, 0},    /* XXX */
  1653.     {"te", s, te_op, NULL,  NULL,   NULL, 0, 0, NULL, 0},
  1654.     {"ti", s, ti_op, NULL,  NULL,   NULL, 0, 0, NULL, 0},
  1655.     {"ue", s, ue_op, ue_in, NULL,   NULL, 0, 0, NULL, 0},
  1656.     {"up", s, up_op, up_in, NULL,   NULL, 0, 0, NULL, 0},
  1657.     {"us", s, us_op, us_in, NULL,   NULL, 0, 0, NULL, 0},
  1658.     {"vb", s, vb_op,  NULL, NULL,   NULL, 0, 0, NULL, 0},
  1659.     {"xn", b, xn_op, xn_in, NULL,   NULL, 0, 0, NULL, 0},
  1660.     {"",   s, showc,  NULL, NULL,   NULL, 0, 0, NULL, 0},
  1661. };
  1662.  
  1663. /* T[Ts] is a special case - its the display-character operation */
  1664. int Ts = (sizeof T)/(sizeof T[0]) - 1;
  1665. @@@ Fin de tcap_ops.c
  1666. echo tcap_parse.c
  1667. cat >tcap_parse.c <<'@@@ Fin de tcap_parse.c'
  1668. /*
  1669.  * This file is a product of Sun Microsystems, Inc. and is provided for
  1670.  * unrestricted use provided that this legend is included on all tape
  1671.  * media and as a part of the software program in whole or part.
  1672.  * Users may copy, modify or distribute this file at will.
  1673.  * 
  1674.  * THIS FILE IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  1675.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  1676.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  1677.  * 
  1678.  * This file is provided with no support and without any obligation on the
  1679.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  1680.  * modification or enhancement.
  1681.  * 
  1682.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  1683.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THIS FILE
  1684.  * OR ANY PART THEREOF.
  1685.  * 
  1686.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  1687.  * or profits or other special, indirect and consequential damages, even
  1688.  * if Sun has been advised of the possibility of such damages.
  1689.  * 
  1690.  * Sun Microsystems, Inc.
  1691.  * 2550 Garcia Avenue
  1692.  * Mountain View, California  94043
  1693.  *
  1694.  * Modifications to the original Sun Microsystems, Inc. source code
  1695.  * made by the Grasshopper Group are in the Public Domain.
  1696.  *
  1697.  * Extensions to this file by Eric Messick of the Grasshopper Group.
  1698.  *
  1699.  * Grasshopper Group
  1700.  * 212 Clayton St
  1701.  * San Francisco, CA 94117
  1702.  *
  1703.  */
  1704.  
  1705. #ifndef lint
  1706. static    char sccsid[] =
  1707.     "@(#)tcap_parse.c 9.5 88/01/19 Copyright 1985 Sun Micro";
  1708. static    char RCSid[] =
  1709.     "@(#)$Header: tcap_parse.c,v 2.3 88/10/04 06:00:03 gnu Release $";
  1710. #endif
  1711.  
  1712.  
  1713. /*
  1714.  * Copyright (c) 1985 by Sun Microsystems, Inc.
  1715.  */
  1716.  
  1717. /*-
  1718.     tcap_parse.c:  Parse termcap output based on termcap entry.
  1719.  
  1720.     tcap_parse.c, Mon Mar 24 11:25:44 1986
  1721.  
  1722.         David Rosenthal,
  1723.         Sun Microsystems
  1724.  */
  1725.     /* XXX - remember longest outstanding partial match? */
  1726.     /* XXX - overlapping partial matches? */
  1727.  
  1728. #include    <stdio.h>
  1729. #include    <ctype.h>
  1730. #include    <sys/types.h>
  1731. #ifdef REF
  1732. #include    <ref/config.h>
  1733. #endif
  1734. #include    "termcap.h"
  1735.  
  1736. extern char *malloc();
  1737. #ifndef bcopy
  1738. extern void bcopy();
  1739. #endif
  1740.  
  1741. static    int TerminalIsBraindamaged = 0;
  1742. /*  Import these from tcap_ops.c */
  1743. extern struct tcap T[];
  1744. extern int Ts;
  1745. extern struct tcap *CheckCR;
  1746. extern struct tcap *CheckNL;
  1747. extern struct tcap *CheckTAB;
  1748. extern struct tcap *CheckBS;
  1749. extern int PageFull;
  1750. extern int PageMode;
  1751.  
  1752. static char *unpad();
  1753. static int tc_init_stacks();
  1754.  
  1755. /*
  1756.  * Initialize the display system from the TERMCAP entry.
  1757.  * We parse the entry and build the tcap structures
  1758.  * describing the operations supported by this type of
  1759.  * terminal.  These descriptions are then used by tc_display()
  1760.  * in interpreting the data stream generated by the
  1761.  * application
  1762.  */
  1763. int
  1764. tc_initialize(term)
  1765.     char *term;
  1766. {
  1767. #ifdef SUNTGETENT
  1768.     static void tc_fix_tcap_ent();
  1769. #endif
  1770.     static char tcapbuf[1024], tcaparea[1024];
  1771.     char       *areap = tcaparea;
  1772.     extern int tgetent(), tgetnum(), tgetflag();
  1773.     extern char *tgetstr();
  1774.     register struct tcap *tp;
  1775.  
  1776.     if (tgetent(tcapbuf, term) != 1) {        /* unknown terminal type? */
  1777.     fprintf(stderr, "tgetent failed\n");
  1778.     return (1);
  1779.     }
  1780. #ifdef SUNTGETENT
  1781.     tc_fix_tcap_ent(tcapbuf);
  1782. #endif
  1783.     set_environment_var("TERMCAP", tcapbuf);
  1784.     for (tp = T; tp < T+Ts; tp++) {
  1785.     switch (tp->t_type) {
  1786.     case string:
  1787.         tp->t_text = unpad(tgetstr(tp->t_key, &areap));
  1788.         if (tp->t_text == NULL)
  1789.         tp->t_text = tp->t_deftext;
  1790.         if (tp->t_text) {
  1791.             tp->t_size = strlen(tp->t_text);
  1792.             if (isprint(tp->t_text[0]))
  1793.                 TerminalIsBraindamaged = 1;
  1794.         } else
  1795.             tp->t_size = 0;
  1796.         break;
  1797.     case num:
  1798.         tp->t_x = tgetnum(tp->t_key);
  1799.         break;
  1800.     case bool:
  1801.         tp->t_x = tgetflag(tp->t_key);
  1802.         break;
  1803.     }
  1804.     /* invoke any initialize routine */
  1805.     if (tp->t_in && (*tp->t_in)(tp)) {
  1806.         fprintf(stderr, "termcap init failed for %s\n", tp->t_key);
  1807.         return (1);
  1808.         }
  1809.     }
  1810.     tc_init_ops();
  1811.     return tc_init_stacks();
  1812. }
  1813.  
  1814. #ifdef HAVE_TERMCAP
  1815. static char *
  1816. unpad(s)
  1817.     register char *s;
  1818. {
  1819.  
  1820.     if (s) {
  1821.     register pad = 0;
  1822.  
  1823.     while (isdigit(*s))
  1824.         pad++, s++;
  1825.     if (pad && *s == '*')
  1826.         s++;
  1827.     }
  1828.     return (s);
  1829. }
  1830.  
  1831. #else    /* !HAVE_TERMCAP, ie next code is for TERMINFO */
  1832.  
  1833. /*
  1834.  * Remove the substring of the form "$<x^>" where x = number, and ^ = characters
  1835.  * in the set [* /]. This is the terminfo way of specifying delays or padding.
  1836.  */
  1837. static char *
  1838. unpad(s)
  1839.     register char *s;
  1840. {
  1841.  
  1842.     if (s) {
  1843.     register char *spt = s;
  1844.     register char *spt1, *spt2;
  1845.     char *strchr();
  1846.  
  1847.     while (spt1 = strchr(spt, '$')) {
  1848.         if (*(spt1 + 1) == '<') {    /* found the '$<' pair */
  1849.             if (spt2 = strchr(spt1, '>')) {
  1850.                 strcpy(spt1, ++spt2);    /* found end '>' */
  1851.                 spt = spt1;        /* copy tail of */
  1852.                 continue;        /* string over  */
  1853.                             /* '$<..', look */
  1854.                             /* for more */
  1855.             } else
  1856.                 break;        /* no match for '$<' so quit */
  1857.         } else {
  1858.             spt = spt1 + 1;        /* found '$' but no '<', */
  1859.             continue;        /* look for more */
  1860.         }
  1861.             
  1862.     }
  1863.     }
  1864.     return (s);
  1865. }
  1866. #endif    /* !HAVE_TERMCAP */
  1867.  
  1868.  
  1869. #ifdef SUNTGETENT
  1870. #define TCAPBUFSIZE 1024
  1871. #define SPECIALSIZE 2
  1872.  
  1873. static struct {
  1874.     char    *last;
  1875.     char     str[3];
  1876. }   tcapSpecials[SPECIALSIZE] = {
  1877.     NULL,    "co",
  1878.     NULL,    "li"
  1879. };
  1880.  
  1881. /*
  1882.  * Stomp on the first "co" and "li" entries in the termcap entry
  1883.  * to avoid braindamage in the Sun version of the termcap library.
  1884.  * Apparently the Sun version of tgetent() looks at the terminal
  1885.  * state and uses this to prepend extra line+column spec's that
  1886.  * reflect the terminal's current state.  This is not what we want,
  1887.  * so our only recourse is to undo the this braindamage here.
  1888.  */
  1889. static void
  1890. tc_fix_tcap_ent(buf)
  1891.     char *buf;
  1892. {
  1893.     char *bp = buf;
  1894. #ifndef SYSVREF
  1895.     char *index();
  1896. #else
  1897. #define index(s, c)    (char *)strchr(s, c)
  1898. #endif
  1899.     int   i;
  1900.  
  1901.     /* for each item in buf ... */
  1902.     for (bp = index(bp, ':'); bp && *(bp+1); bp = index(bp, ':')) {
  1903.     ++bp;
  1904.     /* for each special tcap code ... */
  1905.     for (i = 0; i < SPECIALSIZE; i++) {
  1906.         if (strncmp(tcapSpecials[i].str, bp, 2) == 0) {
  1907.         if (tcapSpecials[i].last)
  1908.             strncpy(tcapSpecials[i].last, "xx", 2);
  1909.         tcapSpecials[i].last = bp;
  1910.         break;
  1911.         }
  1912.     }
  1913.     }
  1914. }
  1915. #endif /* SUNTGETENT */
  1916.  
  1917. /*
  1918.  * Matching is performed with a push-down automata implemented
  1919.  * with dual stacks.  An initial stack is loaded with all the
  1920.  * potential matches from the termcap structure.  Matching then
  1921.  * takes place by popping each potential match off the ``current
  1922.  * stack'' and, if a successful match for the current character
  1923.  * occurs, pushing the match on the ``other stack''.  When the
  1924.  * ``current stack'' is empty (all elements have been examined),
  1925.  * the stacks are swapped and the process restarted.  This continues
  1926.  * until a completed match or the stack of potential matches has
  1927.  * been exhausted.
  1928.  */
  1929. static    struct    tcap **curstack, **cursp;    /* ``potential match'' stack */
  1930. static    struct tcap **otherstack, **othersp;    /* ``match this pass'' stack */
  1931. static    struct tcap **resetstack;        /* prototype curstack */
  1932. static    int stacksize;                /* # of potential matches */
  1933. static    int MatchInProgress;            /* for fast check */
  1934.  
  1935. #define    PushMatch(tp)    (*--othersp = tp)
  1936. #define    PopMatch()    (*cursp++)
  1937. #define    PopMatched()    (*othersp++)
  1938. #define    SwapStacks() { \
  1939.     struct tcap **t; \
  1940.     t = curstack, curstack = otherstack, otherstack = t; \
  1941.     cursp = othersp, othersp = otherstack + stacksize; \
  1942.     MatchInProgress = 1; \
  1943. }
  1944. #define    ResetMatchStack() { \
  1945.     bcopy((char *)resetstack, (char *)curstack, \
  1946.         stacksize*sizeof (struct tcap *)); \
  1947.     cursp = curstack; \
  1948.     MatchInProgress = 0; \
  1949. }
  1950. #define    FlushStack(sp, stack) { \
  1951.     while (sp < stack+stacksize) { \
  1952.         tp = *sp++; \
  1953.         tp->t_index = 0; \
  1954.         tp->t_param = 0 ; \
  1955.         tp->t_matched = 0; \
  1956.         tp->t_2nd = 0; \
  1957.     } \
  1958. }
  1959. #define    FlushMatchStack()    FlushStack(cursp, curstack)
  1960. #define    FlushMatchedStack()    FlushStack(othersp, otherstack);
  1961. #define    MatchStackEmpty()    (cursp >= curstack+stacksize)
  1962. #define    MatchedStackEmpty()    (othersp >= otherstack+stacksize)
  1963.  
  1964. /*
  1965.  * Reset the pattern matching stack and load
  1966.  * it with all the potential matching entries.
  1967.  */
  1968. static int
  1969. tc_init_stacks()
  1970. {
  1971.     register struct tcap *tp;
  1972.  
  1973.     for (tp = T; tp < T+Ts; tp++)
  1974.         if (tp->t_text != NULL)
  1975.         stacksize++;
  1976.     curstack = (struct tcap **)malloc((unsigned)
  1977.             (3*sizeof(struct tcap *) * stacksize));
  1978.     if (!curstack)
  1979.         return 1;
  1980.     otherstack = curstack+stacksize;
  1981.     resetstack = otherstack+stacksize;
  1982.     othersp = resetstack+stacksize;
  1983.     for (tp = T; tp < T+Ts; tp++)
  1984.         if (tp->t_text != NULL)
  1985.             PushMatch(tp);
  1986.     othersp = otherstack+stacksize;
  1987.     ResetMatchStack();
  1988.     return 0;
  1989. }
  1990.  
  1991. extern struct tcap interruptedOp;
  1992.  
  1993. /*
  1994.  * Interpret data from the application.  We match data against
  1995.  * the ``escape sequences'' expected for this termcap description
  1996.  * and, if successful, invoke the routines used to emulate the
  1997.  * capabilities on the window.
  1998.  */
  1999. tc_display(cp, n)
  2000.     u_char *cp;
  2001.     register int n;
  2002. {
  2003.     register int c, j;
  2004.     register struct tcap *tp;
  2005.     static char dbuf[256], *dp = dbuf;
  2006.     int restart, lim;
  2007.  
  2008.     /*
  2009.      * If we're blocked with a page full, indicate
  2010.      * nothing was sent to the screen.  We should
  2011.      * never be called when already blocked, but
  2012.      * just in case, turn scrolling on again so we
  2013.      * don't lost any data.
  2014.      */
  2015.     if (PageFull) {
  2016.     if (interruptedOp.t_key == 0)
  2017.         return (n);
  2018.     scrollreset(0);            /* XXX */
  2019.     }    
  2020.     /*
  2021.      * If we have previous output, process it first.
  2022.      * Check on completion to see if we filled the screen.
  2023.      */
  2024.     if (interruptedOp.t_key) {
  2025.     (*interruptedOp.t_op)(&interruptedOp);
  2026.     if (PageFull)
  2027.         return (n);
  2028.     interruptedOp.t_key = 0;
  2029.     }
  2030.     /*
  2031.      * For each input character, look for potential
  2032.      * matches in the tcap structure.  For each possible
  2033.      * match, construct the resultant output buffer.
  2034.      * On first match process the operation (e.g. invoke
  2035.      * internal routine) and flush extraneous matches.
  2036.      * If input doesn't match any capability, send it to
  2037.      * the window.
  2038.      */
  2039.     while (n > 0 && !PageFull) {
  2040.     /*
  2041.      * If we're not in the middle of a match, then
  2042.      * try and bypass the pattern matcher by performing
  2043.      * special checks on the most common input.
  2044.      */
  2045.     if (!MatchInProgress) {
  2046.         while (n > 0 && !PageFull) {
  2047.         /*
  2048.          * If terminal has only non-printing escape sequences,
  2049.          * then process printable characters w/o matching against
  2050.          * the termcap strings.
  2051.          */
  2052.         if (!TerminalIsBraindamaged) {
  2053.             for (dp = (char *)cp; n > 0 && isprint((int)*cp); n--)
  2054.             cp++;
  2055.             if ((char *)cp > dp) {
  2056.             tp = T+Ts;
  2057.             tp->t_text = dp;    /* use original storage */
  2058.             tp->t_size = (char *)cp - dp;
  2059.             (*tp->t_op)(tp);
  2060.             if (PageFull)
  2061.                 return (n);
  2062.             continue;
  2063.             }
  2064.         }
  2065.         /*
  2066.          * Make quick checks for standard NL, CR, BS, and TAB
  2067.          * characters.  This speeds up scrolling for most
  2068.          * terminal types.
  2069.          */
  2070.         c = *cp;
  2071.         if (CheckNL && c == '\n')
  2072.             tp = CheckNL;
  2073.         else if (CheckCR && c == '\r')
  2074.             tp = CheckCR;
  2075.         else if (CheckTAB && c == '\t')
  2076.             tp = CheckTAB;
  2077.         else if (CheckBS && c == '\b')
  2078.             tp = CheckBS;
  2079.         else
  2080.             break;
  2081.         cp++, n--;
  2082.         (*tp->t_op)(tp);
  2083.         if (PageFull)
  2084.             return (n);
  2085.         }
  2086.         dp = dbuf;
  2087.         if (n == 0)
  2088.         break;
  2089.     }
  2090.     c = *dp++ = *cp++, n--;
  2091.     while (!MatchStackEmpty()) {
  2092.         tp = PopMatch();
  2093. again:
  2094.         j = tp->t_index;
  2095.         restart = 0;
  2096.         /*
  2097.          * Check match against numeric %[d23] specification.
  2098.          */
  2099.         if (tp->t_text[j] == '%') {
  2100.         switch (tp->t_text[j+1]) {
  2101.         case 'd':            /* series of decimal digits */
  2102.             lim = 127;
  2103.             goto digit;
  2104.         case '2':            /* two decimal digits */
  2105.             lim = 2;
  2106.             goto digit;
  2107.         case '3':            /* three decimal digits */
  2108.             lim = 3;
  2109.             /* fall thru.. */
  2110.         digit:
  2111.             if (isdigit(c) && tp->t_matched < lim) {
  2112.             tp->t_matched++;
  2113.             tp->t_param = tp->t_param*10 + (c-'0');
  2114.             goto plainmatch;
  2115.             } else {
  2116.             if (tp->t_matched == 0)
  2117.                 tp->t_param = 1 ;
  2118.             tp->t_matched = 0;
  2119.             restart = !isdigit(c);
  2120.             goto gotvalue;
  2121.             }
  2122.             /*NOTREACHED*/
  2123.             break;
  2124.         case '.':            /* binary character */
  2125.             tp->t_param = c;
  2126.         gotvalue:
  2127.             switch (tp->t_2nd + tp->t_pc_r) {
  2128.             case 0:
  2129.             case 2:
  2130.             if ((tp->t_y = tp->t_param) >= tp->t_yilim)
  2131.                 tp->t_y -= tp->t_yi;
  2132.             break;
  2133.             case 1:
  2134.             if ((tp->t_x = tp->t_param) >= tp->t_xilim)
  2135.                 tp->t_x -= tp->t_xi;
  2136.             break;
  2137.             }
  2138.             tp->t_2nd = !tp->t_2nd;
  2139.             tp->t_index += 2;
  2140.             tp->t_param = 0 ;
  2141.             goto plainmatch;
  2142.         case '%':
  2143.             if ((c & 0177) == '%') {
  2144.             tp->t_index += 2;
  2145.             goto plainmatch;
  2146.             } else
  2147.             goto nomatch;
  2148.         default:
  2149.             abort();    /* XXX */
  2150.             /* NOTREACHED */
  2151.         }
  2152.         } else if ((c & 0177) == (tp->t_text[j] & 0177)) {
  2153.         tp->t_index++;
  2154.     plainmatch:                    /* plain match */
  2155.         if (tp->t_index >= tp->t_size) {/* match completed */
  2156.             if (tp->t_op)
  2157.             (*tp->t_op)(tp);
  2158.             dp = dbuf;
  2159.             tp->t_index = 0;
  2160.             tp->t_matched = 0;
  2161.             tp->t_param = 0 ;
  2162.             tp->t_2nd = 0;
  2163.             goto done;
  2164.         }
  2165.         /*
  2166.          * The end of a %d match is the only case where a
  2167.          * character must be pushed-back and re-parsed.
  2168.          */
  2169.         if (restart)
  2170.             goto again;
  2171.         PushMatch(tp);            /* push partial match */
  2172.         } else {
  2173.     nomatch:                    /* failed match */
  2174.         tp->t_index = 0;
  2175.         tp->t_param = 0 ;
  2176.         tp->t_matched = 0;
  2177.         tp->t_2nd = 0;
  2178.         }
  2179.     }
  2180.     if (!MatchedStackEmpty()) {
  2181.         SwapStacks();
  2182.         continue;
  2183.     }
  2184. done:
  2185.     /*
  2186.      * Come here either because no partial matches were
  2187.      * found in the table, or because a match completed.
  2188.      * In the first case we send the input data off
  2189.      * immediately.  In the second case we reset the
  2190.      * state machines and go on to the next character.  
  2191.      */
  2192.     if (dp - dbuf) {            /* flush output */
  2193.         tp = T+Ts;
  2194.         tp->t_text = dbuf;
  2195.         tp->t_size = dp - dbuf;
  2196.         (*tp->t_op)(tp);
  2197.         dp = dbuf;
  2198.     }
  2199.     FlushMatchedStack();            /* reset partial matches */
  2200.     FlushMatchStack();            /* reset unchecked partials */
  2201.     ResetMatchStack();            /* re-init match stack */
  2202.     }
  2203.     return (n);                /* return number of chars processed */
  2204. }
  2205. @@@ Fin de tcap_parse.c
  2206. echo termcap.h
  2207. cat >termcap.h <<'@@@ Fin de termcap.h'
  2208. /*
  2209.  * This file is a product of Sun Microsystems, Inc. and is provided for
  2210.  * unrestricted use provided that this legend is included on all tape
  2211.  * media and as a part of the software program in whole or part.
  2212.  * Users may copy, modify or distribute this file at will.
  2213.  * 
  2214.  * THIS FILE IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  2215.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  2216.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  2217.  * 
  2218.  * This file is provided with no support and without any obligation on the
  2219.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  2220.  * modification or enhancement.
  2221.  * 
  2222.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  2223.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THIS FILE
  2224.  * OR ANY PART THEREOF.
  2225.  * 
  2226.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  2227.  * or profits or other special, indirect and consequential damages, even
  2228.  * if Sun has been advised of the possibility of such damages.
  2229.  * 
  2230.  * Sun Microsystems, Inc.
  2231.  * 2550 Garcia Avenue
  2232.  * Mountain View, California  94043
  2233.  *
  2234.  * Modifications to the original Sun Microsystems, Inc. source code
  2235.  * made by the Grasshopper Group are in the Public Domain.
  2236.  *
  2237.  * Extensions to this file by Eric Messick of the Grasshopper Group.
  2238.  *
  2239.  * Grasshopper Group
  2240.  * 212 Clayton St
  2241.  * San Francisco, CA 94117
  2242.  *
  2243.  */
  2244. /*
  2245.  * "@(#)termcap.h 9.4 88/01/19 SMI
  2246.  * "@(#)$Header: termcap.h,v 2.0 88/09/16 00:19:39 eric Release $
  2247.  *
  2248.  * Copyright (c) 1985 by Sun Microsystems, Inc.
  2249.  */
  2250.  
  2251.  
  2252.  
  2253. enum tct { string, num, bool};
  2254.  
  2255. struct tcap {
  2256.     char *    t_key;        /* Capability name */
  2257.     enum tct    t_type;        /* Capability type */
  2258.     int        (*t_op)(/* struct tcap * */);
  2259.     int        (*t_in)(/* struct tcap * */);
  2260.     char *    t_text;        /* Capability text */
  2261.     char *    t_deftext;    /* Default text */
  2262.     u_short    t_size;        /* Length of t_text */
  2263.     u_short    t_index;    /* Posn. in t_text */
  2264.     int        t_param;    /* parameter value for %match */
  2265.     u_short    t_matched;    /* Length of matched string */
  2266.     u_short    t_x;        /* Coordinate for cm= etc. */
  2267.     u_short    t_xi;        /* Offset to subtract from t_x */
  2268.     u_short    t_xilim;    /* If t_x >= t_xilim subtract t_xi */
  2269.     u_short    t_y;
  2270.     u_short    t_yi;
  2271.     u_short    t_yilim;
  2272.     unsigned    t_pc_r    : 1;    /* %r present */
  2273.     unsigned    t_pc_n    : 1;    /* %n present */
  2274.     unsigned    t_pc_B    : 1;    /* %B present */
  2275.     unsigned    t_pc_D    : 1;    /* %D present */
  2276.     unsigned    t_2nd    : 1;    /* On second coord */
  2277. };
  2278. @@@ Fin de termcap.h
  2279. exit 0
  2280.  
  2281.