HED SOFTWARE ROUTINES - NON EAU EQUIVALENT * MULTIPLY RNA BY RNM * STORE PRODUCT IN EB,EA * SET EO TO 0 INDICATING THAT OV IS EXPECTED TO BE CLEARED * RETURN P+1 * .MPY NOP LDA RNA CLE,SSA CMA,CME,INA A _ POSITIVE MULTIPICAND LDB RNM SSB CMB,CME,INB STB T1 T1 _ POSITIVE MULTIPLIER CCB ERB STB T2 T2 _ PRODUCT SIGN: -1 IF NEG. LDB M16 STB T3 COUNTER = -16 CLB STB EO EXPECT OV=0 .MPY1 CLE,SLA DO THE MULTIPLY ADB T1 16 ADDS & SHIFTS ERB ERA ISZ T3 JMP .MPY1 ISZ T2 TEST PRODUCT SIGN JMP .MPY2 IT'S POSITIVE CMB DOUBLE LENGTH COMPLIMENT CMA,INA,SZA,RSS INB .MPY2 STA EA SAVE EXPECTED PRODUCT STB EB JMP .MPY,I RETURN P+1 SPC 3 * DIVIDE RNB,RNA BY RMM * RETURN P+1 WITH EXPECTED RESULTS IN EB, EA, & EO * .DIV NOP LDB RNB B,A _ DIVIDEND LDA RNA SSB,RSS MAKE THE DIVIDEND POS. IF NEG. JMP *+4 CMB CMA,INA,SZA,RSS INB STB EB SAVE THE POSITIVE DIVIDEND STA EA TEMPORARILY LDB RNM DIVISOR SSB,RSS CMB,INB MAKE NEGATIVE IF POSITIVE STB MIND MIND _ NEGATIVE DIVISOR SZB,RSS JMP OVFLO OVERFLOW - DIVIDE BY 0 ADB EB SSB,RSS JMP OVFLO OVERFLOW IF ABS(B-DIVISOR) IS + LDB M16 STB COUNT COUNTER _ -16 LDB EB RESTORE LOOP ELA DO THE DIVIDE ELB,CLE STB EB ADB MIND SEZ,RSS LDB EB ISZ COUNT JMP LOOP ELA STA EA SAVE POS. QUOTIENT TEMPORARILY LDA RNB SSA MAKE REMAINDER NEGATIVE IF SIGN CMB,INB OF DIVIDEND WAS NEGATIVE STB EB SAVE THE EXPECTED REMAINDER LDB EA B _ POSITIVE QUOTIENT XOR RNM A(15) = SIGN OF QUOTIENT SSA,RSS TEST SIGN JMP .DIV1 +, GO CHECK SIGN OF QUOTIENT CMB,CLE,INB -, MAKE QUOTIENT NEG. STB EA SAVE NEGATIVE EXPECTED QUOTIENT SEZ,SSB,RSS CHECK SIGN & CARRY NOT BOTH 0 OVFLO CLA,INA,RSS NOV CLA STA EO SAVE EXPECTED OVERFLOW JMP .DIV,I RETURN P+1 .DIV1 SSB JMP OVFLO OVERFLOW IF SIGN NOT 0 JMP NOV * COUNT EQU T1 LOOP COUNT MIND EQU T2 NEGATIVE DIVISOR SPC 3 .ASR NOP CLA STA EO EXPECT OV REGISTER TO BE 0 JSB IISR INITIALIZE SOFTWARE ROUTINE .ASR1 CLE,SLB,BRS CCE DO ASR EQUIVALENT ERA USING STANDARD INSTRUCTIONS ISZ T1 JMP .ASR1 STA EA SAVE THE EXPECTED RESULTS STB EB JMP .ASR,I RETURN P+1 SPC 3 .ASL NOP JSB IISR INITIALIZE SOFTWARE ROUTINE .ASL1 CLE,ELA DO ASL EQUIVALENT ELB USING STANDARD INSTRUCTIONS RBL,ERB MAKE SURE SIGN DOESN'T CHANGE ISZ T1 JMP .ASL1 STA EA SAVE EXPECTED RESULTS STB EB JSB IISR INITIALIZE SOFTWARE ROUTINE .ASL2 CLE,ELA SIGNIFICANT BITS WERE ELB SHIFTED OUT SSB IF SO, MAKE EO=1 CME SEZ JMP ASLOV OVERFLOW: B(15) NOT SAME AS E ISZ T1 JMP .ASL2 CLA,RSS NO OVERFLOW: EO _ 0 ASLOV CLA,INA OVERFLOW: EO _ 1 STA EO JMP .ASL,I RETURN P+1 SPC 3 .LSR NOP JSB IISR INITIALIZE SOFTWARE ROUTINE .LSR1 CLE,ERB DO LSR EQUIVALENT ERA USING STANDARD INSTRUCTIONS ISZ T1 JMP .LSR1 STA EA SAVE THE EXPECTED RESULTS STB EB JMP .LSR,I RETURN P+1 SPC 3 .LSL NOP JSB IISR INITIALIZE SOFTWARE ROUTINE .LSL1 CLE,ELA DO LSL EQUIVALENT ELB USING STANDARD INSTRUCTIONS ISZ T1 JMP .LSL1 STA EA SAVE THE EXPECTED RESULTS STB EB JMP .LSL,I RETURN P+1 SPC 3 .RRR NOP JSB IISR INITIALIZE SOFTWARE ROUTINE .RRR1 CLE,ERB ERA DO RRR EQUIVALENT RBL,ERB USING STANDARD INSTRUCTIONS ISZ T1 JMP .RRR1 STA EA SAVE THE EXPECTED RESULTS STB EB JMP .RRR,I RETURN P+1 SPC 3 .RRL NOP JSB IISR INITIALIZE SOFTWARE ROUTINE .RRL1 CLE,ELA ELB DO RRL EQUIVALENT RAR,ELA USING STANDARD INSTRUCTIONS ISZ T1 JMP .RRL1 STA EA SAVE THE EXPECTED RESULTS STB EB JMP .RRL,I RETURN P+1 SPC 3 IISR NOP LDA SHFT CMA,INA,SZA,RSS MAKE SHFT NEGATIVE ADA M16 MAKE -16 IF 0 STA T1 SAVE COUNTER LDB RNB GET ARGUMENTS IN B & A LDA RNA JMP IISR,I RETURN P+1 HED SHIFT/ROTATE SUBROUTINES * SUBROUTINE TO INITIALIZE SHIFT COUNT FOR SHIFT ROTATE TESTS * IF SWITCH 6 IS UP: SHFT _ SHFT(3-0), S6 _ NON 0 * IF SWITCH 6 IS DOWN: GENERATE NEW ARGUMENTS, SHFT _ S6 _ 0 * RETURN P+1 * ISRT NOP JSB GSR AND BIT6 STA S6 REMEMBER STATE OF SWITCH 6 SZA JMP ISRT1 SWITCH 6 UP STA SHFT SWITCH 6 DOWN: SHFT _ 0 JSB RNG GENERATE NEW ARGUMENTS JMP ISRT,I ISRT1 LDA SHFT AND B17 STA SHFT SHFT _ SHFT(3-0) JMP ISRT,I SPC 3 * SHIFT/ROTATE MESSAGE PROCESSING * SRMP NOP JSB CEM CHECK FOR ERROR MESSAGE JMP SRMP,I NO MESG. WANTED - RETURN P+1 LDA .8 LDB BAWMA JSB MOVE PAK "B,A WAS " LDB RNB CONVERT AND PAK WHAT JSB CUTO6 B & A WAS LDB RNA JSB CUTO6 JSB PBA LIST ANY B & A REGISTER ERRORS JSB PEO LIST ANY E OR OV REG ERRORS JSB PBUF PRINT THE ERROR MESSAGE JMP SRMP,I RETURN P+1 SPC 3 * SUBROUTINE TO CHECK SHIFT COUNT * IF S6 IS NOT 0, RETURN P+2 * IF S6 IS 0, STEP THEN TEST SHFT * RETURN P+2 IF SHFT=16, ELSE RETURN P+1 * CSHFT NOP LDA S6 SZA JMP CSHF2 S6 NOT 0, RETURN P+2 ISZ SHFT SHFT _ SHFT + 1 LDA SHFT CPA .16 CSHF2 ISZ CSHFT SHFT = 16, RETURN P+2 JMP CSHFT,I ELSE RETURN P+1 HED DIAGNOSTIC INITIALIZATION SPC 3 ORG 2000B START CLC 0,C TURN EVERYTHING OFF LDA SRN1 GET CONSTANT FOR RDM NO GEN STA RN1 STORE LDA SRN2 GET CONSTANT FOR RDM NO GEN STA RN2 STORE LDA HLT1 SET TRAP CELL HALTS CLB,INB PUT 1060XX INTO ADDRESS XX ST1 INA XX = 02,03,04,...77 INB STA B,I CPA HLT77 RSS JMP ST1 LDA A2S RESET END OF PASS COUNT STA MG77A STORE 8 ASCII SPACES IN THE 4 STA MG77A+1 WORD STARTING AT LOC. MG77A STA MG77A+2 STA MG77B JSB CNEM CHECK FOR NON-ERROR MESSAGE JMP SOP NO MESSAGE LDA .28 LDB MIA JSB LIST,I PRINT INTRODUCTORY MESSAGE HED TEST 1 DLD SOP CLA STA LCNT NEW PASS - RESET LOOP COUNT AGAIN CLA STA FLG6 NEW LOOP - CLEAR SW. 6 FLAG * CLA,INA STA TST# TEST 1 DLDL JSB RNG CHECK AND PERHAPS GET NEW ARG. LDA RNA GET AND SAVE EXPECTED A & B STA EA LDA RNB STA EB LDA RNAA ADDRESS OF RNA STA DAD SAVE THE DIRECT ADDRESS CLA START WITH 0 STA IL# INDIRECT ADDRESSING LEVELS DLDC ADA APT FORM THE IN-LINE ADDRESS LDA A,I STA DLDA PUT IT IN-LINE DLDR JSB IREGO INITIALIZE THE REGISTERS CLA CLB * NOP ** FOR PATCHING ** DEF DLD,I DO THE DLD MACRO CALL DLDA NOP (ADDRESS) NOP ** FOR PATCHING ** * JSB CHECK SAVE THE REGISTERS & CHECK THEM SZA,RSS A=0 INDICATES NO ERRORS JMP DLD1 NO ERRORS * JSB CEM CHECK FOR ERROR MESSAGE JMP DLD2 NO MESSAGE WANTED JSB PIL# PAK # INDIRECT LEVELS JSB PBA LIST ANY B OR A REG ERRORS JSB PEO LIST ANY E OR OV REG ERRORS JSB PBUF PRINT THE ERROR MESSAGE * DLD2 JSB CEHLT CHECK FOR ERROR HALT HLT 1 ERROR HALT - REGISTERS RESTORED JSB CS9 JMP DLDE SWITCH 9 UP - ERROR BREAKOUT * DLD1 JSB CIA CHECK INDIRECT ADDRESSING JMP DLDC DO FOR NEXT LEVEL DLDE JSB EOT HLT 76B END OF TEST HALT: A_B_1 JSB CS8 JMP DLDL SW. 13 UP - LOOP ON TEST HED TEST 2 DST TST2 LDA .2 STA TST# TEST 2 DSTL JSB RNG CHECK & PERHAPS GET NEW ARG. LDA DSA ADDRESS OF DSA STA DAD SAVE THE DIRECT ADDRESS CLA START WITH 0 STA IL# INDIRECT ADDRESSING LEVELS DSTC ADA APT FORM THE IN-LINE ADDRESS LDA A,I STA DSTA PUT IT IN-LINE CLA STA SA CLEAR STORE LOCATIONS TO STA SB REMOVE ANY RESIDUAL DATA DSTR JSB IREGO INITIALIZE THE REGISTERS STA EA STB EB SAVE ARG'S FOR CHECKING * NOP ** FOR PATCHING ** DEF DST,I DST SA MACRO CALL DSTA NOP (ADDRESS) NOP ** FOR PATCHING ** * LDA SA LOAD WHAT WAS ACTUALLY LDB SB STORED FOR CHECKING JSB CHECK GO CHECK RESULTS SZA,RSS A=0 INDICATES NO ERRORS JMP DST1 NO ERRORS * JSB CEM CHECK FOR ERROR MESSAGE JMP DST2 NO MESSAGE WANTED JSB PIL# PAK # INDIRECT LEVELS LDA REI AND .3 SZA,RSS JMP DST3 ERROR NOT STORED CONTENTS LDA .11 LDB STRMA JSB MOVE PAK "STORED WAS " LDB AB JSB CUTO6 CONVERT AND PACK CONTENTS FOUND LDB AA IN THE STORE LOCATIONS JSB CUTO6 JSB PSB PAK "SB " LDB RNB JSB CUTO6 CONVERT AND PACK WHAT SHOULD LDB RNA HAVE BEEN STORED (CONTENTS OF JSB CUTO6 A & B WHEN DST CALL WAS MADE) DST3 JSB PEO LIST E AND OV REG ERRORS IF ANY JSB PBUF PRINT THE ERROR MESSAGE * DST2 JSB CEHLT CHECK FOR ERROR HALT HLT 2 ERROR HLT: A,B _(STORE LOC.) JSB CS9 JMP DSTE SWITCH 9 UP - ERROR BREAKOUT * DST1 JSB CIA CHECK INDIRECT ADDRESSING JMP DSTC DO FOR NEXT LEVEL DSTE JSB EOT HLT 76B END OF TEST HALT: A_B_2 JSB CS8 JMP DSTL SW. 13 UP - LOOP ON TEST HED TEST 3 MPY TST3 LDA .3 STA TST# TEST 3 MPYL JSB RNG CHECK AND PERHAPS GET NEW ARG. JSB .MPY SOFTWARE ROUTINE - EXPECTED A,B,OV LDA RNMA ADDRESS OF RNM STA DAD SAVE THE DIRECT ADDRESS CLA START WITH 0 STA IL# INDIRECT ADDRESSING LEVELS MPYC ADA APT FORM THE IN-LINE ADDRESS LDA A,I STA MPYA PUT IT IN-LINE MPYR JSB IREG INITIALZE THE REG'S * NOP ** FOR PATCHING ** DEF MPY,I DO THE MPY MACRO CALL MPYA NOP (ADDRESS) NOP ** FOR PATCHING ** * JSB CHECK SAVE THE REGISTERS & CHECK THEM SZA,RSS A=0 INDICATES NO ERRORS JMP MPY1 NO ERROR * JSB CEM CHECK FOR ERROR MESSAGE JMP MPY2 NO MESSAGE WANTED JSB PIL# PAK # INDIRECT LEVELS LDA .8 LDB AMWMA JSB MOVE PAK "A,M WAS " LDB RNA JSB CUTO6 CONVERT & PAK RNA & SPACE LDB RNM JSB CUTO6 CONVERT & PAK RNM & SPACE JSB PBA LIST ANY B & A REG ERRORS JSB PEO LIST ANY E AND OV REG ERRORS JSB PBUF PRINT THE ERROR MESSAGE * MPY2 JSB CEHLT CHECK FOR ERROR HALT HLT 3 ERROR HALT: REGISTERS RESTORED JSB CS9 JMP MPYE SWITCH 9 UP - ERROR BREAKOUT * MPY1 JSB CIA CHECK INDIRECT ADDRESSING JMP MPYC DO FOR NEXT LEVEL MPYE JSB EOT HLT 76B END OF TEST HALT: A_B_3 JSB CS8 JMP MPYL SW. 13 UP - LOOP ON TEST * HED TEST 4 DIV TST4 LDA .4 STA TST# TEST 4 DIVL JSB RNG CHECK AND PERHAPS GET NEW ARG. JSB .DIV SOFTWARE ROUTINE - GET EXPECTED LDA RNMA ADDRESS OF RNM STA DAD SAVE THE DIRECT ADDRESS CLA START WITH 0 STA IL# INDIRECT ADDRESSING LEVELS DIVC ADA APT FORM THE IN LINE ADDRESS LDA A,I STA DIVA PUT IT IN LINE DIVR JSB IREG INITIALIZE THE REG'S * NOP ** FOR PATCHING ** DEF DIV,I DO THE DIV MACRO CALL DIVA NOP (ADDRESS) NOP ** FOR PATCHING ** * JSB CHECK SAVE THE REGISTERS & CHECK SZA,RSS A=0 INDICATES NO ERRORS JMP DIV1 NO ERROR * JSB CEM CHECK FOR ERROR MESSAGE JMP DIV2 NO MESSAGE WANTED JSB PIL# PAK # INDIRECT LEVELS LDA .10 LDB BAMA JSB MOVE PAK "B,A,M WAS " LDB RNB JSB CUTO6 CNVT & PAK RNB & SPACE LDB RNA JSB CUTO6 CNVT & PAK RNA & SPACE LDB RNM JSB CUTO6 CNVT & PAK RNM & SPACE JSB PBA LIST ANY B & A ERRORS JSB PEO LIST ANY E OR OV REG ERRORS JSB PBUF PRINT THE ERROR MESSAGE * DIV2 JSB CEHLT CHECK FOR ERROR HALT HLT 4 ERROR HALT: REGISTERS RESTORED JSB CS9 JMP DIVE SWITCH 9 UP - ERROR BREAKOUT * DIV1 JSB CIA CHECK INDIRECT ADDRESSING JMP DIVC DO FOR NEXT LEVEL DIVE JSB EOT HLT 76B END OF TEST HALT: A_B_4 JSB CS8 JMP DIVL SW. 13 UP - LOOP ON TEST HED TEST 5 ASR TST5 LDA .5 STA TST# TEST 5 ASRL JSB ISRT INITIALIZE SHIFT/ROTATE TEST ASRC JSB .ASR SOFTWARE ROUTINE - GET EXPECTED LDA SHFT FORM THE INSTRUCTION IOR ASR0 STA ASRI PUT IT IN LINE ASRR JSB IREG INITIALIZE THE REGISTERS * NOP ** FOR PATCHING ** ASRI DEF ASR,I ASR (XX) INSTRUCTION NOP ** FOR PATCHING ** * JSB CHECK SAVE THE REGISTERS & CHECK THEM SZA,RSS A=0 INDICATES NO ERRORS JMP ASR1 NO ERRORS JSB SRMP SHIFT/ROTATE MESSAGE PROCESSING JSB CEHLT CHECK FOR ERROR HALT HLT 5 ERROR HALT: REGISTERS RESTORED JSB CS9 JMP ASRE SWITCH 9 UP - ERROR BREAKOUT * ASR1 JSB CSHFT CHECK THE SHIFT COUNT JMP ASRC DO FOR THE NEXT VALUE ASRE JSB EOT HLT 76B END OF TEST HALT: A_B_5 JSB CS8 JMP ASRL SW. 13 UP - LOOP ON TEST HED TEST 6 ASL TST6 LDA .6 STA TST# TEST 6 ASLL JSB ISRT INITIALIZE SHIFT ROTATE TEST ASLC JSB .ASL SOFTWARE ROUTINE - GET EXPECTED LDA SHFT FORM THE INSTRUCTION IOR ASL0 STA ASLI STORE IN LINE ASLR JSB IREG INITIALIZE THE REG'S * NOP ** FOR PATCHING ** ASLI DEF ASL,I ASL (XX) INSTRUCTION NOP ** FOR PATCHING ** * JSB CHECK SAVE THE REGISTERS & CHECK THEM SZA,RSS A=0 INDICATES NO ERRORS JMP ASL1 NO ERRORS * JSB SRMP SHIFT/ROTATE MESSAGE PROCESSING JSB CEHLT CHECK FOR ERROR HALT HLT 6 ERROR HALT: REGISTERS RESTORED JSB CS9 JMP ASLE SWITCH 9 UP - ERROR BREAKOUT * ASL1 JSB CSHFT CHECK THE SHIFT COUNT JMP ASLC DO FOR NEXT VALUE ASLE JSB EOT HLT 76B END OF TEST HALT: A_B_6 JSB CS8 JMP ASLL SW. 13 UP - LOOP ON TEST HED TEST 7 - LSR TST7 LDA .7 STA TST# TEST 7 LSRL JSB ISRT INITIALIZE SHIFT/ROTATE TEST LSRC JSB .LSR SOFTWARE ROUTINE - GET EXPECTED LDA SHFT FORM THE INSTRUCTION IOR LSR0 STA LSRI PUT IT IN LINE LSRR JSB IREGO INITIALIZE THE REGISTERS * NOP ** FOR PATCHING ** LSRI DEF LSR,I LSR (XX) INSTRUCTION NOP ** FOR PATCHING ** * JSB CHECK SAVE THE REGISTERS & CHECK THEM SZA,RSS A=0 INDICATES NO ERROR JMP LSR1 NO ERRORS * JSB SRMP SHIFT/ROTATE MESSAGE PROCESSING JSB CEHLT CHECK FOR ERROR HALT HLT 7 ERROR HALT - REG'S RESTORED JSB CS9 JMP LSRE SWITCH 9 UP - ERROR BREAKOUT * LSR1 JSB CSHFT CHECK THE SHIFT COUNT JMP LSRC DO FOR NEXT VALUE LSRE JSB EOT HLT 76B END OF TEST HALT: A_B_7 JSB CS8 JMP LSRL SW. 13 UP - LOOP ON TEST HED TEST 10 - LSL TST10 LDA B10 STA TST# TEST 10 LSLL JSB ISRT INITIALIZE SHIFT/ROTATE TEST LSLC JSB .LSL SOFTWARE ROUTINE - GET EXPECTED LDA SHFT FORM THE INSTRUCTION IOR LSL0 STA LSLI PUT IT IN LINE LSLR JSB IREGO INITIALIZE THE REGISTERS * NOP ** FOR PATCHING ** LSLI DEF LSL,I LSL (XX) INSTRUCTION NOP ** FOR PATCHING ** * JSB CHECK SAVE THE REGISTERS & CHECK THEM SZA,RSS A=0 INDICATES NO ERRORS JMP LSL1 NO ERRORS * JSB SRMP SHIFT/ROTATE MESSAGE PROCESSING JSB CEHLT CHECK FOR ERROR HALT HLT 10B ERROR HALT - REG'S RESTORED JSB CS9 JMP LSLE SWITCH 9 UP - ERROR BREAKOUT * LSL1 JSB CSHFT CHECK THE SHIFT COUNT JMP LSLC DO FOR NEXT VALUE LSLE JSB EOT HLT 76B END OF TEST HALT: A_B_10 JSB CS8 JMP LSLL SW. 13 UP - LOOP ON TEST HED TEST 11 - RRR TST11 LDA B11 STA TST# TEST 11 RRRL JSB ISRT INITIALIZE SHIFT/ROTATE TEST RRRC JSB .RRR SOFTWARE ROUTINE - BET EXPECTED LDA SHFT FORM THE INSTRUCTION IOR RRR0 STA RRRI PUT IT IN LINE RRRR JSB IREGO INITIALIZE THE REGISTERS * NOP ** FOR PATCHING ** RRRI DEF RRR,I RRR (XX) INSTRUCTION NOP ** FOR PATCHING ** * JSB CHECK SAVE THE REGISTERS & CHECK THEM SZA,RSS A=0 INDICATES NO ERROR JMP RRR1 NO ERRORS * JSB SRMP SHIFT/ROTATE MESSAGE PROCESSING JSB CEHLT CHECK FOR ERROR HALT HLT 11B ERROR HALT - REG'S RESTORED JSB CS9 JMP RRRE SWITCH 9 UP - ERROR BREAKOUT * RRR1 JSB CSHFT CHECK THE SHIFT COUNT JMP RRRC DO FOR NEXT VALUE RRRE JSB EOT HLT 76B END OF TEST HALT: A_B_11 JSB CS8 JMP RRRL SW. 13 UP - LOOP ON TEST HED TEST 12 - RRL TST12 LDA B12 STA TST# TEST 12 RRLL JSB ISRT INITIALIZE SHIFT/ROTATE TEST RRLC JSB .RRL SOFTWARE ROUTINE - GET EXPECTED LDA SHFT FORM THE INSTRUCTION IOR RRL0 STA RRLI PUT IT IN LINE RRLR JSB IREGO INITIALIZE THE REGISTERS * NOP ** FOR PATCHING ** RRLI DEF RRL,I RRL (XX) INSTRUCTION NOP ** FOR PATCHING ** * JSB CHECK SAVE THE REGISTERS & CHECK THEM SZA,RSS A=0 INDICATES AN ERROR JMP RRL1 NO ERRORS * JSB SRMP SHIFT/ROTATE MESSAGE PROCESSING JSB CEHLT CHECK FOR ERROR HALT HLT 12B ERROR HALT - REG'S RESTORED JSB CS9 JMP RRLE SWITCH 9 UP - ERROR BREAKOUT * RRL1 JSB CSHFT CHECK THE SHIFT COUNT JMP RRLC DO FOR NEXT VALUE RRLE JSB EOT HLT 76B END OF TEST HALT: A_B_12 JSB CS8 JMP RRLL SW. 13 UP - LOOP ON TEST HED END OF LOOP - END OF PASS JSB RNG ISZ LCNT WAS ALWAYS DOWN - STEP COUNT LDA LCNT CPA .1500 JMP EOP END OF PASS IF 1500 LOOPS JMP AGAIN NOT END OF PASS - DO NEXT LOOP * * UPDATE END OF PASS COUNT * EOP LDB MA77B ADDR OF LEAST SIGNF CHARS IN MSG NEXT2 LDA B,I NEXT 2 ASCII CHARACTERS INA STEP LEAST SIGNIFICANT DIGIT IOR B20 MAKE SURE BASE IS 0, NOT SPACE STA B,I PUT BACK IN MSG. TEMPORARILY AND B77 MASK OFF LOWER CHARACTER CPA B72 IS IT 10 ? RSS YES JMP DONE NO - FINISHED LDA B,I RESTORE 2 CHARS FROM MESSAGE ADA B366 STEP UPPER CHARACTER,MAKE LOWER 0 IOR BIT12 MAKE SURE UPPER BASE IS 0 STA B,I PUT BACK IN MESSAGE TEMPORARILY AND D7400 MASK OFF UPPER CHARACTER CPA D5000 IS IT 10? RSS YES JMP DONE NO - FINISHED LDA A00 STA B,I REPLACE WITH 2 ASCII 0'S ADB M1 GET ADDR. OF NEXT CHAR. PAIR JMP NEXT2 STEP AND TEST NEXT CHARACTERS * DONE JSB CNEM CHECK FOR NON-ERROR MESSAGE JMP EOP1 NO MESSAGE WANTED LDA .20 PRINT END OF PASS MESSAGE LDB MA77 JSB LIST,I EOP1 JMP EXEC,I CALL DIAGNOSTIC MONITOR EXRTN JSB GSR CHECK SWITCH 12 ALF,SLA RSS HLT 77B HALT 77 IF UP JMP SOP DO NEXT PASS * END EQU * END