.MCALL .MODULE .MODULE LINK,VERSION=45,COMMENT= IDENT=NO,MODNAME=LINK5,GLOBAL=.LINK5 ; Copyright (c) 1998 by Mentec, Inc., Nashua, NH. ; All rights reserved ; ; This software is furnished under a license for use only on a ; single computer system and may be copied only with the ; inclusion of the above copyright notice. This software, or ; any other copies thereof, may not be provided or otherwise ; made available to any other person except for use on such ; system and to one who agrees to these license terms. Title ; to and ownership of the software shall at all times remain ; in Mentec, Inc. ; ; The information in this document is subject to change without ; notice and should not be construed as a commitment by Digital ; Equipment Corporation, or Mentec, Inc. ; ; Digital and Mentec assume no responsibility for the use or ; reliability of its software on equipment which is not supplied ; by Digital or Mentec, and listed in the Software Product ; Description. .SBTTL MAP PASS .ENABL GBL ; CER,MAS,SHD,DBB .IIF NDF EIS$ EIS$= 0 ;SAY EIS NOT AVAILABLE .IIF NDF RST$ RST$= 0 ;TURN OFF RSTS/E SAV PARAMETER FUNCTION ;MAS17 ; EDIT HISTORY ; FIX /K BUG FOR RSTS ;CER01 ; HANDLE ABS PSECT AS ZERO LENGTH & DON'T STORE TEXT ;CER02 ; FIX CORE WRAP ON 177777 BASE ADDR ;MAS05 ; PUT OVERLAY HANDLER IN SYSLIB ;MAS07 ; FIX ILLEGAL MEMORY REFERENCE ON TST (R)+ ;MAS09 ; FIX /X BITMAP PROBLEM ;MAS11 ; XM OVERLAYS (ADDED FUNCTION) ;MAS15 ; ADD RSTS/E SAV PARAMATERS FUNCTION ;MAS17 ; FIX .LIMIT FOR /V SETTOPS ;MAS30 ; ADD /XM, /V ON FIRST LINE ;MAS35 ; BLANK PSECTS OF 0 LENGTH WITH SYMBOLS NOW PRINTED ;SHD01 ; CHANGE SYMBOL STATUS WORD FORMAT ;DBB01 ; ADD SUPPORT FOR GLOBAL SYMBOL CREF ;DBB02 ; STANDARDIZE PROGRAMMED REQUESTS ;DBB03 ; PUT DECIMAL WORD SIZES FOR PSECTS IN MAP ;DBB04 ; ALLOW PSECT SAV ATTRIBUTE TO BE PRINTED IN MAP ;DBB05 ; ADD I-D SPACE CODE ;LB ; ; 045 10-OCT-1996 Modify LINK5 for 4-digit years ; Tim Shoppa .SBTTL MISCELLANEOUS MACRO DEFINITIONS TAB= 11 LF= 12 FF= 14 CR= 15 SPACE= 40 BASEYR= 72. CONFIG= 300 CLK50= 40 GSD= 1 ;OBJECT MODULE CODES ENDGSD= 2 MODEND= 6 BYTBLK= 512. ;BYTE BLOCK SIZE .MCALL .PRINT .WRITW .DATE .GTIM .GVAL ;DBB03 .MACRO ERROR$ ERNB,SEV,ETYP,R .IF NB R .IIF DIF , MOV R,R0 .IFF .IIF IDN , CLR R0 .ENDC JSR R5,ERROOT .BYTE ERNB, SEV*100!ETYP .ENDM .MACRO MAPOUT MSG .IF NB MSG .IIF DIF , MOV MSG,R1 .ENDC CALL PUTMSG .ENDM .IF Z EIS$ .MACRO SOB R,L DEC R BNE L .ENDM .ENDC .MACRO SYMADR R ASL R MOV R,-(SP) ASL R ASL R ADD (SP)+,R ADD SYEN0,R .ENDM ;+ ; BUFFER USAGE IS: ; TXTBLK FOR BUILDING STB OBJECT RECORD ; OBUF TEMPORARY MESSAGE BUFFER AREA ; IBUF 512. BYTES FOR MAP ; EIB512 FOR STB OUTPUT IF REQUIRED ; USE IBUF IF /S & STB REQUIRED(MAP NOT ALLOWED THEN) ;- .PSECT DATA,D .WORD 10 ;ERROR HANDLER INDEX(1ST PHYSICAL LOC OF OVLY) .SBTTL - POST PASS TABLES AND MESSAGES .NLIST BEX .ENABL LC LINE1: .ASCII "RT-11 " .NLCSI TYPE=I,PART=NAME .ASCII " " .NLCSI TYPE=I,PART=RLSVER .ASCII "Load Map " DATIME: .BLKB 28. ;Must be big enough to hold a string like: ;045 ;Wednesday 27-Oct-2002 23:11 ;045 ;1234567890123456789012345678 ;045 ;With an extra byte for null terminator ;045 PAGE: .ASCIZ " Page " CRLF: .ASCIZ ; NEXT 4 IN THIS ORDER LINE2: .ASCII " ""Title:" ;13 SPACES TTL: .ASCII " ""Ident:" ;6 SPACES IDNT: .ASCII " ""/" BHSW: .ASCII "B:" BHVAL: .ASCIZ " " CRLFLF: .ASCIZ LINE4: .ASCIZ "Section Addr""Size" MTITL4: .ASCIZ "Global""Value" MONTHS: .ASCII /-Jan-Feb-Mar-Apr-May-Jun-Jul-Aug-Sep-Oct-Nov-Dec-/ SAT: .ASCIZ /Satur/ SUN: .ASCIZ /Sun/ MON: .ASCIZ /Mon/ TUE: .ASCIZ /Tues/ WED: .ASCIZ /Wednes/ THU: .ASCIZ /Thurs/ FRI: .ASCIZ /Fri/ DAY: .ASCIZ /day / .EVEN PAGNUM: .BLKW .WORD SAT .WORD SUN .WORD MON .WORD TUE .WORD WED .WORD THU .WORD FRI DAYTAB=. MONLEN: .WORD 0-1 ;JANUARY .WORD 31.-1 ;FEBRUARY .WORD 59.-1 ;MARCH .WORD 90.-1 ;APRIL .WORD 120.-1 ;MAY .WORD 151.-1 ;JUNE .WORD 181.-1 ;JULY .WORD 212.-1 ;AUGUST .WORD 243.-1 ;SEPTEMBER .WORD 273.-1 ;OCTOBER .WORD 304.-1 ;NOVEMBER .WORD 334.-1 ;DECEMBER TIME: .BLKW 2 ;HIGH ORDER THEN LOW ORDER ; NEXT 5 MUST BE IN ORDER ;MAS15+ DECEND: .BYTE '. VORMSG: .ASCII "Virtual overlay region" ;ODMSG: USED FOR VALUE ; FOLLOWING MUST START ON AN EVEN ADDRESS AND BE CONTIGUOUS TO END OF VORMSG ODMSG: .ASCII "OOOOO" ;HIGH WD OF 2 WORD OCTAL NUMBER (NOT PRINTED) ODNB: .ASCII "OOOOOO" ;MESSAGE FOR ONE WORD OCTAL NUMBER ODNB1: .ASCII " = " ODNB2: .ASCII "NNNNNN words" COMMA: .ASCII ;MAS30+ .BYTE 0 .ASCIZ "ext free address = " ;MAS30- UGM: .ASCIZ "Undefined globals:" OVSMSG: .ASCIZ "Overlay region" ; NEXT 2 IN THIS ORDER OVRGNB: .ASCII "OOOOOO""Segment " OVSGNB: .ASCIZ "OOOOOO" CLTTT: .BYTE CR,LF,TAB,TAB,TAB,0 SEGSIZ: .ASCIZ " Segment size = " DSPCSZ: .ASCIZ " (D-space)" ISPCSZ: .ASCIZ " (I-space)" ; NEXT 2 MUST BE IN ORDER TAM: .ASCII "Transfer address = " TANB: .ASCIZ "OOOOOO, High limit = " VHIGH: .ASCIZ "Virtual high limit = " VPHYS: .ASCIZ "Extended memory required = " ; NEXT THREE IN THIS ORDER PSMSG: .ASCIZ "Partition" .EVEN SPMSG: .ASCII "----------------------------------------------" SPMSG1: .ASCII "------------------------------------------------" SPMSG2: .ASCIZ "----------------------" .EVEN ; ; I-D SPACE VARIABLES ; TEMPD: .WORD 0 ;HOLDER FOR SIZE OF D-SPACE SEGMENT SPFLAG: .WORD 0 ;0 -> I-SPACE, NONZERO -> D-SPACE DVRSIZ: .WORD 0 ;LARGEST D-SPACE REGION IN A PARTITION .EVEN .PSECT CODE .SBTTL MAPHDR DETERMINE DATE & TIME ;+ ;045 ; DATE FORMAT AS RETURNED IN R0 ;045 ; 15 14 13 10 9 5 4 0 ;045 ; +-------------------------------------+ ;045 ; ! AGE ! MONTH ! DAY ! YEAR-72. ! ;045 ; ! 0-3.! 1-12. ! 1-31. ! ! ;045 ; +-------------------------------------+ ;045 ; ; ; R4 IS THE ASECT SIZE FROM LINK4. IT IS I-SPACE, BUT ; FOR /J, IT IS D-SPACE. ;- MAPHDR::MOV R3,-(SP) ;SAVE R3 AND R4 MOV R4,-(SP) MOV LINPPG,LINLFT ;INITIALIZE LINES LEFT COUNTER .GTIM #PRAREA,#TIME ;GET TIME IN TIME AND TIME+2 ;DBB02 .DATE ;GET DATE IN R0 MOV #DATIME,R1 ;R1 -> OUTPUT AREA MOV R0,R5 ;COPY IT MOV R0,R2 ;AND AGAIN BEQ 70$ ;WHOOPS! NO DATE! ASL R5 ;ISOLATE DAY IN R5 ASL R5 ASL R5 SWAB R5 BIC #^C<37>,R5 ;R5 = DAY ASR R2 ;ISOLATE MONTH IN R2 SWAB R2 MOV R2,R3 ;MAKE AN EXTRA COPY ;045 BIC #^C<17*2>,R2 ;R2 = ;045 BIC #^C<140>,R3 ;ISOLATE AGE*32. IN R3 ;045 BIC #^C<37>,R0 ;AND YEAR IN R0 ADD R3,R0 ;NOW AGE*32.+YEAR IN R0 ;045 SUB #2,R2 ;GET R2= -2 MOV R0,-(SP) ;STACK YEAR FOR DATE PRINTING ADD #BASEYR,@SP MOV R2,-(SP) ;LIKEWISE FOR MONTH MOV R5,-(SP) ;AND DAY ; AT THIS POINT, R0=YEAR - 1972, R5=DAY, R2=-2 ; WE NOW COMPUTE THE DAY-OF-THE-WEEK. MOV R0,-(SP) ;SAVE YEAR DEC R0 ;MAKE LEAP YEAR CORRECTION ASR R0 ASR R0 ADD @SP,R0 INC R0 ADD R0,R5 ;ACCUMULATE DAY BIT #3,(SP)+ ;LEAP YEAR? BNE 10$ ;NOPE - SKIP CORRECTION CMP #2*1,R2 ;AFTER FEBRUARY? ADC R5 ;CORRECT IF SO 10$: ADD MONLEN(R2),R5 ;ADD IN DAYS FROM PREVIOUS MONTHS 20$: SUB #7,R5 ;CHEAPO MODULO 7 BPL 20$ ASL R5 ;MAKE INTO A WORD OFFSET ADD #DAYTAB,R5 ;POINTS INTO TABLE OF PTRS MOV @R5,R5 ;GET PTR TO NAME OF DAY 30$: MOVB (R5)+,(R1)+ ;COPY NAME OF DAY BNE 30$ ;STRING IS TERMINATED BY 0 DEC R1 ;ERASE NULL MOV #DAY,R5 ;POINT TO "DAY " STRING 40$: MOVB (R5)+,(R1)+ ;COPY "DAY " BNE 40$ ;STRING IS TERMINATED BY 0 DEC R1 ;ERASE NULL MOV (SP)+,R0 ;CONVERT DAY CALL CVT2 MOV (SP)+,R0 ;GET -2 ASL R0 ; -4 ADD #MONTHS,R0 MOVB (R0)+,(R1)+ ;MOVE MONTH INTO OUTPUT AREA MOVB (R0)+,(R1)+ MOVB (R0)+,(R1)+ MOVB (R0)+,(R1)+ MOVB (R0)+,(R1)+ MOV (SP)+,R2 ;GET YEAR MOV #19.,R0 ;ASSUME 19XX ;045 CMP R2,#100. ;UNLESS YEAR .GE. 100 ;045 BLO 44$ ;ONLY IF YEAR WAS .GE. 100 ;045 INC R0 ;THEN IT IS 20XX ;045 SUB #100.,R2 ;AND HAVE TO SUBTRACT 100 FROM YEAR ;045 44$: CALL CVT2 ;CONVERT FIRST TWO DIGS TO ASCII ;045 MOV R2,R0 ;AND THEN THE SECOND TWO DIGS ;045 CALL CVT2 ;TO ASCII ;045 MOVB #SPACE,(R1)+ ;LEAVE A BLANK AFTER DATE MOV TIME,R4 ;(R4,R5) = TIME OF DAY MOV TIME+2,R5 ; IN TICKS PAST MIDNIGHT .GVAL #PRAREA,#CONFIG ;GET CONFIG FOR SYSTEM CLOCK INFORMATION TST R0 ;KW11L CLOCK PRESENT? BPL 70$ ;NOPE - NO TIME TO OUTPUT BIT #CLK50,R0 ;50 OR 60 CYCLE? BNE 50$ ;IF NE 50 CYCLES CALL DIV60 ;60 CYCLES. DISCARD TICKS BR 60$ 50$: CALL DIV50 ;50 CYCLES. DISCARD TICKS 60$: CALL DIV60 ;DISCARD SECONDS CALL DIV60 ;R0 = MINUTES MOV R0,-(SP) CALL DIV60 ;R0 = HOURS CALL CVT2 ;CONVERT HOURS TO ASCII MOVB #':,(R1)+ ;PLUS SEPARATOR MOV (SP)+,R0 ;GET MINUTES CALL CVT2 ;AND CONVERT TO ASCII 70$: CLRB @R1 ;PUT IN NULL STRING TERMINATOR .SBTTL OUTPUT THE HEADERS MOV #LINE2,R1 ;R1 -> ASCII AREA FOR 2ND LINE TST ODBLK ;OUTPUT FILE SPECIFIED? BEQ 80$ ;NO MOV #ODBLK+8.,R3 ;GET BINOUT ADDRESS CALL R50ASC ;UNPACK FILE NAME MOVB #'.,(R1)+ ;IND EXTENSION DIVIDER CMP (R3)+,(R3)+ ;ADVANCE TO PRINT EXTENSION CALL R50ASC ;UNPACK THE EXTENSION CMPB -(R1),-(R1) ;ONLY 3 CHAR EXTENSION MOVB #SPACE,-(R1) MOVB (R1)+,@R1 MOVB (R1)+,@R1 80$: MOV #MODNAM+6,R3 ;POINT TO MODULE NAME MOV #TTL,R1 ;R1 -> AREA FOR PROGRAM TITLE CALL R50ASC ;AND PRINT IT MOV #IDENT+6,R3 ;R3 -> IDENTIFICATION TST IDENT ;IS THERE ANY? BEQ 90$ ;NO MOV #IDNT,R1 ;R1 -> IDENT AREA CALL R50ASC ;AND PRINT IT 90$: BIT #SW.B!SW.H,SWITCH ;WAS /B OR /H GIVEN ? BNE 100$ ;YES, OUT SWITCH & VALUE CLRB IDNT+7 ;TERMINATE STRING AFTER IDENT NAME BR 130$ 100$: BIT #SW.B,SWITCH ;/B VALUE GIVEN? BEQ 110$ ;NO MOV BOTTOM,R0 ;VALUE TO CONVERT BR 120$ 110$: BIT #SW.H,SWITCH ;/H GIVEN ? BEQ 130$ ;NO MOV HSWVAL,R0 MOVB #'H,BHSW ;REPLACE B WITH H 120$: MOV #BHVAL,R1 ;PLACE TO STORE ASCII VALUE CALL OCTOUT ;CONVERT VALUE IN R0 CLRB @R1 ;CHANGE TAB TO TERMINATOR 130$: CLR PAGNUM ;INIT PAGE NUMBER CALL HEADER MAPOUT #LINE4 MOVB NUMCOL,R4 ;GET #COLUMNS 140$: MAPOUT #MTITL4 ;PRINT ENTRY HDR DEC R4 ;MORE? BGT 140$ ; MAPOUT #CRLF ; MOV (SP)+,R4 ;RESTORE R3 AND R4 MOV (SP)+,R3 BR RESOLV ;DO REST OF MAP .SBTTL RESOLV SECTION STARTS & GLOBAL SYMBOL VALUES ;+ ; OUTPUT THE ROOT SEGMENT SYMBOLS TO THE MAP. CONVERT THE VALUE WORD ; IN THE SYMBOL TABLE FROM LENGTH TO BASE ADDR FOR SECTION NAMES, ; FROM RELATIVE ENTRY ADDR TO ABSOLUTE ADDRESS FOR GLOBALS. ; INPUT:R3 = ADR OF ASECT SYMBOL TABLE ENTRY ; R4 = SIZE OF ASECT ; USAGE:R0 = TEMP ; R1 -> ASCII STRING PTR ; R4 = LENGTH OF CURRENT SECTION ; R5 = RUNNING SUM OF SECTION SIZES(CURRENT BASE ADR) ; MAY BE I OR D-SPACE IF /J WAS USED ; STACK WILL BE USED FOR SOME TEMPORARIES: ; @SP COLUMN COUNTER ; 2(SP) SEGMENT COUNT FOR MAP OUTPUT ; 4(SP) REGION COUNT FOR MAP OUTPUT ; NOTE: ASECT IS ALWAYS 1ST PRINTED AND "CSECT" IS NON-ZERO. ;- .ENABL LSB TOBIG: ERROR$ ERR50,E$F,E$PRT ;ADDRESS SPACE EXCEEDED RESOLV: CLR YSWNAM+2 ;INIT NEXT AVAILABLE OUTPUT BLOCK CLR -(SP) ;USE FOR OVERLAY REGION COUNT ON MAP CLR -(SP) ;USE FOR OVERLAY SEGMENT COUNT ON MAP CLR -(SP) ;RESERVE A SPACE ON STACK FOR COLUMN CTR CLR R5 ;R5 = CURRENT BASE ADDR (I OR D SPACE) CLR -(R3) ;ASECT BASE ADDRESS IS 0 (VALUE WORD) BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 70$ ;BRANCH IF NOT MOV BOTTOM,ILEN ;LENGTH OF I-SPACE CCB MOV SP,SPFLAG ;WE ALWAYS START WITH D-SPACE BR 70$ ;MAS11 RES1: SYMADR R3 ;CALC PTR TO NEXT NODE BIT S.YSN(R3),#SY.SEC ;NEW SECTION? BNE 10$ ;IF NE KEEP GOING JMP OUTSYM ;NO 10$: BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BNE 20$ ;BRANCH IF YES - WE ALREADY DID THIS INC R5 ;PART OF ROUND ODD SIZES UP BEQ TOBIG ;PREVENT CORE WRAP IF R5=177777 ;MAS05 ADD R4,R5 ;CALC NEW BASE ADDR BCS TOBIG ;C=1 IF ADDRESS SPACE EXCEEDED( > 32K WORDS) BIC #1,R5 ;MAKE NEW BASE EVEN 20$: MOV S.YVAL(R3),R4 ;GET LENGTH OF NEW SECTION ;CER02+ BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 30$ ;BRANCH IF NOT MOV DLEN,R5 ;ASSUME NEW SECTION IS D-SPACE MOV SP,SPFLAG ;SAY WE'RE PROCESSING A D-SPACE PSECT BIT #CS$TYP*400,S.YSN(R3) ;IS NEW SECTION D-SPACE? BNE 30$ ;BRANCH IF YES MOV ILEN,R5 ;IT'S I-SPACE, USE I-SPACE BASE CLR SPFLAG ;SAY WE'RE PROCESSING AN I-SPACE PSECT 30$: BIT #CS$REL*400,S.YSN(R3) ;IF ABS SECTION THEN BASE IS 0 BEQ 40$ ;ABS IF EQ MOV R5,S.YVAL(R3) ;STORE BASE ADDR ;CER02- 40$: CLR CSECT ;SET FLAG FOR NOT PRINTING THIS SECTION CMP S.YNAM(R3),#3100 ;IS IT THE BLANK SECTION? BHIS 60$ ;NO, PRINT IT ;SHD01+ TST R4 ;IS THIS BLANK SECTION 0-LENGTH? BNE 60$ ;NE -> NO, PRINT IT MOV @R3,R1 ;SAVE CURRENT SYMBOL BIC #SY.ENB,R1 ;CLEAR FLAGS BNE 50$ ;IF NE, MORE SYMBOLS TO GO JMP 180$ ;IF EQ END OF CHAIN; NO SYMBOLS 50$: SYMADR R1 ;GET NEXT SYMBOL BIT S.YSN(R1),#SY.SEC ;ANY SYMBOLS IN PSECT? BEQ 60$ ;IF EQ YES JMP 180$ ;IF NE NO ;SHD01- .SBTTL - OUTPUT SECTION NAME, BASE ADR, SIZE & ATTRIBUTES 60$: INC CSECT ;SAY WE ARE PRINTING THIS SECTION TST -(R3) ;BACK UP R3 FOR R50ASC 70$: MOV OBUF,R1 ;R1 -> TEMP ASCII BUFR MOV (PC)+,(R1)+ ;PUT CR & LF IN BUFR .BYTE CR,LF MOVB #SPACE,(R1)+ ;PUT SPACE IN BUFFER ;MAS15 CMP S.YNAM+2(R3),#3100 ;IS IT THE BLANK SECTION? BLO 80$ ;YES CALL R50ASC ;GO PRINT RAD50 NAME 80$: MOVB #TAB,(R1)+ ;TAB OVER FOR ADR MOVB #SPACE,(R1)+ ;MOV SPACE TO BUF, KEEPS (R1)+ WORKING ;MAS15 MOV @R3,R0 ;SECTION BASE ADDR ;CER02 CALL OCTOUT ;PRINT IN OCTAL TSTB (R1)+ ;BUMP PAST TAB CLRB @R1 ;TERMINATE THIS STRING ;DBB04+ MOV R1,-(SP) ;SAVE POINTER TO NULL STRING MAPOUT OBUF ;PRINT IT MOV (SP)+,R1 ;R1 -> NULL STRING MOV R5,-(SP) ;SAVE CURRENT BASE ADDRESS MOV R4,R5 ;SECTION LENGTH CALL SGPRTN ;PRINT "OOOOOO = DDDD. WORDS" (NO CRLF) MOV (SP)+,R5 ;RESTORE CURRENT BASE ADDRESS MOV OBUF,R1 ;R1 -> TEMP ASCII BUFFER MOV #>,(R1)+ ;PUT 2 SPACES IN BUFFER ;DBB04- MOV #"(R,(R1)+ MOV #"W,,R0 ;ASSUME READ/WRITE ACCESS BITB -(R3),#CS$ACC ;IS ACCESS READ ONLY? BEQ 90$ ;NO MOV #"O,,R0 ;CHANGE TO "RO" 90$: MOV R0,(R1)+ ;PROPER TEXT INTO ASCII BUFR MOV #"I,,R0 ;ASSUME "I" INSTRUCTION SECTION TSTB @R3 ;DATA? BPL 110$ ;NO MOV #"D,,R0 BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 120$ ;BRANCH IF NOT INC DLEN ;PART OF ROUND ODD SIZES UP BEQ 100$ ;PREVENT CORE WRAP IF R5=177777 ADD R4,DLEN ;INCREMENT D PSECT SIZE - NEW DBASE BCS 100$ ;C=1 IF ADDRESS SPACE EXCEEDED( > 32K WORDS) BIC #1,DLEN ;MAKE NEW D BASE EVEN BR 120$ 100$: JMP TOBIG ; 110$: BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 120$ ;BRANCH IF NOT INC ILEN ;PART OF ROUND ODD SIZES UP BEQ 100$ ;PREVENT CORE WRAP IF R5=177777 ADD R4,ILEN ;INCREMENT I PSECT SIZE - NEW I BASE BCS 100$ ;C=1 IF ADDRESS SPACE EXCEEDED( > 32K WORDS) BIC #1,ILEN ;MAKE NEW BASE EVEN 120$: MOV R0,(R1)+ MOV #"GB,R0 ;ASSUME GLOBAL SECTION ;DBB05+ BITB #CS$GBL,@R3 ;LOCAL? BEQ 130$ ;BRANCH IF LOCAL BIT #SY.SAV,3(R3) ;GLOBAL SECTION; IS IT ALSO SAV? BEQ 140$ ;BRANCH IF NO SAV ATTRIBUTE MOV #"SA,(R1)+ ;PUT "SAV," IN MOV #"V,,(R1)+ ; THE BUFFER BR 150$ ;DBB05- 130$: MOV #"LC,R0 140$: MOV R0,(R1)+ MOV #"L,,(R1)+ ;LAST 2 CHAR OF "GBL" OR "LCL" 150$: MOV #"RE,(R1)+ ;ASSUME RELOCATABLE MOV #"L,,(R1)+ BITB #CS$REL,@R3 ;ABSOLUTE? BNE 160$ ;NO CMP -(R1),-(R1) ;BACKUP 4 BYTES MOV #"AB,(R1)+ MOV #"S,,(R1)+ 160$: MOV #"OV,(R1)+ ;ASSUME OVERLAY SECTION MOV #"R),(R1)+ BITB #CS$ALO,@R3 ;CONCANATED? BNE 170$ ;NO CMP -(R1),-(R1) MOV #"CO,(R1)+ MOV #"N),(R1)+ 170$: CLRB @R1 ;TERMINATE THIS STRING ADD #3,R3 ;R3 -> STATUS WD OF SYM MAPOUT OBUF ;PUT IT IN MAP CLR @SP ;FORCE RESET OF COLUMN CTR 180$: BR POSTN ;SECTION NAMES DO NOT GO INTO STB ;MAS07 .DSABL LSB .SBTTL OUTSYM OUTPUT SYMBOL NAME & VALUE OUTSYM: BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 10$ ;BRANCH IF NOT BIT SWITCH,#SW.M ;ARE WE ALSO DOING /M? BEQ 10$ ;BRANCH IF NOT CMP S.YNAM(R3),STKBLK ;IS THIS THE STACK SYMBOL? BNE 10$ ;BRANCH IF NOT CMP S.YNAM+2(R3),STKBLK+2 ;IS IT REALLY? BNE 10$ ;BRANCH IF NOT TST SPFLAG ;ARE WE PROCESSING A D-SPACE PSECT? BNE 10$ ;BRANCH IF YES ERROR$ ERR77,E$F,E$PRT ;/M SYMBOL NOT IN D-PSECT 10$: TST -(R3) ;R3 -> VALUE WORD ;CER02 BIT #CS$REL*400,S.YSN+2(R3) ;IF ABS SYMBOL THEN DON'T ADD BASE ;CER02 BNE 30$ ;ABS IF EQU ;MAS07+ CMP #^R$OV,-6(R3) ;IS SYMB FOR OVERLAY HANDLER? BNE 40$ ;NO CMP #^RDF1,-4(R3) ;POSSIBLE-TEST 2ND WD BHI 40$ ;NOT IN RANGE->PRINT IN MAP CMP #^RDF6,-4(R3) ;TEST HIGH LIMIT OF RANGE ;MAS15 BLO 40$ ;NOT IN RANGE -> PRINT ON MAP 20$: TST (R3)+ ;DON'T PRINT IF IN RANGE OF OVERLAY GBLS BR POSTN ;CONTINUE WITHOUT PRINTING GBL ;MAS07- 30$: ADD R5,@R3 ;CALC ABS ADDRESS OF SYMBOL ;CER02 40$: TST CSECT ;IS CURRENT SECTION BEING PRINTED? ;CER02 BEQ 70$ ;NO, DON'T PRINT SYMBOL IN MAP DECB @SP ;RESET COLUMN COUNTER BGT 50$ MAPOUT #CLTTT ; MOVB NUMCOL,@SP ;COLUMN CTR 50$: MOV OBUF,R1 ;R1 -> ASCII BUFR CALL R50ASC ;PRINT RAD50 SYMBOL BIT 2(R3),#SY.IND ;RESOLVED THROUGH OVERLAY HDLR? BEQ 60$ ;NO MOVB #'@,(R1)+ ;INSERT @ TO INDICATE INDIRECT RESOLUTION 60$: MOVB #TAB,(R1)+ ;INSERT TAB MOV @R3,R0 ;ADDR OF SYM CALL OCTOUT TSTB (R1)+ ;SKIP OVER TAB CLRB @R1 ;TERMINATE STRING PUT LEAVE TAB MAPOUT OBUF ;SYMBOL NAME & VALUE 70$: TST (R3)+ ;R3 -> LINK WORD 80$: CALL FBGSD ;AND GENERATE AN STB ENTRY .SBTTL POSTN RESOLVE OVERLAY SYMBOLS IF ANY ;+ ; POSTN: -> NORMAL ENTRY POINT ; POSTN1:-> RENTRY POINT FOR /V PROCESSING CONTINUATION ; INPUT: R5 = CURRENT BASE ADR ; R3 -> INTERNAL SYMBOL TABLE AT S.YSN ; ; I AND D SPACE SEPARATION ; ; YSWNAM+2 WILL REMAIN THE TOTAL SIZE OF THE .SAV FILE ; ILEN = CURRENT I-SPACE BASE ADDRESS (WORDS) ; DLEN = CURRENT D-SPACE BASE ADDRESS (WORDS) ; IROOT = SIZE OF THE I-SPACE ROOT (WORDS) ; DROOT = SIZE OF THE D-SPACE ROOT (WORDS) ; IBASE = SIZE OF THE I-SPACE BASE ADDRESS (BLOCKS) ; DBASE = SIZE OF THE D-SPACE BASE ADDRESS (BLOCKS) ; ; R5 WILL BE USED FOR THE I-SPACE PROCESSING STARTING AT 30$ ;- .ENABL LSB POSTN: MOV @R3,R3 ;MOVE DOWN LINKED CHAIN BIC #SY.ENB,R3 ;ISOLATE ENTRY # PTR BEQ 10$ ;0 = END OF CHAIN JMP RES1 ;CONTINUE PROCESSING SYMBOLS IN CURRENT SEG. 10$: BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BNE 40$ ;BRANCH IF YES - WE ALREADY DID THIS INC R5 ;PART OF ROUND UP BEQ 20$ ;PREVENT CORE WRAP IF R5=177777 ADD R4,R5 ;CALC HIGH LIM FOR ALL PRECEEDING BCC 30$ ;C=1 IF ADDRESS OVERFLOW 20$: JMP TOBIG ;C=0 IF NO ADDRESS OVERFLOW 30$: BIC #1,R5 ;ROUND UP IF ODD 40$: CLR R4 MOV OVSPTR,R3 ;GET PTR TO OVERLAY SEG BLK BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 50$ ;BRANCH IF NOT MOV ILEN,R5 ;USE R5 FOR I-SPACE CALCS ADD DLEN,S.GHLD(R3) ;CALC LENGTH OF D-SPACE SEGMENT 50$: ADD R5,S.GHCL(R3) ;CALC LENGTH OF SEGMENT 60$: MOV S.GRGP(R3),R2 ;GET PTR TO REGION BLK BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 90$ ;BRANCH IF NOT 70$: CMP R.GHLD(R2),DLEN ;> PREV D HIGH LIM FOR REGION??? BHIS 80$ ;BRANCH IF NOT MOV DLEN,R.GHLD(R2) ;YES, UPDATE REGION D HIGH LIM 80$: MOV S.GHLD(R3),TEMPD ; USE TEMPD FOR TEMP D SEG SIZE 90$: CMP -(R2),R5 ;> PREV HIGH LIM FOR REGION??? BHIS 100$ ;NO MOV R5,@R2 ;YES, UPDATE REGION HIGH LIM 100$: MOV S.GHCL(R3),R5 ;USE R5 FOR TEMP SEGMENT SIZE TSTB FLGWD ;PRINT SEGMENT SIZE IF OVERLAYED BPL 120$ ;=+ IF NOT OVERLAYED MOV #SEGSIZ,R1 ;R1 -> INITIAL MSG TO PRINT BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 110$ ;BRANCH IF NOT MOV R5,-(SP) ;SAVE TEMP I-SPACE SEGMENT SIZE MOV TEMPD,R5 ;GET TEMP D-SPACE SEGMENT SIZE CALL SGPRTN ;PRINT TOTAL D-SPACE SIZE OF THIS SEGMENT MAPOUT #DSPCSZ ;PRINT " (D-space)" MOV (SP)+,R5 ;RESTORE TEMP I-SPACE SEGMENT SIZE MOV #SEGSIZ,R1 ;R1 -> INITIAL MSG TO PRINT CALL SGPRTN ;PRINT TOTAL I-SPACE SIZE OF THIS SEGMENT MAPOUT #ISPCSZ ;PRINT " (I-space)" BR 120$ ;SKIP NON I-D SPACE MESSAGE 110$: CALL SGPRT ;PRINT TOTAL SIZE OF THIS SEGMENT 120$: CMP #ASECT,R3 ;IS THIS THE ROOT? BNE 130$ ;BRANCH IF NOT BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 150$ ;BRANCH IF NOT MOV ILEN,IROOT ;ILEN IS THE SIZE OF THE I-SPACE ROOT MOV DLEN,DROOT ;DLEN IS THE SIZE OF THE D-SPACE ROOT BR 140$ ;MERGE BELOW 130$: ADD #2,R5 ;ALLOW FOR BLK OVFLW ON ID WORD BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 150$ ;BRANCH IF NOT ADD #4,R5 ;2 MORE ID WORDS (3 TOTAL) FOR /J OVERLAYS 140$: MOV R5,-(SP) ;SAVE R5 MOV TEMPD,R5 ;GET D-SPACE SIZE IN BLKS ADD #511.,R5 ;NOW CALC # OF BLKS IN OUTPUT ROR R5 ;MAKE WDS BRINGING IN THE CARRY ;CER01 CLRB R5 ;NOW BLKS * 256. ;CER01 SWAB R5 ;NOW BLKS ;CER01 ADD R5,YSWNAM+2 ;AND CALC NEXT AVAILABLE BLK ADD R5,DBASE ;SAVE D BASE MOV (SP)+,R5 ;RESTORE R5 150$: ADD #511.,R5 ;NOW CALC # OF BLKS IN OUTPUT (I-SPACE) ROR R5 ;MAKE WDS BRINGING IN THE CARRY ;CER01 CLRB R5 ;NOW BLKS * 256. ;CER01 SWAB R5 ;NOW BLKS ;CER01 ADD R5,YSWNAM+2 ;AND CALC NEXT AVAILABLE BLK BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 160$ ;BRANCH IF NOT ADD R5,IBASE ;SAVE I BASE 160$: MOV S.GNXP(R3),R3 ;R3 -> NEXT SEGMENT BLK THIS REGION? BNE 200$ ;IF 0 THEN START NEW REGION ;MAS15 MOV @R2,R5 ;GET BASE FOR NEXT REGION BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 170$ ;BRANCH IF NOT MOV R.GHLD+2(R2),TEMPD ;GET D BASE FOR NEXT REGION 170$: MOV R.GNXP+2(R2),R3 ;LINK TO NEXT REGION BLK BEQ XMUPD ;NONE LEFT, UPDATE XM PARTITION NEEDED ;MAS15+ TST R.GNB(R3) ;IS THIS A XM PARTITION? BPL 180$ ;BRANCH IF NOT JMP XMSIZE ;- -> YES -> SIZE XM ;MAS15- 180$: ADD #2,R5 ;LEAVE SPACE FOR ID WORD ;MAS09 BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ POSTN1 ;BRANCH IF NOT ADD #4,R5 ;ADD 2 MORE WORDS FOR I SPACE COUNTER POSTN1: MOV R5,@R3 ;SET BASE FOR REGION BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 190$ ;BRANCH IF NOT MOV TEMPD,R.GSAD(R3) ;SET D-SPACE BASE CLR R.GHLD(R3) ;CLEAR D HI LIMIT INITIALLY 190$: CLR -(R3) ;CLEAR HIGH LIMIT INITIALLY MOV -(R3),R3 ;GET PTR TO 1ST SEG BLK FOR REGION INC 4(SP) ;BUMP OVERLAY REGION COUNT 200$: MOV R3,OVSPTR ;UPDATE OVR SEG BLK PTR MOV #OVSMSG,R1 ;ASSUME /O SEGMENT ;MAS15+ TST SEGBAS ;TEST FOR /V STARTED BEQ 210$ ;= -> /O WAS RIGHT MOV #PSMSG,R1 ;SET UP /V MESSAGE 210$: CALL PUTMSG ;PRINT FIRST HALF MESSAGE ;MAS15- MOV #OVRGNB,R1 ;R1 -> ASCII # HERE MOV 4(SP),R0 CALL OCTOUT ;OVERLAY REGION # INC 2(SP) ;INCREMENT SEGMENT COUNT MOV #OVSGNB,R1 ;R1 -> ASCII SEGMENT # HERE MOV 2(SP),R0 CALL OCTOUT ;SEGMENT # CLRB @R1 ;TERMINATE MESSAGE & GET RID OF TAB MAPOUT #OVRGNB ;PRINT SECOND PART OF MESSAGE ;MAS15 MOV @S.GRGP(R3),R5 ;SET BASE ADDR FOR SEGMENT NEG R5 ;WHEN (-BASE ADR) + HIGH LIMIT OF SEG MOV R5,S.GHCL(R3) ; WE GET THE SIZE OF THIS SEGMENT NEG R5 ;POSITIVE BASE ADR AGAIN BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 220$ ;BRANCH IF NOT MOV R5,ILEN ;UPDATE MASTER I-SPACE BASE ADDRESS MOV IBASE,S.GBSB(R3) ; GET I-SPACE BASE BLOCK MOV R5,-(SP) MOV S.GRGP(R3),R5 ;GET REGION START ADDRESS IN R5 MOV R.GSAD(R5),R5 ;SET D BASE ADDR FOR SEGMENT MOV R5,DLEN ;UPDATE MASTER D-SPACE BASE ADDRESS NEG R5 ;WHEN (-BASE ADR) + HIGH LIMIT OF SEG MOV R5,S.GHLD(R3) ; WE GET THE SIZE OF THIS D SEGMENT MOV DBASE,S.GBBD(R3) ;BASE BLOCK OF D-SPACE SEGMENT MOV (SP)+,R5 BR 230$ ;RETURN TO POSTN 220$: MOV YSWNAM+2,S.GBSB(R3) ;AND BASE BLOCK .IIF NE RST$ CALL FBSEG ;PUT NEW SEGMENT INTO STB FILE ;MAS17 230$: JMP POSTN .DSABL LSB .SBTTL XMUPD UPDATE XM PARTITION SIZE AND MEMORY REQUIREMENTS ;+ ; IF THIS IS THE LAST XM PARTITION ADD ITS SIZES IN TO RUNNING COUNTS ;MAS15+ ; FOR EXTENDED MEMORY USED, AND VIRTUAL HIGH LIMIT. ;- XMUPD: TST -6(R2) ;IS THIS A /V PARTITION? BMI 20$ ;+ -> NOT /V PARTITION BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 10$ ;BRANCH IF NOT MOV TEMPD,DHGHLM ;SAVE D-SPACE ROOT HI LIMIT (INCLUDES .ABS.) 10$: MOV R5,HGHLIM ;NO /V PARTITION?-> SET HIGH LIMIT OF ROOT NOW BR 70$ ;AND GO DO UNDEFINED SYMBOLS 20$: MOV #2,-(SP) ;INCLUDE ID WORD BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 30$ ;BRANCH IF NOT MOV #6,@SP ;I-SPACE HAS 3-WORD ID ROUTINE 30$: ADD @SP,R5 ;INCLUDE ID HEADER CALL DIV32 ;IS /V, GO UPDATE SIZES SUB (SP)+,R5 ;RESET TO WITHOUT ID HEADER BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 50$ ;BRANCH IF NOT CALL DIV32D ;IS /V, GO UPDATE SIZES CMP DVRSIZ,TEMPD ;GET HIGHEST D-SPACE VIRT ADDR USED BLOS 40$ ;LE -> TEMPD IS BIGGEST MOV DVRSIZ,TEMPD ;DVRSIZ IS LARGER -> RESET TEMPD 40$: MOV TEMPD,DSGBLK ;SAVE TEMPD = HIGH D-SPACE VIRT ADDR FOR /V ; (32K MAX) 50$: CMP VIRSIZ,R5 ;GET HIGHEST VIRT ADDR USED BLOS 60$ ;LE -> R5 IS BIGGEST MOV VIRSIZ,R5 ;VIRSIZ IS LARGER -> RESET R5 60$: MOV R5,SEGBLK ;SAVE R5 = HIGH VIRT ADDR FOR /V (32K MAX) 70$: JMP DOUDFS ;MAS15- .SBTTL XMSIZE GET HIGH VIRTUAL ADDR AND XM MEMORY REQUIRED ;+ ; THESE RUNNING SUMS MUST BE SAVED FOR XM PARTITION SIZE CALCULATIONS. ;MAS15+ ; 1.THE AMOUNT OF EXTENDED MEMORY REQUIRED FOR THE /V OVERLAYS (96K MAX). ; 2.THE HIGH VIRTUAL ADDRESS LIMIT FOR ALL CODE (32K MAX). ; THESE ARE IN ADDITION TO THE HIGH LIMIT FOR THE ROOT + /O OVERLAYS (HGHLIM). ; ; AS THIS IS GOING ON, THE PARTITION BASES ARE BEING ROUNDED UP TO 4K ; BOUNDARIES. THIS REQUIRES THE N SWTICH (V:N:M) TO BE SAVED IN THE PARTITION ; DESCRIPTOR BLOCK UP TO THIS TIME. THE HIGH CORE LIMIT OF THE PARTITON ; WILL BE USED FOR THIS (R.GHL). SEGBAS WILL SAVE THE PREVIOUS N VALUE FOR THE ; COMPARISON. ; ; RULES:1.ALL PARTITIONS WITH THE SAME N VALUE START AT THE SAME BASE ADDRESS. ; 2.THE SIZE OF THE LARGEST PARTITION WITH THE SAME N VALUE WILL BE ; ADDED TO THE HIGH VIRTUAL ADDRESS FOR THE PROGRAM (32K MAX). ; 3.THE SIZE OF THE LARGEST SEGMENT IN A PARTITION IS ADDED TO THE ; XM MEMORY REQUIRED (2016KW MAX). ; ; !----------------------------------------------------------------------! ; !OCTAL WORDS OCTAL BYTES ! ; ! ! ; ! 40 = 100 = 32 DECIMAL WORDS ! ; ! 10000 = 20000 = 4K MEMORY ! ; ! 7700000 = 17600000 = 2016KW MEMORY ! ; !77000 X 100 = 6000 X 100 = 2016KW MEMORY = 2064384. WDS. ! ; !----------------------------------------------------------------------! ;- XMSIZE: MOV #2,-(SP) ;INCLUDE ID WORD BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 10$ ;BRANCH IF NOT MOV #6,@SP ;I-SPACE HAS 3-WORD ID ROUTINE 10$: TST SEGBAS ;IS THE THIS FIRST XM PARTITION? BNE 40$ ;= -> 1ST MOV @R2,HGHLIM ;SAVE HIGH LIMIT OF ROOT + /O OVERLAYS BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 20$ ;BRANCH IF NOT MOV R.GHLD+2(R2),DHGHLM ;SAVE D-SPACE HIGH LIM OF ROOT + /O OVLYS 20$: MOV 6(SP),REGION ;SET REGION COUNT TO LAST /O REGION COUNT CLR 6(SP) ;RESET PARTITION COUNT TO ZERO MOV #SPMSG1,R1 ;ASSUME NORMAL MAP (80 COLS) MOV (PC)+,@R1 ;STUFF CR,LF .BYTE CR,LF CMPB #3,NUMCOL ;IS THIS A WIDE MAP? (/W) BEQ 30$ ;= -> 80 COLS MOV #"--,@R1 ;STUFF DASHES MOV #SPMSG,R1 ;130 COL MAP 30$: CALL PUTMSG ;PRINT MESSAGE TO SEPARATE /O AND /V IN MAP BR 50$ ;1ST -> NO OLD PHYS ADDR SIZE TO ADD IN ; NOT FIRST XM PARTITION -> COMPARE N VALUES 40$: ADD @SP,R5 ;SET TO INCLUDE ID HEADER CMP R.GHL(R3),SEGBAS ;COMPARE N VALUES (V:N:M) BEQ 110$ ;= -> SAME N VALUE ; N VALUES ARE DIFFERENT (OR 1ST XM PARTITION -> 50$:) CALL DIV32 ;SAVE EXTENDED ADDR SIZE SUB @SP,R5 ;RESET TO BEFORE ID HEADER BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 50$ ;BRANCH IF NOT CALL DIV32D ;SAVE EXTENDED ADDR SIZE 50$: INC REGION ;REGION COUNTER MOV #ODMSG,R1 ;SET UP REGION NUMBER MOV REGION,R0 ;GET NUMBER CALL OCTOUT ;OUTPUT NUMBER MOV (PC)+,(R1)+ ;PUT IN ADDITIONAL LF,CR .BYTE CR,LF MOVB #0,(R1)+ ;CONVERT TO ASCIZ MESSAGE MOV #VORMSG,R1 ;GET WHOLE MESSAGE CALL PUTMSG ;PRINT IT MAPOUT #SPMSG2 ;UNDER LINE IT CMP VIRSIZ,R5 ;GET LARGEST PARTITION SIZE IN REGION BLOS 60$ ;LE -> R5 HAS LARGEST SIZE IN IT MOV VIRSIZ,R5 ;VIRSIZ WAS LARGER 60$: ADD #17777,R5 ;ROUND SIZE TO 4K + WORD BOUNDARY BCC 80$ ;BRANCH IF DOESN'T OVERFLOW 70$: JMP TOBIG ;C=1 -> MORE THAN 32K -> ERROR 80$: BIC #17777,R5 ;EXACTLY 4K WORD BOUNDARY ADD (SP)+,R5 ;COVER HIDDEN ID HEADER MOV R5,SEGBLK ;RESET BASE OF PARTITION MOV R.GHL(R3),SEGBAS ;SET NEW PARTITION ID CLR VIRSIZ ;RESET VIRSIZ TO 0, NEW PARTITION BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 100$ ;BRANCH IF NOT CMP DVRSIZ,TEMPD ;GET LARGEST PARTITION SIZE IN REGION BLOS 90$ ;LE -> TEMPD HAS LARGEST SIZE IN IT MOV DVRSIZ,TEMPD ;DVRSIZ WAS LARGER 90$: ADD #17777,TEMPD ;ROUND SIZE TO 4K + WORD BOUNDARY BCS 70$ ;C=1 -> MORE THAN 32K -> ERROR BIC #17777,TEMPD ;EXACTLY 4K WORD BOUNDARY MOV TEMPD,DSGBLK ;RESET BASE OF PARTITION ;>>> MOV R.GHLD(R3),DSGBAS ;SET NEW PARTITION ID CLR DVRSIZ ;RESET DVRSIZ TO 0, NEW PARTITION 100$: BR 140$ ;RETURN TO MAIN STREAM PROCESSING ; N VALUES ARE THE SAME 110$: CALL DIV32 ;SAVE EXTENDED ADDR SIZE SUB (SP)+,R5 ;RESET TO BEFORE ID HEADER CMP VIRSIZ,R5 ;GET LARGEST PARTITION SIZE THIS REGION BHIS 120$ ;GE -> VIRSIZ LARGER MOV R5,VIRSIZ ;RESET VIRSIZ TO BIGGER SIZE 120$: MOV SEGBLK,R5 ;RESET R5 TO SAME BASE ADDR BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 140$ ;BRANCH IF NOT CALL DIV32D ;SAVE EXTENDED ADDR SIZE CMP DVRSIZ,TEMPD ;GET LARGEST PARTITION SIZE THIS REGION BHIS 130$ ;GE -> DVRSIZ LARGER MOV TEMPD,DVRSIZ ;RESET DVRSIZ TO BIGGER SIZE 130$: MOV DSGBLK,TEMPD ;RESET TEMPD TO SAME BASE ADDR 140$: JMP POSTN1 ;RETURN TO PROCESSING ;MAS15- .SBTTL DIV32 DIVIDE REG SIZE BY 32. WDS. (100 OCTAL BYTES) & SAVE ;+ ; CALC. SIZE OF XM PARTITIONS, SAVE AS RUNNING SUM OF 32. WORD MULT. ;MAS15+ ;- .ENABL LSB DOERR: ERROR$ ERR0,E$F,E$PRT ;ILLEGAL ERROR DIV32D: MOV R5,-(SP) ;SAVE R5 MOV TEMPD,R5 ;GET D-SPACE BASE OF NEXT PARTITION SUB DSGBLK,R5 ;SUBTRACT OUT BASE OF PARTITION BR 10$ DIV32: MOV R5,-(SP) ;SAVE R5 SUB SEGBLK,R5 ;SUBTRACT OUT BASE OF PARTITION 10$: BIT #77,R5 ;PARTITION SIZE SHOULD BE 32. WORD MULT BNE DOERR ;NE -> ILLEGAL ERROR CLC ROL R5 ;DIVIDE BY 100 OCTAL BYTES (32. WORDS) ROL R5 ;TO GET THE AMOUNT OF EXTENDED ROLB R5 ;MEMORY REQUIRED FOR PROGRAM. SWAB R5 ;THIS IS STORED AS 32. WORD MULTIPLE ADD R5,HIPHYS ;ADD THIS PARTITION SIZE TO LAST CMP #176000,HIPHYS ;TEST FOR >2016KW BLO 20$ ;LT -> OVERFLOW OF XM EXTENDED MEMORY MOV (SP)+,R5 ;RESTORE R5 RETURN 20$: ERROR$ ERR56,E$F,E$PRT ;/V OVERLAY LOGICAL ADDR SPACE EXCEEDED ;MAS15- .DSABL LSB .SBTTL DOUDFS PRINT UNDEFINED GLOBALS IF ANY ; R5 = HIGH LIMIT DOUDFS: ADD #6,SP ;POP SEVERAL STACK TEMPS CALL ENDSTB ;CLOSE OUT THE STB FILE MOV UNDLST,R4 ;R4 -> START OF UNDEFINED LIST FORWARD PTR MOV (R4)+,R3 ;GET POINTER TO LIST OF CMP R4,R3 ;IF LIST HEAD PTS BACK TO ITSELF THEN BEQ DOTADR ; NO UNDEFINED SYMBOLS ; THERE ARE UNDEFINES, PRINT THEM BIT FLGWD,#NO.SYS ;WAS DEFAULT SYSTEM LIBRARY FOUND? BEQ 10$ ;YES IF 0 ERROR$ ERR3,E$W,E$PRT ;DEFAULT SYSTEM LIBRARY NOT FOUND SYSLIB.OBJ 10$: MAPOUT #UGM ;UNDEFINED GLOBALS MESSAGE BIT FLGWD,#FG.TT ;IS MAP ON "TT:" BNE 40$ ;YES IF NE MOV PAGNUM,TEMP ;SAVE THE PAGE NUMBER MOV #LINE1,R0 ;SAVE THE TOP TWO LINES OF THE HEADER MOV #TXTBLK,R1 ;IN TXTBLK FOR AFTER RETURN FROM ERROR OVR MOV #174,R2 ;SIZE OF LINE1 AND LINE2 20$: MOVB (R0)+,(R1)+ ;SAVE THEM SOB R2,20$ ;LOOP ERROR$ ERR15,E$W,E$PRT ;PRINT UNDEFINED GLOBALS WARNING MSG (OVR) MOV TEMP,PAGNUM ;RESTORE THE PAGE NUMBER MOV #LINE1,R0 ;RESTORE THE TOP TWP LINES OF THE HEADER MOV #TXTBLK,R1 ;FROM TXTBLK TO LINE1 AND LINE2 MOV #174,R2 ;SIZE OF LINE1 AND LINE2 30$: MOVB (R1)+,(R0)+ ;RESTORE THEM SOB R2,30$ ;LOOP 40$: BIC #SY.UDF,@R3 ;GET RID OF UNDEF BIT ;DBB01 MOV -(R3),-(SP) ;GET PTR TO NEXT CLR @R3 ;CLEAR ADDR OF CURRENT MOV #TXTBLK,R1 ;R1 -> TEMP ASCII BUFR MOV (PC)+,(R1)+ ; CR & LF .BYTE CR,LF CALL R50ASC ;PRINT RAD50 SYMBOL CLRB @R1 ;TERMINATE MESSAGE MAPOUT #TXTBLK ;OUTPUT UNDEF SYMBOL TO MAP MOV (SP)+,R3 ;R3 -> NEXT UNDEF SYM BIT FLGWD,#FG.TT ;PRINT ON TTY ALSO? BNE 50$ ;NO, TTY IS MAP DEVICE .PRINT #TXTBLK+2 ;OUTPUT UNDEF'S TO TT: (BYPASS CR & LF) 50$: CMP R4,R3 ;DONE? BLO 40$ ;NOT YET .SBTTL DOTADR OUTPUT TRANSFER ADR & CHECK ITS VALIDITY DOTADR: MOV #^C,LKMSK ;LOOK AT SECTION & SEGMENT # BITS CLR SEGNUM ;MUST BE IN ROOT SEGMENT MOV #SY.SEC,LKWD ;ASSUME SECTION NAME LOOKUP MOV #BEGBLK,R3 ;R3 -> TRANSFER ADR BLK CMPB S$YCOD(R3),#4 ;IS SYMBOL A GLOBAL? BNE 10$ ;IF NE THEN A SECTION NAME CLR LKWD ;GLOBAL SYM IN SEGMENT 0 10$: CALL LOOKUP BITB (R3)+,(R3)+ ;R3 -> VALUE WD, LEAVE CARRY ALONE BCC 20$ ;ERROR IF UNDEF TRANS ADR ERROR$ ERR31,E$W,E$PRT ;TRANSFER ADDRESS UNDEFINED OR IN OVERLAY MOV #1,@R3 BR 40$ 20$: BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 30$ ;BRANCH IF NOT BIT SWITCH,#SW.T ;ARE WE ALSO DOING /T BEQ 30$ ;BRANCH IF NOT TSTB -3(R0) ;IS TRANSFER SYMBOL IN AN I-SPACE PSECT? BPL 30$ ;BRANCH IF YES ERROR$ ERR100,E$F,E$PRT ;/T SYMBOL NOT IN I-PSECT 30$: MOV -(R0),R0 ;GET ADR OF SYMBOL ADD R0,@R3 ;CALC TRANSFER ADDRESS 40$: MOV #TANB,R1 ;R1 -> AREA TO STORE TRANS ADR VALUE MOV @R3,R0 ;PICK UP TRANS ADDR CALL OCTOUT MOVB #',,(R1)+ ;CHANGE TAB TO COMMA MOV #TAM,R1 ;R1 -> TRANSFER ADDRESS MSG FOR MAPOUT MOV HGHLIM,R5 ;SET R5 FOR /O+ROOT HIGH LIMIT (R5= NEXT FREE) BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 50$ ;BRANCH IF NOT MOV DHGHLM,R5 ;SET R5 FOR /O+ROOT NEXT FREE (D-SPACE) 50$: SUB #2,R5 ;MAKE IT LAST LOCATION USED ;MAS30 CALL SGPRT ;CONVERT HIGH LIMIT BITB #,FLGWD ;IS THIS /V OR /XM? ;MAS35/MAS15+ BEQ 80$ ;= -> NOT /V OR /XM ;+ ; DOING /V EXTENDED MEMORY OVERLAYS OR /XM LINK -> HAVE TO OUTPUT HIGH VIRTUAL ; ADDRESS, AND NEXT AVAILABLE ADDRESS ;- BITB #XM.OVR,FLGWD ;DO WE HAVE /V OVERLAYS? ;MAS35+ BEQ 70$ ;BRANCH IF NOT, R5 IS OK MOV SEGBLK,R5 ;R5 = NEXT FREE LOCATION (FOR OVLYS) BIT SWIT1,#SW.J ;ARE WE DOING I-D SPACE? BEQ 60$ ;BRANCH IF NOT MOV DSGBLK,R5 ;R5 = NEXT FREE LOCATION (FOR OVLYS) (D-SPACE) 60$: SUB #2,R5 ;MAKE IT LAST USED LOCATION 70$: MOV #COMMA,R1 ;GET ADDR TO STUFF MESSAGE ;MAS30+ MOVB #',,(R1)+ ;INSERT COMMA AND MOVB #SPACE,(R1)+ ;THEN SPACE MOVB #'n,@R1 ;AND SMALL CASE N FOR MESSAGE MOV #VHIGH,R1 ;GET VIRTUAL HIGH LIMIT MSG CALL SGPRT ;PRINT FIRST PART OF MESSAGE ADD #17777,R5 ;ROUND UP TO NEXT PAR BIC #17777,R5 ;SET TO PAR BOUNDARY MOV R5,SEGBLK ;SAVE FOR LATER (/V AND /XM NEED IT) ;MAS35- MOV R5,R0 ;SET UP TO CONVERT THIS WORD TO ASCII MOV #ODMSG,R1 ;AND STORE IT HERE CALL OCTOUT ;CONVERT IT TO ASCII MOVB #CR,(R1)+ ;INSERT CARRIAGE RETURN MOVB #LF,(R1)+ ;AND LINE FEED CLRB (R1)+ ;CLEAR BYTE FOR ASCIZ TERMINATION MOV #ODMSG,R1 ;GET MESSAGE TO PRINT CALL PUTMSG ;AND GO PRINT IT BITB #XM.OVR,FLGWD ;/V OVERLAYS PRESENT? ;MAS35 BEQ 80$ ;EQ -> NO, JUST /XM OR /V ON FIRST LINE ;MAS35 ; FOR /V OVERLAYS, PRINT THE AMOUNT OF EXTENDED MEMORY REQUIRED TO RUN PROGRAM MOV #COMMA,R1 ;GET MESSAGE BUFFER, AND MOVB #CR,(R1)+ ;RESET FOR NEXT MESSAGE WITH CARRIAGE RETURN MOVB #LF,(R1)+ ;LINE FEED, AND CLRB @R1 ;END OF ASCII STRING ;MAS30- MOV #VPHYS,R1 ;GET EXTENDED MEMORY REQUIRED MESSAGE CALL PUTMSG ;PRINT EXTENDED MEMEORY MESSAGE ;+ ; FOR THIS VALUE, ONLY PRINT AS 18 BITS MAXIMUM. 600000 IS THE ; LARGEST PERMITTED EXTENDED MEMORY SIZE. ;- MOV HIPHYS,R0 ;MAKE UP HIGH ORDER OF VALUE MOV R0,-(SP) ;COPY R0 SO CAN DO LOW WORD SWAB @SP ;SHIFT LOW ORDER ALL OF THE WAY (C=0) RORB @SP ;(SHIFT A TOTAL OF ROR @SP ;6 TIMES TO ROR @SP ;MULT BY 100 OCTAL BYTES) ASR R0 ;USING THE HIGH 6 BITS OF VALUE (6000=MAX ;SHIFT OUT ONE BIT FROM HIGH BYTE TO LOW BYTE SWAB R0 ;NOW DO HIGH WORD .ADJUST RIGHT CORECTLY, AND BIC #177770,R0 ;MASK OUT THE UNUSED BITS TO GET THE VALUE MOV R0,-(SP) ;SAVE HIGH ON STACK ASR @SP ;SHIFT TO REMOVE LOW BIT (FOR DEC. CONVERSION) MOV #ODMSG,R1 ;STORE HIGH WORD HERE CALL OCTOUT ;CONVERT HIGH WORD TO ASCII MOV -2(R1),-(SP) ;SAVE LOW BYTE, SINCE LOW WORD OVERWRITES IT MOV 4(SP),R0 ;GET LOW WORD TSTB -(R1) ;SET UP TO STORE LOW WORD HERE CALL OCTOUT ;CONVERT LOW WORD TO ASCII MOV (SP)+,-7(R1) ;RESTORE OVERWRITTEN BYTE (R1 IS ODD NOW) MOVB #SPACE,ODNB1 ;REPLACE TAB WITH SPACE ; NOW CONVERT TWO WORDS TO DECIMAL MOV (SP)+,R1 ;RESTORE HIGH WORD MOV (SP)+,R0 ;RESTORE LOW ORDER ASR R1 ;DIVIDE BY TWO FOR WORDS, NOT BYTES ROR R0 ;IN DOUBLE PRECISION MODE CALL DECASC ;AND CONVERT TO DECIMAL MOV #ODNB,R1 ;GET MESSAGE (ONLY PRINT 6 DIGITS) CALL PUTMSG ;PRINT IT ;MAS15- .SBTTL - FLUSH MAP BUFFER 80$: MOV #511.,R3 ; TO FORCE LAST BUFR OUT. CLR R0 ;ZERO REMAINDER OF BUFR 90$: CALL PUTCHR ; OUTPUT 0 SOB R3,90$ ; WILL CLOSE FILE AFTER ALL DONE JMP DOCASH ;DO INITIALIZATION BEFORE PASS2 .IF NE RST$ ;MAS17+ .SBTTL FBSEG RSTS/E MOVE SEGMENT BLOCK TO STB FILE ;+ ; R3 -> SEGMENT BLOCK ; R5 = SEGMENT BASE ADDRESS ;- FBSEG: BIT FLGWD,#FG.STB ;IS THERE AN STB FILE? BEQ 10$ ;= -> NO STB FILE CALL FBGSD ;LET FBGSD DO MOST OF THE WORK MOV R5,-(R0) ;VALUE (SIZE) IS THE SEGMENT BASE ADDRESS MOV #1*400,-(R0) ;.ASECT (CONTROL SECTION NAME) MOV #^RBS.,-(R0) ;. ABS. (2 WORD RAD50 NAME) MOV #^R. A,-(R0) ;ORDER 10$: RETURN ;MAS17- .ENDC ;RST$ .SBTTL FBGSD STB SUBROUTINES ;+ ; FBBLK= ESWVAL ;CURRENT BLOCK # ; FBPTR= ESWNAM ;BUFFER POINTER ; FBCNT= ESWNAM+2 ;BYTES REMAINING ; INPUT: R3 -> SYMBOL TABLE NODE ; OUTPUT: R3 = SAME AS INPUT ; CLOBBERS R0 & R1 ;- FBGSD: BIT FLGWD,#FG.STB ;IS THERE AN STB FILE? BEQ 20$ ;NO MOV TXTBLK,R0 ;YES, -> UNUSED AREA CMP #TXTBLK+2+56-10,R0 ;IS THERE ROOM FOR ANOTHER GSD ENTRY? BHIS 10$ ;YES JSR R5,FBNEW ;NO, EMIT THIS FB BLOCK AND START ANOTHER + GSD ;OF TYPE GSD 10$: ADD #S.YNAM,R3 ;BACK UP TO SYMBOL NAME MOV (R3)+,(R0)+ ;PUT NAME INTO GSD BLOCK MOV (R3)+,(R0)+ MOV #4*400+110,(R0)+;GSD DEFINITION OF ABSOLUTE SYMBOL TST (R3)+ ;SKIP OVER FLAG WORD MOV (R3)+,(R0)+ ;WITH THIS VALUE MOV R0,TXTBLK ;SAVE POINTER 20$: RETURN ;AND RETURN FBNEW: MOV R3,-(SP) ;SAVE R3 MOV #TXTBLK,R1 ;R1 -> FB BLOCK TO DUMP MOV (R1)+,R0 ;R0 -> END OF WRITTEN DATA SUB R1,R0 ;R0 = LENGTH OF DATA MOV #1,@R1 ;FB BLOCKS ALWAYS START WITH 1 MOV R0,2(R1) ;AND HAVE THE LENGTH NEXT CLR CKSUM ;CLEAR OUT THE CHECKSUM MOV #ESWNAM+2,R3 ;R3 -> BUFR CTRL WORDS 10$: MOVB CKSUM,@TXTBLK ;SET CHECKSUM INTO FB BUFFER 20$: MOVB (R1)+,R0 ;GET NEXT BYTE SUB R0,CKSUM ;PUT INTO CHECKSUM MOVB R0,@-(R3) ;MOVE BYTE TO OUTPUT BUFFER INC (R3)+ ;BUMP OUTPUT BUFFER POINTER DEC @R3 ;DECREMENT COUNT REMAINING BNE 30$ ;MORE LEFT MOV EIB512,-(R3) ;RESET BUFFER POINTER ;DBB03+ .WRITW #PRAREA,#2,(R3)+,#256.,ESWVAL ;WRITE TO STB FILE. BCS STBERR ;ERROR IF C=1 MOV #BYTBLK,@R3 ;RESET BYTE COUNT INC -4(R3) ;BUMP TO NEXT BLOCK ;DBB03- 30$: CMP R1,TXTBLK ;DONE YET? BLO 20$ ;NO BEQ 10$ ;YES, EMIT THE CHECKSUM MOV #TXTBLK+6,R0 ;NOW RESET THE POINTER MOV (R5)+,(R0)+ ;PUT IN THE TYPE REQUESTED MOV R0,TXTBLK ;SAVE THE POINTER MOV (SP)+,R3 ;RESTORE R3 .SBTTL OV5DUM:: DUMMY ENTRY PT FOR ERROR PROCESSING OV5DUM::RTS R5 ;DONE STBERR: ERROR$ ERR34,E$F,E$PRT ;STB WRITE ERR ENDSTB: BIT FLGWD,#FG.STB ;CLOSE OUT THE STB FILE. IS THERE ANY? BEQ 30$ ;NO JSR R5,FBNEW ;YES, CLOSE FB BLOCK AND START A NEW ONE + ENDGSD ;WHICH IS AN ENDGSD BLOCK JSR R5,FBNEW ;CLOSE THAT, START ANOTHER + MODEND ;WHICH IS AN END MODULE BLOCK JSR R5,FBNEW ;CLOSE THAT + 0 ;RANDOM NUMBER MOV #ESWNAM+2,R0 ;POINT TO BUFFER CONTROL CMP #BYTBLK,@R0 ;EMPTY? BEQ 30$ ;YES, WILL CLOSE FILE WHEN ALL DONE 10$: DEC @R0 ;ANY BYTES LEFT? BMI 20$ ;NO CLRB @-(R0) ;YES, ZAP THEM INC (R0)+ ;BUMP BUFFER PTR BR 10$ ;LOOP 20$: .WRITW #PRAREA,#2,EIB512,#256.,ESWVAL ;WRITE TO STB FILE ;DBB03 BCS STBERR ;OUCH 30$: RETURN .SBTTL SGPRT PRINT OCTAL VALUE THEN ITS DECIMAL WORD EQUILEVENT ;+ ; INPUT: R5 = VALUE TO PRINT ; R1 -> MESSAGE TO OUTPUT TO MAP FIRST ; CLOBBERS R0 & R1 ;- SGPRT: CALL PUTMSG ;R1 -> CURRENT MSG TO OUTPUT MOV #ODNB,R1 ;R1 -> AREA TO STORE ASCII TEXT MOV R5,R0 ;INPUT VALUE CALL OCTOUT ;CONVERT VALUE TO OCTAL MOVB #SPACE,(R1)+ ;CHANGE TAB TO BLANK MOV R5,R0 ;GET VALUE AGAIN CLR R1 ;SET HIGH TO ZERO ;MAS15+ INC R0 ;IF ODD # OF BYTES ROUND UP # OF WORDS ;DBB04 ROR R0 ;FROM BYTE SIZE TO WORD SIZE CALL DECASC ;CONVERT TO DECIMAL MOV #ODNB,R1 ;GET ONE WORD MESSAGE CALL PUTMSG ;PRINT IT RETURN ;MAS15- SGPRTN: CLRB COMMA ;DON'T PRINT A AT END OF STRING CALL SGPRT ;PRINT ... "OOOOOO = DDDD. WORDS" (NO CRLF) MOVB #,COMMA ;RESTORE ( IS STILL THERE) RETURN .SBTTL DECASC TWO WORD OCTAL TO DECIMAL ASCII CONVERSION ;+ ; REPLACES OLD CONVERSION ROUTINE ;MAS15+ ; INPUT:R0 -> LOW ORDER OF UNSIGNED BINARY NUMBER ; R1 -> HIGH ORDER OF UNSIGNED BINARY NUMBER ; ; OUTPUT:RESULT ALWAYS STORED IN ODNB2 AS 6 DIGIT NUMBER ; R0, R1 AND R4 CLOBBERED ;- DECASC: MOV R2,-(SP) ;SAVE REGISTERS MOV R3,-(SP) ;R2,R3, AND R4 MOV R4,-(SP) MOV #7,R3 ;SET UP 6 ASCII BYTES + DECIMAL POINT MOV #ODNB2+7,R4 ;BLANK (SPACE) ALL 6 CHARS AT START 10$: MOVB #SPACE,-(R4) SOB R3,10$ ;LOOP FOR ALL SIX (R4 -> ODNB2 AT ENDOF LOOP) MOV #6,R3 ;SET UP FOR 6 DECIMAL CHARACTERS CALL CBOMG ;GO TO SET UP ROUTINE MOVB DECEND,(R4)+ ;PUT IN DECIMAL POINT MOV (SP)+,R4 ;RESTORE REGS MOV (SP)+,R3 MOV (SP)+,R2 RETURN ;RETURN TO MAIN LINE ; FOLLOWING ROUTINES DONATED BY C.G. (CBOMG AND DIV) CBOMG: CALL DIV ;GO TO DIVIDE ROUTINE MOV R2,-(SP) ;SAVE REMAINDER DEC R3 ;ANY DIGITS LEFT? BLE 10$ ;BRANCH IF NOT MOV R0,-(SP) ;TEMP STORE R0 ADD R1,(SP)+ ;ADD TOGETHER, ZERO QUOTIENT? BEQ 10$ ;= -> YES, ZERO CALL CBOMG ;DIVIDE AGAIN 10$: ADD #'0,@SP ;MAKE IT ASCII MOVB (SP)+,(R4)+ ;SAVE DIGIT IN MESSAGE (ODNB2:) RETURN ;RETURN DIV: MOV #40,-(SP) ;SET LOOP COUNT MOV #10.,-(SP) ;SAVE RADIX FOR SUBTRACTS CLR R2 ;CLEAR REMAINDER 10$: ASL R0 ;DOUBLE PRECISION LEFT SHIFT ROL R1 ROL R2 CMP R2,@SP ;SUBTRACT OUT DIVISOR BLO 20$ ;LO -> DO NOT SUBT SUB @SP,R2 ;DO IT INC R0 ;ADD IN LOW BIT 20$: DEC 2(SP) ;DECREMENT LOOP COUNT BGT 10$ ;IF GT -> MORE TO DO CMP (SP)+,(SP)+ ;CLEAN STACK RETURN ;RETURN TO SET UP ROUTINE ;MAS15- .SBTTL PUTCHR OUTPUT A CHARACTER TO THE MAP FILE ;+ ; INPUT: R0 = CHARACTER ; ; OUTPUT:A BUFFER IS WRITTEN AS REQUIRED ; R0 = SAME CHARACTER ;- .ENABL LSB PUTCHR: MOV R0,-(SP) ;SAVE CHARACTER TO OUTPUT MOV #MBPTR,R0 ;R0 -> OUTPUT BUFR PTR TST @R0 ;IF 0 THEN NO MAP REQUESTED BEQ 10$ ;NO MAP WANTED MOVB @SP,@(R0)+ ;PUT CHAR INTO BUFR INC -(R0) ;BUMP POINTER CMP EIB512,@R0 ;AT THE END OF BUFR? BHI 10$ ;NO MOV IBUF,@R0 ;YES, SET START OF BUFR INC -(R0) ;BUMP REL BLOCK # TST -(R0) ;R0 -> MWAREA .WRITW ,#1 ;WRITE TO MAP FILE ;DBB03 BCC 10$ ;NO ERRORS ERROR$ ERR5,E$W,E$PRT ;MAP WRITE ERROR CLR MBPTR ;ABORT OUTPUT OF THE MAP CLR CBPTR ; AND CROSS REFERENCE BUT ;DBB02 10$: MOV (SP)+,R0 RETURN ; CONTINUE OTHER THINGS .DSABL LSB .SBTTL PUTMSG OUTPUT AN ASCIZ MESSAGE TO MAP ;+ ; INPUT: R1 -> ASCIZ MESSAGE ; ; OUTPUT:R1 -> BEYOND END OF MESSAGE ; CLOBBERS R0 ;- .ENABL LSB 10$: CALL PUTCHR ;OUTPUT THIS CHARACTER CMPB #LF,R0 ;WAS IT A LINE FEED? BNE PUTMSG ;IF NE NO DEC LINLFT ;DECREMENT LINES LEFT COUNTER BNE PUTMSG ;IF EQ WE NEED A NEW PAGE MOVB #FF,R0 ;FORCE A FORM FEED TO BE OUTPUT CALL PUTCHR CALL HEADER ;AND OUTPUT THE HEADER PUTMSG: MOVB (R1)+,R0 ;GET A CHARACTER BNE 10$ ;RETURN IF 0 RETURN .DSABL LSB HEADER: MOV R1,-(SP) ;SAVE MESSAGE POINTER MOV LINPPG,LINLFT ;RESET LINES LEFT COUNTER INC PAGNUM ;BUMP PAGE NUMBER CLR R1 ;SETUP R0 AND R1 FOR DECASC ROUTINE MOV PAGNUM,R0 CLRB DECEND ;MAKE DECIMAL NUMBER TERMINATOR NULL CALL DECASC ;CONVERT TO DECIMAL ASCII MOVB #'.,DECEND ;RESTORE "." FOR DECIMAL # TERMINATOR MAPOUT #LINE1 MAPOUT #PAGE MAPOUT #ODNB2 MAPOUT #CRLF MAPOUT #LINE2 MAPOUT #CRLFLF MOV (SP)+,R1 ;RESTORE MESSAGE POINTER RETURN .SBTTL R50ASC: RAD50 TO ASCII CONVERSION ;+ ; INPUT: R1 -> ASCII CHAR OUTPUT AREA ; R3 -> SYMBOL TBL NODE-2 (3 WDS BEYOND WD TO CONVERT) ; USAGE: R2 & R0 = TEMPORARY ; R4 -> DIVISION TABLE ; @SP = # OF CHARACTERS TO BE OUTPUT ; OUTPUT:R3 -> SAME AS INPUT ; R1 -> NEXT FREE OUTPUT BYTE ; CLOBBERS R0 ;- R50ASC: SUB #6,R3 ;BACKUP 3 WDS TO SYMBOL MOV R4,-(SP) ;SAVE R4 & R2 MOV R2,-(SP) MOV #6,-(SP) ;# OF CHARS TO OUTPUT 10$: MOV #DIVTB1,R4 ;R4 -> DIVISION TABLE MOV (R3)+,R2 ;R2 = CURRENT INPUT WORD 20$: TST -(R4) ;NEW WORD REQUIRED YET? BEQ 10$ ;YES CLR R0 ;INITIALIZE QUOTIENT REG 30$: INC R0 ;DIVIDE BY APPROPRIATE POWER OF 50(8) SUB @R4,R2 BCC 30$ DEC R0 ADD @R4,R2 ;RESTORE DIVIDEND TST R0 ;CHARACTER IS A BLANK? BEQ 40$ ;YES CMP #33,R0 ;DOLLAR SIGN, PERIOD, OR DIGIT? BLO 50$ ;PERIOD OR DIGIT BEQ 60$ ;DOLLAR SIGN ADD #40,R0 ;ELSE ALPHA (A-Z) OR QUESTION MARK 40$: ADD #16,R0 50$: ADD #11,R0 60$: ADD #11,R0 70$: MOVB R0,(R1)+ ;STORE CONVERTED CHARACTER IN OUTPUT DEC @SP ;LOOP FOR MORE CHARS BNE 20$ ;YES CMP (SP)+,(R3)+ ;POP CTR & ADD 2 TO R3 MOV (SP)+,R2 MOV (SP)+,R4 RETURN .PSECT DPURE,D .WORD 0 ;END-OF-TABLE FLAG .WORD 1 .WORD 50 .WORD 3100 DIVTB1=. .PSECT CODE .SBTTL OCTOUT: OCTAL TO ASCII OUTPUT ;+ ; R0 = UNSIGNED # TO BE CONVERTED ; R1 -> ADDR OF AREA TO PLACE THE 6 ASCII DIGITS ; A TAB IS LEFT AFTER THE NUMBER & R1 -> TAB CHARACTER ;- OCTOUT: MOVB #30,@R1 SEC ;NOT NEEDED IF C=1 ON ENTRY 10$: ROL R0 ROLB (R1)+ MOVB #206,@R1 20$: ASL R0 BEQ 30$ ;IF 0 THEN DONE ROLB @R1 BCS 20$ BR 10$ 30$: MOVB #TAB,@R1 ;CHANGE 206 TO A TAB RETURN .SBTTL CVT2 - DECIMAL OUTPUT CONVERSION ;+ ; INPUT: R0 = DECIMAL NUMBER ; R1 -> ASCII OUTPUT AREA ; OUTPUT: R0,R3,R4 ARE DESTROYED ; R1 -> NEXT FREE CHARACTER LOCATION ;- CVT2: MOV #DIVTB2,R4 ;SET UP FOR TWO DIGITS 10$: MOVB #'0-1,R3 ;FORM DIGIT IN R3 20$: INC R3 SUB @R4,R0 ;SUBTRACT DIVISOR BHIS 20$ ADD (R4)+,R0 ;RE-ADD THE DIVISOR MOVB R3,(R1)+ ;CONVERTED CHARACTER TST @R4 ;DONE? BNE 10$ ;NO, DO NEXT DIGIT RETURN .PSECT DPURE,D DIVTB2: .WORD 10. .WORD 1 .WORD 0 .PSECT CODE .SBTTL DOUBLE-PRECISION INTEGER DIVISION FOR TIME OUTPUT ; DIVIDES NUMBER IN (R4,R5) BY R3, RETURNING REMAINDER IN R0. .ENABL LSB DIV50: MOV #50.,R3 ;DIVIDE BY 60 BR 10$ DIV60: MOV #60.,R3 ;DIVIDE BY 60 10$: CLR R0 ;INIT REMAINDER MOV #32.,-(SP) ;SHIFT COUNT (16. FOR S.P.) 20$: ASL R5 ;SHIFT AND SUBTRACT ROL R4 ;(NOT NEEDED FOR S.P.) ROL R0 CMP R0,R3 ;SUB OUT DIVISOR ? BLO 30$ ;NO SUB R3,R0 INC R5 ;ADD IN LOW BIT 30$: DEC @SP ;REPEAT COUNT BNE 20$ TST (SP)+ ;POP SHIFT COUNT RETURN .DSABL LSB .PSECT PATCH .BLKW 64. ;PSECT FOR PATCHES .END