( Character to Graphic Print Routines )                         0 VARIABLE CHBASE  DECIMAL                                      : C.                    ( FROM  TO  ---  )                        320 OVER + SWAP    ( 320 = 40 * 8 )                             DO                                                                DUP C@ I C! 1+                                                40 +LOOP                                                        DROP ;                                                                                                                        : (C.")                ( TO --- )                                 R COUNT DUP 1+ R> + >R                                          OVER + SWAP                                                     DO                                                                DUP I C@ 8 * CHBASE @ + ROT C. 1+                             LOOP DROP ;    ;S                                                                                                              ( Screen # 1 )                                                                                                                  : LISTS  OVER + SWAP DO I LIST LOOP ;                           : LOADS  OVER + SWAP DO I LOAD LOOP ;                           : 'S     SP@ 2 - ;                                              : DEPTH  S0 @ 'S - 2 / 2 - ;                                    : LOAD-ED   5 6 LOADS ;                                         : LOAD-$   15 4 LOADS ;                                         : NOT 0= ;                                                      : UMOVE   >R OVER OVER U< R> SWAP                                         IF  <CMOVE  ELSE CMOVE ENDIF ;                        : MTB  EMPTY-BUFFERS  ;                                         : DCX  DECIMAL ;                                                14 LOAD                                                         2 3 LOADS   30 LOAD                           DECIMAL ;S                                                                        ( DUMP routine )                                                                                                                HEX                                                                                                                             : .ADDR       100  /MOD  .HEX  .HEX  ." :  " ;                                                                                  : .DUMP       DUP .ADDR DUP 10 + SWAP DO                                      I C@ .HEX SPACE LOOP ;                                                                                            : DUMP        OVER + SWAP DO CR I .DUMP 10 +LOOP ;                                                                              DECIMAL    ;S                                                                                                                                                                                                                                                                                                                                                                                   ( INDEX, TRIAD, LINE, E, COPY, CLEAR )     HEX                                                                                  : INDEX        CR 1+ SWAP DO                                                      CR I 3 .R SPACE 0 I .LINE                                    LOOP CR ;                                        : TRIAD        CR 3 / 3 * 3 OVER + SWAP                                        DO CR I LIST LOOP CR                                            CR CR ;                                          : LINE         DUP FFF0 AND 17 ?ERROR SCR @ (LINE) DROP ;       : E            LINE C/L BLANKS UPDATE ;                         : CLEAR        SCR ! 10 0 DO FORTH I E LOOP ;                   : COPY         B/SCR * OFFSET @ + SWAP B/SCR * B/SCR OVER                      + SWAP DO DUP  FORTH I BLOCK 2 - ! 1+                           UPDATE LOOP DROP FLUSH ;                                                                                                                                         DECIMAL ;S      ( CASE:, TABLE, ARRAY, CARRAY, CVARIABLE, CCONSTANT )                                                                           : GODO:        <BUILDS SMUDGE ] DOES> SWAP 2* + @ EXECUTE ;                                                                     : ARRAY        <BUILDS 2* ALLOT DOES> SWAP 2* + ;                                                                               : CARRAY       <BUILDS ALLOT DOES> SWAP + ;                                                                                     : TABLE        <BUILDS 0 DO , LOOP DOES> SWAP 2* + @ ;                                                                            HEX                                                                                                                                                                                                                                                                                                                                                                  DECIMAL ;S               ( Proteus Fisk Forth                Forth Video Editor )                                                                        HEX                                                                                                                             VOCABULARY VEDIT  IMMEDIATE    VEDIT  DEFINITIONS                                                                               0 VARIABLE VPTR      0 VARIABLE INSRT                                                                                           : CSHOW    VPTR @ DUP C@ 80 OR SWAP C! ;                        : CBLANK   VPTR @ DUP C@ 7F AND SWAP C! ;                                                                                       : TAB      CBLANK VPTR @ 8 + CFF8 AND   ( 8 place tab stop )               0C00 OR VPTR ! CSHOW ;                                                                                                                                           DECIMAL   ;S                                                                                                                                        ( Proteus Disk Forth                      Video Editor )        HEX                                                             ( The following are cursor positioning routines )                                                                               : ALLCUR   VPTR @ CBLANK + 0C00 OR CFFF AND                                VPTR ! CSHOW ;                                                                                                       : UCUR     -40  ALLCUR ;    ( Move the cursor up )              : DCUR      40  ALLCUR ;    ( Move the cursor down )            : LCUR      -1  ALLCUR ;    ( left )                            : RCUR       1  ALLCUR ;    ( right )                                                                                           : RUB      20 VPTR @ C! LCUR UPDATE ;                                                                                           : INTGL    INSRT @ 0= INSRT ! ;                                                                            DECIMAL    ;S        ( Proteus Disk Forth                      Video Editor )                                                                         HEX                                                                                                                            : NLIN    CBLANK VPTR @ FFC0 AND VPTR ! DCUR ;                                                                                  : BMOVE   VPTR @ + VPTR @ ROT + DUP 3F AND 40 - ABS                       CBLANK UMOVE VPTR @ OR 20 SWAP C!                               CSHOW UPDATE ;                                                                                                        : BINS    VPTR @ 3F AND 3F = IF 20 VPTR @ C! CSHOW                        ELSE  0 1 0 BMOVE ENDIF ;                                                                                             : BDEL    3F  0 1 BMOVE ;                                                                                                       : PCHAR    INSRT @ IF BINS ENDIF VPTR @ C! RCUR UPDATE ;  ;S    ( Proteus Disk Forth                      Video Editor )                                                                        HEX                                                                                                                             : LINS    VPTR @ FFC0 AND DUP DUP 0FFF OR                                 SWAP - 40 -  1+ SWAP DUP 40 + ROT CBLANK UMOVE                  VPTR @ FFC0 AND 40 20 FILL CSHOW UPDATE ;                                                                             : LDEL    VPTR @ FFC0 AND DUP DUP 0FFF OR                                 SWAP - 40 -  1+ SWAP DUP 40 +                                   SWAP ROT CBLANK UMOVE                                           VPTR @ 0FFF OR 3F - 40 20 FILL CSHOW UPDATE ;                                                                         DECIMAL   ;S                                                                                                                                                                                                                                                    ( Proteus Disk Forth                      Video Editor )        HEX                                                            : CONTROL    DUP 17 = IF DROP UCUR 0 0 ENDIF                                 DUP 1A = IF DROP DCUR 0 0 ENDIF                                 DUP  1 = IF DROP LCUR 0 0 ENDIF                                 DUP 13 = IF DROP RCUR 0 0 ENDIF                                 DUP  2 = IF DROP LINS 0 0 ENDIF                                 DUP 10 = IF DROP LDEL 0 0 ENDIF                                 DUP  8 = IF DROP BDEL 0 0 ENDIF   DUP 7F = IF DROP RUB 0 0 THEN DUP 1B = IF 0 ENDIF   ( Escape )  DUP 9 = IF DROP  TAB 0 0 THEN DUP 12 = IF 0 ENDIF   ( Next screen )                           DUP 03 = IF 0 ENDIF   ( Prev screen )                           DUP 0D = IF DROP NLIN 0 0 ENDIF                                 DUP 14 = IF DROP INTGL 0 0 ENDIF                                DUP 0= IF DROP ELSE PCHAR 0 ENDIF ;                 DECIMAL  ;S                                                     ( Proteus Disk Forth                      Video Editor )        FORTH DEFINITIONS                                               HEX                                                             CC00 CONSTANT VDM                                               : L  VEDIT  DECIMAL SCR !                                                BEGIN                                                               SCR @ BLOCK CLS VDM  400 CMOVE                                  VDM  VPTR ! CSHOW                                               BEGIN                                                               KEY CONTROL -DUP                                            UNTIL                                                           CBLANK SCR @ BLOCK                                              VDM  SWAP 400 CMOVE                                                                                                                                                                                                                     -->        ( Proteus Disk Forth                      Video Editor )                                                                                     DUP 1B =                                                        IF                                                                  DROP 1                                                      ELSE                                                                12 = IF -1 ELSE 1 ENDIF                                         SCR @ + 1 MAX 17F MIN SCR ! 0                               ENDIF                                                       UNTIL                                                           CLS                                                             CR  ." Last edit on screen # " SCR @ . CR CR ;                                                                         : KL     SCR @ DUP 17F > IF DROP 1 ENDIF L ;                                                                                                                              DECIMAL  ;S                                                                          ( Character to Graphic Print Routines )                         0 VARIABLE CHBASE                                               : C.                    ( FROM  TO  ---  )                        512 OVER + SWAP    ( 512 = C/L * 8 )                            DO                                                                DUP C@ I C! 1+                                                64 +LOOP                                                        DROP ;                                                                                                                        : (C.")                ( TO --- )                                 R COUNT DUP 1+ R> + >R                                          OVER + SWAP                                                     DO                                                                DUP I C@ 8 * CHBASE @ + ROT C. 1+                             LOOP DROP ;    ;S                                                                                                              ( Forth String Stack Extension  )            HEX                                                                                : C."    22 STATE @                            ( addr --- )              IF                                                                 COMPILE  (C.")  WORD HERE C@  1+ ALLOT                       ELSE                                                               WORD HERE COUNT                                                 OVER + SWAP                                                     DO                                                                 DUP I C@ 8 * CHBASE @ + ROT  C. 1+                           LOOP DROP                                                    ENDIF ;   IMMEDIATE                                                                                                                                                   DECIMAL  ;S                                                                                                                                     ( 14 )                                                                                                                          : (SEL)                                                           0 R <ROT R DUP C@ 127 AND 4 * 1+ DUP R> + >R                    OVER + SWAP 1+ DO OVER I @ =                                    IF 1 OR I 2+ @ <ROT LEAVE ENDIF                                 4 +LOOP SWAP DROP                                               IF EXECUTE C@ 128 AND 0= 0= 2* R> + >R                          ELSE DROP ENDIF ;                                                                                                             : SEL ' (SEL) CFA , HERE 0 C, [COMPILE] [ ; IMMEDIATE           : -> , [COMPILE] ' CFA , 1 OVER +! ; IMMEDIATE                  : NOSEL DUP C@ 128 OR OVER C! [COMPILE] ] ; IMMEDIATE           : SELEND DROP [COMPILE] ] ; IMMEDIATE                                                                                           ;S                                                                                                                               ( Forth String Stack Extention          )          HEX                                                                          FORTH DEFINITIONS                                                                                                               200 CONSTANT *$*       *$* ALLOT                                HERE CONSTANT $0       $0  VARIABLE $P                                                                                          : $P!    $0 $P ! ;                                              : $P@    $P @ ;                                                 : $DROP  $P@ DUP @ + 2+ $P ! ;                                  : $@     DUP >R $P@ SWAP - SWAP OVER R CMOVE                             2 - R> OVER ! $P ! ;                                   : $!     DUP 2+ SWAP @ ROT SWAP CMOVE $DROP ;                   : $.     $P@ DUP 2+ SWAP @ TYPE $DROP ;                         : $DUP   $P@ DUP 2+ SWAP @ $@ ;                                                                         DECIMAL ;S              ( Forth String Stack Extension  )            HEX                                                                                : (")    R DUP 2+ SWAP @        ( Moves string to $STACK )               DUP 2+ R> + >R $@ ;                                                                                                    : "      22 STATE @                                                      IF                                                                 COMPILE  (")  0 C, WORD HERE C@                                 -1 ALLOT DUP , ALLOT                                         ELSE                                                               0 C, WORD HERE C@ -1 ALLOT HERE !                               HERE DUP 2+ SWAP @ $@                                        ENDIF ;   IMMEDIATE                                                                                                                                                   DECIMAL  ;S                                                                      ( Forth String Stack Extension )               HEX                                                                              0E +ORIGIN @ CONSTANT BS                                        7F CONSTANT PBS                                                                                                                 : $INPUT   PAD DUP                                                         BEGIN KEY DUP BS =                                                 IF ( backspace ) >R 2DUP = R> SWAP                                 IF DROP 0 ELSE DROP PBS EMIT 1 - 0 ENDIF                     ELSE DUP 0D =                                                      IF DROP 20 EMIT 1                                               ELSE DUP EMIT OVER C! 1+ 0                                      ENDIF                                                        ENDIF                                                        UNTIL OVER - $@ ;                                                                                   DECIMAL ;S                                                                       ( Forth String Stack Extension )               HEX                                                                              : $VARIABLE    <BUILDS DUP , DUP HERE                                          SWAP BLANKS ALLOT DOES> ;                                                                                        : $VARFILL     OVER @ ROT 2+ SWAP ROT FILL ;                                                                                    : $VAR@        DUP 2+ SWAP @ $@ ;                                                                                               : $VAR!        DUP 20 $VARFILL                                                 DUP 2+ SWAP @ $P@ @ MIN                                         $P@ 2+ <ROT CMOVE $DROP ;                                                                                                                                                                                                      DECIMAL ;S                                                                       ( GRAPHIC ROUTINES )                                                                                                            : C.                    ( FROM   TO   #CHR/LN  ---  )             SWAP OVER 8 *                                                   OVER + SWAP                                                     DO                                                                OVER C@ I C!                                                    SWAP 1+ SWAP                                                    DUP                                                           +LOOP                                                           DROP DROP ;                                                                                                                   ;S                                                                                                                                                                                                                                                              ( Definition of -TEXT )                                         : -TEXT                   ( Address  Count  Address ---  f )      SWAP -DUP                                                       IF                                                                OVER + SWAP                                                     DO                                                                DUP C@ FORTH I C@ -                                             IF                                                                0= LEAVE                                                      ELSE                                                              1+                                                            ENDIF                                                         LOOP                                                          ELSE                                                              DROP 0=                                                       ENDIF ;                                       ;S                                                                              ( The definition for SELECT: )                                                                                                  : CELSE ." ELSE" ;                                                                                                              : CASE:                                                           <BUILDS ?LOADING  !CSP                                             HERE 3 ALLOT    ( One for count, 2 for EXECUTE addr )           BEGIN  ( Until Otherwise: clause )                                 32 WORD HERE                                                    1+ 4 [ ' CELSE 3 + ] LITERAL -TEXT                              IF HERE OVER - 3 / 1-        ( # of cases )                        SWAP C!                   ( Save it )                           ] SMUDGE  1               ( Compile in OTHER: )              ELSE                                                                                                     -->                                                                            ( Continuation of SELECT: )                                                                                                                HERE NUMBER DROP                                                C,     ( Compile in the test byte )                             [COMPILE]  '  CFA                                               ,      ( Compile in the routine address )                       0      ( Have not reached OTHERWISE yet )                    ENDIF                                                        UNTIL                                                                                                                                                                                        DOES>                                                              >R I I C@ 1+ 3 * + @ I 1+ !  ( Set up OTHERWISE )               I 1+                       ( Exec address location )            I C@ 3 * I 3+ + R> 3+   ( Do loop arguments )                                                                         -->  ( Continuation of SELECT: )                                                                                                          DO                                                                 OVER I C@ =                                                     IF                                                                I 1+ @ OVER !    ( Change jump address )                        LEAVE                                                         ENDIF                                                        3 +LOOP                                                         SWAP DROP     ( Drop the character )                            @ EXECUTE ;   ( Go to the specified routine )                                                                                                                                                                                                ;S                                                                                                                                                                                                            ( 24 )                                                          : ONE  ." ONE " ;                                               : TWO  ." TWO " ;                                               : THREE ." THREE " ;                                            : BAD  ." NO GOOD " ;                                                                                                           : HIDE                                                            SEL                                                                1 -> ONE                                                        2 -> TWO                                                        3 -> THREE                                                   OTHERWISE                                                           BAD                                                         SELEND CR ;                                                                                                                   DECIMAL ;S                                                      ( 25 )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ( 26 )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ( 27 )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ( 28 )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ( 29 )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ( Proteus Disk Forth                    Forth Video Editor )                                                                    VOCABULARY EDITOR                                               EDITOR DEFINITIONS                                                                                                              32 CONSTANT BL          HEX CC00 CONSTANT VDM DECIMAL           0 VARIABLE INCNT                                                0 VARIABLE XLOC         ( X COORDINATE )                        0 VARIABLE YLOC                                                 0 VARIABLE INSRT                                                0 VARIABLE ?CHNG                                                0 VARIABLE ?CLR                                                 0 VARIABLE LSTCHR                                               0 VARIABLE ?PADMV                                               0 VARIABLE ?PADSM                                               0 VARIABLE ?ESC                                 -->             ( Proteus Disk Forth                    Forth Video Editor )                                                                    : CURLOC                        ( --- )                           52224 XLOC @ + YLOC @ C/L * + ;                                                                                               : CSHOW                         ( --- )                           CURLOC DUP C@ 128 OR SWAP C!  ;                                                                                               : CBLANK                        ( --- )                           CURLOC DUP C@ 127 AND SWAP C! ;                                                                                               : UPCUR                         ( --- )                           CBLANK YLOC @ 1- DUP 0<                                         IF                                                                DROP 15                                                       ENDIF YLOC ! CSHOW ;                                  -->     ( Proteus Disk Forth                    Forth Video Editor )                                                                    : DNCUR                         ( --- )                           CBLANK YLOC @ 1+ DUP 15 >                                       IF                                                                DROP 0                                                        ENDIF                                                           YLOC ! CSHOW ;                                                                                                                : LFCUR                         ( --- )                           CBLANK XLOC @ 1- DUP 0<                                         IF                                                                DROP C/L 1-                                                   ENDIF                                                           XLOC ! CSHOW ;                                                                                                        -->                                                                     ( Proteus Disk Forth                    Forth Video Editor )                                                                    : RTCUR                         ( --- )                           CBLANK XLOC @ 1+ DUP C/L 1- >                                   IF                                                                 DROP 0                                                       ENDIF                                                           XLOC ! CSHOW ;                                                                                                                : INTGL                         ( --- )                           INSRT @ 0= INSRT !                                              10  INCNT ! ;                                                                                                                 : NXTLN                         ( --- )                           CBLANK 0 XLOC ! DNCUR ;                                                                                               -->     ( Proteus Disk Forth                    Forth Video Editor )                                                                    : CLREOL                        ( --- )                           CBLANK CURLOC C/L XLOC @ -                                      BL FILL CSHOW ;                                                                                                               : BYTINS                        ( --- )                           CBLANK XLOC @ C/L 1- <                                          IF                                                                CURLOC DUP 1+                                                   C/L 1- XLOC @ -                                                 <CMOVE                                                        ENDIF                                                           BL CURLOC C!                                                    1 ?CHNG ! CSHOW ;                                                                                                     -->     ( Proteus Disk Forth                    Forth Video Editor )                                                                    : BYTDEL                        ( --- )                           CBLANK XLOC @ C/L 1- <                                          IF                                                                CURLOC DUP 1+ SWAP                                              C/L 1- XLOC @ -                                                 CMOVE                                                         ENDIF                                                           BL CURLOC                                                       C/L 1- XLOC @ - + C!                                            1 ?CHNG ! CSHOW ;                                                                                                                                                                                                                                                                                                     -->                                                                     ( Proteus Disk Forth                    Forth Video Editor )                                                                    : LNINS                         ( --- )                           CBLANK                                                          YLOC @ 15 <                                                     IF                                                                CURLOC XLOC @ -                                                 DUP C/L +                                                       15 YLOC @ - C/L *                                               <CMOVE                                                        ENDIF                                                           CURLOC XLOC @ -                                                 C/L BL FILL                                                     CSHOW                                                           1 ?CHNG ! ;                                                                                                           -->     ( Proteus Disk Forth                    Forth Video Editor )                                                                    : LNDEL                                 ( --- )                   CBLANK                                                          YLOC @ 15 <                                                     IF                                                                CURLOC XLOC @ -                                                 DUP C/L + SWAP                                                  15 YLOC @ - C/L *                                               CMOVE                                                         ENDIF                                                           CURLOC XLOC @ -                                                 15 YLOC @ - C/L * +                                             C/L BL FILL                                                     CSHOW                                                           1 ?CHNG ! ;                           -->                     ( Proteus Disk Forth                    Forth Video Editor )                                                                    : BFSHW ;                                                                                                                       : BFROT                                                           PAD DUP 320 +                                                   C/L CMOVE                                                       PAD DUP C/L +                                                   SWAP 256 CMOVE                                                  PAD 320 + DUP                                                   C/L - C/L CMOVE                                                 BFSHW ;                                                                                                                                                                                                                                                                                               -->                                                                                     (   PROTEUS DISK FORTH )                                                                                                        : <BFROT                                                          PAD 256 + DUP                                                   C/L + C/L CMOVE                                                 PAD DUP C/L +                                                   256 <CMOVE                                                      PAD DUP 320 +                                                   SWAP C/L CMOVE                                                  BFSHW ;                                                                                                                       : BFCLR                                                           PAD 256 +                                                       C/L BLANKS                                                      <BFROT ;                                                                                              -->                     ( PROTEUS DISK FORTH )                                                                                                          : BFCPY                                                           CBLANK BFROT                                                    CURLOC XLOC @ -                                                 PAD 256 +                                                       C/L CMOVE BFSHW                                                 CSHOW ;                                                                                                                       : >BFLN BFCPY LNDEL ;                                                                                                           : BFLN>                                                           LNINS PAD 256 +                                                 CURLOC XLOC @ -                                                 C/L CMOVE                                                       CSHOW <BFROT ;                        -->                     ( PROTEUS DISK FORTH )                                                                                                          : NWSCR                                                           CBLANK ?CHNG @                                                  IF                                                                VDM SCR @ BLOCK                                                 1024 CMOVE UPDATE                                             ENDIF                                                           SCR @ + 1 MAX SCR !                                             0 ?CHNG !     0 INSRT !                                         0 XLOC  !     0 YLOC !                                          SCR @ BLOCK VDM 1024 CMOVE                                      CSHOW ;                                                                                                                                                                                                                                       -->                                                                             ( PROTEUS DISK FORTH )                                                                                                          : RUB                                                             XLOC @ 0= NOT                                                   IF                                                                LFCUR                                                           BL CURLOC C!                                                    CSHOW 1 ?CHNG !                                               ENDIF                                                           INSRT @ IF BYTDEL ENDIF ;                                                                                                     : TAB                                                             CBLANK XLOC @                                                   4 + 4 / 4 * DUP C/L >                                           IF DROP 0 ENDIF                                                 XLOC ! CSHOW ;               -->                              ( PROTUES DISK FORTH )                                                                                                          : PRVSCR                                                          -1 NWSCR ;                                                                                                                    : NXTSCR                                                          1 NWSCR ;                                                                                                                     : SPLCHR                                                          1 ?ESC ! ;                                                                                                                    : EXIT ;                                                                                                                        : EDTABT                                                          0 ?CHNG !                                                       27 LSTCHR ! ;                                 -->             ( PROTEUS DISK FORTH )                                                                                                          : PTCHR                                                           INSRT @                                                         IF                                                                BYTINS                                                        ENDIF                                                           LSTCHR @ 127 AND CURLOC C!                                      RTCUR XLOC @ 0=                                                 IF                                                                DNCUR                                                         ENDIF                                                           1 ?CHNG !                                                       0 ?ESC !                                                        CSHOW ;                                                                                                            -->                                                                        ( PROTEUS DISK FORTH )                                                                                                          : CONTROL                                                         SEL                                                                 27 -> EXIT        128 -> EDTABT       23 -> UPCUR               26 -> DNCUR         1 -> LFCUR        19 -> RTCUR              127 -> RUB          20 -> INTGL        13 -> NXTLN              180 -> BYTINS      181 -> BYTDEL        2 -> LNINS               16 -> LNDEL       173 -> BFROT       174 -> <BFROT               0 -> BFCLR         0 -> BFCPY         0 -> >BFLN                0 -> BFLN>        18 -> PRVSCR        3 -> NXTSCR              24 -> SPLCHR       12 -> CLREOL        9 -> TAB             NOSEL                                                              PTCHR                                                        SELEND  ;                                             -->                                                                     ( PROTEUS DISK FORTH )                                                                                                          : V                                                               DECIMAL 1 MAX SCR !                                             0 ?CHNG ! CLS                                                   0 NWSCR                                                         ?PADSM @ PAD @ =                                                ?PADMV @ PAD DUP ?PADMV ! =                                     AND NOT                                                         IF PAD 320 BLANKS ENDIF BFSHW                                   BEGIN                                                             INKEY DUP LSTCHR ! -DUP                                         IF                                                                ?ESC @ IF DROP PTCHR 0 LSTCHR !  ELSE CONTROL ENDIF           ELSE                                                                                                           -->          ( PROTEUS DISK FORTH )                                                                                                                INSRT @ IF CBLANK CSHOW ENDIF                                 ENDIF                                                           LSTCHR @ 27 =                                                 UNTIL                                                           ?CHNG @                                                         IF                                                                CBLANK VDM SCR @ BLOCK 1024 CMOVE UPDATE                      ENDIF                                                           PAD @ ?PADSM !                                                  CLS CR                                                          ." Last edit on screen # " SCR @ . CR CR ;                                                                                    : L                                                               SCR @ V ;                                             ;S