; STORE A GIVEN VALUE ; SVAL VAR,VALUE ; WHERE - ; VAR = THE POSITION TO STORE THE GIVEN ; VALUE ; VALUE = THE VALUE TO BE STORED .MACRO SVAL VAR,VALUE MOV #VALUE,VAR ; DO IT TO IT. RETURN .ENDM SVAL ; STORE A VALUE ; FVAL VALUE,MAX ; WHERE - ; VALUE = THE POSITION TO STORE THE SINGLE ; WORD VALUE ; MAX = THE MAXIMUM VALUE TO BE ACCEPTED .MACRO FVAL VALUE,MAX CMP .PNUMB,#MAX ; CHECK FOR ILLEGAL NUMBER BGT 999$ ; TOO LARGE, THEN BRANCH MOV .PNUMB,VALUE ; SET THE NUMBER RETURN 999$: ADD #2,(SP) RETURN .ENDM FVAL ; SET AN ARRAY OF SINGLE WORD POSITIVE INTEGERS ; CALLED BY: ; FVALS VALS,NVALS,MAXN,MAXV ; WHERE - ; VALS = THE ARRAY ; NVALS = THE NUMBER OF WORDS ALREADY IN ARRAY ; MAXN = MAXIMUM NUMBER OF WORDS IN ARRAY ; MAXV = MAXIMUM VALUE OF A VALUE IN ARRAY .MACRO FVALS VALS,NVALS,MAXN,MAXV CMP NVALS,#MAXN ; CHECK IF THE BUFFER IS FULL BGE 999$ ; ERROR CMP .PNUMB,#MAXV ; CHECK FOR MAXIMUM VALUE BGT 999$ ; ERROR MOV #VALS,R0 ; GET BUFFER ADDRESS ADD NVALS,R0 ; ADD THE NUMBER OF WORDS ADD NVALS,R0 INC NVALS ; INCREMENT THE BUFFER COUNT MOV .PNUMB,(R0) ; SET THE VALUE(LS WORD) RETURN 999$: ADD #2,(SP) RETURN .ENDM FVALS ; SET A STRING OF CHARACTERS IN AN ARRAY ; CALLED BY: ; FSTRG COUNT,MAX,BUFFR ; WHERE - ; COUNT = THE VARIABLE TO RECEIVE THE STRING LENGTH ; MAX = THE MAX STRING LENGTH ; BUFFR = THE BUFFER TO STORE THE STRING .MACRO FSTRG COUNT,MAX,BUFFR CMP .PSTCN,#MAX ; CHECK FOR TOO MANY CHARACTERS BGT 999$ ; TOO LARGE, THEN ERROR MOV #BUFFR,R2 ; SET DESTINATION STRING ADDRESS MOV .PSTCN,COUNT ; SET STRING LENGTH MOV .PSTCN,R0 ; SET LOOP COUNTER BEQ 2$ ; CLEAR BUFFER IF ZERO BLT 4$ ; RETURN IF NEGATIVE (ERROR) MOV .PSTPT,R1 ; SET SOURCE STRING POSITION 1$: MOVB (R1)+,(R2)+ ; MOV A CHARACTER SOB R0,1$ ; LOOP 2$: CMP .PSTCN,#MAX ; FULL BUFFER? THEN DONE. BEQ 4$ MOV #MAX,R0 ; COMPUTE HOW MANY ARE LEFT SUB .PSTCN,R0 3$: CLRB (R2)+ ; CLEAR THE REST SOB R0,3$ 4$: RETURN 999$: ADD #2,(SP) RETURN .ENDM FSTRG ; DECODE A FLOATING POINT NUMBER ; CALLED BY: ; RVAL VALUE ; WHERE - ; VALUE = THE REAL VARIABLE RECEIVING THE NUMBER .MACRO RVAL VALUE .MCALL RVAL1 MOV #VALUE,R0 ; STORE THE ADDRESS OF REAL*4 VARIABLE JMP ..FP1 ; GO DO IT. ..FP = ..FP+1 ; INCREMENT NUMBER OF RVAL CALLS .IF EQ ..FP-1 ; IF THIS IS THE FIRST, RVAL1 ; SET UP THE RVAL DATA STRUCTURES .ENDC .ENDM RVAL ; SUB MACRO TO RVAL ; THIS MACRO SETS UP THE DATA STORAGE FOR ; THE FLOATING POINT NUMBER ACTION ROUTINE ; RVAL1 .MACRO RVAL1 ; SET UP THE PARAMETER BLOCK FOR THE FORTRAN ; ROUTINE TO DECODE THE NUMBER ; CALLED BY: ; JMP ...FP1 ; WHERE- ; R0 = ADDRESS OF REAL*4 STORAGE LOCATION ..FP1: MOV R3,-(SP) ; SAVE R3,R4,R5 MOV R4,-(SP) MOV R5,-(SP) MOV R0,-(SP) ; SAVE THE FP ADDRESS ; AS DESCRIBED IN F4P OTS SECTION 4.9 MOV .PSTPT,-(SP) ; PUSH ADDRESS OF INPUT FIELD MOV .PSTCN,-(SP) ; PUSH WIDTH OF INPUT FIELD CLR -(SP) ; PUSH DECIMAL PART WIDTH CLR -(SP) ; PUSH SCALE FACTOR (P FORMAT) JSR PC,RCI$ ; CALL RCI$ ; 4 WORD DOUBLE PRECISION VALUE ; IS RETURNED ON THE STACK SETD ; SET FPP IN DOUBLE PRECISION MODE LDD (SP)+,R0 ; GET THE DOUBLE PRECISION VALUE STCDF R0,@(SP)+ ; STORE IT AS SINGLE PRECISION MOV (SP)+,R5 ; RESTORE R5,R4,R3 MOV (SP)+,R4 MOV (SP)+,R3 RETURN ; ADD THE .TPARS SYNTAX FOR THE FPN .NLIST ME STATE$ FPN TRAN$ '+,..FP10 TRAN$ '-,..FP10 TRAN$ $LAMDA STATE$ ..FP10 TRAN$ !..FP16,..FP11 TRAN$ !..FP15 STATE$ ..FP11 TRAN$ !..FP12,$EXIT TRAN$ $LAMDA,$EXIT STATE$ ..FP12 TRAN$ 'D,..FP13 TRAN$ 'E STATE$ ..FP13 TRAN$ '+,..FP14 TRAN$ '-,..FP14 TRAN$ $LAMDA STATE$ ..FP14 TRAN$ $DNUMB,$EXIT STATE$ ..FP15 TRAN$ $DNUMB STATE$ TRAN$ !..FP16,$EXIT TRAN$ $LAMDA,$EXIT STATE$ ..FP16 TRAN$ '. STATE$ TRAN$ $DNUMB,$EXIT STATE$ .LIST ME .ENDM RVAL1 ; GET A FILE NAME ALONG WITH GIVEN DEFAULTS ; FFILE COUNT,MAX,FILE,DEV,UIC,NAME,EXT,VER ; WHERE - ; COUNT = WORD TO RECEIVE THE FILE STRING LENGTH ; MAX = THE MAX STRING LENGTH ; FILE = BYTE ARRAY TO STORE THE FILE NAME ; DEV = DEFAULT DEVICE (EG. SY:) ; UIC = DEFAULT UIC (EG. <[127,100]>) ; NAME = DEFAULT FILE NAME ; EXT = DEFAULT FILE EXTENTION (EG. .DAT) ; VER = DEFAULT FILE VERSION (EG. <;24>) .MACRO FFILE COUNT,MAX,FILE,DEV,UIC,NAME,EXT,VER .MCALL FFILE1,FFILE2,FFILE3 CLR COUNT ; CLEAR THE BYTE COUNT MOV #MAX,..FF41 ; SET THE MAX CHARACTERS MOV #COUNT,..FF42 ; GET ADDRESS OF STRING LENGTH MOV #FILE,R2 ; GET DESTINATION ADDRESS ..FS = 1 .REPT 5 FFILE3 \..FS ; GET THE 5 PARTS ..FS = ..FS+1 .ENDR MOV ..FF41,R0 ; GET THE REMAINING CHARS BLT 999$ ; OVERFLOW SO ERROR. BEQ 900$ ; DONE? 800$: CLRB (R2)+ ; NO, CLEAR THE REST SOB R0,800$ 900$: RETURN 999$: ADD #2,(SP) ; ERROR RETURN RETURN ..FS = 1 .IRP P,,NAME,EXT,> FFILE2

