home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume1 / 8711 / microemacs-3.9 / 12 < prev    next >
Text File  |  1987-11-20  |  34KB  |  1,410 lines
  1. Article 89 of comp.sources.misc:
  2. Path: tut!osu-cis!cbosgd!mandrill!hal!ncoast!allbery
  3. From: nwd@j.cc.purdue.edu (Daniel Lawrence)
  4. Newsgroups: comp.sources.misc
  5. Subject: MicroEmacs 3.9 (Part 12 of 16)
  6. Message-ID: <5688@ncoast.UUCP>
  7. Date: 17 Nov 87 02:34:43 GMT
  8. Sender: allbery@ncoast.UUCP
  9. Lines: 1395
  10. Approved: allbery@ncoast.UUCP
  11. X-Archive: comp.sources.misc/microemacs-3.9/11
  12.  
  13. # This is a shar archive.
  14. # Remove everything above this line.
  15. # Run the file through sh, not csh.
  16. # (type `sh mes.12')
  17. # If you do not see the message
  18. #    `mes.12 completed!'
  19. # then the file was incomplete.
  20. echo extracting - tcap.c
  21. sed 's/^X//' > tcap.c << 'FRIDAY_NIGHT'
  22. X/*    tcap:    Unix V5, V7 and BS4.2 Termcap video driver
  23. X        for MicroEMACS
  24. X*/
  25. X
  26. X#define    termdef    1            /* don't define "term" external */
  27. X
  28. X#include <stdio.h>
  29. X#include    "estruct.h"
  30. X#include        "edef.h"
  31. X
  32. X#if TERMCAP
  33. X
  34. X#define    MARGIN    8
  35. X#define    SCRSIZ    64
  36. X#define    NPAUSE    10            /* # times thru update to pause */
  37. X#define BEL     0x07
  38. X#define ESC     0x1B
  39. X
  40. Xextern int      ttopen();
  41. Xextern int      ttgetc();
  42. Xextern int      ttputc();
  43. Xextern int    tgetnum();
  44. Xextern int      ttflush();
  45. Xextern int      ttclose();
  46. Xextern int    tcapkopen();
  47. Xextern int    tcapkclose();
  48. Xextern int      tcapmove();
  49. Xextern int      tcapeeol();
  50. Xextern int      tcapeeop();
  51. Xextern int      tcapbeep();
  52. Xextern int    tcaprev();
  53. Xextern int    tcapcres();
  54. Xextern int      tcapopen();
  55. Xextern int      tput();
  56. Xextern char     *tgoto();
  57. X#if    COLOR
  58. Xextern    int    tcapfcol();
  59. Xextern    int    tcapbcol();
  60. X#endif
  61. X
  62. X#define TCAPSLEN 315
  63. Xchar tcapbuf[TCAPSLEN];
  64. Xchar *UP, PC, *CM, *CE, *CL, *SO, *SE;
  65. X
  66. XTERM term = {
  67. X    NULL,    /* these four values are set dynamically at open time */
  68. X    NULL,
  69. X    NULL,
  70. X    NULL,
  71. X    MARGIN,
  72. X    SCRSIZ,
  73. X    NPAUSE,
  74. X        tcapopen,
  75. X        ttclose,
  76. X        tcapkopen,
  77. X        tcapkclose,
  78. X        ttgetc,
  79. X        ttputc,
  80. X        ttflush,
  81. X        tcapmove,
  82. X        tcapeeol,
  83. X        tcapeeop,
  84. X        tcapbeep,
  85. X        tcaprev,
  86. X        tcapcres
  87. X#if    COLOR
  88. X    , tcapfcol,
  89. X    tcapbcol
  90. X#endif
  91. X};
  92. X
  93. Xtcapopen()
  94. X
  95. X{
  96. X        char *getenv();
  97. X        char *t, *p, *tgetstr();
  98. X        char tcbuf[1024];
  99. X        char *tv_stype;
  100. X        char err_str[72];
  101. X
  102. X        if ((tv_stype = getenv("TERM")) == NULL)
  103. X        {
  104. X                puts("Environment variable TERM not defined!");
  105. X                exit(1);
  106. X        }
  107. X
  108. X        if ((tgetent(tcbuf, tv_stype)) != 1)
  109. X        {
  110. X                sprintf(err_str, "Unknown terminal type %s!", tv_stype);
  111. X                puts(err_str);
  112. X                exit(1);
  113. X        }
  114. X
  115. X 
  116. X       if ((term.t_nrow=(short)tgetnum("li")-1) == -1){
  117. X               puts("termcap entry incomplete (lines)");
  118. X               exit(1);
  119. X       }
  120. X    term.t_mrow =  term.t_nrow;
  121. X
  122. X       if ((term.t_ncol=(short)tgetnum("co")) == -1){
  123. X               puts("Termcap entry incomplete (columns)");
  124. X               exit(1);
  125. X       }
  126. X    term.t_mcol = term.t_ncol;
  127. X
  128. X        p = tcapbuf;
  129. X        t = tgetstr("pc", &p);
  130. X        if(t)
  131. X                PC = *t;
  132. X
  133. X        CL = tgetstr("cl", &p);
  134. X        CM = tgetstr("cm", &p);
  135. X        CE = tgetstr("ce", &p);
  136. X        UP = tgetstr("up", &p);
  137. X    SE = tgetstr("se", &p);
  138. X    SO = tgetstr("so", &p);
  139. X    if (SO != NULL)
  140. X        revexist = TRUE;
  141. X
  142. X        if(CL == NULL || CM == NULL || UP == NULL)
  143. X        {
  144. X                puts("Incomplete termcap entry\n");
  145. X                exit(1);
  146. X        }
  147. X
  148. X    if (CE == NULL)        /* will we be able to use clear to EOL? */
  149. X        eolexist = FALSE;
  150. X        
  151. X        if (p >= &tcapbuf[TCAPSLEN])
  152. X        {
  153. X                puts("Terminal description too big!\n");
  154. X                exit(1);
  155. X        }
  156. X        ttopen();
  157. X}
  158. X
  159. Xtcapkopen()
  160. X
  161. X{
  162. X    strcpy(sres, "NORMAL");
  163. X}
  164. X
  165. Xtcapkclose()
  166. X
  167. X{
  168. X}
  169. X
  170. Xtcapmove(row, col)
  171. Xregister int row, col;
  172. X{
  173. X        putpad(tgoto(CM, col, row));
  174. X}
  175. X
  176. Xtcapeeol()
  177. X{
  178. X        putpad(CE);
  179. X}
  180. X
  181. Xtcapeeop()
  182. X{
  183. X        putpad(CL);
  184. X}
  185. X
  186. Xtcaprev(state)        /* change reverse video status */
  187. X
  188. Xint state;        /* FALSE = normal video, TRUE = reverse video */
  189. X
  190. X{
  191. X    static int revstate = FALSE;
  192. X    if (state) {
  193. X        if (SO != NULL)
  194. X            putpad(SO);
  195. X    } else
  196. X        if (SE != NULL)
  197. X            putpad(SE);
  198. X}
  199. X
  200. Xtcapcres()    /* change screen resolution */
  201. X
  202. X{
  203. X    return(TRUE);
  204. X}
  205. X
  206. Xspal(dummy)    /* change palette string */
  207. X
  208. X{
  209. X    /*    Does nothing here    */
  210. X}
  211. X
  212. X#if    COLOR
  213. Xtcapfcol()    /* no colors here, ignore this */
  214. X{
  215. X}
  216. X
  217. Xtcapbcol()    /* no colors here, ignore this */
  218. X{
  219. X}
  220. X#endif
  221. X
  222. Xtcapbeep()
  223. X{
  224. X    ttputc(BEL);
  225. X}
  226. X
  227. Xputpad(str)
  228. Xchar    *str;
  229. X{
  230. X    tputs(str, 1, ttputc);
  231. X}
  232. X
  233. Xputnpad(str, n)
  234. Xchar    *str;
  235. X{
  236. X    tputs(str, n, ttputc);
  237. X}
  238. X
  239. X
  240. X#if    FLABEL
  241. Xfnclabel(f, n)        /* label a function key */
  242. X
  243. Xint f,n;    /* default flag, numeric argument [unused] */
  244. X
  245. X{
  246. X    /* on machines with no function keys...don't bother */
  247. X    return(TRUE);
  248. X}
  249. X#endif
  250. X#else
  251. X
  252. Xhello()
  253. X{
  254. X}
  255. X
  256. X#endif
  257. FRIDAY_NIGHT
  258. echo extracting - termio.c
  259. sed 's/^X//' > termio.c << 'FRIDAY_NIGHT'
  260. X/*
  261. X * The functions in this file negotiate with the operating system for
  262. X * characters, and write characters in a barely buffered fashion on the display.
  263. X * All operating systems.
  264. X */
  265. X#include        <stdio.h>
  266. X#include    "estruct.h"
  267. X#include        "edef.h"
  268. X
  269. X#if   MSDOS & TURBO
  270. X#include <conio.h>
  271. X#endif
  272. X
  273. X#if     AMIGA
  274. X#define NEW 1006L
  275. X#define AMG_MAXBUF      1024L
  276. Xstatic long terminal;
  277. Xstatic char     scrn_tmp[AMG_MAXBUF+1];
  278. Xstatic long     scrn_tmp_p = 0;
  279. X#endif
  280. X
  281. X#if     VMS
  282. X#include        <stsdef.h>
  283. X#include        <ssdef.h>
  284. X#include        <descrip.h>
  285. X#include        <iodef.h>
  286. X#include        <ttdef.h>
  287. X#include    <tt2def.h>
  288. X
  289. X#define NIBUF   128                     /* Input buffer size            */
  290. X#define NOBUF   1024                    /* MM says bug buffers win!     */
  291. X#define EFN     0                       /* Event flag                   */
  292. X
  293. Xchar    obuf[NOBUF];                    /* Output buffer                */
  294. Xint     nobuf;                  /* # of bytes in above    */
  295. Xchar    ibuf[NIBUF];                    /* Input buffer          */
  296. Xint     nibuf;                  /* # of bytes in above  */
  297. Xint     ibufi;                  /* Read index                   */
  298. Xint     oldmode[3];                     /* Old TTY mode bits            */
  299. Xint     newmode[3];                     /* New TTY mode bits            */
  300. Xshort   iochan;                  /* TTY I/O channel             */
  301. X#endif
  302. X
  303. X#if     CPM
  304. X#include        <bdos.h>
  305. X#endif
  306. X
  307. X#if     MSDOS & (LATTICE | MSC | TURBO | AZTEC | MWC86)
  308. Xunion REGS rg;        /* cpu register for use of DOS calls */
  309. Xint nxtchar = -1;    /* character held from type ahead    */
  310. X#endif
  311. X
  312. X#if RAINBOW
  313. X#include "rainbow.h"
  314. X#endif
  315. X
  316. X#if    USG            /* System V */
  317. X#include    <signal.h>
  318. X#include    <termio.h>
  319. X#include    <fcntl.h>
  320. Xint kbdflgs;            /* saved keyboard fd flags    */
  321. Xint kbdpoll;            /* in O_NDELAY mode            */
  322. Xint kbdqp;            /* there is a char in kbdq    */
  323. Xchar kbdq;            /* char we've already read    */
  324. Xstruct    termio    otermio;    /* original terminal characteristics */
  325. Xstruct    termio    ntermio;    /* charactoristics to use inside */
  326. X#endif
  327. X
  328. X#if V7 | BSD
  329. X#undef    CTRL
  330. X#include        <sgtty.h>        /* for stty/gtty functions */
  331. X#include    <signal.h>
  332. Xstruct  sgttyb  ostate;          /* saved tty state */
  333. Xstruct  sgttyb  nstate;          /* values for editor mode */
  334. Xstruct tchars    otchars;    /* Saved terminal special character set */
  335. Xstruct tchars    ntchars = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
  336. X                /* A lot of nothing */
  337. X#if BSD
  338. X#include <sys/ioctl.h>        /* to get at the typeahead */
  339. Xextern    int rtfrmshell();    /* return from suspended shell */
  340. X#define    TBUFSIZ    128
  341. Xchar tobuf[TBUFSIZ];        /* terminal output buffer */
  342. X#endif
  343. X#endif
  344. X
  345. X/*
  346. X * This function is called once to set up the terminal device streams.
  347. X * On VMS, it translates TT until it finds the terminal, then assigns
  348. X * a channel to it and sets it raw. On CPM it is a no-op.
  349. X */
  350. Xttopen()
  351. X{
  352. X#if     AMIGA
  353. X    char oline[NSTRING];
  354. X#if    AZTEC
  355. X    extern    Enable_Abort;    /* Turn off ctrl-C interrupt */
  356. X
  357. X    Enable_Abort = 0;    /* for the Manx compiler */
  358. X#endif
  359. X    strcpy(oline, "RAW:0/0/640/200/");
  360. X    strcat(oline, PROGNAME);
  361. X    strcat(oline, " ");
  362. X    strcat(oline, VERSION);
  363. X    strcat(oline, "/Amiga");
  364. X        terminal = Open(oline, NEW);
  365. X#endif
  366. X#if     VMS
  367. X        struct  dsc$descriptor  idsc;
  368. X        struct  dsc$descriptor  odsc;
  369. X        char    oname[40];
  370. X        int     iosb[2];
  371. X        int     status;
  372. X
  373. X        odsc.dsc$a_pointer = "TT";
  374. X        odsc.dsc$w_length  = strlen(odsc.dsc$a_pointer);
  375. X        odsc.dsc$b_dtype        = DSC$K_DTYPE_T;
  376. X        odsc.dsc$b_class        = DSC$K_CLASS_S;
  377. X        idsc.dsc$b_dtype        = DSC$K_DTYPE_T;
  378. X        idsc.dsc$b_class        = DSC$K_CLASS_S;
  379. X        do {
  380. X                idsc.dsc$a_pointer = odsc.dsc$a_pointer;
  381. X                idsc.dsc$w_length  = odsc.dsc$w_length;
  382. X                odsc.dsc$a_pointer = &oname[0];
  383. X                odsc.dsc$w_length  = sizeof(oname);
  384. X                status = LIB$SYS_TRNLOG(&idsc, &odsc.dsc$w_length, &odsc);
  385. X                if (status!=SS$_NORMAL && status!=SS$_NOTRAN)
  386. X                        exit(status);
  387. X                if (oname[0] == 0x1B) {
  388. X                        odsc.dsc$a_pointer += 4;
  389. X                        odsc.dsc$w_length  -= 4;
  390. X                }
  391. X        } while (status == SS$_NORMAL);
  392. X        status = SYS$ASSIGN(&odsc, &iochan, 0, 0);
  393. X        if (status != SS$_NORMAL)
  394. X                exit(status);
  395. X        status = SYS$QIOW(EFN, iochan, IO$_SENSEMODE, iosb, 0, 0,
  396. X                          oldmode, sizeof(oldmode), 0, 0, 0, 0);
  397. X        if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL)
  398. X                exit(status);
  399. X        newmode[0] = oldmode[0];
  400. X        newmode[1] = oldmode[1] | TT$M_NOECHO;
  401. X        newmode[1] &= ~(TT$M_TTSYNC|TT$M_HOSTSYNC);
  402. X        newmode[2] = oldmode[2] | TT2$M_PASTHRU;
  403. X        status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0,
  404. X                          newmode, sizeof(newmode), 0, 0, 0, 0);
  405. X        if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL)
  406. X                exit(status);
  407. X        term.t_nrow = (newmode[1]>>24) - 1;
  408. X        term.t_ncol = newmode[0]>>16;
  409. X
  410. X#endif
  411. X#if     CPM
  412. X#endif
  413. X
  414. X#if     MSDOS & (HP150 == 0) & LATTICE
  415. X    /* kill the ctrl-break interupt */
  416. X    rg.h.ah = 0x33;        /* control-break check dos call */
  417. X    rg.h.al = 1;        /* set the current state */
  418. X    rg.h.dl = 0;        /* set it OFF */
  419. X    intdos(&rg, &rg);    /* go for it! */
  420. X#endif
  421. X
  422. X#if    USG
  423. X    ioctl(0, TCGETA, &otermio);    /* save old settings */
  424. X    ntermio.c_iflag = 0;        /* setup new settings */
  425. X    ntermio.c_oflag = 0;
  426. X    ntermio.c_cflag = otermio.c_cflag;
  427. X    ntermio.c_lflag = 0;
  428. X    ntermio.c_line = otermio.c_line;
  429. X    ntermio.c_cc[VMIN] = 1;
  430. X    ntermio.c_cc[VTIME] = 0;
  431. X    ioctl(0, TCSETA, &ntermio);    /* and activate them */
  432. X    kbdflgs = fcntl( 0, F_GETFL, 0 );
  433. X    kbdpoll = FALSE;
  434. X#endif
  435. X
  436. X#if     V7 | BSD
  437. X        gtty(0, &ostate);                       /* save old state */
  438. X        gtty(0, &nstate);                       /* get base of new state */
  439. X        nstate.sg_flags |= RAW;
  440. X        nstate.sg_flags &= ~(ECHO|CRMOD);       /* no echo for now... */
  441. X        stty(0, &nstate);                       /* set mode */
  442. X    ioctl(0, TIOCGETC, &otchars);        /* Save old characters */
  443. X    ioctl(0, TIOCSETC, &ntchars);        /* Place new character into K */
  444. X#if    BSD
  445. X    /* provide a smaller terminal output buffer so that
  446. X       the type ahead detection works better (more often) */
  447. X    setbuffer(stdout, &tobuf[0], TBUFSIZ);
  448. X    signal(SIGTSTP,SIG_DFL);    /* set signals so that we can */
  449. X    signal(SIGCONT,rtfrmshell);    /* suspend & restart emacs */
  450. X#endif
  451. X#endif
  452. X    /* on all screens we are not sure of the initial position
  453. X       of the cursor                    */
  454. X    ttrow = 999;
  455. X    ttcol = 999;
  456. X}
  457. X
  458. X/*
  459. X * This function gets called just before we go back home to the command
  460. X * interpreter. On VMS it puts the terminal back in a reasonable state.
  461. X * Another no-operation on CPM.
  462. X */
  463. Xttclose()
  464. X{
  465. X#if     AMIGA
  466. X#if    LATTICE
  467. X        amg_flush();
  468. X        Close(terminal);
  469. X#endif
  470. X#if    AZTEC
  471. X        amg_flush();
  472. X    Enable_Abort = 1;    /* Fix for Manx */
  473. X        Close(terminal);
  474. X#endif
  475. X#endif
  476. X
  477. X#if     VMS
  478. X        int     status;
  479. X        int     iosb[1];
  480. X
  481. X        ttflush();
  482. X        status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0,
  483. X                 oldmode, sizeof(oldmode), 0, 0, 0, 0);
  484. X        if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL)
  485. X                exit(status);
  486. X        status = SYS$DASSGN(iochan);
  487. X        if (status != SS$_NORMAL)
  488. X                exit(status);
  489. X#endif
  490. X#if     CPM
  491. X#endif
  492. X#if     MSDOS & (HP150 == 0) & LATTICE
  493. X    /* restore the ctrl-break interupt */
  494. X    rg.h.ah = 0x33;        /* control-break check dos call */
  495. X    rg.h.al = 1;        /* set the current state */
  496. X    rg.h.dl = 1;        /* set it ON */
  497. X    intdos(&rg, &rg);    /* go for it! */
  498. X#endif
  499. X
  500. X#if    USG
  501. X    ioctl(0, TCSETA, &otermio);    /* restore terminal settings */
  502. X    fcntl(0, F_SETFL, kbdflgs);
  503. X#endif
  504. X
  505. X#if     V7 | BSD
  506. X        stty(0, &ostate);
  507. X    ioctl(0, TIOCSETC, &otchars);    /* Place old character into K */
  508. X#endif
  509. X}
  510. X
  511. X/*
  512. X * Write a character to the display. On VMS, terminal output is buffered, and
  513. X * we just put the characters in the big array, after checking for overflow.
  514. X * On CPM terminal I/O unbuffered, so we just write the byte out. Ditto on
  515. X * MS-DOS (use the very very raw console output routine).
  516. X */
  517. Xttputc(c)
  518. X#if     AMIGA
  519. X        char c;
  520. X#endif
  521. X{
  522. X#if     AMIGA
  523. X        scrn_tmp[scrn_tmp_p++] = c;
  524. X        if(scrn_tmp_p>=AMG_MAXBUF)
  525. X                amg_flush();
  526. X#endif
  527. X#if     VMS
  528. X        if (nobuf >= NOBUF)
  529. X                ttflush();
  530. X        obuf[nobuf++] = c;
  531. X#endif
  532. X
  533. X#if     CPM
  534. X        bios(BCONOUT, c, 0);
  535. X#endif
  536. X
  537. X#if     MSDOS & MWC86
  538. X        putcnb(c);
  539. X#endif
  540. X
  541. X#if    MSDOS & (LATTICE | AZTEC) & ~IBMPC
  542. X    bdos(6, c, 0);
  543. X#endif
  544. X
  545. X#if RAINBOW
  546. X        Put_Char(c);                    /* fast video */
  547. X#endif
  548. X
  549. X
  550. X#if     V7 | USG | BSD
  551. X        fputc(c, stdout);
  552. X#endif
  553. X}
  554. X
  555. X#if    AMIGA
  556. Xamg_flush()
  557. X{
  558. X        if(scrn_tmp_p)
  559. X                Write(terminal,scrn_tmp,scrn_tmp_p);
  560. X        scrn_tmp_p = 0;
  561. X}
  562. X#endif
  563. X
  564. X/*
  565. X * Flush terminal buffer. Does real work where the terminal output is buffered
  566. X * up. A no-operation on systems where byte at a time terminal I/O is done.
  567. X */
  568. Xttflush()
  569. X{
  570. X#if     AMIGA
  571. X        amg_flush();
  572. X#endif
  573. X#if     VMS
  574. X        int     status;
  575. X        int     iosb[2];
  576. X
  577. X        status = SS$_NORMAL;
  578. X        if (nobuf != 0) {
  579. X                status = SYS$QIOW(EFN, iochan, IO$_WRITELBLK|IO$M_NOFORMAT,
  580. X                         iosb, 0, 0, obuf, nobuf, 0, 0, 0, 0);
  581. X                if (status == SS$_NORMAL)
  582. X                        status = iosb[0] & 0xFFFF;
  583. X                nobuf = 0;
  584. X        }
  585. X        return (status);
  586. X#endif
  587. X
  588. X#if     CPM
  589. X#endif
  590. X
  591. X#if     MSDOS
  592. X#endif
  593. X
  594. X#if     V7 | USG | BSD
  595. X        fflush(stdout);
  596. X#endif
  597. X}
  598. X
  599. X/*
  600. X * Read a character from the terminal, performing no editing and doing no echo
  601. X * at all. More complex in VMS that almost anyplace else, which figures. Very
  602. X * simple on CPM, because the system can do exactly what you want.
  603. X */
  604. Xttgetc()
  605. X{
  606. X#if     AMIGA
  607. X        char ch;
  608. X        amg_flush();
  609. X        Read(terminal, &ch, 1L);
  610. X        return(255 & (int)ch);
  611. X#endif
  612. X#if     VMS
  613. X        int     status;
  614. X        int     iosb[2];
  615. X        int     term[2];
  616. X
  617. X        while (ibufi >= nibuf) {
  618. X                ibufi = 0;
  619. X                term[0] = 0;
  620. X                term[1] = 0;
  621. X                status = SYS$QIOW(EFN, iochan, IO$_READLBLK|IO$M_TIMED,
  622. X                         iosb, 0, 0, ibuf, NIBUF, 0, term, 0, 0);
  623. X                if (status != SS$_NORMAL)
  624. X                        exit(status);
  625. X                status = iosb[0] & 0xFFFF;
  626. X                if (status!=SS$_NORMAL && status!=SS$_TIMEOUT)
  627. X                        exit(status);
  628. X                nibuf = (iosb[0]>>16) + (iosb[1]>>16);
  629. X                if (nibuf == 0) {
  630. X                        status = SYS$QIOW(EFN, iochan, IO$_READLBLK,
  631. X                                 iosb, 0, 0, ibuf, 1, 0, term, 0, 0);
  632. X                        if (status != SS$_NORMAL
  633. X                        || (status = (iosb[0]&0xFFFF)) != SS$_NORMAL)
  634. X                                exit(status);
  635. X                        nibuf = (iosb[0]>>16) + (iosb[1]>>16);
  636. X                }
  637. X        }
  638. X        return (ibuf[ibufi++] & 0xFF);    /* Allow multinational  */
  639. X#endif
  640. X
  641. X#if     CPM
  642. X        return (biosb(BCONIN, 0, 0));
  643. X#endif
  644. X
  645. X#if RAINBOW
  646. X        int Ch;
  647. X
  648. X        while ((Ch = Read_Keyboard()) < 0);
  649. X
  650. X        if ((Ch & Function_Key) == 0)
  651. X                if (!((Ch & 0xFF) == 015 || (Ch & 0xFF) == 0177))
  652. X                        Ch &= 0xFF;
  653. X
  654. X        return Ch;
  655. X#endif
  656. X
  657. X#if     MSDOS & MWC86
  658. X        return (getcnb());
  659. X#endif
  660. X
  661. X#if    MSDOS & (LATTICE | MSC | TURBO | AZTEC)
  662. X    int c;        /* character read */
  663. X
  664. X    /* if a char already is ready, return it */
  665. X    if (nxtchar >= 0) {
  666. X        c = nxtchar;
  667. X        nxtchar = -1;
  668. X        return(c);
  669. X    }
  670. X
  671. X    /* call the dos to get a char */
  672. X    rg.h.ah = 7;        /* dos Direct Console Input call */
  673. X    intdos(&rg, &rg);
  674. X    c = rg.h.al;        /* grab the char */
  675. X    return(c & 255);
  676. X#endif
  677. X
  678. X#if     V7 | BSD
  679. X        return(127 & fgetc(stdin));
  680. X#endif
  681. X
  682. X#if    USG
  683. X    if( kbdqp )
  684. X        kbdqp = FALSE;
  685. X    else
  686. X    {
  687. X        if( kbdpoll && fcntl( 0, F_SETFL, kbdflgs ) < 0 )
  688. X            return FALSE;
  689. X        kbdpoll = FALSE;
  690. X        while (read(0, &kbdq, 1) != 1)
  691. X            ;
  692. X    }
  693. X    return ( kbdq & 127 );
  694. X#endif
  695. X}
  696. X
  697. X#if    TYPEAH & (~ST520)
  698. X/* typahead:    Check to see if any characters are already in the
  699. X        keyboard buffer
  700. X*/
  701. X
  702. Xtypahead()
  703. X
  704. X{
  705. X#if    MSDOS & (MSC | TURBO)
  706. X    if (kbhit() != 0)
  707. X        return(TRUE);
  708. X    else
  709. X        return(FALSE);
  710. X#endif
  711. X
  712. X#if    MSDOS & (LATTICE | AZTEC | MWC86)
  713. X    int c;        /* character read */
  714. X    int flags;    /* cpu flags from dos call */
  715. X
  716. X    if (nxtchar >= 0)
  717. X        return(TRUE);
  718. X
  719. X    rg.h.ah = 6;    /* Direct Console I/O call */
  720. X    rg.h.dl = 255;    /*         does console input */
  721. X#if    LATTICE | AZTEC
  722. X    flags = intdos(&rg, &rg);
  723. X#else
  724. X    intcall(&rg, &rg, 0x21);
  725. X    flags = rg.x.flags;
  726. X#endif
  727. X    c = rg.h.al;    /* grab the character */
  728. X
  729. X    /* no character pending */
  730. X    if ((flags & 64) != 0)
  731. X        return(FALSE);
  732. X
  733. X    /* save the character and return true */
  734. X    nxtchar = c;
  735. X    return(TRUE);
  736. X#endif
  737. X
  738. X#if    BSD
  739. X    int x;    /* holds # of pending chars */
  740. X
  741. X    return((ioctl(0,FIONREAD,&x) < 0) ? 0 : x);
  742. X#endif
  743. X
  744. X#if    USG
  745. X    if( !kbdqp )
  746. X    {
  747. X        if( !kbdpoll && fcntl( 0, F_SETFL, kbdflgs | O_NDELAY ) < 0 )
  748. X            return(FALSE);
  749. X        kbdqp = (1 == read( 0, &kbdq, 1 ));
  750. X    }
  751. X    return ( kbdqp );
  752. X#endif
  753. X    return(FALSE);
  754. X}
  755. X#endif
  756. X
  757. FRIDAY_NIGHT
  758. echo extracting - tipc.c
  759. sed 's/^X//' > tipc.c << 'FRIDAY_NIGHT'
  760. X/*
  761. X * The routines in this file provide support for the TI-PC and other
  762. X * compatible terminals. It goes directly to the graphics RAM to do
  763. X * screen output. It compiles into nothing if not a TI-PC driver
  764. X */
  765. X
  766. X#define termdef 1                       /* don't define "term" external */
  767. X
  768. X#include        <stdio.h>
  769. X#include        "estruct.h"
  770. X#include        "edef.h"
  771. X
  772. X#if     TIPC
  773. X
  774. X#define NROW    25                      /* Screen size.                 */
  775. X#define NCOL    80                      /* Edit if you want to.         */
  776. X#define MARGIN  8                       /* size of minimim margin and   */
  777. X#define SCRSIZ  64                      /* scroll size for extended lines */
  778. X#define NPAUSE  200                     /* # times thru update to pause */
  779. X#define BEL     0x07                    /* BEL character.               */
  780. X#define ESC     0x1B                    /* ESC character.               */
  781. X#define SPACE   32                      /* space character              */
  782. X#define SCADD   0xDE000L                /* address of screen RAM        */
  783. X
  784. X#define CHAR_ENABLE     0x08            /* TI attribute to show char    */
  785. X#define TI_REVERSE      0x10            /* TI attribute to reverse char */
  786. X#define BLACK   0+CHAR_ENABLE           /* TI attribute for Black       */
  787. X#define BLUE    1+CHAR_ENABLE           /* TI attribute for Blue        */
  788. X#define RED     2+CHAR_ENABLE           /* TI attribute for Red         */
  789. X#define MAGENTA 3+CHAR_ENABLE           /* TI attribute for Magenta     */
  790. X#define GREEN   4+CHAR_ENABLE           /* TI attribute for Green       */
  791. X#define CYAN    5+CHAR_ENABLE           /* TI attribute for Cyan        */
  792. X#define YELLOW  6+CHAR_ENABLE           /* TI attribute for Yellow      */
  793. X#define WHITE   7+CHAR_ENABLE           /* TI attribute for White       */
  794. X
  795. X
  796. Xextern  int     ttopen();               /* Forward references.          */
  797. Xextern  int     ttgetc();
  798. Xextern  int     ttputc();
  799. Xextern  int     ttflush();
  800. Xextern  int     ttclose();
  801. Xextern  int     timove();
  802. Xextern  int     tieeol();
  803. Xextern  int     tieeop();
  804. Xextern  int     tibeep();
  805. Xextern  int     tiopen();
  806. Xextern  int     tirev();
  807. Xextern    int    ticres();
  808. Xextern  int     ticlose();
  809. Xextern  int     tiputc();
  810. X
  811. X#if     COLOR
  812. Xextern  int     tifcol();
  813. Xextern  int     tibcol();
  814. X
  815. Xint     cfcolor = -1;           /* current forground color */
  816. Xint     cbcolor = -1;           /* current background color */
  817. Xint     ctrans[] =              /* ansi to ti color translation table */
  818. X        {BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE};
  819. X#endif
  820. X
  821. X/*
  822. X * Standard terminal interface dispatch table. Most of the fields point into
  823. X * "termio" code.
  824. X */
  825. XTERM    term    = {
  826. X    NROW-1,
  827. X        NROW-1,
  828. X        NCOL,
  829. X        NCOL,
  830. X        MARGIN,
  831. X        SCRSIZ,
  832. X        NPAUSE,
  833. X        tiopen,
  834. X        ticlose,
  835. X        ttgetc,
  836. X        tiputc,
  837. X        ttflush,
  838. X        timove,
  839. X        tieeol,
  840. X        tieeop,
  841. X        tibeep,
  842. X        tirev,
  843. X        ticres
  844. X#if     COLOR
  845. X        , tifcol,
  846. X        tibcol
  847. X#endif
  848. X};
  849. X
  850. Xextern union REGS rg;
  851. X
  852. X#if     COLOR
  853. Xsetatt( attr )
  854. Xint attr;
  855. X{
  856. X        rg.h.ah = 0x16;         /* set the forground character attribute */
  857. X        rg.h.bl = attr;
  858. X        int86( 0x49, &rg, &rg );
  859. X}
  860. X
  861. Xtifcol(color)           /* set the current output color */
  862. X
  863. Xint color;      /* color to set */
  864. X
  865. X{
  866. X        cfcolor = ctrans[color];
  867. X        setatt ( cfcolor );
  868. X}
  869. X
  870. Xtibcol(color)           /* set the current background color */
  871. X
  872. Xint color;      /* color to set */
  873. X
  874. X{
  875. X        cbcolor = ctrans[color];
  876. X}
  877. X#endif
  878. X
  879. Xtimove(row, col)
  880. X{
  881. X        rg.h.ah = 2;            /* set cursor position function code */
  882. X        rg.h.dh = col;
  883. X        rg.h.dl = row;
  884. X        int86(0x49, &rg, &rg);
  885. X}
  886. X
  887. Xtieeol()        /* erase to the end of the line */
  888. X
  889. X{
  890. X        int ccol;       /* current column cursor lives */
  891. X        int crow;       /*         row  */
  892. X
  893. X        /* find the current cursor position */
  894. X        rg.h.ah = 3;            /* read cursor position function code */
  895. X        int86(0x49, &rg, &rg);
  896. X        ccol = rg.h.dh;         /* record current column */
  897. X        crow = rg.h.dl;         /* and row */
  898. X
  899. X        rg.h.ah = 0x09;         /* Write character at cursor position */
  900. X        rg.h.al = ' ';          /* Space */
  901. X        rg.h.bl = cfcolor;
  902. X        rg.x.cx = NCOL-ccol;    /* Number of characters to write */
  903. X        int86(0x49, &rg, &rg);
  904. X
  905. X}
  906. X
  907. Xtiputc(ch)      /* put a character at the current position in the
  908. X                   current colors */
  909. X
  910. Xint ch;
  911. X
  912. X{
  913. X        rg.h.ah = 0x0E;         /* write char to screen with current attrs */
  914. X        rg.h.al = ch;
  915. X        int86(0x49, &rg, &rg);
  916. X}
  917. X
  918. Xtieeop()                        /* Actually a clear screen */
  919. X{
  920. X
  921. X        rg.h.ah = 0x13;         /* Clear Text Screen and Home Cursor */
  922. X        int86(0x49, &rg, &rg);
  923. X}
  924. X
  925. Xtirev(state)            /* change reverse video state */
  926. X
  927. Xint state;      /* TRUE = reverse, FALSE = normal */
  928. X
  929. X{
  930. X        setatt( state ? cbcolor : cfcolor  );
  931. X}
  932. X
  933. Xticres()    /* change screen resolution */
  934. X
  935. X{
  936. X    return(TRUE);
  937. X}
  938. X
  939. Xspal()        /* change palette string */
  940. X
  941. X{
  942. X    /*    Does nothing here    */
  943. X}
  944. X
  945. Xtibeep()
  946. X{
  947. X        bdos(6, BEL, 0);
  948. X}
  949. X
  950. Xtiopen()
  951. X{
  952. X    strcpy(sres, "NORMAL");
  953. X        revexist = TRUE;
  954. X        ttopen();
  955. X}
  956. X
  957. Xticlose()
  958. X
  959. X{
  960. X#if     COLOR
  961. X        tifcol(7);
  962. X        tibcol(0);
  963. X#endif
  964. X        ttclose();
  965. X}
  966. X#else
  967. Xtihello()
  968. X{
  969. X}
  970. X#endif
  971. X
  972. FRIDAY_NIGHT
  973. echo extracting - vmsvt.c
  974. sed 's/^X//' > vmsvt.c << 'FRIDAY_NIGHT'
  975. X/*
  976. X *  Advanced VMS terminal driver
  977. X *
  978. X *  Knows about any terminal defined in SMGTERMS.TXT and TERMTABLE.TXT
  979. X *  located in SYS$SYSTEM.
  980. X *
  981. X *  Author:  Curtis Smith
  982. X *  Last Updated: 07/14/87
  983. X */
  984. X
  985. X#include    <stdio.h>        /* Standard I/O package        */
  986. X#include    "estruct.h"        /* Emacs' structures        */
  987. X#include    "edef.h"        /* Emacs' definitions        */
  988. X
  989. X#if    VMSVT
  990. X
  991. X#include     <descrip.h>        /* Descriptor definitions    */
  992. X
  993. X/*  These would normally come from iodef.h and ttdef.h  */
  994. X#define IO$_SENSEMODE    0x27        /* Sense mode of terminal    */
  995. X#define TT$_UNKNOWN    0x00        /* Unknown terminal        */
  996. X
  997. X/** Forward references **/
  998. Xint vmsopen(), ttclose(), vmskopen(), vmskclose(), ttgetc(), ttputc();
  999. Xint ttflush(), vmsmove(), vmseeol(), vmseeop(), vmsbeep(), vmsrev();
  1000. Xint vmscres();
  1001. Xextern int eolexist, revexist;
  1002. Xextern char sres[];
  1003. X
  1004. X#if COLOR
  1005. Xint vmsfcol(), vmsbcol();
  1006. X#endif
  1007. X
  1008. X/** SMG stuff **/
  1009. Xstatic char * begin_reverse, * end_reverse, * erase_to_end_line;
  1010. Xstatic char * erase_whole_display;
  1011. Xstatic int termtype;
  1012. X
  1013. X#define SMG$K_BEGIN_REVERSE        0x1bf
  1014. X#define SMG$K_END_REVERSE        0x1d6
  1015. X#define SMG$K_SET_CURSOR_ABS        0x23a
  1016. X#define SMG$K_ERASE_WHOLE_DISPLAY    0x1da
  1017. X#define SMG$K_ERASE_TO_END_LINE        0x1d9
  1018. X
  1019. X
  1020. X/* Dispatch table. All hard fields just point into the terminal I/O code. */
  1021. XTERM    term    = {
  1022. X    24 - 1,                /* Max number of rows allowable */
  1023. X    /* Filled in */ - 1,        /* Current number of rows used    */
  1024. X    132,                /* Max number of columns    */
  1025. X    /* Filled in */ 0,        /* Current number of columns    */
  1026. X    64,                /* Min margin for extended lines*/
  1027. X    8,                /* Size of scroll region    */
  1028. X    100,                /* # times thru update to pause */
  1029. X    vmsopen,            /* Open terminal at the start    */
  1030. X    ttclose,            /* Close terminal at end    */
  1031. X    vmskopen,            /* Open keyboard        */
  1032. X    vmskclose,            /* Close keyboard        */
  1033. X    ttgetc,                /* Get character from keyboard    */
  1034. X    ttputc,                /* Put character to display    */
  1035. X    ttflush,            /* Flush output buffers        */
  1036. X    vmsmove,            /* Move cursor, origin 0    */
  1037. X    vmseeol,            /* Erase to end of line        */
  1038. X    vmseeop,            /* Erase to end of page        */
  1039. X    vmsbeep,            /* Beep                */
  1040. X    vmsrev,                /* Set reverse video state    */
  1041. X    vmscres                /* Change screen resolution    */
  1042. X#if    COLOR
  1043. X    , vmsfcol,            /* Set forground color        */
  1044. X    vmsbcol                /* Set background color        */
  1045. X#endif
  1046. X};
  1047. X
  1048. X/***
  1049. X *  ttputs  -  Send a string to ttputc
  1050. X *
  1051. X *  Nothing returned
  1052. X ***/
  1053. Xttputs(string)
  1054. Xchar * string;                /* String to write        */
  1055. X{
  1056. X    if (string)
  1057. X        while (*string != '\0')
  1058. X            ttputc(*string++);
  1059. X}
  1060. X
  1061. X
  1062. X/***
  1063. X *  vmsmove  -  Move the cursor (0 origin)
  1064. X *
  1065. X *  Nothing returned
  1066. X ***/
  1067. Xvmsmove(row, col)
  1068. Xint row;                /* Row position            */
  1069. Xint col;                /* Column position        */
  1070. X{
  1071. X    char buffer[32];
  1072. X    int ret_length;
  1073. X    static int request_code = SMG$K_SET_CURSOR_ABS;
  1074. X    static int max_buffer_length = sizeof(buffer);
  1075. X    static int arg_list[3] = { 2 };
  1076. X    register char * cp;
  1077. X    
  1078. X    register int i;
  1079. X
  1080. X    /* Set the arguments into the arg_list array
  1081. X     * SMG assumes the row/column positions are 1 based (boo!)
  1082. X     */
  1083. X    arg_list[1] = row + 1;
  1084. X    arg_list[2] = col + 1;
  1085. X
  1086. X    if ((smg$get_term_data(        /* Get terminal data        */
  1087. X        &termtype,        /* Terminal table address    */
  1088. X        &request_code,        /* Request code            */
  1089. X        &max_buffer_length,    /* Maximum buffer length    */
  1090. X        &ret_length,        /* Return length        */
  1091. X        buffer,            /* Capability data buffer    */
  1092. X        arg_list)        /* Argument list array        */
  1093. X
  1094. X    /* We'll know soon enough if this doesn't work        */
  1095. X            & 1) == 0) {
  1096. X                ttputs("OOPS");
  1097. X                return;
  1098. X            }
  1099. X
  1100. X    /* Send out resulting sequence                */
  1101. X    i = ret_length;
  1102. X    cp = buffer;
  1103. X    while (i-- > 0)
  1104. X        ttputc(*cp++);
  1105. X}
  1106. X
  1107. X
  1108. X/***
  1109. X *  vmsrev  -  Set the reverse video status
  1110. X *
  1111. X *  Nothing returned
  1112. X ***/
  1113. Xvmsrev(status)
  1114. Xint status;                /* TRUE if setting reverse    */
  1115. X{
  1116. X    if (status)
  1117. X        ttputs(begin_reverse);
  1118. X    else 
  1119. X        ttputs(end_reverse);
  1120. X}
  1121. X
  1122. X/***
  1123. X *  vmscres  -  Change screen resolution (which it doesn't)
  1124. X *
  1125. X *  Nothing returned
  1126. X ***/
  1127. Xvmscres()
  1128. X{
  1129. X    /* But it could.  For vt100/vt200s, one could switch from
  1130. X    80 and 132 columns modes */
  1131. X}
  1132. X
  1133. X
  1134. X#if    COLOR
  1135. X/***
  1136. X *  vmsfcol  -  Set the forground color (not implimented)
  1137. X *
  1138. X *  Nothing returned
  1139. X ***/
  1140. Xvmsfcol()
  1141. X{
  1142. X}
  1143. X
  1144. X/***
  1145. X *  vmsbcol  -  Set the background color (not implimented)
  1146. X *
  1147. X *  Nothing returned
  1148. X ***/
  1149. Xvmsbcol()
  1150. X{
  1151. X}
  1152. X#endif
  1153. X
  1154. X/***
  1155. X *  vmseeol  -  Erase to end of line
  1156. X *
  1157. X *  Nothing returned
  1158. X ***/
  1159. Xvmseeol()
  1160. X{
  1161. X    ttputs(erase_to_end_line);
  1162. X}
  1163. X
  1164. X
  1165. X/***
  1166. X *  vmseeop  -  Erase to end of page (clear screen)
  1167. X *
  1168. X *  Nothing returned
  1169. X ***/
  1170. Xvmseeop()
  1171. X{
  1172. X    ttputs(erase_whole_display);
  1173. X}
  1174. X
  1175. X
  1176. X/***
  1177. X *  vmsbeep  -  Ring the bell
  1178. X *
  1179. X *  Nothing returned
  1180. X ***/
  1181. Xvmsbeep()
  1182. X{
  1183. X    ttputc('\007');
  1184. X}
  1185. X
  1186. X
  1187. X/***
  1188. X *  vmsgetstr  -  Get an SMG string capability by name
  1189. X *
  1190. X *  Returns:    Escape sequence
  1191. X *        NULL    No escape sequence available
  1192. X ***/ 
  1193. Xchar * vmsgetstr(request_code)
  1194. Xint request_code;            /* Request code            */
  1195. X{
  1196. X    register char * result;
  1197. X    static char seq_storage[1024];
  1198. X    static char * buffer = seq_storage;
  1199. X    static int arg_list[2] = { 1, 1 };
  1200. X    int max_buffer_length, ret_length;
  1201. X
  1202. X    /*  Precompute buffer length */
  1203. X    
  1204. X    max_buffer_length = (seq_storage + sizeof(seq_storage)) - buffer;
  1205. X
  1206. X    /* Get terminal commands sequence from master table */
  1207. X
  1208. X    if ((smg$get_term_data(    /* Get terminal data        */
  1209. X        &termtype,    /* Terminal table address    */
  1210. X        &request_code,    /* Request code            */
  1211. X        &max_buffer_length,/* Maximum buffer length    */
  1212. X        &ret_length,    /* Return length        */
  1213. X        buffer,        /* Capability data buffer    */
  1214. X        arg_list)    /* Argument list array        */
  1215. X
  1216. X    /* If this doesn't work, try again with no arguments */
  1217. X    
  1218. X        & 1) == 0 && 
  1219. X
  1220. X        (smg$get_term_data(    /* Get terminal data        */
  1221. X            &termtype,    /* Terminal table address    */
  1222. X            &request_code,    /* Request code            */
  1223. X            &max_buffer_length,/* Maximum buffer length    */
  1224. X            &ret_length,    /* Return length        */
  1225. X            buffer)        /* Capability data buffer    */
  1226. X
  1227. X    /* Return NULL pointer if capability is not available */
  1228. X    
  1229. X            & 1) == 0)
  1230. X                return NULL;
  1231. X
  1232. X    /* Check for empty result */
  1233. X    if (ret_length == 0)
  1234. X        return NULL;
  1235. X    
  1236. X    /* Save current position so we can return it to caller */
  1237. X
  1238. X    result = buffer;
  1239. X
  1240. X    /* NIL terminate the sequence for return */
  1241. X    
  1242. X    buffer[ret_length] = 0;
  1243. X
  1244. X    /* Advance buffer */
  1245. X
  1246. X    buffer += ret_length + 1;
  1247. X
  1248. X    /* Return capability to user */
  1249. X    return result;
  1250. X}
  1251. X
  1252. X
  1253. X/** I/O information block definitions **/
  1254. Xstruct iosb {            /* I/O status block            */
  1255. X    short    i_cond;        /* Condition value            */
  1256. X    short    i_xfer;        /* Transfer count            */
  1257. X    long    i_info;        /* Device information            */
  1258. X};
  1259. Xstruct termchar {        /* Terminal characteristics        */
  1260. X    char    t_class;    /* Terminal class            */
  1261. X    char    t_type;        /* Terminal type            */
  1262. X    short    t_width;    /* Terminal width in characters        */
  1263. X    long    t_mandl;    /* Terminal's mode and length        */
  1264. X    long    t_extend;    /* Extended terminal characteristics    */
  1265. X};
  1266. Xstatic struct termchar tc;    /* Terminal characteristics        */
  1267. X
  1268. X/***
  1269. X *  vmsgtty - Get terminal type from system control block
  1270. X *
  1271. X *  Nothing returned
  1272. X ***/
  1273. Xvmsgtty()
  1274. X{
  1275. X    short fd;
  1276. X    int status;
  1277. X    struct iosb iostatus;
  1278. X    $DESCRIPTOR(devnam, "SYS$INPUT");
  1279. X
  1280. X    /* Assign input to a channel */
  1281. X    status = sys$assign(&devnam, &fd, 0, 0);
  1282. X    if ((status & 1) == 0)
  1283. X        exit (status);
  1284. X
  1285. X    /* Get terminal characteristics */
  1286. X    status = sys$qiow(        /* Queue and wait        */
  1287. X        0,            /* Wait on event flag zero    */
  1288. X        fd,            /* Channel to input terminal    */
  1289. X        IO$_SENSEMODE,        /* Get current characteristic    */
  1290. X        &iostatus,        /* Status after operation    */
  1291. X        0, 0,            /* No AST service        */
  1292. X        &tc,            /* Terminal characteristics buf */
  1293. X        sizeof(tc),        /* Size of the buffer        */
  1294. X        0, 0, 0, 0);        /* P3-P6 unused            */
  1295. X
  1296. X    /* De-assign the input device */
  1297. X    if ((sys$dassgn(fd) & 1) == 0)
  1298. X        exit(status);
  1299. X
  1300. X    /* Jump out if bad status */
  1301. X    if ((status & 1) == 0)
  1302. X        exit(status);
  1303. X    if ((iostatus.i_cond & 1) == 0)
  1304. X        exit(iostatus.i_cond);
  1305. X}
  1306. X
  1307. X
  1308. X/***
  1309. X *  vmsopen  -  Get terminal type and open terminal
  1310. X *
  1311. X *  Nothing returned
  1312. X ***/
  1313. Xvmsopen()
  1314. X{
  1315. X    /* Get terminal type */
  1316. X    vmsgtty();
  1317. X    if (tc.t_type == TT$_UNKNOWN) {
  1318. X        printf("Terminal type is unknown!\n");
  1319. X        printf("Try set your terminal type with SET TERMINAL/INQUIRE\n");
  1320. X        printf("Or get help on SET TERMINAL/DEVICE_TYPE\n");
  1321. X        exit(3);
  1322. X    }
  1323. X
  1324. X    /* Access the system terminal definition table for the        */
  1325. X    /* information of the terminal type returned by IO$_SENSEMODE    */
  1326. X    if ((smg$init_term_table_by_type(&tc.t_type, &termtype) & 1) == 0)
  1327. X        return -1;
  1328. X        
  1329. X    /* Set sizes */
  1330. X    term.t_nrow = ((unsigned int) tc.t_mandl >> 24) - 1;
  1331. X    term.t_ncol = tc.t_width;
  1332. X
  1333. X    /* Get some capabilities */
  1334. X    begin_reverse = vmsgetstr(SMG$K_BEGIN_REVERSE);
  1335. X    end_reverse = vmsgetstr(SMG$K_END_REVERSE);
  1336. X    revexist = begin_reverse != NULL && end_reverse != NULL;
  1337. X    erase_to_end_line = vmsgetstr(SMG$K_ERASE_TO_END_LINE);
  1338. X    eolexist = erase_to_end_line != NULL;
  1339. X    erase_whole_display = vmsgetstr(SMG$K_ERASE_WHOLE_DISPLAY);
  1340. X
  1341. X    /* Set resolution */
  1342. X    strcpy(sres, "NORMAL");
  1343. X
  1344. X    /* Open terminal I/O drivers */
  1345. X    ttopen();
  1346. X}
  1347. X
  1348. X
  1349. X/***
  1350. X *  vmskopen  -  Open keyboard (not used)
  1351. X *
  1352. X *  Nothing returned
  1353. X ***/
  1354. Xvmskopen()
  1355. X{
  1356. X}
  1357. X
  1358. X
  1359. X/***
  1360. X *  vmskclose  -  Close keyboard (not used)
  1361. X *
  1362. X *  Nothing returned
  1363. X ***/
  1364. Xvmskclose()
  1365. X{
  1366. X}
  1367. X
  1368. X
  1369. X/***
  1370. X *  fnclabel  -  Label function keys (not used)
  1371. X *
  1372. X *  Nothing returned
  1373. X ***/
  1374. X#if    FLABEL
  1375. Xfnclabel(f, n)        /* label a function key */
  1376. Xint f,n;    /* default flag, numeric argument [unused] */
  1377. X{
  1378. X    /* on machines with no function keys...don't bother */
  1379. X    return(TRUE);
  1380. X}
  1381. X#endif
  1382. X
  1383. X
  1384. X/***
  1385. X *  spal  -  Set palette type  (Are you kidding?)
  1386. X *
  1387. X *  Nothing returned
  1388. X ***/
  1389. Xspal()
  1390. X{
  1391. X}
  1392. X
  1393. X#else
  1394. X
  1395. X/***
  1396. X *  hellovms  -  Avoid error because of empty module
  1397. X *
  1398. X *  Nothing returned
  1399. X ***/
  1400. Xhellovms()
  1401. X{
  1402. X}
  1403. X
  1404. X#endif
  1405. FRIDAY_NIGHT
  1406. echo mes.12 completed!
  1407. # That's all folks!
  1408.  
  1409.  
  1410.