home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / pascal / library / dos / grafik / tiftool / mem.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1990-12-07  |  17.3 KB  |  587 lines
  1.  
  2. PROGRAM MEMXXX;
  3. { MEMORY- KONFIGURATION DES 286- NEAT- CHIPSATZES ANZEIGEN & EINSTELLEN }
  4.  
  5.  
  6. {
  7.   FÜR DIE ANZEIGE DER EMS PAGEFRAME WIRD TURBO PROFESSIONAL BENUTZT
  8.   OHNE TURBO PROFESSIONAL BITTE '.$DEFINE TPROF' ODER '$UNDEF TPROF' EINTRAGEN
  9. }
  10. {$DEFINE TPROF}
  11.  
  12.  
  13. USES  DOS,
  14. {$IFDEF TPROF}
  15.       TPCRT,TPSTRING,TPEMS,
  16. {$ELSE}
  17.       CRT,TPERSATZ,
  18. {$ENDIF}
  19.       NEATUNIT;
  20. {
  21.   TPSTRING WIRD GEBRAUCHT FÜR :
  22.   FUNCTION HEXW(WERT:WORD):STRING; WANDELT EINE WORD- VARIABLE IN HEX- STRING
  23.   FUNCTION HEXB(WERT:BYTE):STRING; WANDELT EINE BYTE- VARIABLE IN HEX- STRING
  24.   DIESE FUNCTIONS SIND IN TPERSATZ NACHGEBILDET
  25. }
  26.  
  27.  
  28. TYPE  SOF     = RECORD O,S : WORD; END;
  29.  
  30.  
  31. CONST TANORM    : BYTE = $07;
  32.       TAGRUEN   : BYTE = $02;
  33.       TAGRUEN2  : BYTE = $0A;
  34.       TAROT     : BYTE = $04;
  35.       TAROT2    : BYTE = $0C;
  36.       TAROT3    : BYTE = $CE;
  37.       TAGELB    : BYTE = $0E;
  38.       TAHELL    : BYTE = $0F;
  39.  
  40. CONST BLSIZ     : WORD = $4000;
  41.  
  42.  
  43. VAR   I,J,K       : INTEGER;
  44.       W           : WORD;
  45.       P           : ARRAY[1..10] OF STRING;
  46.       PP          : BYTE;
  47.       QUIET,NNMI  : BOOLEAN;
  48.       PFBP        : POINTER;
  49.       BUFFER      : ARRAY[0..32767] OF BYTE;
  50.  
  51.  
  52. FUNCTION RAMTEST(SEGM:WORD):BOOLEAN;
  53. VAR   I,W    : WORD;
  54.       B1,B2  : BYTE;
  55.  
  56. PROCEDURE KEINEMS;
  57. BEGIN
  58.   I := 0;
  59.   WHILE (I < 17) AND (MEM[SEGM:I] = MEM[SEGM:I]) DO INC(I);
  60.   IF I < 16 THEN BEGIN
  61.     TEXTATTR := TAROT;
  62.     WRITE('undef.');
  63.     TEXTATTR := TANORM;
  64.   END ELSE BEGIN
  65.     W := MEMW[SEGM:0];
  66.     IF (W = $55AA) OR (W = $AA55) THEN BEGIN
  67.       TEXTATTR := TAGRUEN2;
  68.       WRITE('BIOS  ');
  69.       TEXTATTR := TANORM;
  70.     END ELSE BEGIN
  71.       I := 0;
  72.       WHILE (I < BLSIZ) AND (MEML[SEGM:I] = $FFFFFFFF) DO INC(I,4);
  73.       IF I < BLSIZ THEN BEGIN
  74.         IF (B1 <> (B2 XOR $FF)) THEN BEGIN
  75.           WRITE('EPROM ');
  76.         END ELSE BEGIN
  77.           CASE LASTMODE OF
  78.             0..6 : BEGIN
  79.                      IF (SEGM >= $B800) AND
  80.                         (SEGM <  $C000)
  81.                         THEN WRITE('VIDEO ')
  82.                         ELSE WRITE('..... ');
  83.                    END;
  84.                7 : BEGIN
  85.                      IF (SEGM >= $B000) AND
  86.                         (SEGM <  $B800)
  87.                         THEN WRITE('VIDEO ')
  88.                         ELSE WRITE('..... ');
  89.                    END;
  90.           13..19 : BEGIN
  91.                      IF (SEGM >= $A000) AND
  92.                         (SEGM <  $B000)
  93.                         THEN WRITE('VIDEO ')
  94.                         ELSE WRITE('..... ');
  95.                    END;
  96.           ELSE
  97.             WRITE('..... ');
  98.           END; { CASE LASTMODE }
  99.         END;
  100.       END ELSE BEGIN
  101.         TEXTATTR := TAGRUEN;
  102.         WRITE('frei  ');
  103.         TEXTATTR := TANORM;
  104.       END;
  105.     END;
  106.   END;
  107. END; { KEINEMS }
  108.  
  109. BEGIN { RAMTEST }
  110.   NMI(OFF);
  111.   RAMTEST := FALSE;
  112.  
  113.   B1 := MEM[SEGM:0];
  114.   MEM[SEGM:0] := B1 XOR $FF;
  115.   B2 := MEM[SEGM:0];
  116.   MEM[SEGM:0] := B1;
  117.  
  118.   IF NOT QUIET THEN BEGIN
  119.     WRITE(HEXW(SEGM),':');
  120.     WRITE(HEXB(B1));
  121.     WRITE(' ');
  122.  
  123. {$IFDEF TPROF}
  124.     IF EMSINSTALLED THEN BEGIN
  125.       PFBP := EMSPAGEFRAMEPTR;
  126.       IF (SEGM >= SOF(PFBP).S) AND (SEGM < (SOF(PFBP).S+$1000)) THEN BEGIN
  127.         TEXTATTR := TAGELB;
  128.         WRITE(' EMS  ');
  129.         TEXTATTR := TANORM;
  130.       END ELSE BEGIN
  131.         KEINEMS;
  132.       END;
  133.     END ELSE
  134. {$ENDIF}
  135.              KEINEMS;
  136.     IF B1 <> (B2 XOR $FF) THEN BEGIN
  137.       I := 0;
  138.       WHILE (I < 17) AND (MEM[SEGM:I] = MEM[SEGM:I]) DO INC(I);
  139.       IF I < 16 THEN WRITE('???')
  140.                 ELSE WRITE('...');
  141.     END ELSE BEGIN
  142.       TEXTATTR := TAHELL;
  143.       WRITE('RAM');
  144.       TEXTATTR := TANORM;
  145.     END;
  146.     WRITE('  ');
  147.   END;
  148.  
  149.   IF B1 = (B2 XOR $FF) THEN RAMTEST := TRUE;
  150.   IF NOT NNMI THEN NMI(ON);
  151. END; { RAMTEST }
  152.  
  153.  
  154. PROCEDURE SHADOWDISP;
  155. VAR   I,J  : WORD;
  156. BEGIN
  157.   FOR I := $0A TO $0F DO BEGIN
  158.     FOR J := 0 TO (65535 DIV BLSIZ) DO BEGIN
  159.       IF RAMTEST((I SHL 12) + (J * (BLSIZ SHR 4))) THEN {};
  160.       IF (J AND 3) = 3 THEN WRITELN;
  161.     END;
  162.     IF WHEREX > 50 THEN WRITELN;
  163.   END; { NEXT I }
  164. END; { SHADOWDISP }
  165.  
  166.  
  167.  
  168. PROCEDURE SHADOWCHECK;
  169. VAR   I,J,K          : WORD;
  170.       IL             : INTEGER;
  171.       REG65          : BYTE;
  172.       REG68          : BYTE;
  173.       RAM,ROM        : ARRAY[0..4095] OF BYTE;
  174.       ERRCNT         : WORD;
  175.       OK,LEER,VSHAD  : BOOLEAN;
  176.       CH1            : CHAR;
  177. BEGIN
  178.   WRITELN;
  179.   TEXTATTR := TAHELL;
  180.   WRITELN('  Vergleich des BIOS- Shadow- RAM mit dem BIOS- EPROM');;
  181.   WRITELN;
  182.   IF NOT ISAT OR NOT ISNEAT THEN BEGIN
  183.     WRITELN;
  184.     TEXTATTR := TAROT3;
  185.     WRITELN('  Dies Programm funktioniert nur mit NEAT- Computern');
  186.     TEXTATTR := TANORM;
  187.     HALT;
  188.   END;
  189.  
  190. { BIOS 0F800 TESTEN }
  191.   IF GETBIT(NEAT,$65,0) = '0' THEN BEGIN
  192.     WRITELN('  Im Segment 0F000 befindet sich ROM');
  193.   END ELSE BEGIN
  194.     TEXTATTR := TAGELB;
  195.     WRITELN('  Im Segment 0F000 befindet sich Shadow RAM');
  196.     IF GETBIT(NEAT,$65,4) = '0' THEN BEGIN
  197.       TEXTATTR := TAROT2;
  198.       WRITELN('  Shadow RAM im Segment 0F000 ist nicht schreibgeschützt !');
  199.     END ELSE BEGIN
  200.       TEXTATTR := TAGRUEN;
  201.       WRITELN('  Shadow RAM im Segment 0F000 ist schreibgeschützt');
  202.     END;
  203.     TEXTATTR := TANORM;
  204.     ERRCNT := 0;
  205.     OK := TRUE;
  206.     REG65 := GETPORT(NEAT,$65);
  207.     I := GETPORT(NEAT,$69);
  208.     IF (I AND $C0) <> $C0 THEN BEGIN
  209.       WRITELN('  ? keine 32k Bytes RAM in 0F000:0800 eingeschaltet ?');
  210.     END;
  211.     FOR I := 0 TO 7 DO BEGIN
  212.       CLI; { WICHTIG ! }
  213.       RESBIT(NEAT,$65,0); { ROM ENABLE SEGMENT F000 }
  214.       MOVE(MEM[$F800:I*4096],ROM,4096);
  215.       SETBIT(NEAT,$65,0); { RAM ENABLE SEGMENT F000 }
  216.       MOVE(MEM[$F800:I*4096],RAM,4096);
  217.       SETPORT(NEAT,$65,REG65);
  218.       STI;
  219.       FOR J := 0 TO 4095 DO BEGIN
  220.         IF RAM[J] <> ROM[J] THEN BEGIN
  221.           IF ERRCNT < 16 THEN BEGIN
  222.             WRITELN('F000:',HEXW($8000+I*4096+J),' ROM = ',HEXB(ROM[J]),' RAM = ',HEXB(RAM[J]));
  223.             OK := FALSE;
  224.           END;
  225.           INC(ERRCNT);
  226.         END;
  227.       END; { NEXT J }
  228.     END; { NEXT I }
  229.     IF OK THEN BEGIN
  230.       TEXTATTR := TAGRUEN2;
  231.       WRITELN('  BIOS- Shadow- RAM ok');
  232.     END ELSE BEGIN
  233.       TEXTATTR := TAROT3;
  234.       WRITE(ERRCNT:5,' Differenzen gefunden  ');
  235.       TEXTATTR := TANORM;
  236.       WRITE('  Shadow- RAM- Inhalt wiederherstellen ? ');
  237.       CH1 := UPCASE(READKEY);
  238.       IF CH1 = #0 THEN BEGIN CH1 := READKEY; CH1 := #0; END;
  239.       IF (CH1 = 'J') OR (CH1 = 'Y') THEN BEGIN
  240.         FOR I := 0 TO 7 DO BEGIN
  241.           CLI; { WICHTIG ! }
  242.           RESBIT(NEAT,$65,0); { ROM ENABLE SEGMENT F000 }
  243.           MOVE(MEM[$F800:I*4096],ROM,4096);
  244.           SETBIT(NEAT,$65,0); { RAM ENABLE SEGMENT F000 }
  245.           RESBIT(NEAT,$65,4); { WRITE ENABLE SEGMENT F000 }
  246.           MOVE(ROM,MEM[$F800:I*4096],4096);
  247.           SETPORT(NEAT,$65,REG65);
  248.           STI;
  249.         END; { NEXT I }
  250.       END;
  251.     END;
  252.   END;
  253.   TEXTATTR := TANORM;
  254.  
  255.   WRITELN;
  256. { BIOS 0C000 TESTEN }
  257.   IF GETBIT(NEAT,$65,3) = '0' THEN BEGIN
  258.     WRITELN('  Im Segment 0C000 befindet sich ROM (???)');
  259.   END ELSE BEGIN
  260.     REG65 := GETPORT(NEAT,$65);
  261.     REG68 := GETPORT(NEAT,$68);
  262.     CASE (REG68 AND 3) OF
  263.       0,2 : BEGIN
  264.               WRITELN('  Kein Shadow- RAM FÜR Video- BIOS AUF 0C000:0');
  265.               K := 0;
  266.             END;
  267.         1 : BEGIN
  268.               TEXTATTR := TAGELB;
  269.               WRITELN('  16k Bytes Shadow- RAM für Video- BIOS AUF 0C000:0');
  270.               K := 3;
  271.             END;
  272.         3 : BEGIN
  273.               TEXTATTR := TAGELB;
  274.               WRITELN('  32k Bytes Shadow- RAM für Video- BIOS AUF 0C000:0');
  275.               K := 7;
  276.             END;
  277.     END; { CASE }
  278.     IF K > 0 THEN BEGIN
  279.       IF GETBIT(NEAT,$65,7) = '0' THEN BEGIN
  280.         TEXTATTR := TAROT2;
  281.         WRITELN('  Shadow RAM im Segment 0C000 ist nicht schreibgeschützt !');
  282.       END ELSE BEGIN
  283.         TEXTATTR := TAGRUEN;
  284.         WRITELN('  Shadow RAM im Segment 0C000 ist schreibgeschützt');
  285.       END;
  286.     END;
  287.     TEXTATTR := TANORM;
  288.  
  289.     VSHAD := K <> 0;
  290. { ERMITTELN, WIE GROß DAS EGA/VGA- EPROM IST }
  291.     LEER := TRUE;
  292.     IF K > 0 THEN I := K ELSE I := 7;
  293.     REPEAT
  294.       CLI; { WICHTIG ! }
  295.       ANDPORT(NEAT,$68,$FC); { RAM DISABLE SEGMENT C000, 32K }
  296.       MOVE(MEM[$C000:I*4096],ROM,4096);
  297.       SETPORT(NEAT,$68,REG68);
  298.       STI;
  299.       IL := 4095;
  300.       WHILE (IL >= 0) AND LEER DO BEGIN
  301.         IF ROM[IL] <> $FF THEN LEER := FALSE;
  302.         DEC(IL);
  303.       END; { WHILE }
  304.       IF LEER THEN DEC(I);
  305.     UNTIL (I = 0) OR NOT LEER;
  306.     K := I;
  307.     WRITELN('  Größe des EGA/VGA- BIOS = ',SUCC(K) SHL 2,'k Bytes');
  308.  
  309.     IF VSHAD THEN BEGIN
  310.       ERRCNT := 0;
  311.       OK := TRUE;
  312.       FOR I := 0 TO K DO BEGIN
  313.         CLI; { WICHTIG ! }
  314.         ANDPORT(NEAT,$68,$FC); { RAM DISABLE SEGMENT C000, 32K }
  315.         MOVE(MEM[$C000:I*4096],ROM,4096);
  316.         ORPORT(NEAT,$68,3); { RAM ENABLE SEGMENT C000, 32K }
  317.         MOVE(MEM[$C000:I*4096],RAM,4096);
  318.         SETPORT(NEAT,$68,REG68);
  319.         STI;
  320.         FOR J := 0 TO 4095 DO BEGIN
  321.           IF RAM[J] <> ROM[J] THEN BEGIN
  322.             IF ERRCNT < 16 THEN BEGIN
  323.               WRITELN('C000:',HEXW(I*4096+J),' ROM = ',HEXB(ROM[J]),' RAM = ',HEXB(RAM[J]));
  324.               OK := FALSE;
  325.             END;
  326.             INC(ERRCNT);
  327.           END;
  328.         END; { NEXT J }
  329.       END; { NEXT I }
  330.       IF OK THEN BEGIN
  331.         TEXTATTR := TAGRUEN2;
  332.         WRITELN('  Video- BIOS- Shadow- RAM ok');
  333.       END ELSE BEGIN
  334.         TEXTATTR := TAROT3;
  335.         WRITE(ERRCNT:5,' Differenzen gefunden  ');
  336.         TEXTATTR := TANORM;
  337.         WRITE('  Shadow- RAM- Inhalt wiederherstellen ? ');
  338.         CH1 := UPCASE(READKEY);
  339.         IF CH1 = #0 THEN BEGIN CH1 := READKEY; CH1 := #0; END;
  340.         IF (CH1 = 'J') OR (CH1 = 'Y') THEN BEGIN
  341.           FOR I := 0 TO K DO BEGIN
  342.             CLI; { WICHTIG ! }
  343.             ANDPORT(NEAT,$68,$FC); { RAM DISABLE SEGMENT C000, 32K }
  344.             MOVE(MEM[$C000:I*4096],ROM,4096);
  345.             ORPORT(NEAT,$68,3); { RAM ENABLE SEGMENT C000, 32K }
  346.             RESBIT(NEAT,$65,7); { WRITE ENABLE SEGMENT C000 }
  347.             MOVE(ROM,MEM[$C000:I*4096],4096);
  348.             SETPORT(NEAT,$65,REG65);
  349.             SETPORT(NEAT,$68,REG68);
  350.             STI;
  351.           END; { NEXT I }
  352.         END;
  353.       END;
  354.     END; { IF VSHAD }
  355.   END;
  356.   TEXTATTR := TANORM;
  357. END; { SHADOWCHECK }
  358.  
  359.  
  360. PROCEDURE HILFE;
  361. BEGIN
  362.   WRITELN;
  363.   WRITELN('MEM - Programm zur Speicherkonfiguration fÜr NEAT 286');
  364.   WRITELN('  Optionen :');
  365.   WRITELN('  W0        - 0 wait einschalten');
  366.   WRITELN('  W1        - 1 wait einschalten');
  367.   WRITELN('  UNPROTECT - Shadow- RAM write enable ( C000 und F000 )');
  368.   WRITELN('  PROTECT   - Shadow- RAM writeprotect ( C000 und F000 )');
  369.   WRITELN('  HDC       - HDC- EPROM von C800..CFFF ins shadow- RAM kopieren)');
  370.   WRITELN('  NMIOFF    - NMI (Parity- Prüfung) ausschalten');
  371.   WRITELN('  NMION     - NMI (Parity- Prüfung) einschalten');
  372.   WRITELN('  Q         - Quiet = keine Video- Ausgabe');
  373.   WRITELN;
  374.   WRITELN('  ENB-A .. ENB-F  - RAM auf Segment A000 .. F000 einschalten');
  375.   WRITELN('  INI-A .. INI-F  - RAM auf Segment A000 .. F000 initialisieren');
  376.   WRITELN('  DSB-A .. DSB-F  - RAM auf Segment A000 .. F000 ausschalten');
  377.   WRITELN('  HAT-A .. HAT-F  - RAM Anwesenheitsprüfung für BATCH');
  378.   WRITELN('  PROT-C          - RAM auf Segment C000 writeprotect ( nur C000 ! )');
  379.   WRITELN;
  380.   WRITELN('  SPEED1    - normale  Geschwindigkeit (TURBO Taste wirkt)');
  381.   WRITELN('  SPEED2    - halbe    Geschwindigkeit (TURBO Taste wirkt)');
  382.   WRITELN('  SPEED3    - minimale Geschwindigkeit (TURBO Taste wirkt nicht)');
  383.   WRITELN;
  384.   WRITELN('  CHECK     - Prüfung des Shadow- RAM auf Gleichheit mit EPROMs');
  385.   HALT(0);
  386. END;
  387.  
  388.  
  389. BEGIN { MAIN }
  390.  
  391. { VIDEOATTRIBUTE FÜR LCD- DIPLAY & MONOCHROM }
  392.   IF (STUPCASE(GETENV('CRT'))='LCD') OR
  393.      (LO(LASTMODE) = 7) THEN BEGIN
  394.   END;
  395.  
  396.   TEXTATTR := TANORM;
  397.   QUIET := FALSE;
  398.   NNMI := FALSE;
  399.   PP := PARAMCOUNT;
  400.   FOR I := 1 TO PP DO BEGIN
  401.     P[I] := PARAMSTR(I);
  402.     IF P[I][1] = '/' THEN DELETE(P[I],1,1);
  403.     IF P[I][1] = '-' THEN DELETE(P[I],1,1);
  404.     FOR J := 1 TO LENGTH(P[I]) DO P[I][J] := UPCASE(P[I][J]);
  405.     IF P[I] = 'Q' THEN QUIET := TRUE;
  406.     IF P[I] = '?' THEN HILFE;
  407.     IF P[I] = '2'  THEN BLSIZ := 2048;
  408.     IF P[I] = '4'  THEN BLSIZ := 4096;
  409.     IF P[I] = '8'  THEN BLSIZ := 8192;
  410.     IF P[I] = '16' THEN BLSIZ := 16384;
  411.     IF P[I] = '32' THEN BLSIZ := 32768;
  412.   END; { NEXT I }
  413.  
  414.   TEXTATTR := TAHELL;
  415.   IF NOT ISNEAT THEN BEGIN
  416.     WRITELN;
  417.     WRITELN('       NEAT-286 Memory-Utility        Erklärung mit MEM ?');
  418.     WRITELN;
  419.     TEXTATTR := TAROT3;
  420.     WRITELN('  Kein NEAT- Chipsatz gefunden');
  421.     TEXTATTR := TANORM;
  422.     WRITELN;
  423.     SHADOWDISP;
  424.     HALT(0);
  425.   END;
  426.  
  427.   IF NOT QUIET THEN BEGIN
  428.     WRITELN;
  429.     WRITELN('       NEAT-286 Memory-Utility        Erklärung mit MEM ?');
  430.     TEXTATTR := TANORM;
  431.     WRITELN;
  432.     WRITE('Memory- Wait : ',GETBIT(NEAT,$6B,5),' Wait erkannt');
  433.   END;
  434.  
  435.   TEXTATTR := TANORM;
  436.   FOR I := 1 TO PP DO BEGIN
  437.     IF P[I] = 'HDC' THEN BEGIN
  438. { GGF. EPROM VOM HDC INS SHADOW- RAM KOPIEREN }
  439.       IF GETBIT(NEAT,$68,2) = '0' THEN BEGIN
  440.         FOR W := 0 TO 32767 DO BUFFER[W] := MEM[$C800:W];
  441.         ORPORT(NEAT,$68,$0C);  { ENABLE RAM C800..CFFF }
  442.         ANDPORT(NEAT,$65,$7F); { WRITE ENABLE C000..CFFF }
  443.         FOR W := 0 TO 32767 DO MEM[$C800:W] := BUFFER[W];
  444.         ORPORT(NEAT,$65,$80);  { WRITE DISABLE C000..CFFF }
  445.       END ELSE WRITE(#7); { IF (W AND 4) = 0 }
  446.     END;
  447.   END; { NEXT I }
  448.  
  449. { ZUERST GGF. WAIT EINSTELLEN }
  450.   FOR I := 1 TO PP DO BEGIN
  451.     IF P[I] = 'W0' THEN BEGIN
  452.       IF GETBIT(NEAT,$6B,5) = '1' THEN BEGIN
  453.         ANDPORT(NEAT,$6B,$DF);
  454.         IF NOT QUIET THEN
  455.           WRITE(',  ',GETBIT(NEAT,$6B,5),' Wait eingestellt');
  456.       END;
  457.     END;
  458.     IF P[I] = 'W1' THEN BEGIN
  459.       IF GETBIT(NEAT,$6B,5) = '0' THEN BEGIN
  460.         ORPORT(NEAT,$6B,$20);
  461.         IF NOT QUIET THEN
  462.           WRITE(',  ',GETBIT(NEAT,$6B,5),' Wait eingestellt');
  463.       END;
  464.     END;
  465.   END; { NEXT I }
  466.   IF NOT QUIET THEN WRITELN;
  467.  
  468. { GGF. RAM ENABLE/DISABLE/INIT/ANWESENHEITSPRÜFUNG }
  469.   FOR I := 1 TO PP DO BEGIN
  470. { GGF. PROTECT / UNPROTECT FÜR SHADOW- RAM (C000..CFFF & F000..FFFF) }
  471.     IF P[I] = 'UNPROTECT' THEN ANDPORT(NEAT,$65,$6F);
  472.     IF P[I] = 'PROTECT'   THEN ORPORT(NEAT,$65,$90);
  473.     IF P[I] = 'PROT-C'    THEN ORPORT(NEAT,$65,$80);
  474. { GGF. NMI EIN/AUSSCHALTEN }
  475.     IF P[I] = 'NMIOFF'    THEN BEGIN
  476.       NMI(OFF);
  477.       NNMI := TRUE;
  478.     END;
  479.     IF P[I] = 'NMION'     THEN BEGIN
  480.       NMI(ON);
  481.       NNMI := FALSE;
  482.     END;
  483.     IF P[I] = 'CHECK'     THEN BEGIN
  484.       SHADOWCHECK;
  485.       QUIET := TRUE;
  486.     END;
  487. { RAM ENABLE }
  488.     IF P[I] = 'ENB-F' THEN ORPORT(NEAT,$69,$F0);
  489.     IF P[I] = 'ENB-E' THEN ORPORT(NEAT,$69,$0F);
  490.     IF P[I] = 'ENB-D' THEN ORPORT(NEAT,$68,$F0);
  491.     IF P[I] = 'ENB-C' THEN ORPORT(NEAT,$68,$0F);
  492.     IF P[I] = 'ENB-B' THEN ORPORT(NEAT,$67,$0F);
  493.     IF P[I] = 'ENB-B0' THEN ORPORT(NEAT,$67,$03);
  494.     IF P[I] = 'ENB-A' THEN ORPORT(NEAT,$67,$F0);
  495. { RAM DISABLE }
  496.     IF P[I] = 'DSB-F' THEN ANDPORT(NEAT,$69,$0F);
  497.     IF P[I] = 'DSB-E' THEN ANDPORT(NEAT,$69,$F0);
  498.     IF P[I] = 'DSB-D' THEN ANDPORT(NEAT,$68,$0F);
  499.     IF P[I] = 'DSB-C' THEN ANDPORT(NEAT,$68,$F0);
  500.     IF P[I] = 'DSB-B' THEN ANDPORT(NEAT,$67,$F0);
  501.     IF P[I] = 'DSB-A' THEN ANDPORT(NEAT,$67,$0F);
  502. { RAM ENABLE & INIT }
  503.     IF P[I] = 'INI-F' THEN BEGIN
  504.       ORPORT(NEAT,$69,$F0);
  505.       FILLCHAR(MEM[$F000:0],$FFFF,0);
  506.       MEM[$F000:$FFFF] := 0;
  507.     END;
  508.     IF P[I] = 'INI-E' THEN BEGIN
  509.       ORPORT(NEAT,$69,$0F);
  510.       FILLCHAR(MEM[$E000:0],$FFFF,0);
  511.       MEM[$E000:$FFFF] := 0;
  512.     END;
  513.     IF P[I] = 'INI-D' THEN BEGIN
  514.       ORPORT(NEAT,$68,$F0);
  515.       FILLCHAR(MEM[$D000:0],$FFFF,0);
  516.       MEM[$D000:$FFFF] := 0;
  517.     END;
  518.     IF P[I] = 'INI-C' THEN BEGIN
  519.       ORPORT(NEAT,$68,$0F);
  520.       FILLCHAR(MEM[$C000:0],$FFFF,0);
  521.       MEM[$C000:$FFFF] := 0;
  522.     END;
  523.     IF P[I] = 'INI-B' THEN BEGIN
  524.       ORPORT(NEAT,$67,$0F);
  525.       FILLCHAR(MEM[$B000:0],$FFFF,0);
  526.       MEM[$B000:$FFFF] := 0;
  527.     END;
  528.     IF P[I] = 'INI-B0' THEN BEGIN
  529.       ORPORT(NEAT,$67,$03);
  530.       FILLCHAR(MEM[$B000:0],$8000,0);
  531.     END;
  532.     IF P[I] = 'INI-A' THEN BEGIN
  533.       ORPORT(NEAT,$67,$F0);
  534.       FILLCHAR(MEM[$A000:0],$FFFF,0);
  535.       MEM[$A000:$FFFF] := 0;
  536.     END;
  537. { RAM ANWESENHEITSPRÜFUNG }
  538.     IF P[I] = 'HAT-F' THEN BEGIN
  539.       QUIET := TRUE;
  540.       IF NOT RAMTEST($F000) THEN HALT(1);
  541.     END;
  542.     IF P[I] = 'HAT-E' THEN BEGIN
  543.       QUIET := TRUE;
  544.       IF NOT RAMTEST($E000) THEN HALT(1);
  545.     END;
  546.     IF P[I] = 'HAT-D' THEN BEGIN
  547.       QUIET := TRUE;
  548.       IF NOT RAMTEST($D000) THEN HALT(1);
  549.     END;
  550.     IF P[I] = 'HAT-C' THEN BEGIN
  551.       QUIET := TRUE;
  552.       IF NOT RAMTEST($C000) THEN HALT(1);
  553.     END;
  554.     IF P[I] = 'HAT-B' THEN BEGIN
  555.       QUIET := TRUE;
  556.       IF NOT RAMTEST($B000) THEN HALT(1);
  557.     END;
  558.     IF P[I] = 'HAT-A' THEN BEGIN
  559.       QUIET := TRUE;
  560.       IF NOT RAMTEST($A000) THEN HALT(1);
  561.     END;
  562.  
  563.     IF P[I] = 'SPEED1' THEN BEGIN
  564.       ANDPORT(NEAT,$60,$EF);
  565.       ANDPORT(NEAT,$62,$FC);
  566.     END;
  567.     IF P[I] = 'SPEED2' THEN BEGIN
  568.       ANDPORT(NEAT,$60,$EF);
  569.       ANDPORT(NEAT,$62,$FC);
  570.       ORPORT (NEAT,$60,$10);
  571.     END;
  572.     IF P[I] = 'SPEED3' THEN BEGIN
  573.       ANDPORT(NEAT,$60,$EF);
  574.       ANDPORT(NEAT,$62,$FC);
  575.       ORPORT (NEAT,$62,$02);
  576.       ORPORT (NEAT,$60,$10);
  577.     END;
  578.   END; { NEXT I }
  579.  
  580.   IF NOT QUIET THEN BEGIN
  581.     WRITELN;
  582.     SHADOWDISP;
  583.   END;
  584.  
  585. END.
  586.  
  587.