home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 100-199 / ff195.lzh / MicroEMACS / src.zoo / tcap.c < prev    next >
C/C++ Source or Header  |  1989-03-23  |  13KB  |  560 lines
  1. /*    tcap:    Unix V5, SUN OS, SCO XENIX, V7 and BS4.2 Termcap video driver
  2.         for MicroEMACS 3.10
  3.  
  4.          12-10-88 - Modifications made by Guy Turcotte to accomodate
  5.                     SunOS V4.0 and Xenix V2.2.1 :
  6.  
  7.                   SunOS mods:
  8.                   
  9.                   o p_seq field of TBIND struct augmented to 10 chars
  10.                     to take into account longer definitions for keys
  11.                     (some Sun's keys definitions need at least 7 chars...)
  12.                     as such, the code in get1key has been modified to take
  13.                     care of the longer p_seq string.
  14.  
  15.                   o tcapopen modified to take care of the tgetstr problem
  16.                     (returns NULL on undefined keys instead of a valid
  17.                     string pointer...)
  18.  
  19.                   o The timout algorithm of get1key has been modified to
  20.                     take care of the following select() function problem:
  21.                     if some chars are already in the terminal buffer before
  22.                     select is called and no others char appears on the terminal,
  23.                     it will timeout anyway... (maybe a feature of SunOs V4.0)
  24.  
  25.                   Xenix mods:
  26.  
  27.                   o The first two points indicated above are applicable for
  28.                     the Xenix OS
  29.  
  30.                   o With my current knowledge, I can't find a clean solution
  31.                     to the timeout problem of the get1key function
  32.                     under Xenix. I modified the code to get rid of the BSD code 
  33.                     (via the #if directive) and use the Xenix nap() and rdchk()
  34.                     functions to 
  35.                     make a 1/30 second wait. Seems to work as long as there is
  36.                     not to much of activity from other processes on the system.
  37.                     (The link command of the makefile must be modified to
  38.                     link with the x library... you must add the option -lx)
  39.  
  40.                   o The input.c file has been modified to not include the
  41.                     get1key function defined there in the case of USG. The
  42.                     #if directive preceeding the get1key definition has been
  43.                     modified from:
  44.  
  45.                      #if (V7 == 0) && (BSD == 0)
  46.  
  47.                     to:
  48.  
  49.                      #if (V7 == 0) && (BSD == 0) && (USG == 0)
  50.                      
  51.                   o The following lines define the new termcap entry for
  52.                     the ansi kind of terminal: it permits the use of functions
  53.                     keys F1 .. F10 and keys HOME,END,PgUp,PgDn on the IBM PC
  54.                     keyboard (the last 3 lines of the definition have been
  55.                     added):
  56.  
  57.  li|ansi|Ansi standard crt:\
  58.      :al=\E[L:am:bs:cd=\E[J:ce=\E[K:cl=\E[2J\E[H:cm=\E[%i%d;%dH:co#80:\
  59.      :dc=\E[P:dl=\E[M:do=\E[B:bt=\E[Z:ei=:ho=\E[H:ic=\E[@:im=:li#25:\
  60.      :nd=\E[C:pt:so=\E[7m:se=\E[m:us=\E[4m:ue=\E[m:up=\E[A:\
  61.      :kb=^h:ku=\E[A:kd=\E[B:kl=\E[D:kr=\E[C:eo:sf=\E[S:sr=\E[T:\
  62.      :GS=\E[12m:GE=\E[10m:GV=\63:GH=D:\
  63.      :GC=E:GL=\64:GR=C:RT=^J:G1=?:G2=Z:G3=@:G4=Y:GU=A:GD=B:\
  64.      :CW=\E[M:NU=\E[N:RF=\E[O:RC=\E[P:\
  65.      :WL=\E[S:WR=\E[T:CL=\E[U:CR=\E[V:\
  66.      :HM=\E[H:EN=\E[F:PU=\E[I:PD=\E[G:\
  67.      :k1=\E[M:k2=\E[N:k3=\E[O:k4=\E[P:k5=\E[Q:\
  68.      :k6=\E[R:k7=\E[S:k8=\E[T:k9=\E[U:k0=\E[V:\
  69.      :kh=\E[H:kH=\E[F:kA=\E[L:kN=\E[G:kP=\E[I:
  70.                     
  71. */
  72.  
  73. #define termdef 1            /* don't define "term" external */
  74.  
  75. #include <stdio.h>
  76. #include    "estruct.h"
  77. #include    "etype.h"
  78. #include    "edef.h"
  79. #include    "elang.h"
  80.  
  81. #if TERMCAP
  82.  
  83. #if    USG | HPUX
  84. #include    <time.h>
  85. #endif
  86. #if    BSD | V7
  87. #include    <sys/types.h>
  88. #include    <sys/time.h>
  89. #endif
  90.  
  91. #define MARGIN    8
  92. #define SCRSIZ    64
  93. #define NPAUSE    10            /* # times thru update to pause */
  94. #define BEL    0x07
  95. #define ESC    0x1B
  96.  
  97. /*    Termcap Sequence definitions    */
  98.  
  99. typedef struct TBIND {
  100.     char p_name[4]; /* sequence name */
  101.     short p_code;    /* resulting keycode of sequence */
  102.     char p_seq[10];    /* terminal escape sequence */
  103. } TBIND;
  104.  
  105. TBIND ttable[] = {
  106.     "bt",    SHFT | CTRL | 'i',    "",    /* backtab */
  107.     "k1",    SPEC | '1',        "",    /* function key 1 */
  108.     "k2",    SPEC | '2',        "",    /* function key 2 */
  109.     "k3",    SPEC | '3',        "",    /* function key 3 */
  110.     "k4",    SPEC | '4',        "",    /* function key 4 */
  111.     "k5",    SPEC | '5',        "",    /* function key 5 */
  112.     "k6",    SPEC | '6',        "",    /* function key 6 */
  113.     "k7",    SPEC | '7',        "",    /* function key 7 */
  114.     "k8",    SPEC | '8',        "",    /* function key 8 */
  115.     "k9",    SPEC | '9',        "",    /* function key 9 */
  116.     "k0",    SPEC | '0',        "",    /* function key 10 */
  117.     "kA",    CTRL | 'O',        "",    /* insert line */
  118.     "kb",    CTRL | 'H',        "",    /* backspace */
  119.     "kC",    CTRL | 'L',        "",    /* clear screen */
  120.     "kD",    SPEC | 'D',        "",    /* delete character */
  121.     "kd",    SPEC | 'N',        "",    /* down cursor */
  122.     "kE",    CTRL | 'K',        "",    /* clear to end of line */
  123.     "kF",    CTRL | 'V',        "",    /* scroll down */
  124.     "kH",    SPEC | '>',        "",    /* home down [END?] key */
  125.     "kh",    SPEC | '<',        "",    /* home */
  126.     "kI",    SPEC | 'C',        "",    /* insert character */
  127.     "kL",    CTRL | 'K',        "",    /* delete line */
  128.     "kl",    SPEC | 'B',        "",    /* left cursor */
  129.     "kN",    SPEC | 'V',        "",    /* next page */
  130.     "kP",    SPEC | 'Z',        "",    /* previous page */
  131.     "kR",    CTRL | 'Z',        "",    /* scroll down */
  132.     "kr",    SPEC | 'F',        "",    /* right cursor */
  133.     "ku",    SPEC | 'P',        "",    /* up cursor */
  134. };
  135.  
  136. #define    NTBINDS    sizeof(ttable)/sizeof(TBIND)
  137.  
  138. extern int    ttopen();
  139. extern int    ttgetc();
  140. extern int    ttputc();
  141. extern int    tgetnum();
  142. extern int    ttflush();
  143. extern int    ttclose();
  144. extern int    tcapkopen();
  145. extern int    tcapkclose();
  146. extern int    tcapgetc();
  147. extern int    tcapmove();
  148. extern int    tcapeeol();
  149. extern int    tcapeeop();
  150. extern int    tcapbeep();
  151. extern int    tcaprev();
  152. extern int    tcapcres();
  153. extern int    tcapopen();
  154. extern int    tcapclose();
  155. extern int    tput();
  156. extern char    *tgoto();
  157. #if    COLOR
  158. extern    int    tcapfcol();
  159. extern    int    tcapbcol();
  160. #endif
  161.  
  162. #define TCAPSLEN 1024
  163. char tcapbuf[TCAPSLEN];
  164. char *UP, PC, *CM, *CE, *CL, *SO, *SE, *IS, *KS, *KE;
  165.  
  166. TERM term = {
  167.     0, 0, 0, 0,    /* these four values are set dynamically at open time */
  168.     MARGIN,
  169.     SCRSIZ,
  170.     NPAUSE,
  171.     tcapopen,
  172.     tcapclose,
  173.     tcapkopen,
  174.     tcapkclose,
  175.     tcapgetc,
  176.     ttputc,
  177.     ttflush,
  178.     tcapmove,
  179.     tcapeeol,
  180.     tcapeeop,
  181.     tcapbeep,
  182.     tcaprev,
  183.     tcapcres
  184. #if    COLOR
  185.     , tcapfcol,
  186.     tcapbcol
  187. #endif
  188. };
  189.  
  190. /*    input buffers and pointers    */
  191.  
  192. #define    IBUFSIZE    64    /* this must be a power of 2 */
  193.  
  194. unsigned char in_buf[IBUFSIZE];    /* input character buffer */
  195. int in_next = 0;        /* pos to retrieve next input character */
  196. int in_last = 0;        /* pos to place most recent input character */
  197.  
  198. in_init()    /* initialize the input buffer */
  199.  
  200. {
  201.     in_next = in_last = 0;
  202. }
  203.  
  204. in_check()    /* is the input buffer non-empty? */
  205.  
  206. {
  207.     if (in_next == in_last)
  208.         return(FALSE);
  209.     else
  210.         return(TRUE);
  211. }
  212.  
  213. in_put(event)
  214.  
  215. int event;    /* event to enter into the input buffer */
  216.  
  217. {
  218.     in_buf[in_last++] = event;
  219.     in_last &= (IBUFSIZE - 1);
  220. }
  221.  
  222. int in_get()    /* get an event from the input buffer */
  223.  
  224. {
  225.     register int event;    /* event to return */
  226.  
  227.     event = in_buf[in_next++];
  228.     in_next &= (IBUFSIZE - 1);
  229.     return(event);
  230. }
  231.  
  232. /*    Open the terminal
  233.     put it in RA mode
  234.     learn about the screen size
  235.     read TERMCAP strings for function keys
  236. */
  237.  
  238. tcapopen()
  239.  
  240. {
  241.     register int index;        /* general index */
  242.     char *t, *p;
  243.     char tcbuf[1024];
  244.     char *tv_stype;
  245.     char err_str[72];
  246.     char *getenv();
  247.     char *tgetstr();
  248.  
  249.     if ((tv_stype = getenv("TERM")) == NULL) {
  250.         puts(TEXT182);
  251. /*             "Environment variable TERM not defined!" */
  252.         meexit(1);
  253.     }
  254.  
  255.     if ((tgetent(tcbuf, tv_stype)) != 1) {
  256.         sprintf(err_str, TEXT183, tv_stype);
  257. /*                 "Unknown terminal type %s!" */
  258.         puts(err_str);
  259.         meexit(1);
  260.     }
  261.  
  262.  
  263.     if ((term.t_nrow=(short)tgetnum("li")-1) == -1) {
  264.            puts(TEXT184);
  265. /*            "termcap entry incomplete (lines)" */
  266.            meexit(1);
  267.     }
  268.     term.t_mrow =  term.t_nrow;
  269.  
  270.     if ((term.t_ncol=(short)tgetnum("co")) == -1){
  271.         puts(TEXT185);
  272. /*            "Termcap entry incomplete (columns)" */
  273.         meexit(1);
  274.     }
  275.     term.t_mcol = term.t_ncol;
  276.  
  277.     p = tcapbuf;
  278.     t = tgetstr("pc", &p);
  279.     if (t)
  280.         PC = *t;
  281.  
  282.     CL = tgetstr("cl", &p);
  283.     CM = tgetstr("cm", &p);
  284.     CE = tgetstr("ce", &p);
  285.     UP = tgetstr("up", &p);
  286.     SE = tgetstr("se", &p);
  287.     SO = tgetstr("so", &p);
  288.     if (SO != NULL)
  289.         revexist = TRUE;
  290.  
  291.     if (CL == NULL || CM == NULL || UP == NULL)
  292.     {
  293.         puts(TEXT186);
  294. /*             "Incomplete termcap entry\n" */
  295.         meexit(1);
  296.     }
  297.  
  298.     if (CE == NULL)     /* will we be able to use clear to EOL? */
  299.         eolexist = FALSE;
  300.          
  301.     IS = tgetstr("is", &p); /* extract init string */
  302.     KS = tgetstr("ks", &p); /* extract keypad transmit string */
  303.     KE = tgetstr("ke", &p); /* extract keypad transmit end string */
  304.             
  305.     /* read definitions of various function keys into ttable */
  306.     for (index = 0; index < NTBINDS; index++) {
  307.         strcpy(ttable[index].p_seq,
  308.             fixnull(tgetstr(ttable[index].p_name, &p)));
  309.     }
  310.  
  311.     /* tell unix we are goint to use the terminal */
  312.     ttopen();
  313.  
  314.     /* make sure we don't over run the buffer (TOO LATE I THINK) */
  315.     if (p >= &tcapbuf[TCAPSLEN]) {
  316.         puts(TEXT187);
  317. /*             "Terminal description too big!\n" */
  318.         meexit(1);
  319.     }
  320.  
  321.     /* send init strings if defined */
  322.     if (IS != NULL)
  323.         putpad(IS);
  324.  
  325.     if (KS != NULL)
  326.         putpad(KS);
  327.  
  328.     /* initialize the input buffer */
  329.     in_init();
  330. }
  331.  
  332. tcapclose()
  333. {
  334.     /* send end-of-keypad-transmit string if defined */
  335.     if (KE != NULL)
  336.         putpad(KE);
  337.     ttclose();
  338. }
  339.  
  340. tcapkopen()
  341.  
  342. {
  343.     strcpy(sres, "NORMAL");
  344. }
  345.  
  346. tcapkclose()
  347.  
  348. {
  349. }
  350.  
  351. unsigned int extcode(c)
  352.  
  353. unsigned int c;
  354.  
  355. {
  356.     return(c);
  357. }
  358.  
  359. /*    TCAPGETC:    Get on character.  Resolve and setup all the
  360.             appropriate keystroke escapes as defined in
  361.             the comments at the beginning of input.c
  362. */
  363.  
  364. int tcapgetc()
  365.  
  366. {
  367.     int c;        /* current extended keystroke */
  368.  
  369.     /* if there are already keys waiting.... send them */
  370.     if (in_check())
  371.         return(in_get());
  372.  
  373.     /* otherwise... get the char for now */
  374.     c = get1key();
  375.  
  376.     /* unfold the control bit back into the character */
  377.     if (CTRL & c)
  378.         c = (c & ~ CTRL) - '@';
  379.  
  380.     /* fold the event type into the input stream as an escape seq */
  381.     if ((c & ~255) != 0) {
  382.         in_put(0);        /* keyboard escape prefix */
  383.         in_put(c >> 8);        /* event type */
  384.         in_put(c & 255);    /* event code */
  385.         return(tcapgetc());
  386.     }
  387.  
  388.     return(c);
  389. }
  390.  
  391. /*    GET1KEY:    Get one keystroke. The only prefixs legal here
  392.             are the SPEC and CTRL prefixes.
  393.  
  394.     Note:
  395.  
  396.         Escape sequences that are generated by terminal function
  397.         and cursor keys could be confused with the user typing
  398.         the default META prefix followed by other chars... ie
  399.  
  400.         UPARROW  =  <ESC>A   on some terminals...
  401.         apropos  =  M-A
  402.  
  403.         The difference is determined by measuring the time between
  404.         the input of the first and second character... if an <ESC>
  405.         is types, and is not followed by another char in 1/30 of
  406.         a second (think 300 baud) then it is a user input, otherwise
  407.         it was generated by an escape sequence and should be SPECed.
  408. */
  409.  
  410. int PASCAL NEAR get1key()
  411.  
  412. {
  413.     register int c;
  414.     register int index;    /* index into termcap binding table */
  415.     char *sp;
  416. #if    BSD | V7 | HPUX
  417.     int fdset;
  418.     struct timeval timeout;
  419. #endif
  420.     char cseq[10];        /* current sequence being parsed */
  421.  
  422.     c = ttgetc();
  423.  
  424.     /* if it is not an escape character */
  425.     if (c != 27)
  426.             return(c);
  427.  
  428.     /* process a possible escape sequence */
  429.     /* set up to check the keyboard for input */
  430. #if    BSD | V7 | HPUX
  431.     fdset = 1;
  432.     timeout.tv_sec = 0;
  433.     timeout.tv_usec = 35000L;
  434.  
  435.     /* check to see if things are pending soon */
  436.     if (kbdmode != PLAY &&
  437.         select(1, &fdset, (int *)NULL, (int *)NULL, &timeout) == 0)
  438.         return(CTRL | '[');
  439. #endif
  440.  
  441. #if XENIX | SUNOS
  442.     if ((kbdmode != PLAY) && (rdchk(0) <= 0)) {
  443.         nap(35000L);
  444.         if (rdchk(0) <= 0)
  445.             return(CTRL | '[');
  446.     }
  447. #endif
  448.  
  449. #if    USG
  450.     /* we don't know how to do this check for a pending char within
  451.        1/30th of a second machine independantly in the general System V
  452.        case.... so we don't */
  453.     if (kbdmode != PLAY)
  454.         return(CTRL | '[');
  455. #endif
  456.  
  457.     /* a key is pending within 1/30 of a sec... its an escape sequence */
  458.     cseq[0] = 27;
  459.     sp = &cseq[1];
  460.     while (sp < &cseq[6]) {
  461.         c = ttgetc();
  462.         *sp++ = c;
  463.         *sp = 0;
  464.         for (index = 0; index < NTBINDS; index++) {
  465.             if (strcmp(cseq, ttable[index].p_seq) == 0)
  466.                 return(ttable[index].p_code);
  467.         }
  468.     }
  469.     return(SPEC | 0);
  470. }
  471.  
  472. tcapmove(row, col)
  473. register int row, col;
  474. {
  475.     putpad(tgoto(CM, col, row));
  476. }
  477.  
  478. tcapeeol()
  479. {
  480.     putpad(CE);
  481. }
  482.  
  483. tcapeeop()
  484. {
  485.     putpad(CL);
  486. }
  487.  
  488. tcaprev(state)        /* change reverse video status */
  489.  
  490. int state;        /* FALSE = normal video, TRUE = reverse video */
  491.  
  492. {
  493. /*    static int revstate = FALSE;*/
  494.  
  495.     if (state) {
  496.         if (SO != NULL)
  497.             putpad(SO);
  498.     } else
  499.         if (SE != NULL)
  500.             putpad(SE);
  501. }
  502.  
  503. tcapcres()    /* change screen resolution */
  504.  
  505. {
  506.     return(TRUE);
  507. }
  508.  
  509. spal(dummy)    /* change palette string */
  510.  
  511. {
  512.     /*    Does nothing here    */
  513. }
  514.  
  515. #if    COLOR
  516. tcapfcol()    /* no colors here, ignore this */
  517. {
  518. }
  519.  
  520. tcapbcol()    /* no colors here, ignore this */
  521. {
  522. }
  523. #endif
  524.  
  525. tcapbeep()
  526. {
  527.     ttputc(BEL);
  528. }
  529.  
  530. putpad(str)
  531. char    *str;
  532. {
  533.     tputs(str, 1, ttputc);
  534. }
  535.  
  536. putnpad(str, n)
  537. char    *str;
  538. {
  539.     tputs(str, n, ttputc);
  540. }
  541.  
  542.  
  543. #if    FLABEL
  544. fnclabel(f, n)        /* label a function key */
  545.  
  546. int f,n;    /* default flag, numeric argument [unused] */
  547.  
  548. {
  549.     /* on machines with no function keys...don't bother */
  550.     return(TRUE);
  551. }
  552. #endif
  553. #else
  554.  
  555. hello()
  556. {
  557. }
  558.  
  559. #endif
  560.