home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / pascal / library / dos / tp_util / xsetup.pas < prev   
Encoding:
Pascal/Delphi Source File  |  1990-05-27  |  18.5 KB  |  794 lines
  1.  
  2. PROGRAM XSETUP;
  3. { ZUGRIFF AUF DAS CMOS- RAM }
  4.  
  5.  
  6. USES  DOS,SELECTD,NEATUNIT,TPCRT,
  7.       TPSTRING,TPWINDOW,TPENHKBD;
  8.  
  9.  
  10. TYPE  S80     = STRING[80];
  11.  
  12. CONST INDEX   = $70; { INDEX - REGISTER }
  13.       DATA    = $71; { DATA - REGISTER }
  14.  
  15. CONST TANORM  : BYTE = $07;
  16.       TAHELL  : BYTE = $0F;
  17.       TADIFF  : BYTE = $0E;
  18.  
  19.       TAUHR   : BYTE = $1F;
  20.       TARES   : BYTE = $4F;
  21.       TANEAT  : BYTE = $2F;
  22.       TACHK   : BYTE = $5F;
  23.       TACCHK  : BYTE = $06;
  24. { FÜR DIE NEAT- RGISTER- ANZEIGE }
  25.       TADGR   : BYTE = $08;
  26.       TANDF   : BYTE = $0C;
  27.       TANR    : BYTE = $0F;
  28.  
  29.       TABOOT  : BYTE = $4F;
  30.  
  31.  
  32. CONST CRAMSIZ = 63;   { ANZAHL BYTES IM CMOS- RAM -1 }
  33.       CRAMS2  = 127;  { ANZAHL BYTES IM CMOS- RAM -1 }
  34.  
  35.  
  36. VAR   I,J,K              : INTEGER;
  37.       CH                 : CHAR;
  38.       RAMSIZ,B1          : BYTE;
  39.       FILEDA,DISPL,DUMP,
  40.       WENABLE,EMSENB     : BOOLEAN;
  41.       SAVDAT,INDAT       : ARRAY[0..CRAMS2] OF BYTE;
  42.       SAVFIL             : FILE OF BYTE;
  43.       FNAM               : STRING;
  44.       S                  : S80;
  45.  
  46.       CHK,CHK2           : WORD;
  47.       DEBUGWIN           : WINDOWPTR;
  48.       PA,MA,W            : WORD;
  49.       MODE,EP            : BYTE;
  50.  
  51.  
  52. PROCEDURE BOOT;
  53. BEGIN
  54.   TEXTATTR := TABOOT;
  55.   CLRSCR;
  56.   GOTOXY(25,12);
  57.   WRITELN('Das System wird neu gestartet');
  58.   MEMW[$40:$72] := $1234; { MAGIC WORD }
  59.   INLINE($EA/$FFF0/$F000); { JMP FAR $F000:$FFF0 }
  60. END;
  61.  
  62.  
  63. FUNCTION CMOS(B:BYTE):BYTE;
  64. BEGIN
  65.   PORT[INDEX] := B;
  66.   CMOS := PORT[DATA];
  67. END;
  68.  
  69.  
  70. FUNCTION GETNEAT(IDX:BYTE):BYTE;
  71. BEGIN
  72.   PORT[$22] := IDX;
  73.   GETNEAT := PORT[$23];
  74. END;
  75.  
  76.  
  77. PROCEDURE CALCCHK;
  78. VAR  I,J  : INTEGER;
  79. BEGIN
  80.   CHK := 0;
  81.   CHK2 := 0;
  82.   FOR I := 0 TO RAMSIZ DO BEGIN
  83.     J := CMOS(I);
  84.     CASE I OF
  85.       $10..$2D : CHK := CHK + J;
  86.       $41..$53 : CHK2 := CHK2 + J;
  87.     END; { CASE }
  88.   END; { NEXT I }
  89. END;
  90.  
  91.  
  92. PROCEDURE CHKSUM;
  93. BEGIN
  94.   CALCCHK;
  95.   SETPORT(RTC,$2E,HI(CHK));
  96.   SETPORT(RTC,$2F,LO(CHK));
  97.  
  98.   IF RAMSIZ = CRAMS2 THEN BEGIN
  99.     SETPORT(RTC,$7E,HI(CHK2));
  100.     SETPORT(RTC,$7F,LO(CHK2));
  101.   END;
  102. END;
  103.  
  104.  
  105. PROCEDURE NEATDIFF;
  106. VAR   B1,B2   : BYTE;
  107.  
  108. PROCEDURE DISPNEAT(IDX,CADDR,MSK:BYTE);
  109. BEGIN
  110.   B1 := GETNEAT(IDX) AND (MSK XOR $FF);
  111.   IF CMOS(CADDR) <> B1 THEN BEGIN
  112.     TEXTATTR := TANDF;
  113.     WRITE(HEXB(B1));
  114.     TEXTATTR := TANR;
  115.   END ELSE WRITE(HEXB(B1));
  116.   WRITE(' ');
  117. END;
  118.  
  119. BEGIN
  120.   IF RAMSIZ <> CRAMS2 THEN EXIT;
  121.   TEXTATTR := TANORM;
  122.   GOTOXY(1,11);
  123.   WRITELN('NEAT Reg. :  60            64           68');
  124.   WRITE('   ');
  125.   TEXTATTR := TANR;
  126.   DISPNEAT($01,$41,0);
  127.  
  128.   TEXTATTR := TADGR;
  129.   WRITE(HEXB(GETNEAT($02)),'    ');
  130.   TEXTATTR := TANR;
  131.  
  132.   WRITE(' ');
  133.   DISPNEAT($60,$44,$CA);
  134.   DISPNEAT($61,$45,0);
  135.   DISPNEAT($62,$46,$C0);
  136.  
  137.   TEXTATTR := TADGR;
  138.   WRITE(HEXB(GETNEAT($63)),' : ',HEXB(GETNEAT($64)),' ');
  139.   TEXTATTR := TANR;
  140.  
  141.   DISPNEAT($65,$49,0);
  142.   DISPNEAT($66,$4A,$7F);
  143.   DISPNEAT($67,$4B,0);
  144.   WRITE(' ');
  145.   DISPNEAT($68,$4C,0);
  146.   DISPNEAT($69,$4D,0);
  147.   DISPNEAT($6A,$4E,$1F);
  148.   DISPNEAT($6B,$4F,0);
  149.   GOTOXY(1,13);
  150.   DISPNEAT($6C,$50,$0F);
  151.   DISPNEAT($6D,$51,0);
  152.   DISPNEAT($6E,$52,0);
  153.   DISPNEAT($6F,$53,$19);
  154.   TEXTATTR := TANORM;
  155. END;
  156.  
  157.  
  158. PROCEDURE READSETUP;
  159. VAR   I,IOR  : INTEGER;
  160. BEGIN
  161. {$I-}
  162.   WENABLE := TRUE;
  163.   TEXTATTR := TANORM;
  164.   GOTOXY(1,1); CLREOL;
  165.   FILEDA := FALSE;
  166.  
  167.   ASSIGN(SAVFIL,FNAM);
  168.   RESET(SAVFIL);
  169.   IOR := IORESULT;
  170.   IF IOR = 0 THEN BEGIN
  171.     WRITELN('DATEN AUS SAVE- FILE : ');
  172.     TEXTATTR := TAHELL;
  173.     FILEDA := TRUE;
  174.     FOR I := 0 TO RAMSIZ DO BEGIN
  175.       READ(SAVFIL,SAVDAT[I]);
  176.       IF IORESULT <> 0 THEN BEGIN
  177.         SAVDAT[I] := 0;
  178.         WRITE('??');
  179.         WENABLE := FALSE;
  180.         FILEDA  := FALSE;
  181.       END ELSE WRITE(HEXB(SAVDAT[I]));
  182.       IF (I AND $F) = $F THEN WRITELN ELSE BEGIN
  183.         IF (I AND 7) = 7 THEN WRITE(' : ') ELSE BEGIN
  184.           IF (I AND 3) = 3 THEN WRITE('  ') ELSE WRITE(' ');
  185.         END;
  186.       END;
  187.     END; { NEXT I }
  188.     TEXTATTR := TANORM;
  189.     CLOSE(SAVFIL);
  190.     GOTOXY(25,1);
  191. { DATUM / UHRZEIT AUS SAVE- FILE ANZEIGEN }
  192.     WRITE('(',HEXB(SAVDAT[7]),'.',HEXB(SAVDAT[8]),'.19',HEXB(SAVDAT[9]),'  ');
  193.     WRITE(HEXB(SAVDAT[4]),':',HEXB(SAVDAT[2]),':',HEXB(SAVDAT[0]),')');
  194.   END ELSE BEGIN
  195.     WRITELN(#7,'File ',FNAM,' nicht gefunden');
  196.   END;
  197. {$I+}
  198. END;
  199.  
  200.  
  201. PROCEDURE SAVESETUP;
  202. VAR   I  : INTEGER;
  203. BEGIN
  204. {$I-}
  205.   GOTOXY(1,1); CLREOL;
  206.   ASSIGN(SAVFIL,FNAM);
  207.   REWRITE(SAVFIL);
  208.   IF IORESULT = 0 THEN BEGIN
  209.     FOR I := 0 TO RAMSIZ DO BEGIN
  210.       SAVDAT[I] := CMOS(I);
  211.       WRITE(SAVFIL,SAVDAT[I]);
  212.     END; { NEXT I }
  213.     CLOSE(SAVFIL);
  214.     READSETUP;
  215.   END ELSE BEGIN
  216.     WRITELN(#7,'File ',FNAM,' nicht gefunden');
  217.   END;
  218. {$I+}
  219. END;
  220.  
  221.  
  222. PROCEDURE RESTORESETUP;
  223. VAR   I  : INTEGER;
  224. BEGIN
  225.   IF NOT WENABLE THEN EXIT;
  226.   READSETUP;
  227.   IF FILEDA THEN BEGIN
  228.     PORT[INDEX] := 9;
  229.     PORT[DATA] := SAVDAT[9];
  230.     FOR I := 14 TO RAMSIZ DO BEGIN
  231.       PORT[INDEX] := I;
  232.       PORT[DATA] := SAVDAT[I];
  233.     END;
  234.   END; { FILEDA & NEXT I }
  235. END;
  236.  
  237.  
  238. PROCEDURE BEREINIGEN;
  239. VAR   I  : INTEGER;
  240. BEGIN
  241.   PORT[INDEX] := 1; PORT[DATA] := 0;
  242.   PORT[INDEX] := 3; PORT[DATA] := 0;
  243.   PORT[INDEX] := 5; PORT[DATA] := 0;
  244.   FOR I := $34 TO $3F DO BEGIN
  245.     PORT[INDEX] := I; PORT[DATA] := 0;
  246.   END; { NEXT I }
  247. END;
  248.  
  249.  
  250. PROCEDURE DUMPLIST;
  251. VAR  I,J  : INTEGER;
  252. BEGIN
  253.   CALCCHK;
  254.   GOTOXY(1,16);
  255.   TEXTATTR := TAHELL;
  256.   FOR I := 0 TO RAMSIZ DO BEGIN
  257.     J := CMOS(I);
  258.     CASE I OF
  259.       $00..$0F : TEXTATTR := TAUHR;
  260.            $11 : TEXTATTR := TARES;
  261.            $13 : TEXTATTR := TARES;
  262.       $1B..$2D : TEXTATTR := TARES;
  263.       $2E..$2F : TEXTATTR := TACHK;
  264.       $34..$3F : TEXTATTR := TARES;
  265.       $41..$53 : TEXTATTR := TANEAT;
  266.       $7E..$7F : TEXTATTR := TACHK;
  267.     END; { CASE }
  268.     IF FILEDA THEN BEGIN
  269.       IF J <> SAVDAT[I] THEN TEXTATTR := (TEXTATTR AND $F0) + TADIFF;
  270.     END;
  271.     WRITE(HEXB(J));
  272.     TEXTATTR := TAHELL;
  273.     IF (I AND $F) = $F THEN BEGIN
  274.       IF I = 47 THEN BEGIN
  275.         TEXTATTR := TACCHK;
  276.         WRITE(' ',HEXW(CHK));
  277.         TEXTATTR := TAHELL;
  278.       END;
  279.       IF I = 127 THEN BEGIN
  280.         TEXTATTR := TACCHK;
  281.         WRITE(' ',HEXW(CHK2));
  282.         TEXTATTR := TAHELL;
  283.       END;
  284.       WRITELN;
  285.     END ELSE BEGIN
  286.       IF (I AND 7) = 7 THEN WRITE(' : ') ELSE BEGIN
  287.         IF (I AND 3) = 3 THEN WRITE('  ') ELSE WRITE(' ');
  288.       END;
  289.     END;
  290.   END; { NEXT I }
  291.   TEXTATTR := TANORM;
  292. END;
  293.  
  294.  
  295. PROCEDURE INTLIST;
  296. VAR  I  : INTEGER;
  297. BEGIN
  298.   GOTOXY(46,15); TEXTATTR := TAHELL;
  299.   WRITE(HEXB(CMOS(7)),'.',HEXB(CMOS(8)),'.',HEXB(CMOS($32)),HEXB(CMOS(9)));
  300.   TEXTATTR := TANORM;
  301.  
  302.   GOTOXY(1,16);
  303.   WRITE('        Zeit : '); TEXTATTR := TAHELL;
  304.   WRITE(HEXB(CMOS(4)),':',HEXB(CMOS(2)),':',HEXB(CMOS(0)));
  305.   TEXTATTR := TANORM;
  306.   WRITE('          Alarmzeit : '); TEXTATTR := TAHELL;
  307.   WRITE(HEXB(CMOS(5)),':',HEXB(CMOS(3)),':',HEXB(CMOS(1)));
  308.   TEXTATTR := TANORM;
  309.   WRITELN;
  310.  
  311.   WRITE('    Disk A/B : '); TEXTATTR := TAHELL;
  312.   WRITE(HEXB(CMOS($10))); TEXTATTR := TANORM;
  313.   WRITELN;
  314.   WRITE('  Platte C/D : '); TEXTATTR := TAHELL;
  315.   WRITE(HEXB(CMOS($12))); TEXTATTR := TANORM;
  316.   WRITELN;
  317.   WRITE('Plattentyp C = '); TEXTATTR := TAHELL;
  318.   WRITE(HEXB(CMOS($19))); TEXTATTR := TANORM;
  319.   WRITE(', D = '); TEXTATTR := TAHELL;
  320.   WRITE(HEXB(CMOS($1A))); TEXTATTR := TANORM;
  321.   WRITELN;
  322.  
  323.   GOTOXY(30,17);
  324.   I := CMOS($15) + 256 * CMOS($16);
  325.   WRITE('   System RAM : '); TEXTATTR := TAHELL; WRITE(I:4,'k'); TEXTATTR := TANORM;
  326.   GOTOXY(30,18);
  327.   I := CMOS($17) + 256 * CMOS($18);
  328.   WRITE('Expansion RAM : '); TEXTATTR := TAHELL; WRITE(I:4,'k'); TEXTATTR := TANORM;
  329.   GOTOXY(30,19);
  330.   I := CMOS($30) + 256 * CMOS($31);
  331.   WRITE(' Extended RAM : '); TEXTATTR := TAHELL; WRITE(I:4,'k'); TEXTATTR := TANORM;
  332.  
  333.   GOTOXY(1,20);
  334.   WRITE('Konfig. Byte : ');
  335.   TEXTATTR := TAHELL; WRITE(HEXB(CMOS($14))); TEXTATTR := TANORM;
  336.   WRITE('            Power On Flag : ');
  337.   TEXTATTR := TAHELL; WRITE(HEXB(CMOS($33))); TEXTATTR := TANORM;
  338.   WRITELN;
  339.  
  340.   GOTOXY(1,21);
  341.   WRITE('Diag. Status : ');
  342.   TEXTATTR := TAHELL; WRITE(HEXB(CMOS($0E))); TEXTATTR := TANORM;
  343.   WRITE('          ??? Abbruch ??? : ');
  344.   TEXTATTR := TAHELL; WRITE(HEXB(CMOS($0F))); TEXTATTR := TANORM;
  345.  
  346.   GOTOXY(1,22);
  347.   WRITE('  Checksumme : ');
  348.   TEXTATTR := TAHELL; WRITE(HEXB(CMOS($2E)),' ',HEXB(CMOS($2F)));
  349.   TEXTATTR := TANORM;
  350.  
  351. END;
  352.  
  353.  
  354. FUNCTION MAKEHEX(S:S80):BYTE;
  355. VAR   I,D  : WORD;
  356. BEGIN
  357.   D := 0;
  358.   FOR I := 1 TO LENGTH(S) DO BEGIN
  359.     IF S[I] IN ['0'..'9'] THEN D := D * 16 + ORD(S[I]) - $30;
  360.     IF S[I] IN ['A'..'F'] THEN D := D * 16 + ORD(S[I]) - $37;
  361.     IF S[I] IN ['a'..'f'] THEN D := D * 16 + ORD(S[I]) - $57;
  362.     D := D AND $FF;
  363.   END;
  364.   MAKEHEX := D;
  365. END;
  366.  
  367.  
  368. PROCEDURE EMSAUS;
  369. VAR   TA  : BYTE;
  370. BEGIN
  371.   FNAM := 'NOEMS.SU';
  372.   READSETUP;
  373.   RESTORESETUP;
  374.   FNAM := 'XSETUP.SAV';
  375.   IF FILEDA THEN BEGIN
  376.     SAVESETUP;
  377.   END ELSE BEGIN
  378.     RESTORESETUP;
  379.     TA := TEXTATTR;
  380.     TEXTATTR := $CE;
  381.     GOTOXY(23,1);
  382.     WRITE(' ***  File NOEMS.SU nicht vorhanden  *** ');
  383.     TEXTATTR := TA;
  384.   END;
  385. END;
  386.  
  387.  
  388. PROCEDURE EMSEIN;
  389. VAR   TA  : BYTE;
  390. BEGIN
  391.   FNAM := 'EMS.SU';
  392.   READSETUP;
  393.   RESTORESETUP;
  394.   FNAM := 'XSETUP.SAV';
  395.   IF FILEDA THEN BEGIN
  396.     PORT[$22] := $65;
  397.     B1 := PORT[$23];
  398.     B1 := B1 AND $FE;
  399.     PORT[$22] := $65;
  400.     PORT[$23] := B1;
  401.     SAVESETUP;
  402.   END ELSE BEGIN
  403.     RESTORESETUP;
  404.     TA := TEXTATTR;
  405.     TEXTATTR := $CE;
  406.     GOTOXY(23,1);
  407.     WRITE(' ***  File EMS.SU nicht vorhanden  *** ');
  408.     TEXTATTR := TA;
  409.   END;
  410. END;
  411.  
  412.  
  413. PROCEDURE HEADER;
  414. BEGIN
  415.   WINDOW(1,15,80,25); CLRSCR; WINDOW(1,1,80,25);
  416.   GOTOXY(1,15);
  417.   IF DUMP THEN BEGIN
  418.     WRITE('aktuelle CMOS- RAM- Daten (DUMP) :');
  419.   END ELSE BEGIN
  420.     WRITE('aktuelle CMOS- RAM- Daten (INTERPRETIERT) :');
  421.   END;
  422.   GOTOXY(55,2); WRITE('Save    Setup ......... S');
  423.   GOTOXY(55,3); WRITE('Restore Setup ......... R');
  424.   GOTOXY(55,4);
  425.   IF DUMP THEN  WRITE('interpretierte Liste .. I')
  426.           ELSE  WRITE('dump Liste ............ D');
  427.   GOTOXY(55,5); WRITE('Checksumme Korrigieren  C');
  428.   IF RAMSIZ = CRAMS2 THEN BEGIN
  429.     GOTOXY(55,6);
  430.     IF EMSENB THEN WRITE('EMS ausschalten ....... 1')
  431.               ELSE WRITE('EMS einschalten ....... 1');
  432.   END;
  433.   GOTOXY(55,7); WRITE('  BOOT ................ B');
  434.   GOTOXY(55,8); WRITE('Modifizieren .......... M');
  435.   GOTOXY(55,9); WRITE('<Esc> = ENDE');
  436.   TEXTATTR := TAHELL;
  437.  
  438.   GOTOXY(55,11);
  439.   TEXTATTR := TAUHR; WRITE('Uhr'); TEXTATTR := TANORM;
  440.   GOTOXY(67,11);
  441.   TEXTATTR := TARES; WRITE('Reserviert'); TEXTATTR := TANORM;
  442.   GOTOXY(55,12);
  443.   TEXTATTR := TANEAT; WRITE('NEAT Setup'); TEXTATTR := TANORM;
  444.   GOTOXY(67,12);
  445.   TEXTATTR := TACHK; WRITE('Checksumme'); TEXTATTR := TANORM;
  446.   GOTOXY(55,13);
  447.   TEXTATTR := TADIFF; WRITELN('Differenz zu Save- File'); TEXTATTR := TANORM;
  448.   GOTOXY(55,14);
  449.   TEXTATTR := TACCHK; WRITELN('errechnete Checksumme'); TEXTATTR := TANORM;
  450. END;
  451.  
  452.  
  453. PROCEDURE UPDATESCREEN;
  454. BEGIN
  455.   IF DUMP THEN DUMPLIST ELSE INTLIST;
  456.   IF RAMSIZ = CRAMS2 THEN BEGIN
  457.     NEATDIFF;
  458.     IF (SAVDAT[$4F] AND $10) = 0 THEN BEGIN
  459.       IF EMSENB THEN BEGIN
  460.         GOTOXY(55,6);
  461.         WRITE('EMS einschalten ....... 1');
  462.       END;
  463.       EMSENB := FALSE;
  464.     END ELSE BEGIN
  465.       IF NOT EMSENB THEN BEGIN
  466.         GOTOXY(55,6);
  467.         WRITE('EMS ausschalten ....... 1');
  468.       END;
  469.       EMSENB := TRUE;
  470.     END;
  471.   END;
  472. END;
  473.  
  474.  
  475. PROCEDURE WINDERR;
  476. BEGIN
  477.   WRITELN;
  478.   WRITELN('  WINDOW ERROR  ');
  479.   HALT;
  480. END;
  481.  
  482.  
  483. PROCEDURE DEBUG;
  484. VAR   P        : POINTER;
  485.       CH1,CH2  : CHAR;
  486.       I        : WORD;
  487.       TA       : BYTE;
  488.  
  489. PROCEDURE UPDATEBACKGROUND;
  490. BEGIN
  491.   P := ERASETOPWINDOW;
  492.   UPDATESCREEN;
  493.   IF NOT DISPLAYWINDOW(DEBUGWIN) THEN WINDERR;
  494. END;
  495.  
  496. PROCEDURE ANZEIGE;
  497. BEGIN
  498.   HIDDENCURSOR;
  499.   GOTOXY(2,2);
  500.   WRITE('CMOS- Adresse [',HEXB(MA),'] ->   ');
  501.   GOTOXY(2,3);
  502.   WRITE('NEAT- Port    [',HEXB(PA),'] ->   ');
  503.   GOTOXY(2,5);
  504.   IF MODE = 1 THEN TEXTATTR := TEXTATTR XOR $77;
  505.   WRITE('aNd');
  506.   TEXTATTR := TA;
  507.   WRITE(', ');
  508.   IF MODE = 2 THEN TEXTATTR := TEXTATTR XOR $77;
  509.   WRITE('Or');
  510.   TEXTATTR := TA;
  511.   WRITE(', ');
  512.   IF MODE = 3 THEN TEXTATTR := TEXTATTR XOR $77;
  513.   WRITE('Xor');
  514.   TEXTATTR := TA;
  515.   WRITE(', ');
  516.   IF MODE = 4 THEN TEXTATTR := TEXTATTR XOR $77;
  517.   WRITE('bitSet');
  518.   TEXTATTR := TA;
  519.   WRITE(', ');
  520.   IF MODE = 5 THEN TEXTATTR := TEXTATTR XOR $77;
  521.   WRITE('bitReset');
  522.   TEXTATTR := TA;
  523.   WRITE(', ');
  524.   IF MODE = 6 THEN TEXTATTR := TEXTATTR XOR $77;
  525.   WRITE('Wert');
  526.   TEXTATTR := TA;
  527.   GOTOXY(2,6);
  528.   WRITE('<Esc> = Ende,          + INC, - DEC');
  529.   CASE EP OF
  530.     1 : BEGIN
  531.           GOTOXY(17,2);
  532.           WRITE(HEXB(W));
  533.         END;
  534.     2 : BEGIN
  535.           GOTOXY(17,3);
  536.           WRITE(HEXB(W));
  537.         END;
  538.     3 : BEGIN
  539.           GOTOXY(24,2);
  540.           IF MODE IN [4,5] THEN WRITE(W) ELSE WRITE(HEXB(W));
  541.         END;
  542.     4 : BEGIN
  543.           GOTOXY(24,3);
  544.           IF MODE IN [4,5] THEN WRITE(W) ELSE WRITE(HEXB(W));
  545.         END;
  546.   END; { CASE EP }
  547.   BLOCKCURSOR;
  548. END;
  549.  
  550. PROCEDURE SETADDR;
  551. BEGIN
  552.   CASE EP OF
  553.     1 : MA := W;
  554.     2 : PA := W;
  555.   END; { CASE EP }
  556. END;
  557.  
  558. PROCEDURE SETVAL;
  559. BEGIN
  560.   CASE EP OF
  561.       1 : W := MA;
  562.       2 : W := PA;
  563.     3,4 : W := 0;
  564.   END; { CASE EP }
  565. END;
  566.  
  567. PROCEDURE STELLE(PORT,INDEX,WERT:WORD);
  568. BEGIN
  569.   CASE MODE OF
  570.     1 : ANDPORT(PORT,INDEX,WERT);
  571.     2 : ORPORT (PORT,INDEX,WERT);
  572.     3 : XORPORT(PORT,INDEX,WERT);
  573.     4 : SETBIT (PORT,INDEX,WERT);
  574.     5 : RESBIT (PORT,INDEX,WERT);
  575.     6 : SETPORT(PORT,INDEX,WERT);
  576.   END;
  577. END;
  578.  
  579. BEGIN { DEBUG }
  580.   IF NOT DISPLAYWINDOW(DEBUGWIN) THEN WINDERR;
  581.   TA := TEXTATTR;
  582.  
  583.   REPEAT
  584.     ANZEIGE;
  585.     CH1 := UPCASE(READKEY); IF CH1 = #0 THEN CH2 := READKEY ELSE CH2 := #0;
  586.     CASE CH1 OF
  587.     ^[,#0 : BEGIN END;
  588.        ^M : BEGIN
  589.               CASE EP OF
  590.                 1 : BEGIN
  591.                       MA := W;
  592.                       EP := 3;
  593.                     END;
  594.                 2 : BEGIN
  595.                       PA := W;
  596.                       EP := 4;
  597.                     END;
  598.                 3 : BEGIN
  599.                       STELLE(RTC,MA,W);
  600.                       CHKSUM;
  601.                       UPDATEBACKGROUND;
  602.                     END;
  603.                 4 : BEGIN
  604.                       STELLE(NEAT,PA,W);
  605.                       UPDATEBACKGROUND;
  606.                     END;
  607.               END; { CASE EP }
  608.             END;
  609.        ^H : BEGIN
  610.               W := W SHR 4;
  611.               ANZEIGE;
  612.             END;
  613.       '+' : BEGIN
  614.               INC(W);
  615.               SETADDR;
  616.               ANZEIGE;
  617.             END;
  618.       '-' : BEGIN
  619.               DEC(W);
  620.               SETADDR;
  621.               ANZEIGE;
  622.             END;
  623.  '0'..'9',
  624.  'A'..'F' : BEGIN
  625.               IF (EP IN [3,4]) AND (MODE IN [4,5]) THEN BEGIN
  626.                 IF CH1 IN ['0'..'7'] THEN VAL(CH1,W,I);
  627.               END ELSE BEGIN
  628.                 W := (W SHL 4) AND $FF;
  629.                 IF CH1 >= 'A' THEN W := W + ORD(CH1) - $37
  630.                               ELSE W := W + ORD(CH1) - $30;
  631.               END;
  632.               ANZEIGE;
  633.             END;
  634.       'N' : BEGIN
  635.               MODE := 1;
  636.               W := 0;
  637.               ANZEIGE;
  638.             END;
  639.       'O' : BEGIN
  640.               MODE := 2;
  641.               W := 0;
  642.               ANZEIGE;
  643.             END;
  644.       'X' : BEGIN
  645.               MODE := 3;
  646.               W := 0;
  647.               ANZEIGE;
  648.             END;
  649.       'S' : BEGIN
  650.               MODE := 4;
  651.               W := 0;
  652.               ANZEIGE;
  653.             END;
  654.       'R' : BEGIN
  655.               MODE := 5;
  656.               W := 0;
  657.               ANZEIGE;
  658.             END;
  659.       'W' : BEGIN
  660.               MODE := 6;
  661.               W := 0;
  662.               ANZEIGE;
  663.             END;
  664.     END; { CASE CH1 }
  665.     CASE CH2 OF
  666.        #72 : BEGIN
  667.                SETADDR;
  668.                IF EP IN [2,4] THEN DEC(EP) ELSE INC(EP);
  669.                SETVAL;
  670.              END;
  671.        #80 : BEGIN
  672.                SETADDR;
  673.                IF EP IN [2,4] THEN DEC(EP) ELSE INC(EP);
  674.                SETVAL;
  675.              END;
  676.        #75 : BEGIN
  677.                SETADDR;
  678.                IF EP IN [3,4] THEN DEC(EP,2) ELSE INC(EP,2);
  679.                SETVAL;
  680.              END;
  681.        #77 : BEGIN
  682.                SETADDR;
  683.                IF EP IN [3,4] THEN DEC(EP,2) ELSE INC(EP,2);
  684.                SETVAL;
  685.              END;
  686.       #141 : IF MOVEWINDOW(0,-1) THEN BLOCKCURSOR;
  687.       #145 : IF MOVEWINDOW(0, 1) THEN BLOCKCURSOR;
  688.       #115 : IF MOVEWINDOW(-2,0) THEN BLOCKCURSOR;
  689.       #116 : IF MOVEWINDOW( 2,0) THEN BLOCKCURSOR;
  690.     END; { CASE CH2 }
  691.  
  692.   UNTIL CH1 = ^[;
  693.   HIDDENCURSOR;
  694.   P := ERASETOPWINDOW;
  695. END;
  696.  
  697.  
  698. BEGIN { MAIN }
  699.   IF NOT ISAT THEN BEGIN
  700.     WRITELN;
  701.     WRITELN('XSETUP ist nur auf AT- Computern (mit CMOS-RAM) einsetzbar');
  702.     HALT;
  703.   END;
  704.   CLRSCR;
  705.   HIDDENCURSOR;
  706.   DUMP := TRUE;
  707.   EMSENB := FALSE;
  708.  
  709. { TEXTATTRIBUTE FÜR CRT- DISPLAY ABRICHTEN }
  710.   IF (STUPCASE(GETENV('CRT'))='LCD') THEN BEGIN
  711.     TADIFF  := $70;
  712.     TAUHR   := $02;
  713.     TARES   := $27;
  714.     TACHK   := $04;
  715.     TACCHK  := $04;
  716.     TADGR   := $02;
  717.     TANDF   := $04;
  718.   END;
  719. { TEXTATTRIBUTE FÜR MONOCHROM ABRICHTEN }
  720.   IF LASTMODE = 7 THEN BEGIN
  721.     TADIFF  := $10;
  722.     TAUHR   := $02;
  723.     TARES   := $01;
  724.     TACHK   := $09;
  725.     TACCHK  := $09;
  726.     TADGR   := $01;
  727.     TANDF   := $09;
  728.   END;
  729.  
  730.   { CREATE DEBUG WINDOW }
  731.   if not MakeWindow(DEBUGWIN,40,1,80,9,True,True,TRUE,$70,$16,$1E,' Modifizieren ')
  732.     THEN WINDERR;
  733.   MA   := 0;
  734.   PA   := $60;
  735.   MODE := 6;
  736.   EP   := 1;
  737.   W    := 0;
  738.  
  739.   IF CMOS(0) <> CMOS(64) THEN RAMSIZ := CRAMS2 ELSE RAMSIZ := CRAMSIZ;
  740.   IF CMOS(0) <> CMOS(64) THEN RAMSIZ := CRAMS2 ELSE RAMSIZ := CRAMSIZ;
  741.   TEXTATTR := TANORM;
  742.   FNAM := 'XSETUP.SAV';
  743.   READSETUP;
  744.  
  745.   CASE PARAMCOUNT OF
  746.     1 : BEGIN
  747.           S := PARAMSTR(1);
  748.           PORT[INDEX] := $19;
  749.           PORT[DATA] := MAKEHEX(S);
  750.           CHKSUM;
  751.         END;
  752.     2 : BEGIN
  753.           S := PARAMSTR(1);
  754.           PORT[INDEX] := $19;
  755.           PORT[DATA] := MAKEHEX(S);
  756.           S := PARAMSTR(2);
  757.           PORT[INDEX] := $1A;
  758.           PORT[DATA] := MAKEHEX(S);
  759.           CHKSUM;
  760.         END;
  761.   END; { CASE }
  762.  
  763.   HEADER;
  764.   REPEAT
  765.     REPEAT UPDATESCREEN;
  766.     UNTIL KEYPRESSED;
  767.  
  768.     CH := UPCASE(READKEY);
  769.     CASE CH OF
  770.       'S' : SAVESETUP;
  771.       'R' : RESTORESETUP;
  772.       'D' : IF NOT DUMP THEN BEGIN
  773.               DUMP := TRUE;
  774.               HEADER;
  775.             END;
  776.       'I' : IF DUMP THEN BEGIN
  777.               DUMP := FALSE;
  778.               HEADER;
  779.             END;
  780.       'B' : BOOT;
  781.       'C' : CHKSUM;
  782.       '1' : IF EMSENB THEN EMSAUS ELSE EMSEIN;
  783.       'X' : BEREINIGEN;
  784.       'M' : DEBUG;
  785.     END; { CASE }
  786.   UNTIL CH = ^[;
  787.  
  788.   GOTOXY(1,24);
  789.   TEXTATTR := TANORM;
  790.   NORMALCURSOR;
  791.  
  792. END.
  793.  
  794.