( STANDARD FORTH LOAD BLOCK FOR PDP11 WITH EIS)                 FORGET FORTH   OCTAL                                                    11 LOAD 12 LOAD 13 LOAD 14 LOAD 15 LOAD 16 LOAD 17 LOAD                                 24 LOAD 25 LOAD 26 LOAD 27 LOAD 30 LOAD 31 LOAD 32 LOAD 33 LOAD 34 LOAD 35 LOAD 36 LOAD 37 LOAD 40 LOAD 41 LOAD 42 LOAD 43 LOAD 44 LOAD 45 LOAD 46 LOAD         DECIMAL                                                         40 C EDIT                                                       : STANDARD ;                                                    0 MESSAGE BLK 0SET                                              ;S                                                                                                                                                                                                                                                                                                                                                                                              ( STANDARD FORTH LOAD BLOCK FOR ANY PDP11)                      FORGET FORTH   OCTAL                                                    11 LOAD 12 LOAD 13 LOAD 14 LOAD 15 LOAD         17 LOAD                 22 LOAD 23 LOAD                 26 LOAD 27 LOAD 30 LOAD 31 LOAD 32 LOAD 33 LOAD 34 LOAD 35 LOAD 36 LOAD 37 LOAD 40 LOAD 41 LOAD 42 LOAD 43 LOAD 44 LOAD 45 LOAD 46 LOAD         DECIMAL                                                         40 C EDIT                                                       : STANDARD ;                                                    0 MESSAGE  BLK 0SET                                             ;S                                                                                                                                                                                                                                                                                                                                                                                              ( STANDARD FORTH LOAD BLOCK FOR PDP11 WITH EAE)                 FORGET FORTH   OCTAL                                                    11 LOAD 12 LOAD 13 LOAD 14 LOAD 15 LOAD         17 LOAD 20 LOAD 21 LOAD                                 26 LOAD 27 LOAD 30 LOAD 31 LOAD 32 LOAD 33 LOAD 34 LOAD 35 LOAD 36 LOAD 37 LOAD 40 LOAD 41 LOAD 42 LOAD 43 LOAD 44 LOAD 45 LOAD 46 LOAD         DECIMAL                                                         40 C EDIT                                                       : STANDARD ;                                                    0 MESSAGE BLK 0SET                                              ;S                                                                                                                                                                                                                                                                                                                                                                                              ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ( COMMON ADDRESS AND NUMERIC CONSTANTS)                         : C CONSTANT ;                                                  BASE 02 + C SP00  BASE 04 + C RP00 (  BASE -20 + C HEAD)        BASE 06 + C LAST  BASE 10 + C DP    BASE 12 + C DELIM           BASE 14 + C PREV  BASE 32 + C D     BASE 30 + C STATE           BASE 42 4 + + C IN                                              0 C 0   1 C 1   2 C 2   3 C 3   -1 C -1   -2 C -2   -3 C -3     4 C 4   5 C 5   6 C 6   7 C 7                                   1 C T   4 C S   5 C IC   6 C R                                  14 C S)  24 C S)+  44 C S-)                                     : 1+ 1 + ; : 2+ 2 + ; : 1- -1 + ; : 2- -2 + ;                   : 4+ 4 + ; : 4- 4 - ;                                           001000 C NE  001400 C EQ  100000 C PL  100400 C MI              102000 C VC  102400 C VS  103000 C CC  103400 C CS              002000 C GE  002400 C LT  003000 C GT  003400 C LE              101000 C HI  101400 C LS  103000 C HS  103400 C LO  ;S          ( COMMON ASSEMBLER)                                             5000 1OP CLR,  5100 1OP COM,  5200 1OP INC,  5300 1OP DEC,      5400 1OP NEG,  5500 1OP ADC,  5600 1OP SBC,  5700 1OP TST,      6000 1OP ROR,  6100 1OP ROL,  6200 1OP ASR,  6300 1OP ASL,      0100 1OP JMP,  0200 1OP RTS,  0300 1OP SWAB,  0240 1OP CLEAR,   0260 1OP SET,                                                   10000 2OP MOV,  20000 2OP CMP,  30000 2OP BIT,  40000 2OP BIC,  50000 2OP BIS,  60000 2OP ADD, 160000 2OP SUB,  04000 2OP JSR,  : NEXT, IC 30 + JMP, ;   : SEMI, IC R 20 + MOV, NEXT, ;         : ORCON CONSTANT ;CODE S) IC 10 + BIS, SEMI,                    10 ORCON )   20 ORCON )+ 30 ORCON @)+ 40 ORCON -)               50 ORCON @-) 60 ORCON I) 70 ORCON @I) 100000 ORCON \ ( BYTEFLG) 27 CONSTANT #  37 CONSTANT @#  67 CONSTANT P  77 CONSTANT @P    : SEC, 1 SET, ;                                                 : CLC, 1 CLEAR, ; : RTI, 2 , ; : WAIT, 1 , ; : HALT, 0 , ;      : J, P JMP, ;   ;S                                              ( SET 0SET 1SET 1+! 1-! !BIS !BIC)                              CODE 0SET S @)+ CLR, NEXT,                                      CODE 1SET S @)+ 1 # MOV, NEXT,                                  CODE -1SET S @)+ -1 # MOV, NEXT,                                CODE 1-! S @)+ DEC, NEXT,                                       CODE 2+! S @)+ 2 # ADD, NEXT,                                   CODE 1+! S @)+ INC, NEXT,                                       CODE 2* S) ASL, NEXT,                                           CODE 2/ S) ASR, NEXT,                                           : SET SWAP C , ;CODE IC @)+ IC )+ MOV, SEMI,                    CODE COM S) COM, NEXT,                                          ;S                                                              CODE !BIS 0 S)+ MOV, 0 ) S)+ BIS, NEXT,                         CODE !BIC 0 S)+ MOV, 0 ) S)+ BIC, NEXT,                                                                                                                                                         ( - @ ! +! OR AND XOR MINUS OVER HERE )                         CODE - S) S)+ SUB, NEXT,                                        CODE @ S) 0 S @I) MOV, NEXT,                                    CODE B@ S) \ 0 S @I) MOV, S) 177400 # BIC, NEXT,                CODE ! T S)+ MOV, T ) S)+ MOV, NEXT,                            CODE B! T S)+ MOV, T ) \ S) MOV, S)+ TST, NEXT,                 CODE +! T S)+ MOV, T ) S)+ ADD, NEXT,                           CODE OR S) S)+ BIS, NEXT,                                       CODE AND S) COM, S) S)+ BIC, NEXT,                              CODE XOR T 2 S I) MOV, 2 S)+ MOV, S) 2 BIS, 1 COM, 2 1 BIC,       S) 2 BIC, NEXT,  ( UNIVERSAL PDP11)                           CODE MINUS S) NEG, NEXT,                                        CODE OVER  T 2 S I) MOV, S-) T MOV, NEXT,                       CODE HERE S-) DP P MOV, NEXT,                                   ;S                                                                                                                              ( ASSEMBLER CONDITIONALS FOR ANY PDP11)                         : HERE/ HERE 2/ ;                                               : NOT/ 400 XOR ;                                                : IF, NOT/ HERE SWAP HERE/ 1+ - , ;                             : THEN, HERE/ SWAP +! ;      : ELSE, 0 IF, SWAP THEN, ;         : BEGIN, HERE/ ;                                                : END, NOT/ SWAP HERE/ 1+ - 377 AND + , ;                       : SOB, DEC, EQ END, ;                                           CODE NOT S) COM, S) 177776 # BIC, NEXT,                         ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                              ( EXTRA BLOCK FOR PDP-11/40,03, ETC)                            6700 1OP SXT,                                                   70000 2OP MUL,  71000 2OP DIV,  72000 2OP ASH,                  73000 2OP ASHC, 74000 2OP XOR,  ( 77000 2OP  SOB, )             CODE SOB T S)+ MOV, 6 # T ASH, T 77000 # ADD, S) 2 S I) SUB,      S) 1777700 # BIC, T S)+ ADD, S) T MOV, NEXT,                  : SOB, HERE/ 1+ SWAP SOB , ;                                    CODE XOR T S)+ MOV, S) T XOR, NEXT,                             ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ( MOVE MAX MIN ABS >R R> IARRAY ARRAY INTEGER)                  CODE BMOVE 0 S)+ MOV, GT IF, T S)+ MOV, 2 S)+ MOV, BEGIN,         T )+ \ 2 )+ MOV, 0 SOB, ELSE, S)+ S)+ CMP, THEN, NEXT,        CODE MOVE 0 S)+ MOV, GT IF, T S)+ MOV, 2 S)+ MOV, BEGIN,          T )+ 2 )+ MOV, 0 SOB, ELSE, S)+ S)+ CMP, THEN, NEXT,          CODE DP+! DP P S)+ ADD, NEXT,                                   CODE MAX T S)+ MOV, T S) CMP, LT IF, S) T MOV, THEN, NEXT,      CODE MIN T S)+ MOV, T S) CMP, GT IF, S) T MOV, THEN, NEXT,      CODE ABS S) TST, MI IF, S) NEG, THEN, NEXT,                     CODE >R R -) S )+ MOV, NEXT,                                    CODE R> S-) R )+ MOV, NEXT,                                     : IARRAY ENTER ;CODE S-) IC MOV, SEMI,                          : ARRAY IARRAY 2* DP+! ;                                        : INTEGER IARRAY , ;   : SUBROUTINE IARRAY ;  ;S                : FILL SWAP >R OVER ! DUP 2+ R> 1- MOVE ;                       : CLEAR 0 FILL ; ( ADR #WD VALUE FILL, OR ADR #WD CLEAR)        ( /MOD MOD * / FOR DPDP11 WITH EAE)                             -500 C _DIV    -476 C _AC     -474 C _MQ     -472 C _MUL        -470 C _SC     -466 C _NOR    -464 C _LSH    -462 C _ASH        -467 C _SR                                                      CODE /MOD 0 _MQ # MOV, S) TST, NE IF, 0 ) 2 S I) MOV, 0 -) TST,   _DIV P S)+ MOV, S) 0 )+ MOV, S -) 0 ) MOV,  THEN, NEXT,       CODE * 0 _MQ # MOV, 0 )+ S)+ MOV,                                 0 ) S) MOV, S) 0 -) MOV, NEXT,                                CODE / 0 _MQ # MOV, 0 ) 2 S I) MOV, _DIV P S)+ MOV,               S) 0 ) MOV, NEXT,                                             CODE */ 0 _MQ # MOV, T S)+ MOV, 0 )+ S)+ MOV, 0 ) S)+ MOV,        _DIV P T MOV, S-) 0 -) MOV, NEXT,                             : MOD /MOD DROP ;                                               ;S                                                                                                                                                                                              ( M* M/ M/MOD WITH EAE)                                         CODE M/MOD 0 _MQ # MOV, R -) S)+ MOV, 0 ) S)+ MOV, _DIV P R )     MOV, 3 -2 0 I) MOV, 2 0 ) MOV, S) ASL, 3 ROL, 0 ) 3             MOV, _DIV P R ) MOV, 0 -) TST, R -) 0 )+ MOV, 3 0 ) MOV,        0 ) S) MOV, 0 -) R )+ MOV, _ASH P DEC, _DIV P R )+ MOV,         T 0 )+ MOV, S) 0 ) MOV, 3 ASR, CS IF, S) 100000 # BIS,          THEN, 2 3 ADD, S -) 2 MOV, S-) T MOV, NEXT,                   : M/ M/MOD DROP ;                                               CODE M* 0 _MQ # MOV, R -) S)+ MOV, 0 )+ S)+ MOV, 0 ) R ) MOV,     T 0 -) MOV, 2 CLR, S) ROR, 2 ADC, 0 )+ S) MOV,                  0 ) R ) MOV, _ASH P INC, 2 DEC, NE IF, R ) CLR, THEN,           S) R )+ MOV, S) 0 -) ADD, T ADC, T 0 -) ADD,                    S-) T MOV, NEXT,                                              ;S                                                                                                                                                                                              ( DVD MPY FOR ANY PDP11)                                        SUBROUTINE DVD S) TST, EQ IF, S)+ S)+ CMP, S-) CLR, S-) CLR,      7 RTS, THEN, R -) CLR, S) TST, MI IF, S) NEG, R ) 2 # ADD,      THEN, 2 S I) TST, MI IF, R ) 3 # ADD, 2 S I) NEG, 4 S I) NEG,   2 S I) SBC, THEN, R -) 20 # MOV, BEGIN, 4 S I) ASL, 2 S I)      ROL, NE IF, 4 S I) INC, 2 S I) S) SUB, CS IF, 2 S I) S) ADD, 4  S I) DEC, THEN, THEN, R ) DEC, EQ END, R )+ S)+ CMP, R ) ASR,   CS IF, S) NEG, THEN, R )+ ASR, CS IF, 2 S I) NEG, THEN,         R -) S) MOV, S) 2 S I) MOV, 2 S I) R )+ MOV, 7 RTS,           SUBROUTINE MPY R -) CLR, S) TST, MI IF, S) NEG, R ) INC, THEN,    2 S I) TST, MI IF, 2 S I) NEG, R ) INC, THEN,                   R -) 21 # MOV, R -) CLR, R -) CLR, BEGIN,                       R ) ROR, 2 R I) ROR, S) ROR, CS IF, R ) 2 S I) ADD, THEN,       4 R I) DEC, EQ END, S) R )+ MOV, 2 S I) R )+ MOV, R )+ TST,     R )+ ASR, CS IF, S) NEG, 2 S I) NEG, S) SBC, THEN, 7 RTS,     ;S                                                              ( /MOD, M/MOD, *, /, MOD FOR ANY PDP11)                         CODE /MOD R -) S) MOV, S) CLR, 2 S I) TST, MI IF, S) DEC, THEN,   S-) R )+ MOV, DVD P 7 JSR, NEXT,                              CODE M/MOD R -) S) MOV, S) CLR, 2 S I) TST, MI IF, S) DEC, THEN,  S-) R ) MOV, DVD P 7 JSR, 0 S) MOV, S) CLR, 4 S I) ASL,         2 S I) ROL, MI IF, S) DEC, THEN, S-) R ) MOV, DVD P 7 JSR,      1 S)+ MOV, S) ASR, 2 S I) ROR, S-) R )+ MOV, DVD P 7 JSR,       1 ASR, CS IF, S) 100000 # BIS, THEN, 0 1 ADD, 2 2 S I) MOV,     S) S)+ MOV, S-) 0 MOV, S-) 2 MOV, NEXT,                       CODE * MPY P 7 JSR, S)+ TST, NEXT,                              : / /MOD SWAP DROP ;                                            : MOD /MOD DROP ;                                               ;S                                                                                                                                                                                                                                                              ( */ /MOD MOD * /      FOR PDP11 WITH EIS)                      CODE */ 2 S)+ MOV, 0 S)+ MOV, S)+ 0 MUL, 2 0 DIV,                 S-) 0 MOV, NEXT,                                              CODE /MOD T 2 S I) MOV, 0 SXT, S)+ 0 DIV,                         CS IF, 0 CLR, T SXT, THEN, S) T MOV, S-) 0 MOV, NEXT,         CODE * T S)+ MOV, S)+ T MUL, S-) T MOV, NEXT,                                                                                   : / /MOD SWAP DROP ;                                            : MOD /MOD DROP ;                                                                                                               ;S                                                                                                                                                                                                                                                                                                                                                                                              ( M* M/MOD M/ WITH EIS)                                         CODE M* 2 S)+ MOV, 3 S)+ MOV, 2 3 MUL, 0 S) MOV, S) CLR,          0 ROR, S) ADC, 2 0 MUL, 1 # 0 ASHC, S) DEC, NE IF, 2 CLR,       THEN, 1 2 ADD, 0 ADC, 0 3 ADD, S) 1 MOV, T 0 MOV, PUSH J,     CODE M/MOD R -) S)+ MOV, 3 S)+ MOV, 2 SXT, R ) 2 DIV, S )         ASL, 3 ROL, 1 3 MOV, 0 SXT, R ) 0 DIV, 3 0 MOV, 0 1 MOV,        1 S) MOV, -1 # 0 ASHC, R )+ 0 DIV, S) 0 MOV, 3 ASR, CS IF,      S) 100000 # BIS, THEN, 2 3 ADD, S -) 2 MOV, PUSH J,           ( INPUT TO M/MOD MUST BE POSITIVE)                              : M/ M/MOD DROP ;                                               ;S                                                                                                                                                                                                                                                                                                                                                                                              ( TEST AND COMPARE FUNCTION)                                    : 0TST ENTER NOT/ OVER SWAP END, DUP 1+ 0 END,                    ;CODE T CLR, S) TST, IC ) JMP,                                : CMPR 0TST                                                       ;CODE T CLR, S)+ 2 S I) CMP, IC ) JMP,                        BEGIN, T INC, S) T MOV, SEMI,                                   EQ 0TST 0=   LT 0TST 0<                                         GT 0TST 0>   NE 0TST 0<>                                        LE 0TST 0<=  GE 0TST 0>=                                        EQ CMPR =   LO CMPR L<                                          HI CMPR L>   NE CMPR <>                                         LS CMPR L<=  HS CMPR L>=                                        LT CMPR <    GT CMPR >                                          LE CMPR <=   GE CMPR >=                                         DROP   ;S                                                                                                                       ( MK! MK@ EXEC, EXEC ROLL PICK)                                 : FLUSH FLUSH FLUSH ;                                           0 INTEGER MARK                                                  : MK! HERE MARK ! ;                                             : MK@ MARK @ ;                                                  205 INTEGER RTSIC                                               : EXEC, @# IC JSR, RTSIC , ;                                    CODE EXEC S @)+ IC JSR, HERE 2+ , SEMI,                         CODE ROLL 0 S)+ MOV, GT IF, 0 ASL, 0 S ADD, 1 0 -) MOV, BEGIN,    2 0 I) 0 -) MOV, 0 S CMP, EQ END, S) 1 MOV, THEN, NEXT,       CODE PICK 0 S) MOV, 0 ASL, 0 S ADD, S) 0 ) MOV, NEXT,           : ,CODE ENTER 2* HERE + HERE 2- ! ;                             ;S                                                                                                                                                                                                                                                              ( ADOPT ORPHANS AND ?DEF)                                       CODE LIT S-) IC )+ MOV, NEXT,                                   CODE P-VX 0 DP P MOV, 1 \ 6 0 I) MOV, 1 177760 # BIC, 1 ASL,      1 HERE 10 + # ADD, S -) 1 MOV, NEXT,    40 DP+!               : ADOPT , ; IMMEDIATE                                           : ADOPTX P-VX @ , ; IMMEDIATE                                   0 , 0 , LAST P HERE #                                           : ORFANX HERE P-VX ! :> MOV, NEXT,                              : :ORFNX ORFANX >: ;                                            : ?DEF WORD 0 FIND 1 + ;                                        ;S                                                                                                                                                                                                                                                                                                                                                                                              ( ORPHANS)                                                      :ORFN0 , HERE 0 , ;                                             ORFAN1 S)+ TST, NE IF, IC )+ TST, NEXT, THEN,                   ORFAN2 IC IC ) MOV, NEXT,                                       ORFAN3 S) S)+ CMP, EQ IF, IC )+ S)+ CMP, NEXT,                    THEN, IC IC ) MOV, NEXT,                                      ORFAN4 R -) IC MOV, R -) S)+ MOV, R -) S)+ MOV, NEXT,           ORFAN5 2 R I) INC, R ) 2 R I) CMP, LT IF, IC 4 R I) MOV,          NEXT, THEN, R 6 # ADD, NEXT,                                  ORFAN6 2 R I) S) ADD, S)+ TST, MI IF, R ) 2 R I) CMP, LT IF,      R 6 # ADD, NEXT, THEN, IC 4 R I) MOV, NEXT, THEN, R ) 2 R I)    CMP, LT IF, IC 4 R I) MOV, NEXT, THEN, R 6 # ADD, NEXT,       ;S                                                                                                                                                                                                                                                              ( DO LOOP +LOOP I J K TERM)                                     CODE DO STATE P TST, NE IF, >: LIT ADOPT4 , LIT ?^C , ; THEN,     R -) IN P MOV, R -) S)+ MOV, R -) S)+ MOV, NEXT,  IMMEDIATE   CODE LOOP STATE P TST, NE IF, >: LIT ADOPT5 , ; THEN,             2 R I) INC, R ) 2 R I) CMP, LT IF, IN P 4 R I) MOV, ELSE,       R 6 # ADD, THEN, NEXT,  IMMEDIATE                             CODE +LOOP STATE P TST, NE IF, >: LIT ADOPT6 , ; THEN,            2 R I) S) ADD, S)+ TST, MI IF, R ) 2 R I) CMP,                  LT IF, R 6 # ADD, NEXT, THEN, IN P 4 R I) MOV, NEXT,            THEN, R ) 2 R I) CMP, LT IF, IN P 4 R I) MOV, NEXT, THEN,       R 6 # ADD, NEXT,  IMMEDIATE                                   CODE I S-) 02 R I) MOV, NEXT,   CODE J S-) 10 R I) MOV, NEXT,   CODE K S-) 16 R I) MOV, NEXT,   CODE TERM 2 R I) R ) MOV, NEXT, ;S                                                                                                                                                                                              ( IF ELSE THEN CASE BEGIN END)                                  CODE BEGIN STATE P TST, NE IF, S-) DP P MOV, ELSE,                R -) IN P MOV, THEN, NEXT,  IMMEDIATE                         CODE END STATE P TST, NE IF, >: LIT ?^C , LIT ADOPT1 , , :>       ELSE, S)+ TST, NE IF, R )+ TST, ELSE, IN P R ) MOV, THEN,       THEN, NEXT, IMMEDIATE                                         CODE THEN STATE P TST, NE IF, >: HERE SWAP ! :> THEN, NEXT,       IMMEDIATE                                                     CODE ELSE STATE P TST, NE IF, >: LIT ADOPT2 ADOPT0 SWAP OVER 2+   SWAP ! :> ELSE, BEGIN, % ?DEF EXEC, S)+ TST, % THEN # 2 CMP,    EQ END, THEN, NEXT,  IMMEDIATE                                CODE IF STATE P TST, NE IF, >: LIT ADOPT1 ADOPT0 ;                THEN, S)+ TST, EQ IF, BEGIN, % ?DEF EXEC, S)+ TST, % THEN # 2   CMP, EQ IF, NEXT, THEN, % ELSE # 2 CMP, EQ END, THEN, NEXT,     IMMEDIATE                                                     : CASE LIT ADOPT3 ADOPT0 ;  IMMEDIATE  ;S                       ( DOUBLE PRECISION INTEGER PACKAGE)                             : 2INTEGER INTEGER , ;                                          : 2CONSTANT C , ;CODE S -) 2 IC I) MOV, S -) IC ) MOV, SEMI,    CODE 2@ 2 S) MOV, S-) 2 )+ MOV, 2 S I) 2 ) MOV, NEXT,           CODE 2! T S)+ MOV, T )+ S)+ MOV, T ) S)+ MOV, NEXT,             CODE DMINUS S) NEG, 2 S I) NEG, S) SBC, NEXT,                   CODE D+ 2 S I) S)+ ADD, 2 S I) S)+ ADD, S) ADC, NEXT,           CODE 2SWAP 0 S)+ MOV, 1 S)+ MOV, S-) 2 S I) MOV, 4 S I) 1 MOV,    S-) 2 S I) MOV, 4 S I) 0 MOV, NEXT,                           CODE D+! 0 S)+ MOV, 0 )+ S)+ ADD, 0 ) S)+ ADD, 0 -) ADC, NEXT,  CODE 2DUP S -) 2 S I) MOV, S -) 2 S I) MOV, NEXT,               CODE 2DROP S)+ S)+ CMP, NEXT,                                   CODE D- 2 S I) S)+ SUB, 2 S I) S)+ SUB, S) SBC, NEXT,           CODE DABS S) TST, MI IF, % DMINUS J, THEN, NEXT,                ;S                                                                                                                              ( 2>R 2R> 2OVER D< D> SGN. D>=)                                 CODE 2>R R -) S)+ MOV, R -) S)+ MOV, NEXT,                      CODE 2R> S-) R )+ MOV, S-) R )+ MOV, NEXT,                      CODE 2OVER S-) 6 S I) MOV, S-) 6 S I) MOV, NEXT,                CODE D< 0 S)+ MOV, 2 S)+ MOV, T CLR, 0 S)+ CMP,                   LT IF, T INC, ELSE, EQ IF, 2 S) CMP, CS IF, T INC,                    THEN, THEN, THEN, S) T MOV, NEXT,                       : D> 2SWAP D< ;                                                 CODE D>= 1 CLR, 2 S I) S)+ CMP, NE IF, LT IF, 1 INC, THEN, S)+    S)+ CMP, S) T MOV, NEXT, THEN, 2 S I) S)+ CMP, LS IF, 1 INC,  THEN, S)+ TST, S) T MOV, NEXT,                                  ;S                                                                                                                                                                                                                                                                                                                              ( COPY EXCHANGE [ \,)                                           : COPY SWAP BLOCK DROP PREV 2+ ! UPDATE FLUSH ;                 CODE @! 0 S)+ MOV, T 0 ) MOV, 0 ) S)+ MOV, PUSH J,              : EXCHANGE BLOCK DROP UPDATE BLOCK DROP UPDATE PREV 2+            DUP 6 + OVER @ SWAP @! SWAP ! FLUSH ;                         CODE 2GET 0 IC MOV, 0 -) 0 -) CMP, S-) 0 ) MOV,                         S-) 0 -) MOV, NEXT,                                     : [ IMMEDIATE LIT ADOPT2 , HERE 0 , HERE 135 DELIM ! WORD COUNT   DUP 2/ 2* 2+ DP+! , , HERE SWAP ! % 2GET , ;                  : \, 400 * SWAP 377 AND OR , ;                                  ( OPTIMIZE J, TO USE BR INSTRUCTIONS)                           : J, HERE 2+ OVER - 400 L> IF J, ELSE 2/ 0 END, THEN ;          ;S                                                                                                                                                                                                                                                              ( NUMBER OUTPUT )                                               CODE SE 0 SP00 P MOV, S) ASL, 0 S)+ SUB, 0 S CMP,                 HI IF, % ABORT P JMP, THEN, NEXT,                             2 ,CODE !DIGIT 0 , 0 , 0 S )+ MOV, GT IF, IC ) DEC, IC @)+ \      0 MOV, THEN, SEMI,                                            CODE BUFFER 0 ' !DIGIT # MOV, 0 ) DP P MOV, 0 ) 50 # ADD,         0 ) 0 )+ MOV, NEXT,                                           CODE +- S )+ S )+ CMP, 0 ' !DIGIT # MOV, 1 0 )+ MOV,              S )+ TST, MI IF, 1 -) \ 55 # MOV, THEN,                         S -) 1 MOV, S -) 0 ) MOV, S) 1 SUB, NEXT,                     : DIGIT BASE @ M/MOD 11 OVER < IF 7 + THEN 60 + !DIGIT DABS ;   : DIGITS BEGIN DIGIT OVER ABS OVER + 0= END ;                   :ORFN@ BUFFER DIGITS +- ;                                       : (.) BASE @ 12 < IF 0 SWAP ELSE DUP ABS THEN 0 ADOPT@ ;        : CONVERT (.) DROP ;                                            ;S                                                              ( NUMERIC TYPE OUT)                                             : SPACE [  ] TYPE ;                                             : SPACES 0 MAX DUP 0> IF 0 DO SPACE LOOP ELSE DROP THEN ;       : .R 2 SE >R (.) R> OVER - SPACES TYPE ;                        : .D 2 SE SWAP OVER DABS ADOPT@ ;                               : D.R >R .D R> OVER - SPACES TYPE ;                             : . 1 SE (.) TYPE ;                                             : O. 1 SE BASE @ SWAP OCTAL . BASE ! ;                          : D. .D TYPE ;                                                  : DO. 2 SE BASE @ OCTAL >R 2>R 0 2R> ADOPT@ R> BASE ! TYPE ;    : D? 2@ D. ;                                                    : ? @ . ;                                                       : O? @ O. ;                                                     ;S                                                                                                                                                                                              ( LINE SPACES? LIST SHOW DUMP)                                  0 INTEGER BLK    20040 INTEGER BLANKS                           1 ,CODE SPACES? 100 , 0 IC ) MOV, T S) MOV, T 0 ADD, BEGIN,             40 # \ T -) CMP, EQ IF, 0 DEC, ELSE, 0 CLR, THEN,               EQ END, T S) SUB, T INC, S-) T MOV, SEMI,               : LINE 1 - 17 MIN 100 * BLK @ BLOCK  + ;                        : LIST BLK ! 21 1 DO I 3 .R SPACE I LINE SPACES? TYPE CR LOOP ; : SHOW 1+ SWAP DO [ BLOCK ] TYPE I DUP . CR LIST                  5 0 DO CR LOOP LOOP ;                                         CODE SWAB S) SWAB, NEXT,                                        : DUMP 2* OVER + DUP 3 ROLL DO I 0 6 D.R [ :] TYPE                DUP I 20 + MIN I DO I @ 7 .R 2 +LOOP CR 20 +LOOP DROP ;       ;S                                                                                                                                                                                                                                                              ( RAD50)                                                        MK! 00 00 \, 00 00 \, 33 00 \, 00 00 \, 00 00 \, 00 00 \, 00 00  \, 34 00 \, 36 37 \, 40 41 \, 42 43 \, 44 45 \, 46 67 \, 00 00  \, 00 00 \, 00 00 \, 00 01 \, 02 03 \, 04 05 \, 06 07 \, 10 11  \, 12 13 \, 14 15 \, 16 17 \, 20 21 \, 22 23 \, 24 25 \, 26 27  \, 30 31 \, 32 33 \, 34 35 \, 36 37 \, 40 41 \, 42 43 \, 44 45  \, 46 47 \,                                                    CODE RAD50 2 3 # MOV, S-) CLR, BEGIN, S-) 50 # MOV, % * EXEC,     3 \ 2 S @I) MOV, 3 40 # SUB, NE IF, 2 S I) INC, THEN, 1 \ MK@   3 I) MOV, S) 1 ADD, 2 SOB, NEXT,                              ;S                                                                                                                                                                                                                                                                                                                                                                                              ( DEV:FILNAM.EXT TO RAD50)                                      IARRAY FNAME 0 , 0 , 0 , 0 ,                                    : GETRAD 2* FNAME + SWAP HERE 200 + SWAP 0 DO RAD50 SWAP >R       OVER ! 2+ R> LOOP DROP DROP ;                                 CODE PARS 0 S)+ MOV, 1 S)+ MOV, 2 S) MOV, 3 DP P MOV, 3 200 #     ADD, BEGIN, 0 \ 2 ) CMP, EQ IF, 3 )+ \ 40 # MOV, 1 CLR, 2       INC, ELSE, 40 # \ 2 ) CMP, EQ IF, 3 )+ \ 40 # MOV, 1 CLR,       ELSE, 3 )+ \ 2 )+ MOV, THEN, THEN, 1 DEC, LE END, EQ IF, 2      INC, THEN, S) 2 MOV, NEXT,                                    : PARSE WORD HERE 1+ 3 72 PARS 1 0 GETRAD                                    6 56 PARS 2 1 GETRAD                                            3 40 PARS 1 3 GETRAD DROP ;                        ;S                                                                                                                                                                                                                                                              ( GCH/PCH -RT11-  LINK AND CREATE RT11 FILES)                   44 CONSTANT JSW                                                 CODE GCH S -) JSW P MOV, JSW P 50000 # BIS, BEGIN,                104340 , ( EMT 340) CC END, JSW P S ) MOV, S ) 0 MOV, NEXT,   CODE PCH 0 S )+ MOV, 104341 , ( EMT 341) NEXT,                                                                                  : FILE ENTER PARSE FNAME HERE 4 MOVE 10 DP+!                      ;CODE S-) IC MOV, SEMI,                                       : /COPY >R >R DISK BLOCK DROP R> R> DISK UPDATE                   PREV 2+ ! FLUSH ;                                             ;S                                                                                                                                                                                                                                                                                                                                                                                              ( STANDARD FILE DEFINITIONS)                                    ( SYSTEM IS DEFINED IN KERNEL)                                  FILE XED DK:XED.DAT                                            FILE BFP DK:BFP.DAT                                            FILE EFP DK:EFP.DAT                                            FILE MUX DK:MUX.DAT                                            FILE MSG DK:MSG.DAT                                            FILE RTS DK:RTS.DAT                                            FILE SCRATCH DK:SCRTCH.DAT                                     FILE DPMATH DK:DPMATH.DAT                                      ;S                                                                                                                                                                                                                                                                                                                                                                                              ( MESSAGE AND  DEFERRED OPERATIONS)                             : MESSAGE 20 /MOD CHANNEL @ >R MSG DISK BLK ! 1+ LINE SPACES?     TYPE R> DISK ;                                                ( <N> MESSAGE  GETS THE N-TH LINE OF FILE MSG AND TYPES ON)     (    THE TERMINAL.  PREVIOUS DISK IS RESTORED.)                                                                                 CODE )! 0 S @)+ MOV, 0 ) S)+ MOV, NEXT,                         CODE )@ 0 S @)+ MOV, S-) 0 ) MOV, NEXT,                         CODE )+! 0 S)+ MOV, 1 0 ) MOV, 1 )+ S)+ MOV, 0 ) 1 MOV, NEXT,   CODE )+@ 0 S)+ MOV, 1 0 ) MOV, S-) 1 )+ MOV, 0 ) 1 MOV, NEXT,   CODE -)! 0 S)+ MOV, 1 0 ) MOV, 1 -) S)+ MOV, 0 ) 1 MOV, NEXT,   CODE -)@ 0 S)+ MOV, 1 0 ) MOV, S-) 1 -) MOV, 0 ) 1 MOV, NEXT,   ;S                                                                                                                                                                                                                                                              ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ( TEXT EDITOR)                                                  : EDITOR ;   : FORGET FLUSH FORGET ;                            32 ARRAY TEXT                                                   : BLANKIT BLANKS @ OVER ! DUP 2+ 31 MOVE ;                      : STRING TEXT BLANKIT DELIM ! WORD HERE COUNT TEXT SWAP BMOVE ; : " 34 STRING ;  : ( 41 STRING ;                                : HOLD DUP LINE TEXT 32 MOVE ;                                  : T HOLD LINE SPACES? BLANKS 2 TYPE TYPE ;                      : R LINE TEXT SWAP 32 MOVE UPDATE ;                             : D HOLD DUP 16 < IF 16 SWAP DO I 1+ LINE DUP 32 - 32 MOVE        LOOP ELSE DROP THEN 16 LINE BLANKIT UPDATE ;                  : I DUP 15 DO I LINE DUP 64 + 32 MOVE -1 +LOOP 1+ R ;           ;S                                                                                                                                                                                                                                                              ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ;S                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ;S