home *** CD-ROM | disk | FTP | other *** search
/ Microsoft Programmer's Library 1.3 / Microsoft-Programers-Library-v1.3.iso / sampcode / alde_c / desmet_c / vt100tst / vt100tst.c < prev   
Encoding:
C/C++ Source or Header  |  1985-12-12  |  21.2 KB  |  889 lines
  1. /*
  2. This program is supposed to test the compatibility of VT100-compatible
  3. terminals. However: it's also a nice demo of the capabilities of a VT100.
  4. The author is not on the net but I will forward comments and ideas of
  5. enhancements to him. What other VT100 functions should be tested?
  6.  
  7. The program was written under TOPS-10 so the author is probably not very
  8. interested in enhancements pertaining to UN*X.
  9. The responsibility for distributing this program is mine, the author has
  10. only given his consent.
  11.  
  12.     {decvax,philabs}!mcvax!enea!ttds!johanw
  13.  
  14. Cut at this line
  15. =========================================================================*/
  16. /*
  17.                                VTTEST.C
  18.  
  19.                 Written nov-dec 1983 by Per Lindberg,
  20.           Stockholm University Computer Center (QZ), Sweden.
  21.  
  22.                   THE MAD PROGRAMMER STRIKES AGAIN!
  23.  
  24. This is a program to test the compatibility (or to demonstrate the
  25. non-compatibility) of so-called "VT100-compatible" terminals. In
  26. conformance of the good old hacker traditions, the only documentation
  27. of this program is the source code itself. To understand it, you also
  28. need a copy of the original VT100 manual from DEC.
  29.  
  30. This program is not nearly finished yet, it only tests about half
  31. of what it should. And there is neither any support for all the
  32. different variations of VT100, like VT125, VT131 or the new VT200
  33. series. I might fix that someday, but in the meantime, feel free to
  34. snarf my program and hack it up.
  35.  
  36. The original version of this program was (and is still) written in a
  37. losing implementation of C, the John Hopkins University portable JHU
  38. C, as installed on the DECsystem-10 under TOPS-10. It is not a full
  39. implementation of C (as defined in "the C programming language" by
  40. Kernighan & Ritchie). One of its worst cretinisms is that identifiers
  41. are only significant to the first five characters. I hope to get a
  42. better C compiler for the DEC-10 soon.
  43.  
  44. */
  45.  
  46. #include <stdio.h>
  47.  
  48.  
  49. char *getlin(str)
  50. char *str;
  51. {
  52.     static char buf[100];
  53.     printf("%s", str);
  54.     return(gets(buf));
  55. }
  56.  
  57. main () {
  58.  
  59.  
  60. #define vt100 1
  61. #define vt102 2
  62.  
  63.     int     vttype;
  64.  
  65.     vttype = inittype ();
  66.     tst_movements ();
  67.     tst_screen ();
  68.     tst_characters ();
  69.     tst_doublesize ();
  70.     tst_reports ();
  71.     tst_vt52 ();
  72.     bye ();
  73. }
  74.  
  75. tst_movements () {
  76.  
  77.  /* Test of: CUF (Cursor Forward) CUB (Cursor Backward) CUD (Cursor Down)      IND (Index)  NEL (Next Line) CUU (Cursor
  78.     Up)        RI  (Reverse Index) CUP (Cursor Position)  HVP (Horizontal and Vertical Position) ED  (Erase in Display)
  79.     EL  (Erase in Line) PCALN (Screen Alignment Display) <CR> <BS> */
  80.  
  81.     int     row, col;
  82.  
  83. /*  pcaln();  */
  84.     ed (2);
  85.     pcaln ();
  86.     cup (9, 10);
  87.     ed (1);
  88.     cup (18, 60);
  89.     ed (0);
  90.     el (1);
  91.     cup (9, 71);
  92.     el (0);
  93.     for (row = 10; row <= 16; row++) {
  94.     cup (row, 10);
  95.     el (1);
  96.     cup (row, 71);
  97.     el (0);
  98.     }
  99.     cup (17, 30);
  100.     el (2);
  101.     for (col = 1; col <= 80; col++) {
  102.     hvp (24, col);
  103.     printf ("*");
  104.     hvp (1, col);
  105.     printf ("*");
  106.     }
  107.     cup (2, 2);
  108.     for (row = 2; row <= 23; row++) {
  109.     printf ("+");
  110.     cub (1);
  111.     ind ();
  112.     }
  113.     cup (23, 79);
  114.     for (row = 23; row >= 2; row--) {
  115.     printf ("+");
  116.     cub (1);
  117.     ri ();
  118.     }
  119.     cup (2, 1);
  120.     for (row = 2; row <= 23; row++) {
  121.     printf ("*");
  122.     cup (row, 80);
  123.     printf ("*");
  124.     cub (10);
  125.     if (row < 10)
  126.         nel ();
  127.     else
  128.         printf ("\n");
  129.     }
  130.     cup (2, 10);
  131.     cub (42);
  132.     cuf (2);
  133.     for (col = 3; col <= 78; col++) {
  134.     printf ("+");
  135.     cuf (0);
  136.     cub (2);
  137.     cuf (1);
  138.     }
  139.     cup (23, 70);
  140.     cuf (42);
  141.     cub (2);
  142.     for (col = 78; col >= 3; col--) {
  143.     printf ("+");
  144.     cub (1);
  145.     cuf (1);
  146.     cub (0);
  147.     printf ("%c", 8);
  148.     }
  149.     cup (1, 1);
  150.     cuu (10);
  151.     cuu (1);
  152.     cuu (0);
  153.     cup (24, 80);
  154.     cud (10);
  155.     cud (1);
  156.     cud (0);
  157.  
  158.     cup (10, 12);
  159.     for (row = 10; row <= 15; row++) {
  160.     for (col = 12; col <= 69; col++)
  161.         printf (" ");
  162.     cud (1);
  163.     cub (58);
  164.     }
  165.     cuu (5);
  166.     cuf (1);
  167.     printf ("The screen should be cleared, and have a unbroken border");
  168.     cup (12, 13);
  169.     printf ("of *'s and +'s around the edge, and exactly in the");
  170.     cup (13, 13);
  171.     printf ("middle there should be a frame of E's around this text");
  172.     cup (14, 13);
  173.     printf ("with one (1) free position around it. Now, push <RETURN>");
  174.     getlin ("");
  175. }
  176.  
  177. tst_screen () {
  178.  
  179.  /* Test of: - PCSTBM (Set Top and Bottom Margins) - TBC    (Tabulation Clear) - HTS    (Horizontal Tabulation Set) -
  180.     SM RM  (Set/Reset mode): - 80/132 chars - Origin: Realtive/absolute - Scroll: Smooth/jump - Wraparound */
  181.  
  182.     int     i, row, col, down, soft;
  183.  
  184.     ed (2);
  185.     sm ("?7");                        /* Wrap Around ON */
  186.     cup (1, 1);
  187.     for (col = 1; col <= 160; col++)
  188.     printf ("*");
  189.     rm ("?7");                        /* Wrap Around OFF */
  190.     cup (3, 1);
  191.     for (col = 1; col <= 160; col++)
  192.     printf ("*");
  193.     sm ("?7");                        /* Wrap Around ON */
  194.     cup (5, 1);
  195.     printf ("This should be three identical lines of *'s completely filling\n");
  196.     printf ("the top of the screen without any empty lines between.\n");
  197.     getlin ("Push <RETURN>");
  198.  
  199.     ed (2);
  200.     cup (1, 1);
  201.     for (col = 1; col <= 79; col++)
  202.     printf ("+");
  203.     for (row = 1; row <= 24; row++) {
  204.     hvp (row, 80);
  205.     printf ("*");
  206.     }
  207.     cup (10, 10);
  208.     printf ("This illustrates the \"wrap around bug\" which exists on a");
  209.     cup (11, 10);
  210.     printf ("standard VT100. On the top of the screen there should be");
  211.     cup (12, 10);
  212.     printf ("a row of +'s, and the rightmost column should be filled");
  213.     cup (13, 10);
  214.     printf ("with *'s. But if the bug is present, some of the *'s may");
  215.     cup (14, 10);
  216.     printf ("be placed in other places, e.g. in the leftmost column,");
  217.     cup (15, 10);
  218.     printf ("and the top line of +'s may be scrolled away.");
  219.     cup (17, 10);
  220.     printf ("Of course, a good VT100-compatible terminal should have");
  221.     cup (18, 10);
  222.     printf ("means of shutting this bug off (if it has it at all!)");
  223.     cup (20, 10);
  224.     getlin ("Push <RETURN>");
  225.  
  226.     ed (2);
  227.     tbc (3);
  228.     cup (1, 1);
  229.     for (col = 1; col <= 78; col + = 3) {
  230.     cuf (3);
  231.     hts ();
  232.     }
  233.     cup (1, 4);
  234.     for (col = 4; col <= 78; col + = 6) {
  235.     tbc (0);
  236.     cuf (6);
  237.     }
  238.     cup (1, 7);
  239.     tbc (1);
  240.     tbc (2);                        /* no-op */
  241.     cup (1, 1);
  242.     for (col = 1; col <= 78; col + = 6)
  243.     printf ("\t*");
  244.     cup (2, 2);
  245.     for (col = 2; col <= 78; col + = 6)
  246.     printf ("     *");
  247.     cup (4, 1);
  248.     getlin ("These two lines should look the same. Push <RETURN>");
  249.     sm ("?3");                        /* 132 cols */
  250.     ed (2);                        /* VT100 clears screen on SM3/RM3, but not obviously, so... */
  251.     cup (1, 1);
  252.     tbc (3);
  253.     for (col = 1; col <= 132; col + = 8) {
  254.     cuf (8);
  255.     hts ();
  256.     }
  257.     cup (1, 1);
  258.     for (col = 1; col <= 130; col + = 10)
  259.     printf ("1234567890");
  260.     printf ("12");
  261.     cup (3, 1);
  262.     getlin ("This is 132 column mode. Push <RETURN>");
  263.     rm ("?3");                        /* 80 cols */
  264.     ed (2);                        /* VT100 clears screen on SM3/RM3, but not obviously, so... */
  265.     cup (1, 1);
  266.     for (col = 1; col <= 80; col + = 10)
  267.     printf ("1234567890");
  268.     cup (3, 1);
  269.     getlin ("This is 80 column mode. Push <RETURN>");
  270.     ed (2);
  271.     sm ("?6");                        /* Origin mode (relative) */
  272.     for (soft = -1; soft <= 0; soft++) {
  273.     if (soft)
  274.         sm ("?4");
  275.     else
  276.         rm ("?4");
  277.     for (row = 12; row >= 1; row - = 11) {
  278.         pcstbm (row, 24 - row + 1);
  279.         ed (2);
  280.         for (down = 0; down >= -1; down--) {
  281.         if (down)
  282.             cuu (24);
  283.         else
  284.             cud (24);
  285.         for (i = 1; i <= 30; i++) {
  286.             printf ("%s scroll %s region %d Line %d\n",
  287.                 soft ? "Soft" : "Jump",
  288.                 down ? "down" : "up",
  289.                 2 * (13 - row), i);
  290.             if (down) {
  291.             ri ();
  292.             ri ();
  293.             }
  294.         }
  295.         }
  296.         getlin ("Push <RETURN>");
  297.     }
  298.     }
  299.     ed (2);
  300.     pcstbm (23, 24);
  301.     printf ("\nThis line should be at the bottom of the screen.");
  302.     cup (1, 1);
  303.     printf ("This line should be the one above the bottom of the screeen.");
  304.     getlin (" Push <RETURN>");
  305.     ed (2);
  306.     rm ("?6");                        /* Origin mode (absolute) */
  307.     cup (24, 1);
  308.     printf ("This line should be at the bottom of the screen.");
  309.     cup (1, 1);
  310.     printf ("This line should be at the top of the screen.");
  311.     getlin (" Push <RETURN>");
  312.     pcstbm (1, 24);
  313. }
  314.  
  315. tst_characters () {
  316.                             /* Test of: PCLL   (Load LEDs) SCS    (Select Character Set)
  317.                                SGR    (Select Graphic Rendition) SM RM  (Set/Reset Mode) -
  318.                                Inverse PCSC   (Save Cursor) PCRC   (Restore Cursor) */
  319.  
  320.     int     i, j, g, cset;
  321.     char   *tststr, chcode[5], *setmsg[5], *ledmsg[6], *ledseq[6], *attr[5];
  322.  
  323.     tststr = "*qx`";
  324.  
  325.     chcode[0] = 'A';
  326.     chcode[1] = 'B';
  327.     chcode[2] = '0';
  328.     chcode[3] = '1';
  329.     chcode[4] = '2';
  330.     setmsg[0] = "UK / national (character set A)";
  331.     setmsg[1] = "US ASCII (B)";
  332.     setmsg[2] = "Special graphics and line drawing (0)";
  333.     setmsg[3] = "Alternate character ROM standard characters (1)";
  334.     setmsg[4] = "Alternate character ROM special graphics (2)";
  335.  
  336.     ledmsg[0] = "L1 L2 L3 L4";
  337.     ledseq[0] = "1;2;3;4";
  338.     ledmsg[1] = "   L2 L3 L4";
  339.     ledseq[1] = "1;0;4;3;2";
  340.     ledmsg[2] = "   L2 L3";
  341.     ledseq[2] = "1;4;;2;3";
  342.     ledmsg[3] = "L1 L2";
  343.     ledseq[3] = ";;2;1";
  344.     ledmsg[4] = "L1";
  345.     ledseq[4] = "1";
  346.     ledmsg[5] = "";
  347.     ledseq[5] = "";
  348.  
  349.     attr[0] = ";0";
  350.     attr[1] = ";1";
  351.     attr[2] = ";4";
  352.     attr[3] = ";5";
  353.     attr[4] = ";7";
  354.  
  355.     ed (2);
  356.     cup (10, 1);
  357.     printf ("These LEDs (\"lamps\") on the keyboard should be on:");
  358.     for (i = 0; i <= 5; i++) {
  359.     cup (10, 52);
  360.     el (0);
  361.     printf (ledmsg[i]);
  362.     pcll ("0");
  363.     pcll (ledseq[i]);
  364.     cup (12, 1);
  365.     getlin ("Push <RETURN>");
  366.     }
  367.     ed (2);
  368.     cup (1, 10);
  369.     printf ("Selected as G0 (with SI)");
  370.     cup (1, 48);
  371.     printf ("Selected as G1 (with SO)");
  372.     for (cset = 0; cset <= 4; cset++) {
  373.     scs (1, 'B');
  374.     cup (3 + 4 * cset);
  375.     sgr ("1");
  376.     printf (setmsg[cset]);
  377.     sgr ("0");
  378.     for (g = 0; g <= 1; g++) {
  379.         scs (g, chcode[cset]);
  380.         for (i = 1; i <= 3; i++) {
  381.         cup (3 + 4 * cset + i, 10 + 38 * g);
  382.         for (j = 0; j <= 31; j++) {
  383.             printf ("%c", i * 32 + j);
  384.         }
  385.         }
  386.     }
  387.     }
  388.     scs (1, 'B');
  389.     cup (24, 1);
  390.     getlin ("These are the installed character sets. Push <RETURN>");
  391.  
  392.     ed (2);
  393.     cup (1, 20);
  394.     printf ("Graphic rendition test pattern:");
  395.     cup (4, 1);
  396.     sgr ("0");
  397.     printf ("vanilla");
  398.     cup (4, 40);
  399.     sgr ("0;1");
  400.     printf ("bold");
  401.     cup (6, 6);
  402.     sgr (";4");
  403.     printf ("underline");
  404.     cup (6, 45);
  405.     sgr (";1");
  406.     sgr ("4");
  407.     printf ("bold underline");
  408.     cup (8, 1);
  409.     sgr ("0;5");
  410.     printf ("blink");
  411.     cup (8, 40);
  412.     sgr ("0;5;1");
  413.     printf ("bold blink");
  414.     cup (10, 6);
  415.     sgr ("0;4;5");
  416.     printf ("underline blink");
  417.     cup (10, 45);
  418.     sgr ("0;1;4;5");
  419.     printf ("bold underline blink");
  420.     cup (12, 1);
  421.     sgr ("1;4;5;0;7");
  422.     printf ("negative");
  423.     cup (12, 40);
  424.     sgr ("0;1;7");
  425.     printf ("bold negative");
  426.     cup (14, 6);
  427.     sgr ("0;4;7");
  428.     printf ("underline negative");
  429.     cup (14, 45);
  430.     sgr ("0;1;4;7");
  431.     printf ("bold underline negative");
  432.     cup (16, 1);
  433.     sgr ("1;4;;5;7");
  434.     printf ("blink negative");
  435.     cup (16, 40);
  436.     sgr ("0;1;5;7");
  437.     printf ("bold blink negative");
  438.     cup (18, 6);
  439.     sgr ("0;4;5;7");
  440.     printf ("underline blink negative");
  441.     cup (18, 45);
  442.     sgr ("0;1;4;5;7");
  443.     printf ("bold underline blink negative");
  444.     sgr ("");
  445.  
  446.     rm ("?5");                        /* Inverse video off */
  447.     cup (23, 1);
  448.     el (0);
  449.     getlin ("Black background. Push <RETURN>");
  450.     sm ("?5");                        /* Inverse video */
  451.     cup (23, 1);
  452.     el (0);
  453.     getlin ("Inverse video. Push <RETURN>");
  454.     rm ("?5");
  455.     ed (2);
  456.     cup (8, 12);
  457.     printf ("normal");
  458.     cup (8, 24);
  459.     printf ("bold");
  460.     cup (8, 36);
  461.     printf ("underscored");
  462.     cup (8, 48);
  463.     printf ("blinking");
  464.     cup (8, 60);
  465.     printf ("reversed");
  466.     cup (10, 1);
  467.     printf ("stars:");
  468.     cup (12, 1);
  469.     printf ("line:");
  470.     cup (14, 1);
  471.     printf ("x'es:");
  472.     cup (16, 1);
  473.     printf ("diamonds:");
  474.     for (cset = 0; cset <= 3; cset++) {
  475.     for (i = 0; i <= 4; i++) {
  476.         cup (10 + 2 * cset, 12 + 12 * i);
  477.         sgr (attr[i]);
  478.         if (cset == 0 || cset == 2)
  479.         scs (0, 'B');
  480.         else
  481.         scs (0, '0');
  482.         for (j = 0; j <= 4; j++) {
  483.         printf ("%c", tststr[cset]);
  484.         }
  485.         pcsc ();
  486.         cup (cset + 1, i + 1);
  487.         sgr ("");
  488.         scs (0, 'B');
  489.         printf ("A");
  490.         pcrc ();
  491.         for (j = 0; j <= 4; j++) {
  492.         printf ("%c", tststr[cset]);
  493.         }
  494.     }
  495.     }
  496.     sgr ("0");
  497.     scs (0, 'B');
  498.     cup (22, 1);
  499.     printf ("There should be 10 characters of each flavour, and a rectangle\n");
  500.     getlin ("of 5 x 4 A's filling the top left of the screen. Push <RETURN>");
  501. }
  502.  
  503. tst_doublesize () {
  504.                             /* Test of: PCSWL  (Single Width Line) PCDWL  (Double Width
  505.                                Line) PCDHL  (Double Height Line) (also implicit double
  506.                                width) */
  507.  
  508.     int     i, w, w1;
  509.  
  510.  /* Print the test pattern in both 80 and 132 character width  */
  511.  
  512.     for (w = 0; w <= 1; w++) {
  513.     w1 = 13 * w;
  514.  
  515.     ed (2);
  516.     cup (1, 1);
  517.     if (w) {
  518.         sm ("?3");
  519.         printf ("132 column mode");
  520.     }
  521.     else {
  522.         rm ("?3");
  523.         printf (" 80 column mode");
  524.     }
  525.  
  526.     cup (5, 3 + 2 * w1);
  527.     printf ("v------- left margin");
  528.  
  529.     cup (7, 3 + 2 * w1);
  530.     printf ("This is a normal-sized line");
  531.     pcdhl (0);
  532.     pcdhl (1);
  533.     pcdwl ();
  534.     pcswl ();
  535.  
  536.     cup (9, 2 + w1);
  537.     printf ("This is a Double-width line");
  538.     pcswl ();
  539.     pcdhl (0);
  540.     pcdhl (1);
  541.     pcdwl ();
  542.  
  543.     cup (11, 2 + w1);
  544.     pcdwl ();
  545.     pcswl ();
  546.     pcdhl (1);
  547.     pcdhl (0);
  548.     printf ("This is a Double-width-and-height line");
  549.     cup (12, 2 + w1);
  550.     pcdwl ();
  551.     pcswl ();
  552.     pcdhl (0);
  553.     pcdhl (1);
  554.     printf ("This is a Double-width-and-height line");
  555.  
  556.     cup (14, 2 + w1);
  557.     pcdwl ();
  558.     pcswl ();
  559.     pcdhl (1);
  560.     pcdhl (0);
  561.     el (2);
  562.     printf ("This is another such line");
  563.     cup (15, 2 + w1);
  564.     pcdwl ();
  565.     pcswl ();
  566.     pcdhl (0);
  567.     pcdhl (1);
  568.     printf ("This is another such line");
  569.  
  570.     cup (17, 3 + 2 * w1);
  571.     printf ("^------- left margin");
  572.  
  573.     cup (21, 1);
  574.     printf ("This is not a double-width line");
  575.     for (i = 0; i <= 1; i++) {
  576.         cup (21, 6);
  577.         if (i) {
  578.         printf ("**is**");
  579.         pcdwl ();
  580.         }
  581.         else {
  582.         printf ("is not");
  583.         pcswl ();
  584.         }
  585.         cup (23, 1);
  586.         getlin ("Push <RETURN>");
  587.     }
  588.     }
  589.  
  590.     rm ("?3");
  591.     ed (2);
  592.  
  593.     scs (0, '0');
  594.     cup (8, 1);
  595.     pcdhl (0);
  596.     printf ("lqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqk");
  597.     cup (9, 1);
  598.     pcdhl (1);
  599.     printf ("lqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqk");
  600.     cup (10, 1);
  601.     pcdhl (0);
  602.     printf ("x                                   x");
  603.     cup (11, 1);
  604.     pcdhl (1);
  605.     printf ("x                                   x");
  606.     cup (12, 1);
  607.     pcdhl (0);
  608.     printf ("x                                   x");
  609.     cup (13, 1);
  610.     pcdhl (1);
  611.     printf ("x                                   x");
  612.     cup (14, 1);
  613.     pcdhl (0);
  614.     printf ("x                                   x");
  615.     cup (15, 1);
  616.     pcdhl (1);
  617.     printf ("x                                   x");
  618.     cup (16, 1);
  619.     pcdhl (0);
  620.     printf ("mqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqj");
  621.     cup (17, 1);
  622.     pcdhl (1);
  623.     printf ("mqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqj");
  624.     scs (0, 'B');
  625.     sgr ("1;5");
  626.     cup (12, 3);
  627.     printf ("The mad programmer strikes again!");
  628.     cup (13, 3);
  629.     printf ("The mad programmer strikes again!");
  630.     sgr ("0");
  631.     cup (22, 1);
  632.     printf ("Another test pattern...  a frame with blinking bold text,\n");
  633.     getlin ("all in double-height double-width size.  Push <RETURN>");
  634.  
  635.  /* the FACIT 4431 has a bug when you scroll    */
  636.                             /* down doublesized text thru the bottom line. */
  637.  
  638.     pcstbm (8, 24);
  639.     cup (8, 1);                        /* We are in absolute origin mode */
  640.     for (i = 1; i <= 12; i++)
  641.     ri ();
  642.     cup (1, 1);
  643.     getlin ("Exactly half of the box should remain. Push <RETURN>");
  644. }
  645.  
  646. tst_reports () {
  647.                             /* Test of: <ENQ> (AnswerBack Message) SM RM  (Set/Reset Mode)
  648.                                - LineFeed / Newline - Cursor Keys - Keypad */
  649.     ;
  650. }
  651.  
  652. tst_vt52 () {
  653.                             /* Test of: SM RM  (Set/Reset Mode) - ANSI / VT52 */
  654.     ;
  655. }
  656.  
  657. esc (s) char   *s; {
  658.     printf ("%c%s", 27, s);
  659. }
  660.  
  661. esc2 (s1, s2) char  s1, s2; {
  662.     printf ("%c%s%s", 27, s1, s2);
  663. }
  664.  
  665. brcstr (ps, c) char *ps, c; {
  666.     printf ("%c[%s%c", 27, ps, c);
  667. }
  668.  
  669. brc (pn, c) int pn;
  670. char    c; {
  671.     char   *str, *ptr;
  672.     ptr = str = "[    ";
  673.     ptr++;
  674.     if (pn > 99) {
  675.     *ptr++ = (pn / 100) + 48;
  676.     pn % = 100;
  677.     }
  678.     if (pn > 9) {
  679.     *ptr++ = (pn / 10) + 48;
  680.     pn % = 10;
  681.     }
  682.     *ptr++ = pn + 48;
  683.     *ptr++ = c;
  684.     *ptr = '\0';
  685.     printf ("%c%s", 27, str);
  686. }
  687.  
  688. brc2 (pn1, pn2, c) int  pn1, pn2;
  689. char    c; {
  690.     char   *str, *ptr;
  691.     ptr = str = "[        ";
  692.     ptr++;
  693.     if (pn1 > 99) {
  694.     *ptr++ = (pn1 / 100) + 48;
  695.     pn1 % = 100;
  696.     }
  697.     if (pn1 > 9) {
  698.     *ptr++ = (pn1 / 10) + 48;
  699.     pn1 % = 10;
  700.     }
  701.     *ptr++ = pn1 + 48;
  702.     *ptr++ = ';';
  703.     if (pn2 > 99) {
  704.     *ptr++ = (pn2 / 100) + 48;
  705.     pn2 % = 100;
  706.     }
  707.     if (pn2 > 9) {
  708.     *ptr++ = (pn2 / 10) + 48;
  709.     pn2 % = 10;
  710.     }
  711.     *ptr++ = pn2 + 48;
  712.     *ptr++ = c;
  713.     *ptr = '\0';
  714.     printf ("%c%s", 27, str);
  715. }
  716.  
  717. char   *readto (c) char c; {
  718.  
  719.  /* read characters one-by-one without echo until c is read. */
  720.  
  721.  /* NOT YET IMPLEMENTED! */
  722.  
  723.     return ("Not Yet Implemented!!");
  724. }
  725.  
  726. cub (pn) int    pn; {                    /* Cursor Backward */
  727.     brc (pn, 'D');
  728. }
  729. cud (pn) int    pn; {                    /* Cursor Down */
  730.     brc (pn, 'B');
  731. }
  732. cuf (pn) int    pn; {                    /* Cursor Forward */
  733.     brc (pn, 'C');
  734. }
  735. cup (pn1, pn2) int  pn1, pn2; {                /* Cursor Position */
  736.     brc2 (pn1, pn2, 'H');
  737. }
  738. cuu (pn) int    pn; {                    /* Cursor Up */
  739.     brc (pn, 'A');
  740. }
  741. da (pn) {                        /* Device Attributes */
  742.     char   *str;
  743.     brc (pn, 'c');
  744.     str = readto ('c');
  745. }
  746. pcaln () {                        /* Screen Alignment Display */
  747.     esc ("#8");
  748. }
  749. pcdhl (lower) int   lower; {                /* Double Height Line (also double width) */
  750.     if (lower)
  751.     esc ("#4");
  752.     else
  753.     esc ("#3");
  754. }
  755. pcdwl () {                        /* Double Wide Line */
  756.     esc ("#6");;
  757. }
  758. pcid () {                        /* Identify Terminal (obsolete) */
  759.     esc ("Z");
  760. }
  761. pckpam () {                        /* Keypad Application Mode */
  762.     esc ("=");;
  763. }
  764. pcpnm () {                        /* Keypad Numeric Mode */
  765.     esc (">");
  766. }
  767. pcll (ps) char *ps; {                    /* Load LEDs */
  768.     brcstr (ps, 'q');
  769. }
  770. pcrc () {                        /* Restore Cursor */
  771.     esc ("8");
  772. }
  773. pcreqtparm (pn) {                    /* Request Terminal Parameters */
  774.     char   *str;
  775.     brc (pn, 'x');
  776.     str = readto ('x');
  777. }
  778. pcsc () {                        /* Save Cursor */
  779.     esc ("7");;
  780. }
  781. pcstbm (pn1, pn2) int   pn1, pn2; {            /* Set Top and Bottom Margins */
  782.     brc2 (pn1, pn2, 'r');
  783. }
  784. pcswl () {                        /* Single With Line */
  785.     esc ("#5");
  786. }
  787. pctst (pn) int  pn; {                    /* Invoke Confidence Test */
  788.     brc2 (2, pn, 'y');
  789. }
  790. dsr (pn) {                        /* Device Status Report */
  791.     char   *str;
  792.     brc (pn, 'n');
  793.     str = readto ('n');
  794. }
  795. ed (pn) int pn; {                    /* Erase in Display */
  796.     brc (pn, 'J');
  797. }
  798. el (pn) int pn; {                    /* Erase in Line */
  799.     brc (pn, 'K');
  800. }
  801. hts () {                        /* Horizontal Tabulation Set */
  802.     esc ("H");
  803. }
  804. hvp (pn1, pn2) int  pn1, pn2; {                /* Horizontal and Vertical Position */
  805.     brc2 (pn1, pn2, 'f');
  806. }
  807. ind () {                        /* Index */
  808.     esc ("D");
  809. }
  810. mc (pn) int pn; {                    /* Media Copy (Not VT100?) */
  811.     brc (pn, 'i');
  812. }
  813. nel () {                        /* Next Line */
  814.     esc ("E");
  815. }
  816. ri () {                            /* Reverse Index */
  817.     esc ("M");
  818. }
  819. ris () {                        /* Reset to Initial State */
  820.     esc ("c");
  821. }
  822. rm (ps) char   *ps; {                    /* Reset Mode */
  823.     brcstr (ps, 'l');
  824. }
  825. scs (g, c) int  g;
  826. char    c; {                        /* Select character Set */
  827.     printf ("%c%c%c%c%c%c%c", 27, g ? ')' : '(', c,
  828.         27, g ? '(' : ')', 'B',
  829.         g ? 14 : 15);
  830. }
  831. sgr (ps) char  *ps; {                    /* Select Graphic Rendition */
  832.     brcstr (ps, 'm');
  833. }
  834. sm (ps) char   *ps; {                    /* Set Mode */
  835.     brcstr (ps, 'h');
  836. }
  837. tbc (pn) int    pn; {                    /* Tabulation Clear */
  838.     brc (pn, 'g');
  839. }
  840.  
  841. inittype () {
  842.  
  843.     int     ok;
  844.     char   *answer;
  845.  
  846.     answer = "vt102";
  847.     goto frotz;                        /* Bypass this code for now. */
  848.  
  849.     printf ("Compatibility test of terminal with respect to VT100\n\n\n");
  850.     do {
  851.     answer = (getlin ("What is your terminal type (vt100, vt102)? "));
  852.     ok = (strcmp (answer, "vt100") == 0) ||
  853.          (strcmp (answer, "vt102") == 0);
  854.     if (!ok)
  855.         printf ("Type 'vt100' or 'vt102'!\n");
  856.     }
  857.     while (!ok);
  858.  
  859. frotz:                             /* bypass hack         */
  860.  
  861.  /* Set up my personal prejudices     */
  862.  
  863.     esc ("<");                        /* Enter ANSI mode (if in VT52 mode)     */
  864.     rm ("?3");                        /* 80 col mode         */
  865.     rm ("?5");                        /* Black background     */
  866.     sm ("?7");                        /* Wrap around on     */
  867.  
  868.     return ((strcmp (answer, "vt100") == 0) ? vt100 : vt102);
  869. }
  870.  
  871. bye () {
  872.                             /* Force my personal prejudices upon the poor luser     */
  873.  
  874.     rm ("?3");                        /* 80 col mode         */
  875.     rm ("?5");                        /* Black background     */
  876.     rm ("?6");                        /* Absolute origin mode     */
  877.     sm ("?7");                        /* Wrap around on     */
  878.     pcstbm (0, 0);                    /* No scroll region     */
  879.  
  880.  /* Say goodbye */
  881.  
  882.     ed (2);
  883.     cup (12, 30);
  884.     printf ("That's all, folks!\n\n");
  885.     exit (3);
  886. }
  887.  
  888.  
  889.