home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / simtel / sigm / vols000 / vol069 / install.pas < prev    next >
Pascal/Delphi Source File  |  1984-04-29  |  20KB  |  710 lines
  1. PROGRAM INSTALL;
  2. {++++++++++++++++++++++++++++++++++++++++++++++++++++++++}
  3. {+ WRITTEN BY:         Raymond E. Penley        +}
  4. {+ DATE WRITTEN:     September 19, 1981        +}
  5. {+                            +}
  6. {+ SUMMARY:                        +}
  7. {+    Writes a data file 'TERMIO.FIL' that may be used    +}
  8. {+  by a User Prgm for different terminal types without +}
  9. {+  having to rewrite the source prgm.            +}
  10. {+                            +}
  11. {+ NOTES:                        +}
  12. {+   The variable definitions for all the terminals    +}
  13. {+  are not complete.  Please modify for your terminal    +}
  14. {+  and send a copy of the changes to the Pascal/Z    +}
  15. {+  Users' Group.  Thank you.                           +}
  16. {+                            +}
  17. {+    writes()           - write a sequence to console    +}
  18. {+    puts()           - write a sequence to disk file    +}
  19. {+    gets()           - read a sequence from disk file +}
  20. {+    closes()           - writes nulls to data file    +}
  21. {+    concats()        - concatenates 2 short sequences +}
  22. {+    clear_screen     -                +}
  23. {+    gotoxy(xy)       - position to XY coordinates    +}
  24. {+                            +}
  25. {++++++++++++++++++++++++++++++++++++++++++++++++++++++++}
  26.  
  27. CONST
  28.   alphalen = 10;
  29.   default = 80;
  30.  
  31. TYPE
  32.   BYTE = 0..255;
  33.   alpha = array [0..alphalen] of byte;
  34.   BFILE = FILE OF BYTE;
  35.   DSTRING = STRING DEFAULT;
  36.   STRING34 = PACKED ARRAY [1..34] OF CHAR;
  37.   STRING0 = STRING 0;
  38.   STRING10 = STRING 10;
  39.   STRING255 = STRING 255;
  40.  
  41. VAR
  42.   bell     : char;    { ASCII value for terminal bell character }
  43.   bx     : byte;    { global byte indexer }
  44.   ESC     : BYTE;    { ASCII escape character }
  45.   ix     : integer;    { global integer indexer }
  46.   NULL     : BYTE;    { ASCII null character }
  47.   selected : BOOLEAN;    { a terminal has been selected flag }
  48.   termio : BFILE;    { terminal data file   }
  49.   termtype : byte;
  50.   VALID  : BOOLEAN;
  51.  
  52.      { first 5 bytes for some misc terminal values }
  53.    DELMIS,        { delay after other functions. e.g. home up }
  54.    DELCUS,        { delay after direct addressing of cursor }
  55.    X_OFF,        { offset to add to column }
  56.    Y_OFF,        { offset to add to row }
  57.    XY         : BYTE;    { flag for column/row or row/column addressing scheme }
  58.      { string sequences }
  59.    CLRSCR,        { CLEAR SCREEN }
  60.    CUR,         { CURSOR ADDRESSING LEADIN STRING }
  61.    eraeos,        { CLEAR TO END OF SCREEN }
  62.    eraeol,        { CLEAR TO END OF LINE }
  63.    HOME,        { HOME UP CURSOR }
  64.    LockKbd,        { Lock KEYBOARD }
  65.    UnlockKbd,        { Unlock KEYBOARD }
  66.    LINDEL,        { delete screen line containing cursor }
  67.    LININS,        { insert a blank line on screen }
  68.    INVON,        { turn on highlighting - inverse video }
  69.    INVOFF,        { turn off highlighting }
  70.    CRSON,        { SET CURSOR ON AND BLINKING }
  71.    CRSOFF : ALPHA;    { SET CURSOR DISPLAY OFF }
  72.  
  73.  
  74. function length(x:string255): integer;external;
  75.  
  76. procedure setlength(var x: string0; y: integer); external;
  77.  
  78. procedure keyin(var c: char); external;
  79.  
  80. function toupper(ch: char): char;
  81. begin
  82.   if  (('a'<=ch) and (ch<='z')) then
  83.     toupper := chr(ord(ch)-32)
  84.   else
  85.     toupper := ch
  86. end{ of toupper };
  87.  
  88.  
  89. procedure writes( strng: alpha );
  90. { writes writes a string of type alpha to the console
  91.   device. }
  92. var    ix: byte;
  93. begin
  94.   for ix:=1 to strng[0] do
  95.     write( chr(strng[ix]) )
  96. end{ of writes };
  97.  
  98.  
  99. procedure puts( var fb: BFILE; var strng: alpha );
  100. { procedure puts writes a string of type alpha
  101.   to the specified file of type BFILE. }
  102. var    ix: byte;
  103. begin
  104.   write( fb, strng[0]:1 );      { length byte }
  105.   for ix:=1 to strng[0] do
  106.     write( fb, strng[ix]:1 )
  107. end{ of puts };
  108.  
  109.  
  110. procedure gets( var fb: BFILE; var strng: alpha );
  111. { procedure gets reads a string of type alpha from the
  112.   specified file of type BFILE. }
  113. var    ix: byte;
  114. begin
  115.   read( fb, strng[0] );     { first byte is always length }
  116.   for ix:=1 to strng[0] do
  117.     read( fb, strng[ix] )
  118. end{ of gets };
  119.  
  120.  
  121. procedure closes( var fb: BFILE );
  122. { closes marks the end of file with 8 nulls }
  123. var    ix: 1..8;
  124.     null : byte;
  125. begin
  126.   null := 0;
  127.   for ix:=1 to 8 do
  128.      write( fb, null:1 )
  129. end;
  130.  
  131.  
  132. procedure concats( var first, second, new: alpha );
  133. { concatenates two short strings of type alpha into
  134.   a third string "new".
  135.   e.g.       concats( INVON, REVERSE, RVON );
  136. }
  137. var    ix,k,k1: byte;
  138. begin
  139.   if ( first[0] + second[0] ) <= alphalen then begin
  140.      k := first[0];    { length(first) }
  141.      k1 := second[0];    { length(second) }
  142.      for ix:=1 to k do new[ix] := first[ix];
  143.      for ix:=1 to k1 do new[k+ix] := second[ix];
  144.      new[0] := k + k1
  145.   end
  146.   else
  147.      new[0] := 0
  148. end{ of concats };
  149.  
  150.  
  151.  
  152.     {++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++}
  153.     {+ THE FOLLOWING PROCEDURES ARE TO BE USED IN YOUR PROGRAMS +}
  154.     {++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++}
  155.  
  156. Procedure Clear_Screen;
  157. var    ix: byte;
  158. begin
  159.   writes( CLRSCR );
  160.   for ix:=0 to DELMIS do {}
  161. end;
  162.  
  163.  
  164. Procedure gotoxy(x_coord, y_coord: integer);
  165. var    ix, x_pos, y_pos: integer;
  166. begin
  167.   X_POS := x_coord + X_OFF;
  168.   Y_POS := y_coord + Y_OFF;
  169.   IF ( XY=2 ) AND ( X_POS<31 ) THEN X_POS := X_POS + 96;
  170.   writes( CUR );
  171.   IF ( XY=1 ) OR ( XY=2 ) THEN
  172.     write( CHR(X_POS), CHR(Y_POS) )
  173.   ELSE
  174.     write( CHR(Y_POS), CHR(X_POS) );
  175.   for ix:=0 TO DELCUS do {}
  176. end;
  177.  
  178.  
  179. PROCEDURE CVRT( alphanum   : dstring;  { input string to be parsed }
  180.         var vector : alpha;    { returned values }
  181.         var len    : integer;  { count of # of values returned }
  182.         low_check,           { low range }
  183.         high_check : integer); { high range }
  184. { RETURNS len = -1 for any errors }
  185. label 2;{quick exit}
  186. var    error  : boolean;
  187.     int    : integer; { integer number returned by IVAL }
  188.     rng    : integer; { Range of alphanumeric string.   }
  189.               { required by IVAL            }
  190.  
  191. {$iDELETE.LIB }
  192.  
  193. {$iIVAL.LIB }
  194.  
  195. BEGIN { parse alphanum, check for errors }
  196.   error := false;
  197.   len := 0;
  198.   if length(alphanum)=0 then {EXIT} goto 2;
  199.   Repeat
  200.     rng := IVAL( alphanum, int );
  201.     if ( rng>0 ) then begin { valid digit entered }
  202.        if int<low_check then begin { valid integer but < low range }
  203.      writeln( bell, int, ' less than ', low_check:1, '. Reenter');
  204.      error := true
  205.        end{if int<low_check}
  206.        else if int>high_check then begin { valid integer but > high range }
  207.      writeln( bell, int, ' exceeds ', high_check:1, '. Reenter');
  208.      error := true
  209.        end{if int>high_check}
  210.        else begin { digits in range low_check..high_check }
  211.      len := len + 1;
  212.      vector[len] := int
  213.        end{else};
  214.        { compress input string until all gone }
  215.        delete( alphanum, 1, rng-1 )
  216.     end{ if rng > 0 };
  217.     if ( rng<0 ) then begin { integer exceeds maxint }
  218.       writeln( bell, ' overflow');
  219.       error := true
  220.     end
  221.   Until ( rng<=0 ) or ( error );
  222.   if error then len := -1;
  223. 2:{quick exit}
  224. End{ of CVRT };
  225.  
  226.  
  227. PROCEDURE CREATE;
  228. VAR  ix       : byte;
  229.      done     : boolean;
  230.      len      : integer;
  231.      t          : alpha;
  232.      answer   : dstring;
  233.  
  234.    PROCEDURE DO_strng( S: DSTRING; VAR strng: alpha );
  235.    begin
  236.      Repeat
  237.        done := false;
  238.        writeln; writeln;
  239.        writeln('*** ', S, ' ***               Normally 2 or more bytes.');
  240.        writeln;
  241.        write(' ':12, 'Present Values               --->');
  242.        if strng[0]>0 then
  243.      for ix:=1 to strng[0] do write( strng[ix]:4 );
  244.        writeln;
  245.        write(' ':12, 'Enter New Values or Return   ---> ');
  246.        readln(answer);
  247.        CVRT( answer, t, len, 0, 255 );
  248.        if len=0 then done := true
  249.        else if len>0 then begin
  250.       strng[0] := len;
  251.       for ix:=1 to len do strng[ix] := t[ix]
  252.        end
  253.        { else len<0 so error }
  254.      Until ( done )
  255.    END{ of Q };
  256.  
  257.    PROCEDURE DO_abyte( S: DSTRING; VAR abyte: byte );
  258.    BEGIN
  259.      Repeat
  260.        done := false;
  261.        writeln; writeln;
  262.        writeln('*** ', S, ' ***               Normally 1 Byte.');
  263.        writeln;
  264.        writeln(' ':12, 'Present Value                --->', abyte:4 );
  265.        write(  ' ':12, 'Enter New Value or Return    ---> ');
  266.        readln(answer);
  267.        CVRT( answer, t, len, 0, 255 );
  268.        if len=0 then
  269.      done := true
  270.        else if len>0 then
  271.      abyte := t[1]
  272.        { else len<0 so error }
  273.      Until ( done )
  274.    END{ of P };
  275.  
  276.  
  277. BEGIN{ CREATE }
  278.   WRITELN; ; WRITELN;
  279.   WRITELN('Enter Decimal Equiv. of Esc Sequence separated by CR');
  280.   WRITELN;
  281.  
  282.   DO_strng('Clear Screen Code', CLRSCR);
  283.  
  284.   DO_abyte('Delay for Clear Screen', DELMIS );
  285.  
  286.   DO_abyte('Delay for Cursor Addr', DELCUS );
  287.  
  288.   DO_abyte('Column Offset', X_OFF );
  289.  
  290.   DO_abyte('Row Offset', Y_OFF );
  291.  
  292.   WRITELN(' ':18, 'Cursor Addressing Scheme');
  293.   writeln; writeln;
  294.   writeln('Direct cursor positioning e.g. Escape + "=" + Column + Row');
  295.  
  296.   DO_strng('Cursor Leadin String', CUR);
  297.   writeln;writeln;
  298.   writeln('Column/Row or Row/Column flag');
  299.   writeln('ENTER:');
  300.   writeln('   0 = ROW/COLUMN = Row first <most terminals>');
  301.   writeln('   1 = COLUMN/ROW = Column first');
  302.   writeln('   2 = Hazeltine terminal');
  303.   Repeat
  304.     done := false;
  305.     writeln;
  306.     writeln(' ':12, 'Present Value                --->', XY:3 );
  307.     write(  ' ':12, 'Enter New Value or Return    ---> ');
  308.     readln(answer);
  309.     CVRT( answer, t, len, 0, 2 );
  310.     if len=0 then done := true
  311.     else if len>0 then XY := t[1]
  312.   Until ( done );
  313.  
  314.   DO_strng('Clear to End of Screen', eraeos);
  315.  
  316.   DO_strng('Clear to End of Line', eraeol);
  317.  
  318.   DO_strng('Home Command Code', HOME);
  319.  
  320.   DO_strng('Keyboard Lock Code', LockKbd);
  321.  
  322.   DO_strng('Keyboard Unlock Code', UnlockKbd);
  323.  
  324.   DO_strng('Delete Screen line Code', LINDEL);
  325.  
  326.   DO_strng('Insert blank line Code', LININS);
  327.  
  328.   DO_strng('Inverse Video On', INVON);
  329.  
  330.   DO_strng('Inverse Video Off', INVOFF);
  331.  
  332.   DO_strng('Cursor Display On', CRSON);
  333.  
  334.   DO_strng('Cursor Display Off', CRSOFF);
  335.  
  336.   { additional strings may be entered here }
  337.  
  338. END{ of CREATE };
  339.  
  340.  
  341. Procedure InitDefault;
  342. begin
  343.    { INIT SOME TERMINAL VARIABLES TO STANDARD DEFINITIONS }
  344.     DELMIS := 20;  { NOTE - YOU MIGHT HAVE TO TRY DIFFERENT VALUES }
  345.     DELCUS := 20;  { DEPENDING ON THE REACTIONS OF YOUR TERMINAL.  }
  346.     XY := 0;
  347.     X_OFF := 32;
  348.     Y_OFF := 32;
  349.    { INITIALIZE LENGTHS OF STRINGS TO 2 CHARS }
  350.     CLRSCR[0] := 2;
  351.     CUR[0] := 2;
  352.     eraeos[0] := 2;
  353.     eraeol[0] := 2;
  354.     HOME[0] := 2;
  355.     LockKbd[0] := 2;
  356.     UnlockKbd[0] := 2;
  357.     LINDEL[0] := 2;
  358.     LININS[0] := 2;
  359.     INVON[0] := 2;
  360.     INVOFF[0] := 2;
  361.     CRSON[0] := 2;
  362.     CRSOFF[0] := 2;
  363.  
  364.     {++++++++++++++++++++++++++++++++++++++++++++++++++++}
  365.     { DEFAULT PARAMETERS FOR TELEVIDEO 912/920 TERMINALS }
  366.     {++++++++++++++++++++++++++++++++++++++++++++++++++++}
  367.  
  368.     { CLEAR SCREEN }
  369.     CLRSCR[1] := ESC;        CLRSCR[2] := 43;
  370.     { CURSOR POSITIONING LEAD IN STRING }
  371.     CUR[1] := ESC;        CUR[2] := 61;
  372.     { ERASE TO END OF SCREEN }
  373.     eraeos[1]:= ESC;        eraeos[2] := 89;
  374.     { ERASE TO END OF LINE }
  375.     eraeol[1] := ESC;        eraeol[2] := 59;
  376.     HOME[1] := ESC;        HOME[2] := 30;
  377.     LockKbd[1] := ESC;        LockKbd[2] := 35;
  378.     UnlockKbd[1] := ESC;    UnlockKbd[2] := NULL;
  379.     LINDEL[1] := esc;        LINDEL[2] := ord('R');
  380.     LININS[1] := esc;        LININS[2] := ord('E');
  381.     { INVERSE VIDEO ON }
  382.     INVON[1] := ESC;        INVON[2] := ORD('j');
  383.     { INVERSE VIDEO OFF }
  384.     INVOFF[1] := ESC;        INVOFF[2] := ord('k');
  385.     CRSON[1] := NULL;        CRSON[2] := NULL;
  386.     CRSOFF := CRSON;
  387. end{ of InitDefault };
  388.  
  389.  
  390. PROCEDURE INITIALIZE;
  391. { terminal type is not one of those listed or user desires to }
  392. { make changes to terminal data file. }
  393. VAR    ch    : char;
  394.     bx    : byte;
  395.     valid : boolean;
  396.  
  397.    PROCEDURE INIT1;
  398.    BEGIN
  399.    {   INITIALIZE STRING SEQUENCES TO ZERO LENGTH   }
  400.      XY := 0;
  401.      CLRSCR[0] := 0;
  402.      CUR[0] := 0;
  403.      DELMIS := 0;
  404.      CLRSCR[0] := 0;
  405.      DELCUS := 0;
  406.      X_OFF := 0;
  407.      Y_OFF := 0;
  408.      eraeos[0] := 0;
  409.      eraeol[0] := 0;
  410.      HOME[0] := 0;
  411.      LockKbd[0] := 0;
  412.      UnlockKbd[0] := 0;
  413.      INVON[0] := 0;
  414.      INVOFF[0] := 0;
  415.      LINDEL[0] := 0;
  416.      LININS[0] := 0;
  417.      CRSON[0] := 0;
  418.      CRSOFF[0] := 0;
  419.    END{ of INIT1 };
  420.  
  421. BEGIN{ INITIALIZE }
  422.   { First try to open data file. }
  423.   { OPEN file TERMIO.FIL for READ assign termio }
  424.   RESET('TERMIO.FIL',termio);
  425.  
  426.   INIT1; { init string sequences to zero }
  427.  
  428.   { if end of file then file does not exist, so continue to process. }
  429.   if not eof(termio) then begin
  430.     read( termio, bx, DELMIS, DELCUS, X_OFF, Y_OFF, XY );
  431.     gets( termio, CLRSCR );
  432.     gets( termio, CUR );
  433.     gets( termio, eraeos );
  434.     gets( termio, eraeol );
  435.     gets( termio, HOME );
  436.     gets( termio, LockKbd );
  437.     gets( termio, UnlockKbd );
  438.     gets( termio, LINDEL );
  439.     gets( termio, LININS );
  440.     gets( termio, INVON );
  441.     gets( termio, INVOFF );
  442.     gets( termio, CRSON );
  443.     gets( termio, CRSOFF );
  444.   end{if};
  445.  
  446.   { Create new/revised data file }
  447.   CREATE
  448. END{ of INITIALIZE };
  449.  
  450.  
  451. PROCEDURE Menu;
  452. BEGIN
  453.   WRITELN(' 1 - HAZELTINE 1500');
  454.   WRITELN(' 2 - SOROC IQ-120 or IQ-140');
  455.   WRITELN(' 3 - INFOTON I-100');
  456.   WRITELN(' 4 - TELEVIDEO 912 or 920');
  457.   WRITELN(' 5 - BEEHIVE');
  458.   WRITELN(' 6 - HEATH H-19');
  459.   WRITELN(' 7 - ADDS REGENT');
  460.   WRITELN(' 8 - ZENTEC (DYNABYTE 5022)');
  461.   WRITELN(' 9 - DIRECT VP800');
  462.   WRITELN('10 - TRS-80 (Pickles & Trout CP/M)');
  463.   WRITELN('11 - VECTOR GRAPHIC ( w/ 4.0 or newer Monitor ROM)');
  464.   WRITELN('12 - TELEVIDEO 950');
  465.   WRITELN('13 - NONE OF THE ABOVE');
  466.   WRITELN;  WRITELN
  467. END{ of Menu };
  468.  
  469.  
  470. Procedure Write_File;
  471. var    bx : byte;
  472. begin
  473. { OPEN file TERMIO_FIL for WRITE assign termio }
  474.   REWRITE( 'TERMIO.FIL', termio );
  475.   WRITELN; 
  476.  
  477.   bx := 5;     { set length for this string sequence }
  478.   write( termio,        { first 5 bytes in this sequence }
  479.          bx:1,        { length byte }
  480.          DELMIS:1,        { delay - misc }
  481.          DELCUS:1,        { delay - cursor addressing }
  482.          X_OFF:1,        { x-coord offset }
  483.          Y_OFF:1,        { y-coord offset }
  484.          XY:1 );        { col/row or row/col flag }
  485.   puts(termio, CLRSCR);      { CLEAR SCREEN }
  486.   puts(termio, CUR);         { CURSOR LEADIN STRING }
  487.   puts(termio, eraeos);      { CLEAR TO END OF SCREEN }
  488.   puts(termio, eraeol);      { CLEAR TO END OF LINE }
  489.   puts(termio, HOME);         { HOME UP CURSOR }
  490.   puts(termio, LockKbd);     { Lock KEYBOARD }
  491.   puts(termio, UnlockKbd);   { UNLOCK KEYBOARD }
  492.   puts(termio, LINDEL);      { delete screen line containing cursor }
  493.   puts(termio, LININS);      { insert a blank line on screen }
  494.   puts(termio, INVON);         { turn on highlighting - inverse video }
  495.   puts(termio, INVOFF);      { turn off highlighting }
  496.   puts(termio, CRSON);         { cursor display on }
  497.   puts(termio, CRSOFF);      { cursor display off }
  498.   closes( termio );
  499. end{ of Write File };
  500.  
  501.  
  502.  
  503. BEGIN { MAIN PROGRAM }
  504.   FOR bx:=1 TO 24 DO WRITELN;
  505.   bell := chr(7);    { ASCII value bell character }
  506.   ESC := 27;        { ASCII Escape char }
  507.   NULL := 0;        { ASCII Null char   }
  508.   REPEAT
  509.     VALID := TRUE;
  510.     Menu;
  511.     WRITE('Enter Terminal Type to be Used ( 1 - 13 ) : ');
  512.     READLN( termtype );
  513.     IF ( termtype<1 ) OR ( termtype>13 ) THEN BEGIN
  514.       VALID := FALSE;
  515.       WRITELN;
  516.       WRITELN;
  517.       WRITELN(bell, 'Invalid terminal type. Reenter.');
  518.       WRITELN; WRITELN; WRITELN
  519.     END
  520.   UNTIL VALID;
  521.  
  522.   InitDefault;      { INIT SOME TERMINAL VARIABLES TO STANDARD DEFINITIONS }
  523.  
  524.   CASE termtype OF
  525.      1: BEGIN { ******    HAZELTINE TERMINAL ****** }
  526.       CLRSCR[1] := 126;    CLRSCR[2] := 28;
  527.       CUR[1] := 126;    CUR[2] := 17;
  528.       XY := 2;
  529.       X_OFF := 0;
  530.       Y_OFF := 32;
  531.       eraeos[1] := 126;    eraeos[2] := 24;
  532.       eraeol[1] := 126;    eraeol[2] := 15;
  533.       HOME[1] := 126;    HOME[2] := 18;
  534.       LockKbd[1] := 126;    LockKbd[2] := 21;
  535.       UnlockKbd[1] := 126;    UnlockKbd[2] := 6;
  536.     END;
  537.  
  538.      2: BEGIN { ****** SOROC TERMINAL ****** }
  539.       CLRSCR[0] := 4;
  540.       CLRSCR[1] := ESC;
  541.       CLRSCR[2] := 43;
  542.       CLRSCR[3] := NULL;
  543.       CLRSCR[4] := NULL;
  544.       CUR[2] := 61;
  545.       eraeos[2] := 89;
  546.       eraeol[2] := 59;
  547.       HOME[0] := 1;
  548.       HOME[1] := 30;
  549.       LockKbd[2] := 35;
  550.       UnlockKbd[2] := NULL;
  551.     END;
  552.  
  553.      3: BEGIN { ****** INFOTON TERMINAL ****** }
  554.       CLRSCR[0] := 1;
  555.       CLRSCR[1] := 12;
  556.       CUR[2] := 102;
  557.       eraeos[2] := 74;
  558.       eraeol[2] := 75;
  559.       HOME[2] := 72;
  560.       LockKbd[2] := 104;
  561.       UnlockKbd[2] := 108;
  562.     END;
  563.  
  564.      4: { ****** TELEVIDEO TERMINAL ****** };
  565.     { DEFAULT PARAMETERS ARE SET UP FOR TVI 912/920 TERM }
  566.  
  567.      5: BEGIN { ******* BEEHIVE TERMINAL  ****** }
  568.         CLRSCR[2] := 69;
  569.         CUR[2] := 70;
  570.         eraeos[2] := 74;
  571.         eraeol[2] := 75;
  572.         HOME[2] := 72;
  573.         LockKbd[2] := 35;
  574.         UnlockKbd[2] := NULL;
  575.     END;
  576.  
  577.      6: BEGIN { ****** HEATH TERMINAL ****** }
  578.         CLRSCR[2] := 69;
  579.         CUR[2] := 89;
  580.         eraeos[2] := 74;
  581.         eraeol[2] := 75;
  582.         HOME[2] := 72;
  583.         LockKbd[2] := 125;
  584.         UnlockKbd[2] := 123;
  585.     END;
  586.  
  587.      7: BEGIN { ****** ADDS 60 ****** }
  588.       CLRSCR[0] := 0;
  589.       CLRSCR[1] := 12;
  590.       CUR[2] := 89;
  591.       eraeos[2] := 107;
  592.       eraeol[2] := 75;
  593.       HOME[0] := 1;
  594.       HOME[1] := 8;
  595.       LockKbd[2] := 53;
  596.       UnlockKbd[2] := 54;
  597.     END;
  598.  
  599.      8: BEGIN { ****** ZENTEC (DYNABYTE 5022) ****** }
  600.       eraeos[2] := 121;
  601.       eraeol[2] := 84;
  602.       HOME[0] := 1;
  603.       HOME[1] := 30;
  604.     END;
  605.  
  606.      9: BEGIN { ****** DIRECT VP800 ****** }
  607.       CLRSCR[0] := 5;
  608.       CLRSCR[1] := ESC;          CLRSCR[2] := 72;
  609.       CLRSCR[3] := NULL;          CLRSCR[4] := ESC;
  610.       CLRSCR[5] := 74;
  611.       CUR[2] := 89;
  612.       eraeos[2] := 74;
  613.       eraeol[2] := 75;
  614.       HOME[2] := 72;
  615.       LockKbd[0] := 1;
  616.       LockKbd[1] := NULL;
  617.       UnlockKbd[0] := 1;
  618.       UnlockKbd[1] := NULL;
  619.  
  620.       FOR IX:=1 TO 24 DO WRITELN;
  621.       WRITELN('NOTE:');
  622.       WRITELN;
  623.       WRITE('PRIOR TO RUNNING THE SOFTWARE THE TERMINAL ');
  624.       WRITELN('MUST BE CONFIGURED TO EMULATE');
  625.       WRITE('A VT-52 TERMINAL_ ');
  626.       WRITELN('PLEASE CONSULT THE VP800 USER MANUAL FOR PROCEDURE ON');
  627.       WRITELN('HOW TO ALTER AND SAVE SETUP FEATURES'); WRITELN;
  628.       WRITELN;
  629.     END;
  630.  
  631.     10: BEGIN { ****** TRS-80 (PICKLES & TROUT) ****** }
  632.       CLRSCR[0] := 1;
  633.       CLRSCR[1] := 12;
  634.       CUR[1] := ESC;    CUR[2] := 89;
  635.       eraeos[0] := 1;
  636.       eraeos[1]:= 2;
  637.       eraeol[0] := 1;
  638.       eraeol[1] :=    1;
  639.       HOME[0] := 1;
  640.       HOME[1] := 6;
  641.       LockKbd[0] := 1;
  642.       LockKbd[1] := NULL;
  643.       UnlockKbd[0] := 1;
  644.       UnlockKbd[1] := NULL;
  645.     END;
  646.  
  647.     11: BEGIN { ****** VECTOR GRAPHIC W/ 4.0 OR NEWER MONITOR ****** }
  648.       CLRSCR[0] := 1;
  649.       CLRSCR[1] := 4;
  650.       CUR[0] := 1;
  651.       CUR[1] := ESC;
  652.       XY := 1;
  653.       X_OFF := 128;
  654.       Y_OFF := 128;
  655.       eraeos[0] := 1;
  656.       eraeos[1]:= 16;
  657.       eraeol[0] := 1;
  658.       eraeol[1] := 17;
  659.       HOME[0] := 1;
  660.       HOME[1] := 2;
  661.       LockKbd[0] := 1;
  662.       LockKbd[1] := NULL;
  663.       UnlockKbd[0] := 1;
  664.       UnlockKbd[1] := NULL;
  665.     END;
  666.  
  667.      12: BEGIN { ***** TELEVIDEO 950 ***** }
  668.        DELMIS := 10;
  669.        DELCUS := 10;
  670.        LINDEL[0] := 2;
  671.        LINDEL[1] := ESC;
  672.        LINDEL[2] := ORD('R');
  673.        LININS[0] := 2;
  674.        LININS[1] := ESC;
  675.        LININS[2] := ORD('E');
  676.        LockKbd[0] := 2;
  677.        LockKbd[1] := ESC;
  678.        LockKbd[2] := ORD('#');
  679.        UnlockKbd[0] := 2;
  680.        UnlockKbd[1] := ESC;
  681.        UnlockKbd[2] := ORD('"');
  682.        INVON[0] := 3;    { INVERSE VIDEO ON }
  683.        INVON[1] := ESC;
  684.        INVON[2] := ORD('G');
  685.        INVON[3] := ORD('4');
  686.        INVOFF[0] := 3;    { INVERSE VIDEO OFF }
  687.        INVOFF[1] := ESC;
  688.        INVOFF[2] := ORD('G');
  689.        INVOFF[3] := ORD('0');
  690.        CRSON[0] := 3;    { SET CURSOR ON AND BLINKING }
  691.        CRSOFF[0] := 3;    { SET CURSOR DISPLAY OFF }
  692.        CRSON[1] := ESC;
  693.        CRSON[2] := ORD('.');
  694.        CRSON[3] := ORD('1');
  695.        CRSOFF[0] := 3;    { SET CURSOR DISPLAY OFF }
  696.        CRSOFF[1] := ESC;
  697.        CRSOFF[2] := ORD('.');
  698.        CRSOFF[3] := ORD('0');
  699.      END;
  700.  
  701.      13: BEGIN { ****** TERMINAL NOT ONE OF THE ABOVE TYPES ****** }
  702.        INITIALIZE;
  703.      END
  704.   END{CASE};
  705.  
  706.   Write_File;
  707.  
  708.   for bx:=1 to 5 do writeln;
  709. END{ of INSTALL }.
  710.