home *** CD-ROM | disk | FTP | other *** search
/ Garbo / Garbo.cdr / pc / source / pcserial.zoo / serial.3 < prev   
Encoding:
Text File  |  1990-04-04  |  22.3 KB  |  1,268 lines
  1.  
  2. #! /bin/sh
  3. # This is a shell archive.  Remove anything before this line, then unpack
  4. # it by saving it into a file and typing "sh file".  To overwrite existing
  5. # files, type "sh file -c".  You can also feed this as standard input via
  6. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  7. # will see the following message at the end:
  8. #        "End of archive 3 (of 3)."
  9. # Contents:  vt100.c
  10. # Wrapped by jb@deneb on Sat Mar 24 10:42:20 1990
  11. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  12. if test -f 'vt100.c' -a "${1}" != "-c" ; then 
  13.   echo shar: Will not clobber existing file \"'vt100.c'\"
  14. else
  15. echo shar: Extracting \"'vt100.c'\" \(20360 characters\)
  16. sed "s/^X//" >'vt100.c' <<'END_OF_FILE'
  17. X/*
  18. X *                               VT100.C
  19. X *
  20. X *                           Written for the
  21. X *
  22. X *                              Datalight
  23. X *                           Microsoft V 5.x
  24. X *                                TurboC
  25. X *                                  &
  26. X *                               Zortech
  27. X *
  28. X *                             C Compilers
  29. X *
  30. X *            Copyright (c) John Birchfield 1987, 1988, 1989
  31. X */
  32. X
  33. X#include <stdio.h>
  34. X#include <process.h>
  35. X#include <ctype.h>
  36. X#include "_kb.h"
  37. X#include "8250xon.h"
  38. X#include "screen.h"
  39. X#include "vt100.h"
  40. X#if (!defined (TRUE))
  41. X#    define TRUE  (1)
  42. X#    define FALSE (0)
  43. X#endif
  44. X
  45. char Duplex [2]    = { 'F', 0 },
  46. X     RubOut [2]    = { 255, 0 },
  47. X     BackSpace [2] = { 8,   0 },
  48. X     Cmask     [2] = {127,  0 },
  49. X     CrLf      [2] = {  0,  0 };
  50. X
  51. X
  52. X#if (defined (STANDALONE))
  53. X#include "options.h"
  54. void print_screen_header (void);
  55. X
  56. main (argc, argv)
  57. int argc;
  58. char *argv [];
  59. X{
  60. X    FILE *fp;
  61. X    void vt100_driver (), VT100_init ();
  62. X    set_options (argc, argv);
  63. X    trap_ctrl_break ();
  64. X    timer_init ();
  65. X    xon8250_init (Port, 4096);
  66. X    fputs ("--  VT100 Terminal Emulator --\n", stdout);
  67. X    if (Cfg_Str [0])
  68. X    {
  69. X        xon8250_port_init (Cfg_Str);
  70. X        fputs (Opt_Msg, stdout);
  71. X    }
  72. X    else
  73. X    {
  74. X        xon8250_port_enable ();
  75. X        fputs ("Default Port Settings Used\n", stdout);
  76. X    }
  77. X    fputs ("Use <Alt>F10 to exit, <Alt>F9 to spawn DOS,"
  78. X           " or <Alt>F8 to Send Break\n", stdout);
  79. X    screen_init();
  80. X    
  81. X    print_screen_header ();
  82. X    rowcol (23, 0);
  83. X    while (xon8250_timed_read (1) != -1)
  84. X        ;
  85. X    VT100_init ();
  86. X    vt100_driver ();
  87. X    xon8250_term ((Cfg_Str [0])?1:0);
  88. X    timer_term ();
  89. X    release_ctrl_break ();
  90. X}
  91. X
  92. X
  93. X
  94. void
  95. print_screen_header ()
  96. X{
  97. X    char save = Scr_ATTR;
  98. X    Scr_ATTR = INVERSE;
  99. X    rowcol(24,0);
  100. X    cleol();
  101. X    rowcol (24, 0);
  102. X    aputs (INVERSE, "VT100 Emulator");
  103. X    Scr_ATTR = save;
  104. X}
  105. X#endif
  106. X
  107. X
  108. X
  109. X/*--------------------------------------------------------------------*
  110. X |               All of the VT100 Specific Stuff Follows              |
  111. X *--------------------------------------------------------------------*/
  112. void    ANSI_MODE (void), CUB (void), CUD (void), CUF (void),
  113. X        CUP (void), CUU (void), DA (void), DECSTBM (void), DECSC (void),
  114. X        DECALN (void), DECRC (void), DSR (void), ED (void), EL (void),
  115. X        RESET (void), RM (void), SGR (void), SM (void), TBC (void),
  116. X        escA (void), escB (void), escC (void), escD (void), escE (void),
  117. X        escF (void), escG (void), escH (void), escI (void),
  118. X        escJ (void), escK (void), escM (void), escY (void), escZ (void);
  119. X
  120. X#define    P_MAX         6    /* max no of parameter accumulators */
  121. X#define E_BUFF_MAX    11    /* max chars in escape interpreter buffer */
  122. X
  123. static    int        save_row,         save_col,
  124. X                save_attr,        save_crlf,
  125. X                initdone = '\0',
  126. X                tab_stop[80],
  127. X                special_graphics, ansi_mode,
  128. X                appl_mode,        DECKPNM,
  129. X                vt_save_attr,
  130. X                vt_save_row,      vt_save_col,
  131. X                vt_top,              vt_bot,
  132. X                vt_tlim,          vt_blim,
  133. X                vt_row,           vt_col,
  134. X                vt_crlf,          vt_org,
  135. X                vt_wrap,          vt_xoff;
  136. X
  137. char            ansi_cursor_set[]    = "\\eO%c",
  138. X                ansi_cursor_reset[]    = "\\e[%c",
  139. X                vt52_cursor[]        = "\\e%c",
  140. X                  vt52_kp[]            = "\\e?%c",
  141. X                ansi_kp[]            = "\\eO%c",
  142. X                *kp_sptr,            *cursor_sptr;
  143. X
  144. void vt_putf(char *,...),
  145. X     vtpf_itoa (int),
  146. X     vtput_char (char c),
  147. X     VT_Put_Scr (char),
  148. X     VT100_Cmd (char),
  149. X     VT100_KB (char),
  150. X     VT100_Out (char);
  151. X
  152. void
  153. vt100_driver () 
  154. X{
  155. X    int chin, chout;
  156. X    do 
  157. X    {
  158. X        if (!(vt_xoff) && ((chin = xon8250_read ()) != -1))
  159. X            if (chin &= *Cmask)
  160. X                VT100_Cmd (chin);
  161. X        if ((chout = _kb ()) != -1) 
  162. X        {
  163. X            switch (chout) 
  164. X            {
  165. X                case PF5:
  166. X                    tab_stop[vt_col] = TRUE;
  167. X                    break;
  168. X                case PF6:
  169. X                    tab_stop[vt_col] = FALSE;
  170. X                    break;
  171. X                case APF8:
  172. X                    xon8250_write_break ();
  173. X                    break;
  174. X                case APF9:
  175. X                    spawnlp (0, "COMMAND.COM", "COMMAND.COM", (char *) 0);
  176. X                    print_screen_header ();
  177. X                    vt_row = 23; vt_col = 0;
  178. X                    rowcol (vt_row, vt_col);
  179. X                    break;
  180. X                case APF10:
  181. X                    break;
  182. X                default:
  183. X                    if (chout != APF1)
  184. X                        VT100_KB (chout);
  185. X                    break;
  186. X            }
  187. X        }
  188. X    } while (chout != APF10);
  189. X}
  190. X
  191. X
  192. X
  193. X
  194. X/*--------------------------- VT100_Cmd () ---------------------------*/
  195. X/*
  196. X *
  197. X */
  198. static    int    p_ix          = 0, p_acc [P_MAX] = { 0 };
  199. static char lastchar = '\0';
  200. void
  201. VT100_Cmd (char ch)
  202. X{
  203. X    if (ch==BS)
  204. X    {
  205. X        if (vt_col) 
  206. X        {
  207. X            rowcol (vt_row,--vt_col);
  208. X        }
  209. X        return;
  210. X    }
  211. X    if (lastchar && (ch==CAN || ch==SUB))
  212. X        goto reset;
  213. X    if (ch==DEL)
  214. X        return;
  215. X
  216. X    switch (lastchar)
  217. X    {
  218. X        default:
  219. X            if (ch==ESC)
  220. X            {
  221. X                lastchar = ch;
  222. X                while (p_ix >= 0)
  223. X                    p_acc [p_ix--] = 0;
  224. X                p_ix = 0;
  225. X                return;
  226. X            }
  227. X            VT100_Out (ch);
  228. X            return;
  229. X        case ESC:
  230. X            switch (ch)
  231. X            {
  232. X                case ESC: return;
  233. X                case '[':
  234. X                case '(':
  235. X                case ')':
  236. X                case 'Y':
  237. X                case '#': lastchar = ch;   return;
  238. X                case '7': DECSC ();        goto reset;
  239. X                case '8': DECRC ();        goto reset;
  240. X                case '<': ANSI_MODE ();    goto reset;
  241. X                case '>': DECKPNM = FALSE; goto reset;
  242. X                case '=': DECKPNM = TRUE;  goto reset;
  243. X                case 'A': escA  ();        goto reset;
  244. X                case 'B': escB  ();        goto reset;
  245. X                case 'C': escC  ();        goto reset;
  246. X                case 'D': escD  ();        goto reset;
  247. X                case 'E': escE  ();        goto reset;
  248. X                case 'F': escF  ();        goto reset;
  249. X                case 'G': escG  ();        goto reset;
  250. X                case 'H': escH  ();        goto reset;
  251. X                case 'I': escI  ();        goto reset;
  252. X                case 'J': ED ();           goto reset;
  253. X                case 'K': EL ();           goto reset;
  254. X                case 'M': escM  ();        goto reset;
  255. X                case 'Z': escZ  ();        goto reset;
  256. X                case 'c': RESET ();        goto reset;
  257. X                case 'y':                  goto reset;
  258. X                default : VT100_Out (ch);  goto reset;
  259. X            }
  260. X        case '[':
  261. X            switch (ch)
  262. X            {
  263. X                case 'A': CUU ();     goto reset;
  264. X                case 'B': CUD ();     goto reset;
  265. X                case 'C': CUF ();     goto reset;
  266. X                case 'D': CUB ();     goto reset;
  267. X                case 'H':
  268. X                case 'f': CUP ();     goto reset;
  269. X                case 'J': ED ();      goto reset;
  270. X                case 'K': EL ();      goto reset;
  271. X                case 'c': DA ();      goto reset;
  272. X                case 'g': TBC ();     goto reset;
  273. X                case 'h': SM ();      goto reset;
  274. X                case 'l': RM ();      goto reset;
  275. X                case 'm': SGR ();     goto reset;
  276. X                case 'n': DSR ();     goto reset;
  277. X                case 'q':             goto reset;
  278. X                case 'r': DECSTBM (); goto reset;
  279. X                case ';': p_ix++;
  280. X                case '?':             return;
  281. X                default:
  282. X                    if isdigit (ch)
  283. X                    {
  284. X                        p_acc [p_ix] *= 10;
  285. X                        p_acc [p_ix] += (ch-'0');
  286. X                        return;
  287. X                    }
  288. X                    VT100_Out (ch);
  289. X                    goto reset;
  290. X            }
  291. X        case '(':
  292. X        case ')': goto reset;
  293. X        case '#':
  294. X            if (ch=='8')
  295. X                DECALN ();
  296. X            goto reset;
  297. X        case 'Y':
  298. X            p_acc [p_ix++] = ch - 31;
  299. X            if (p_ix < 2)
  300. X                break;
  301. X            else
  302. X            {
  303. X                CUP ();
  304. X                goto reset;
  305. X            }
  306. X    }
  307. X    return;
  308. reset:
  309. X    lastchar = '\0';
  310. X}
  311. X
  312. X
  313. X
  314. X
  315. X/*--------------------------- VT100_Out () ---------------------------*/
  316. X/*
  317. X *
  318. X */
  319. void
  320. VT100_Out (char ch)
  321. X{
  322. X    switch (ch) 
  323. X    {
  324. X        case BEL:
  325. X            putchar (ch);
  326. X            rowcol (vt_row, vt_col);
  327. X            break;
  328. X        case HT:
  329. X            while (vt_col < 79)
  330. X                if (tab_stop[++vt_col])
  331. X                    break;
  332. X            rowcol(vt_row, vt_col);
  333. X            break;
  334. X        case DEL:
  335. X        case ESC:
  336. X            break;
  337. X        default:
  338. X            VT_Put_Scr (ch);
  339. X            break;
  340. X    }
  341. X}
  342. X
  343. X
  344. X
  345. X
  346. X/*------------------------- VT_Put_Scr () -------------------------*/
  347. X/*
  348. X *
  349. X */
  350. void
  351. VT_Put_Scr (char ch)
  352. X{
  353. X    static char vt_wrapped = FALSE;
  354. X
  355. X    if (vt_wrapped) 
  356. X    {
  357. X        if (ch == CR)
  358. X            return;
  359. X        vt_wrapped = FALSE;
  360. X        if (ch == LF)
  361. X            return;
  362. X    }
  363. X    if (vt_row > vt_bot)
  364. X    {
  365. X        rowcol (vt_row=vt_bot, vt_col);
  366. X        scroll_up (1, vt_top, 0, vt_bot, 79);
  367. X    }
  368. X    switch (ch) 
  369. X    {
  370. X        case CR:
  371. X            vt_col = 0;
  372. X            rowcol (vt_row, vt_col);
  373. X            if (vt_crlf == FALSE)
  374. X                break;
  375. X        case LF:
  376. X        case VT:
  377. X        case FF:
  378. X            if (++vt_row > vt_bot)
  379. X                scroll_up (1, vt_top, 0, vt_row=vt_bot, 79);
  380. X            rowcol (vt_row, vt_col);
  381. X            break;
  382. X        default:
  383. X            aput (Scr_ATTR, ch);
  384. X            if (++vt_col > 79) 
  385. X            {
  386. X                if (!vt_wrap)
  387. X                    rowcol (vt_row, --vt_col);
  388. X                else
  389. X                {
  390. X                    vt_col = 0;
  391. X                    vt_row++;
  392. X                    vt_wrapped = TRUE;
  393. X                }
  394. X            }
  395. X            break;
  396. X    }
  397. X}
  398. X
  399. X
  400. X
  401. X
  402. X/*---------------------------- DECALN () ----------------------------*/
  403. X/*
  404. X *
  405. X */
  406. void
  407. DECALN (void)
  408. X{
  409. X    int i=1920;
  410. X    rowcol (0, 0);
  411. X    while (i--)
  412. X        aput (Scr_ATTR, 'E');
  413. X    rowcol (vt_row, vt_col);
  414. X}
  415. X/*----------------------------- DECSC () -----------------------------*/
  416. X/*
  417. X * ESC 7 - Save Cursor  (DEC Private)
  418. X */
  419. void
  420. DECSC (void)
  421. X{
  422. X    vt_save_row        = vt_row;
  423. X    vt_save_col        = vt_col;
  424. X    vt_save_attr    = Scr_ATTR;
  425. X}
  426. X
  427. X
  428. X
  429. X
  430. X/*----------------------------- DECRC () -----------------------------*/
  431. X/*
  432. X * ESC 8 - Restore Cursor (DEC Private)
  433. X */
  434. void
  435. DECRC (void)
  436. X{
  437. X    vt_row        = vt_save_row;
  438. X    vt_col        = vt_save_col;
  439. X    Scr_ATTR    = vt_save_attr;
  440. X    rowcol (vt_row, vt_col);
  441. X}
  442. X
  443. X
  444. X
  445. X
  446. X/*------------------------------ DSR () ------------------------------*/
  447. X/*
  448. X *
  449. X */
  450. void
  451. DSR (void)
  452. X{
  453. X    switch (p_acc [0])
  454. X    {
  455. X        case 5:    vt_putf ("\\e[0n");                             break;
  456. X        case 6: vt_putf ("\\e[%d;%dR", vt_row + 1, vt_col + 1); break;
  457. X        default:                                                break;
  458. X    }
  459. X}
  460. X
  461. X
  462. X
  463. X
  464. X/*--------------------------- ANSI_MODE () ---------------------------*/
  465. X/*
  466. X * ESC  < - Enter ANSI Mode
  467. X */
  468. void
  469. ANSI_MODE (void)
  470. X{
  471. X    ansi_mode = TRUE;
  472. X    kp_sptr = ansi_kp;
  473. X    cursor_sptr = (appl_mode)? ansi_cursor_set: ansi_cursor_reset;
  474. X}
  475. X
  476. X
  477. X
  478. X
  479. X/*------------------------------ SGR () ------------------------------*/
  480. X/*
  481. X *
  482. X */
  483. void
  484. SGR (void)
  485. X{
  486. X    char    blink        = FALSE,
  487. X            bold        = FALSE,
  488. X            underscore    = FALSE,
  489. X            reverse        = FALSE;
  490. X    int        i;
  491. X    for (i = 0; i < P_MAX; i++)
  492. X        switch (p_acc[i]) 
  493. X        {
  494. X            case 1:
  495. X                bold = TRUE;
  496. X                break;
  497. X            case 4:
  498. X                underscore = TRUE;
  499. X                break;
  500. X            case 5:
  501. X                blink    = TRUE;
  502. X                break;
  503. X            case 7:
  504. X                reverse = TRUE;
  505. X                break;
  506. X            default:
  507. X                break;
  508. X        }
  509. X    if (underscore) 
  510. X    {
  511. X        Scr_ATTR = UNDERLINE;
  512. X        if (reverse)
  513. X            Scr_ATTR |= INVERSE;
  514. X    }
  515. X    else if (reverse)
  516. X        Scr_ATTR = INVERSE;
  517. X    else
  518. X        Scr_ATTR = NORMAL;
  519. X    if (bold)
  520. X        Scr_ATTR |= BRIGHT;
  521. X    if (blink)
  522. X        Scr_ATTR |= BLINK;
  523. X}
  524. X
  525. X/*----------------------------- escA () -----------------------------*/
  526. X/*
  527. X *
  528. X */
  529. void
  530. escA (void) 
  531. X{
  532. X    if ((ansi_mode == FALSE) && (vt_row))
  533. X        rowcol (--vt_row, vt_col);
  534. X}
  535. X
  536. X
  537. X
  538. X
  539. X/*----------------------------- escB () -----------------------------*/
  540. X/*
  541. X *
  542. X */
  543. void
  544. escB (void) 
  545. X{
  546. X    if ((ansi_mode == FALSE) && (vt_row < 23))
  547. X        rowcol (++vt_row, vt_col);
  548. X}
  549. X
  550. X
  551. X
  552. X
  553. X/*----------------------------- escC () -----------------------------*/
  554. X/*
  555. X *
  556. X */
  557. void
  558. escC (void) 
  559. X{
  560. X    if ((ansi_mode == FALSE) && (vt_col < 79))
  561. X        rowcol (vt_row, ++vt_col);
  562. X}
  563. X
  564. X
  565. X
  566. X
  567. X/*----------------------------- escD () -----------------------------*/
  568. X/*
  569. X *
  570. X */
  571. void
  572. escD (void) 
  573. X{
  574. X    if (ansi_mode)
  575. X        if (vt_row < vt_bot)
  576. X            rowcol (++vt_row, vt_col);
  577. X        else
  578. X            scroll_up (1, vt_top, 0, vt_bot, 79);
  579. X    else if (vt_col)
  580. X        rowcol (vt_row, --vt_col);
  581. X}
  582. X
  583. X
  584. X
  585. X
  586. X/*----------------------------- escE () -----------------------------*/
  587. X/*
  588. X *
  589. X */
  590. void
  591. escE (void) 
  592. X{
  593. X    if (ansi_mode) 
  594. X    {
  595. X        vt_col = 0;
  596. X        if (vt_row < vt_bot)
  597. X            rowcol (++vt_row, vt_col);
  598. X        else 
  599. X        {
  600. X            scroll_up (1, vt_top, 0, vt_bot, 79);
  601. X            rowcol (vt_row, vt_col);
  602. X        }
  603. X    }
  604. X}
  605. X
  606. X
  607. X
  608. X
  609. X/*----------------------------- escF () -----------------------------*/
  610. X/*
  611. X *
  612. X */
  613. void
  614. escF (void) 
  615. X{
  616. X    special_graphics = TRUE;
  617. X}
  618. X
  619. X
  620. X
  621. X
  622. X/*----------------------------- escG () -----------------------------*/
  623. X/*
  624. X *
  625. X */
  626. void
  627. escG (void) 
  628. X{
  629. X    special_graphics = FALSE;
  630. X}
  631. X
  632. X
  633. X
  634. X
  635. X/*----------------------------- escH () -----------------------------*/
  636. X/*
  637. X *
  638. X */
  639. void
  640. escH (void) 
  641. X{
  642. X    if (ansi_mode) 
  643. X    {
  644. X        tab_stop [vt_col] = TRUE;
  645. X        return;
  646. X    }
  647. X    vt_row = vt_col = 0;
  648. X    rowcol (vt_row, vt_col);
  649. X}
  650. X
  651. X
  652. X
  653. X
  654. X/*----------------------------- escI () -----------------------------*/
  655. X/*
  656. X *
  657. X */
  658. void
  659. escI (void) 
  660. X{
  661. X    if (ansi_mode == FALSE)
  662. X        if (vt_row > vt_top)
  663. X            rowcol (--vt_row, vt_col);
  664. X        else 
  665. X        {
  666. X            scroll_dn (1, vt_top, 0, vt_bot, 79);
  667. X            rowcol (vt_row, vt_col);
  668. X        }
  669. X}
  670. X
  671. X
  672. X
  673. X
  674. X/*----------------------------- escJ () -----------------------------*/
  675. X/*
  676. X *
  677. X */
  678. void
  679. escJ (void) 
  680. X{
  681. X    if (ansi_mode == FALSE) 
  682. X    {
  683. X        clrscrn ();
  684. X        rowcol (vt_row, vt_col);
  685. X    }
  686. X}
  687. X
  688. X
  689. X
  690. X
  691. X/*----------------------------- escK ()  -----------------------------*/
  692. X/*
  693. X *
  694. X */
  695. void
  696. escK (void) 
  697. X{
  698. X    if (ansi_mode == FALSE)
  699. X        scroll_up (0, vt_row, vt_col, vt_row, 79);
  700. X}
  701. X
  702. X
  703. X
  704. X
  705. X/*----------------------------- escM () -----------------------------*/
  706. X/*
  707. X *
  708. X */
  709. void
  710. escM (void) 
  711. X{
  712. X    if (ansi_mode)
  713. X        if (vt_row > vt_top)
  714. X            rowcol (--vt_row, vt_col);
  715. X        else 
  716. X        {
  717. X            scroll_dn (1, vt_top, 0, vt_bot, 79);
  718. X            rowcol (vt_row, vt_col);
  719. X        }
  720. X}
  721. X
  722. X
  723. X
  724. X
  725. X/*----------------------------- escZ () -----------------------------*/
  726. X/*
  727. X *
  728. X */
  729. void
  730. escZ (void)
  731. X{
  732. X    vt_putf ("\\e/Z");
  733. X}
  734. X
  735. X
  736. X
  737. X
  738. X/*------------------------------ DA () ------------------------------*/
  739. X/*
  740. X *
  741. X */
  742. void
  743. DA (void) 
  744. X{
  745. X    vt_putf ("\\e[?1;0c");
  746. X}
  747. X
  748. X
  749. X
  750. X
  751. X/*------------------------------ CUU () ------------------------------*/
  752. X/*
  753. X * ESC [ Pn A - Cursor Up
  754. X */
  755. void
  756. CUU (void)
  757. X{
  758. X    do 
  759. X    {
  760. X        if (vt_row > vt_tlim)
  761. X            rowcol (--vt_row, vt_col);
  762. X    } while (--p_acc[0] > 0);
  763. X}
  764. X
  765. X
  766. X
  767. X
  768. X/*------------------------------ CUD () ------------------------------*/
  769. X/*
  770. X * ESC [ Pn B - Cursor Down
  771. X */
  772. void
  773. CUD (void) 
  774. X{
  775. X    do 
  776. X    {
  777. X        if (vt_row < vt_blim)
  778. X            rowcol (++vt_row, vt_col);
  779. X    } while (--p_acc[0] > 0);
  780. X}
  781. X
  782. X
  783. X
  784. X
  785. X/*------------------------------ CUF () ------------------------------*/
  786. X/*
  787. X * ESC [ Pn C - Cursor Forward
  788. X */
  789. void
  790. CUF (void) 
  791. X{
  792. X    do 
  793. X    {
  794. X        if (vt_col < 79)
  795. X            rowcol (vt_row, ++vt_col);
  796. X    } while (--p_acc[0] > 0);
  797. X}
  798. X
  799. X
  800. X
  801. X
  802. X/*------------------------------ CUB () ------------------------------*/
  803. X/*
  804. X * ESC [ Pn D - Cursor Backward
  805. X */
  806. void
  807. CUB (void) 
  808. X{
  809. X    do 
  810. X    {
  811. X        if (vt_col)
  812. X            rowcol (vt_row, --vt_col);
  813. X    } while (--p_acc[0] > 0);
  814. X}
  815. X
  816. X
  817. X
  818. X
  819. X/*------------------------------ CUP () ------------------------------*/
  820. X/*
  821. X * ESC [ Pn ; Pn H - Cursor Position
  822. X *                or
  823. X * ESC [ Pn ; Pn f - Horizontal and Vertical  Position
  824. X */
  825. void
  826. CUP (void)
  827. X{
  828. X    if (p_acc[0])
  829. X        --p_acc[0];
  830. X    if (p_acc[1])
  831. X        --p_acc[1];
  832. X    vt_row = p_acc[0] + vt_tlim; vt_col = p_acc[1];
  833. X    vt_row = (vt_row<24)?vt_row:23;
  834. X    vt_col = (vt_col<80)?vt_col:79;
  835. X    if (vt_row <= vt_blim)
  836. X        rowcol (vt_row, vt_col);
  837. X}
  838. X
  839. X
  840. X
  841. X            
  842. X/*------------------------------ ED () ------------------------------*/
  843. X/*
  844. X * ESC [ Ps J - Erase in Display
  845. X */
  846. void
  847. XED (void)
  848. X{
  849. X    int    ch;
  850. X    if (vt_row < vt_top || vt_row > vt_bot)
  851. X        return;
  852. X    switch (p_acc[0]) 
  853. X    {
  854. X        case 0: /* from current cursor position to end of page */
  855. X            scroll_up (0, vt_row, vt_col, vt_row, 79);
  856. X            if (vt_row < vt_bot)
  857. X                scroll_up (0, vt_row+1, 0, vt_bot, 79);
  858. X            break;
  859. X        case 1: /* from start of screen to current position */
  860. X            if (vt_row > vt_top)
  861. X                scroll_up (0, vt_top, 0, vt_row-1, 79);
  862. X            scroll_up (0, vt_row, 0, vt_row, vt_col);
  863. X            break;
  864. X        case 2:
  865. X            scroll_up (0, vt_top, 0, vt_bot, 79);
  866. X            break;
  867. X        default:
  868. X            break;
  869. X    }
  870. X}
  871. X
  872. X
  873. X
  874. X
  875. X/*------------------------------ EL () ------------------------------*/
  876. X/*
  877. X * ESC [ Ps K - Erase In Line
  878. X */
  879. void
  880. XEL (void)
  881. X{
  882. X    int    ch;
  883. X    if (vt_row < vt_top || vt_row > vt_bot)
  884. X        return;
  885. X    switch (p_acc[0]) 
  886. X    {
  887. X        case 0:
  888. X            scroll_up (0, vt_row, vt_col, vt_row, 79);
  889. X            break;
  890. X        case 1: /* from start of line to current position */
  891. X            scroll_up (0, vt_row, 0, vt_row, vt_col);
  892. X            break;
  893. X        case 2:
  894. X            scroll_up (0, vt_row, 0, vt_row, 79);
  895. X            break;
  896. X        default:
  897. X            break;
  898. X    }
  899. X}
  900. X
  901. X
  902. X
  903. X
  904. X/*------------------------------ TBC () ------------------------------*/
  905. X/*
  906. X * ESC [ Ps g - Tabulation Clear
  907. X */
  908. void
  909. TBC (void)
  910. X{
  911. X    int    i;
  912. X    if (p_acc[0] == 0)
  913. X        tab_stop [vt_col] = FALSE;
  914. X    else if (p_acc[0] == 3)
  915. X        for (i = 0; i < 80; i++)
  916. X            tab_stop [i] = FALSE;
  917. X}
  918. X
  919. X
  920. X
  921. X
  922. X/*------------------------------ SM () ------------------------------*/
  923. X/*
  924. X * ESC [ Ps ; ... ; Ps h - Set Mode
  925. X */
  926. void
  927. SM (void)
  928. X{
  929. X    int i;
  930. X    for (i = 0; i < P_MAX; i++)
  931. X        switch (p_acc[i]) 
  932. X        {
  933. X            case 1:
  934. X                appl_mode = TRUE;
  935. X                cursor_sptr = ansi_cursor_set;
  936. X                break;
  937. X            case 5:
  938. X                Scr_ATTR = INVERSE;
  939. X                break;
  940. X            case 6:
  941. X                vt_org = TRUE;
  942. X                vt_tlim = vt_row = vt_top;
  943. X                vt_blim = vt_bot;
  944. X                vt_col = 0;
  945. X                rowcol (vt_row, vt_col);
  946. X                break;
  947. X            case 7:
  948. X                vt_wrap = TRUE;
  949. X                break;
  950. X            case 20:
  951. X                vt_crlf = TRUE;
  952. X                break;
  953. X        }
  954. X}                
  955. X
  956. X
  957. X
  958. X
  959. X/*-------------------------- RM () --------------------------*/
  960. X/*
  961. X * ESC [ Ps l - Reset Mode
  962. X */
  963. void
  964. RM (void)
  965. X{
  966. X    int i;
  967. X    for (i = 0; i < P_MAX; i++)
  968. X        switch (p_acc[i]) 
  969. X        {
  970. X            case 1:
  971. X                appl_mode = FALSE;
  972. X                cursor_sptr = ansi_cursor_reset;
  973. X                break;
  974. X            case 2:
  975. X                ansi_mode = FALSE;
  976. X                cursor_sptr = vt52_cursor;
  977. X                kp_sptr = vt52_kp;
  978. X                break;
  979. X            case 5:
  980. X                Scr_ATTR = NORMAL;
  981. X                break;
  982. X            case 6:
  983. X                vt_org = FALSE;
  984. X                vt_row = vt_tlim = 0; vt_col = 0;
  985. X                vt_blim = 23;
  986. X                rowcol (vt_row, vt_col);
  987. X                break;
  988. X            case 7:
  989. X                vt_wrap = FALSE;
  990. X                break;
  991. X            case 20:
  992. X                vt_crlf = FALSE;
  993. X                break;
  994. X        }
  995. X}                
  996. X
  997. X
  998. X
  999. X
  1000. X/*---------------------------- DECSTBM () ----------------------------*/
  1001. X/*
  1002. X *
  1003. X */
  1004. void
  1005. DECSTBM (void)
  1006. X{
  1007. X    if (p_acc [0]) p_acc [0]--;
  1008. X    if (p_acc [1]) p_acc [1]--;
  1009. X    if (p_acc[1] > p_acc[0]) 
  1010. X    {
  1011. X        vt_top = p_acc[0];
  1012. X        vt_bot = (p_acc[1] < 24) ? p_acc [1]: 23;
  1013. X        vt_tlim = (vt_org) ? vt_top: 0;
  1014. X        vt_blim = (vt_org) ? vt_bot: 23;
  1015. X        vt_row = vt_tlim; vt_col = 0;
  1016. X        rowcol (vt_row, vt_col);
  1017. X    }
  1018. X}
  1019. X
  1020. X
  1021. X
  1022. X
  1023. X/*----------------------------- RESET () -----------------------------*/
  1024. X/*
  1025. X *
  1026. X */
  1027. void
  1028. RESET (void)
  1029. X{
  1030. X    int i;
  1031. X    appl_mode = DECKPNM = FALSE;
  1032. X    ansi_mode = vt_wrap = TRUE;
  1033. X    cursor_sptr = ansi_cursor_reset;
  1034. X    kp_sptr = ansi_kp;
  1035. X    vt_tlim = vt_top = 0;
  1036. X    vt_blim = vt_bot = 23;
  1037. X    vt_crlf = (*CrLf == 'Y')? 1: 0;
  1038. X    vt_xoff = vt_org = FALSE;
  1039. X    p_ix = 0;
  1040. X    for (i = 0; i < 80; i++)
  1041. X        tab_stop[i] = '\0';
  1042. X    i = g_rowcol ();
  1043. X    vt_row = i / 256; vt_col = i % 256;
  1044. X    lastchar = '\0';
  1045. X}
  1046. X
  1047. X
  1048. X
  1049. X
  1050. X/*-------------------------- VT100_init () --------------------------*/
  1051. X/*
  1052. X *
  1053. X */
  1054. void
  1055. VT100_init () 
  1056. X{
  1057. X    int i;
  1058. X    if (initdone == FALSE) 
  1059. X    {
  1060. X        appl_mode = DECKPNM = FALSE;
  1061. X        ansi_mode = vt_wrap = TRUE;
  1062. X        cursor_sptr = ansi_cursor_reset;
  1063. X        kp_sptr = ansi_kp;
  1064. X        vt_tlim = vt_top = 0;
  1065. X        vt_blim = vt_bot = 23;
  1066. X        vt_crlf = (*CrLf == 'Y')? 1: 0;
  1067. X        vt_xoff = vt_org = FALSE;
  1068. X        p_ix = 0;
  1069. X        for (i = 0; i < 80; i++)
  1070. X            tab_stop[i] = '\0';
  1071. X        i = g_rowcol ();
  1072. X        vt_row = i / 256; vt_col = i % 256;
  1073. X        lastchar = '\0';
  1074. X        initdone = TRUE;
  1075. X    }
  1076. X    for (i = 0; i < P_MAX; i++)
  1077. X        p_acc[i] = 0;
  1078. X    p_ix = 0;
  1079. X    rowcol (vt_row, vt_col);
  1080. X}
  1081. X
  1082. X
  1083. X
  1084. X
  1085. X/*--------------------------- VT100_KB () ---------------------------*/
  1086. X/*
  1087. X *
  1088. X */
  1089. void
  1090. VT100_KB (char ch)
  1091. X{
  1092. X    if ((ch >= PF1) && (ch <= PF4))
  1093. X        vt_putf (kp_sptr, ('P' + ch - PF1));
  1094. X    else if ((ch >= SPF1) && (ch <= SPF10))
  1095. X        if (ch == SPF10)
  1096. X            if (DECKPNM)
  1097. X                vt_putf (kp_sptr, 'p');
  1098. X            else
  1099. X                vtput_char ('0');
  1100. X        else if (DECKPNM)
  1101. X            vt_putf (kp_sptr, ('q' + ch - SPF1));
  1102. X        else
  1103. X            vtput_char (ch - SPF1 + '1');
  1104. X    else if ((ch >= UPCHAR) && (ch <= LFCHAR))
  1105. X        vt_putf (cursor_sptr, (ch - UPCHAR + 'A'));
  1106. X    else
  1107. X        switch (ch) 
  1108. X        {
  1109. X            case PF7:
  1110. X                if (DECKPNM)
  1111. X                    vt_putf (kp_sptr, 'm');
  1112. X                else
  1113. X                    vtput_char ('-');
  1114. X                break;
  1115. X            case PF8:
  1116. X                if (DECKPNM)
  1117. X                    vt_putf (kp_sptr, 'l');
  1118. X                else
  1119. X                    vtput_char (',');
  1120. X                break;
  1121. X            case PF9:
  1122. X                if (DECKPNM)
  1123. X                    vt_putf (kp_sptr, 'n');
  1124. X                else
  1125. X                    vtput_char ('.');
  1126. X                break;
  1127. X            case PF10:
  1128. X                if (DECKPNM)
  1129. X                    vt_putf (kp_sptr, 'M');
  1130. X                else
  1131. X                    vtput_char (CR);
  1132. X                break;
  1133. X            case HCHAR:
  1134. X                vt_putf (cursor_sptr, 'H');
  1135. X                break;
  1136. X            case DEL1:
  1137. X                vtput_char (*RubOut);
  1138. X                break;
  1139. X            case BS:
  1140. X                vtput_char (*BackSpace);
  1141. X                break;
  1142. X            default:
  1143. X                vtput_char (ch);
  1144. X                break;
  1145. X        }
  1146. X}
  1147. X
  1148. X
  1149. X
  1150. void vt_putf(cp, cv)
  1151. char *cp; int cv;
  1152. X
  1153. X{
  1154. X    char c;
  1155. X    int    *cvp,i;
  1156. X
  1157. X    cvp = &cv;
  1158. X    while(*cp)
  1159. X        switch(c = *cp++) 
  1160. X        {
  1161. X            case '\\':
  1162. X                vtput_char((c = *cp++) == 'e' ? ESC : c);
  1163. X                break;
  1164. X            case '%':
  1165. X                switch (c = *cp++) 
  1166. X                {
  1167. X                    case 'c':
  1168. X                        vtput_char (*cvp++);
  1169. X                        break;
  1170. X                    case 'n':
  1171. X                        c = *cp++;
  1172. X                        while (!xon8250_write_buffer_empty ())
  1173. X                            ;
  1174. X                        for (i = 1000 * (c - '0'); i > 0; i--)
  1175. X                            ;
  1176. X                        break;
  1177. X                    case 'd':
  1178. X                        vtpf_itoa (*cvp++);
  1179. X                        break;
  1180. X                    default:
  1181. X                        break;
  1182. X                }
  1183. X                break;
  1184. X            default:
  1185. X                vtput_char(c);
  1186. X                break;
  1187. X        }
  1188. X}
  1189. X
  1190. X
  1191. void
  1192. vtput_char (char c)
  1193. X{
  1194. X    int i;
  1195. X    if (*Duplex == 'H')
  1196. X        VT100_Cmd (c);
  1197. X    while (xon8250_write (c) == -1)
  1198. X        ;
  1199. X    if (c==XOFF)
  1200. X        vt_xoff = TRUE;
  1201. X    else if (c==XON)
  1202. X        vt_xoff = FALSE;
  1203. X}
  1204. X
  1205. static    char    vtpf_str [6];
  1206. X
  1207. void    vtpf_itoa (int i)
  1208. X{
  1209. X    char *cp;
  1210. X    cp = vtpf_str;
  1211. X    *cp = '\0';
  1212. X    i = (i < 0) ? -i: i;
  1213. X    while (i) 
  1214. X    {
  1215. X        *cp++ = (i % 10) + '0';
  1216. X        i /= 10;
  1217. X    }
  1218. X    while (--cp >= vtpf_str) 
  1219. X    {
  1220. X        if (*Duplex == 'H')
  1221. X            VT100_Cmd (*cp);
  1222. X        while (xon8250_write (*cp) == -1)
  1223. X            ;
  1224. X    }
  1225. X}
  1226. X
  1227. X
  1228. void
  1229. vt_scrup (int cnt, int tr, int tc, int br, int bc)
  1230. X{
  1231. X    char sv_atr;
  1232. X    sv_atr = Scr_ATTR;
  1233. X    if (Scr_ATTR != 0x70 && Scr_ATTR != 0x79)
  1234. X        Scr_ATTR = NORMAL;
  1235. X    scroll_up (cnt, tr, tc, br, bc);
  1236. X    Scr_ATTR = sv_atr;
  1237. X} 
  1238. X
  1239. END_OF_FILE
  1240. if test 20360 -ne `wc -c <'vt100.c'`; then
  1241.     echo shar: \"'vt100.c'\" unpacked with wrong size!
  1242. fi
  1243. # end of 'vt100.c'
  1244. fi
  1245. echo shar: End of archive 3 \(of 3\).
  1246. cp /dev/null ark3isdone
  1247. MISSING=""
  1248. for I in 1 2 3 ; do
  1249.     if test ! -f ark${I}isdone ; then
  1250.     MISSING="${MISSING} ${I}"
  1251.     fi
  1252. done
  1253. if test "${MISSING}" = "" ; then
  1254.     echo You have unpacked all 3 archives.
  1255.     rm -f ark[1-9]isdone
  1256. else
  1257.     echo You still need to unpack the following archives:
  1258.     echo "        " ${MISSING}
  1259. fi
  1260. ##  End of shell archive.
  1261. exit 0
  1262. +----------------------
  1263. | John Birchfield      
  1264. | jb@altair.csustan.edu
  1265. +----------------------
  1266.  
  1267.  
  1268.