,\..FS ..FS = ..FS + 1 .ENDR ..FC = ..FC+1 ; INCREMENT NUMBER OF FFILE CALLS .IF EQ ..FC-1 ; IF THIS IS THE FIRST, FFILE1 ; SET UP THE FILE DATA STRUCTURES .ENDC .ENDM FFILE ; SUB MACRO TO FFILE ; THIS SETS UP THE STORAGE FOR THE INPUT ; FILE NAME AND THE APPROPRIATE ACTION ; ROUTINES ; FFILE1 .MACRO FFILE1 .EVEN ..FF1: .WORD 0 ; STORAGE FOR THE DEVICE .BLKB 5. .EVEN ..FF2: .WORD 0 ; STORAGE FOR THE UIC .BLKB 9. .EVEN ..FF3: .WORD 0 ; STORAGE FOR THE FILE NAME .BLKB 9. .EVEN ..FF4: .WORD 0 ; STORAGE FOR THE FILE EXTENTION .BLKB 4. .EVEN ..FF5: .WORD 0 ; STORAGE FOR THE FILE VERSION .BLKB 6. .MCALL FSTRG ; SET UP THE ACTION ROUTINES FOR THE FILE SYNTAX ..FF30: CLR ..FF1 ; INITIALIZE THE STRING LENGTHS CLR ..FF2 CLR ..FF3 CLR ..FF4 CLR ..FF5 RETURN ..FF21: FSTRG ..FF1,5.,..FF1+2 ; GET THE DEVICE ..FF22: FSTRG ..FF2,9.,..FF2+2 ; GET THE UIC ..FF23: FSTRG ..FF3,9.,..FF3+2 ; GET THE FILE NAME ..FF24: FSTRG ..FF4,4.,..FF4+2 ; GET THE FILE EXTENTION ..FF25: FSTRG ..FF5,6.,..FF5+2 ; GET THE FILE VERSION ; MOVE A FILE STRING SEGMENT ; CALLED BY: ; JSR ..FF40 ; WHERE- ; R0 = ADDRESS OF THE INPUT STRING ; R1 = ADDRESS OF THE DEFAULT STRING ; R2 = ADDRESS OF DESTINATION STRING ; ..FF41 = NUMBER OF REMAINING CHARACTERS ; ..FF42 = ADDRESS OF CHARACTER COUNTER ..FF40: MOV R1,-(SP) ; STORE THE DEFAULT TST (R0)+ ; POINT TO THE INPUT STRING MOV R0,R1 ; GET THE INPUT STRING ADDRESS MOV -(R0),R0 ; GET THE INPUT STRING LENGTH BNE 11$ ; IF THERE IS SOMETHING, PROCESS IT MOV (SP)+,R0 ; RESTORE THE DEFAULT TST (R0)+ ; POINT TO THE DEFAULT STRING MOV R0,R1 ; GET THE DEFAULT STRING ADDRESS MOV -(R0),R0 ; GET THE DEFAULT STRING LENGTH BEQ 14$ ; NOTHING HERE EITHER, THEN DONE BR 12$ ; SKIP 11$: TST (SP)+ ; GET RID OF DEFAULT 12$: DEC ..FF41 ; SUBTRACT ANOTHER CHAR FROM REMAINING BLT 13$ ; NONE LEFT, THEN DON'T TRANSFER MOVB (R1)+,(R2)+ ; MOVE THE BYTE INC @..FF42 ; INCREMENT THE STRING LENGTH 13$: SOB R0,12$ ; LOOP? 14$: RETURN ; DONE ..FF41: .WORD 0 ; STORAGE FOR THE REMAINING CHARACTERS ..FF42: .WORD 0 ; STORAGE FOR ADDRESS OF NUMBER OF CHARACTERS ; ADD THE .TPARS SYNTAX FOR A FILE .NLIST ME STATE$ CLRFIL TRAN$ $LAMDA,$EXIT,..FF30 STATE$ FILE TRAN$ !..FF17,..FF10,..FF21 TRAN$ $LAMDA STATE$ ..FF10 TRAN$ !..FF16,..FF11,..FF22 TRAN$ $LAMDA STATE$ ..FF11 TRAN$ !..FF15,..FF12 TRAN$ $STRNG,..FF12,..FF23 TRAN$ !..FF19 STATE$ ..FF12 TRAN$ !..FF13,$EXIT,..FF25 TRAN$ $LAMDA,$EXIT STATE$ ..FF13 TRAN$ <';> STATE$ TRAN$ $NUMBR,$EXIT TRAN$ !..FF14,$EXIT STATE$ ..FF14 TRAN$ '- STATE$ TRAN$ '1,$EXIT STATE$ ..FF15 TRAN$ $STRNG,,..FF23 STATE$ TRAN$ !..FF19,$EXIT STATE$ ..FF16 TRAN$ '[ STATE$ TRAN$ $NUMBR STATE$ TRAN$ <',> STATE$ TRAN$ $NUMBR STATE$ TRAN$ '],$EXIT STATE$ ..FF17 TRAN$ $ALPHA STATE$ TRAN$ $ALPHA STATE$ TRAN$ $NUMBR,..FF18 TRAN$ $LAMDA STATE$ ..FF18 TRAN$ ':,$EXIT STATE$ ..FF19 TRAN$ !..FF20,$EXIT,..FF24 STATE$ ..FF20 TRAN$ '. STATE$ TRAN$ $STRNG,$EXIT TRAN$ $LAMDA,$EXIT STATE$ .LIST ME .ENDM FFILE1 ; SUB MACRO TO FFILE ; THIS SETS UP THE DEFAULT FILE NAME STORAGE ; FFILE2 VALUE,NUMB ; WHERE - ; VALUE = THE DEFAULT STRING ; NUMB = THE LOCAL VARIABLE NUMBER ; FOR THE STRING .MACRO FFILE2 VALUE,NUMB .EVEN .NCHR TEST, NUMB'$: .WORD TEST .ASCII /VALUE/ .ENDM FFILE2 ; SUB MACRO TO FFILE ; MOVE EITHER THE PARSED OR DEFAULT FILE PART ; FFILE3 NUMB ; WHERE - ; NUMB = FILE PART NUMBER .MACRO FFILE3 NUMB MOV #..FF'NUMB,R0 ; GET INPUT STRING MOV #NUMB'$,R1 ; GET DEFAULT STRING JSR PC,..FF40 ; PROCESS THE SUB-STRING .ENDM FFILE3