.SBTTL INTRODUCTION
	.TITLE	SPG	;LV11 GRAPHIC DESPOOLER TASK
	.IDENT	'V001C'
;
; LV11 (VERSATEC MATRIX LINE PRINTER) GRAPHIC DESPOOLER TASK.
;
; THIS TASK PROVIDES QUASI-DEVICE-INDEPENDENT GRAPHICS CAPABILITIES WHEN
; COMBINED WITH THE RSX11D VIDEO TUBE (VT01) DEVICE HANDLER AND THE
; RSX11D MATRIX LINE PRINTER (LV11) HANDLER WITH PLOTTING CAPABILITIES.
; EFFECTIVELY, THIS TASK ACCEPTS GRAPHIC CONTROL AND TEXT DATA IN THE
; SAME FORMAT AS IS USED BY THE VT01 HANDLER (INCLUDING ARBITRARY X AND
; Y COORDINATES OF POINTS, LINES, AND TEXT TO BE DRAWN), AND CONVERTS IT 
; TO A FORM ACCEPTABLE TO THE LV11 PLOTTING HANDLER (DOT BY DOT LEFT-TO-
; RIGHT, TOP-TO-BOTTOM BLACK OR WHITE INFORMATION USED TO SET THE PROPER
; NIBS AS EACH LINE IS PRINTED).  TO DO THIS, IT MAINTAINS A 512 BY 512
; BIT ARRAY, EACH ELEMENT OF WHICH REPRESENTS THE STATE (BLACK OR WHITE)
; OF A SINGLE POINT ON THE GRAPH (A GIVEN X AND Y COORDINATE IN THE RANGE
; 0 TO 511).  AS INPUT GRAPHIC CONTROL AND TEXT DATA IS PROCESSED, IT 
; SETS THE NECESSARY BITS IN THE ARRAY (SOFTWARE TEXT AND VECTOR 
; GENERATION); WHEN ALL THE DATA FOR ONE PLOT HAS BEEN PROCESSED, THE 
; RESULTING ARRAY IS OUTPUT LINE BY LINE (EACH LINE IS 512 BITS) TO THE
; LV11 FOR PRINTING.  SINCE THE VT01 VIDEO TUBE USES A 2048 BY 2048 UNIT 
; COORDINATE SYSTEM, 11 BIT X AND Y COORDINATES ARE ACCEPTED BUT THE LOW
; 2 BITS ARE IGNORED, PROVIDING 1/4 THE RESOLUTION BUT MAINTAINING 
; COMPATIBILITY.
;
; THE PROCEDURE FOR USING THIS GRAPHIC DESPOOLER IS SIMILAR TO THAT FOR
; THE MULTI-DEVICE DESPOOLER AND QUEUE MANAGER (SPR2.. AND SPR...), BUT
; THE GRAPHIC DESPOOLER (SPG...) IS REQUESTED DIRECTLY BY THE TASK 
; PRODUCING GRAPHIC OUTPUT SO THAT THE QUEUE MANAGER AND SPOOLER QUEUE
; ARE BYPASSED; ALSO, THE GRAPHIC DESPOOLER CAN ONLY SERVICE ONE DEVICE
; AT A TIME.  THE SEQUENCE IS THUS TO WRITE OUT GRAPHIC OUTPUT (IN THE 
; SAME FORM AS WOULD BE ACCEPTED BY THE VT01 HANDLER) TO A MASS STORAGE
; DEVICE FILE; WHEN THE FILE IS CLOSED, THE FILENAME AND OTHER RELEVANT
; DATA ARE SENT TO THE GRAPHIC DESPOOLER BY A VSDR$ (VARIABLE-LENGTH 
; SEND DATA AND REQUEST OR RESUME RECEIVER) DIRECTIVE.  THE DESPOOLER 
; (SPG...) RECEIVES THE DATA SENT VIA A VRCX$ DIRECTIVE (VARIABLE-
; LENGTH RECEIVE DATA OR EXIT IF NONE), OPENS THE FILE FOR INPUT, READS
; AND PROCESSES THE FILE (SETTING BITS IN THE PLOT ARRAY) AND FINALLY 
; WRITES THE CONTENTS OF THE PLOT ARRAY TO THE LV11 HANDLER A LINE AT A 
; TIME BY MEANS OF QIO$ DIRECTIVES WITH A CARRIAGE CONTROL CHARACTER OF 
; "+" (WHICH SELECTS PLOT MODE INSTEAD OF PRINT MODE).  WHEN PROCESSING 
; IS COMPLETED, THE INPUT FILE IS DELETED (UNLESS OTHERWISE INDICATED 
; BY THE REQUESTING TASK).
;

; GRAPHIC AND TEXT DRAWING CAPABILITIES SUPPORTED INCLUDE A 128 
; CHARACTER SET (EXTENDED ASCII), POINT AND LINE (VECTOR) GENERATION,
; VARIABLE TEXT SIZES, POSITIONING OF TEXT AT ARBITRARY X AND Y
; COORDINATES, AND AUTOMATIC STARTING OF A NEW PAGE (NEW PLOT) WHEN A
; LINE FEED BEYOND THE BOTTOM OF THE PAGE OR A FORM FEED IS ENCOUNTERED.
; THE CONTENTS OF THE INPUT FILE IS INTERPRETED AS SUCCESSIVE 7-BIT
; ASCII CHARACTERS (ONE PER BYTE).  PRINTING CHARACTERS (CODES 041 TO
; 176 OCTAL) ARE DRAWN ON THE PLOT STARTING AT THE CURRENT POSITION
; (INITIALLY, THE TOP LEFT CORNER), AND THE CURRENT POSITION IS UPDATED
; (X INCREASED BY ONE CHARACTER WIDTH).  CHARACTER CODES 000 (NUL) AND
; 177 (DEL) ARE IGNORED.  CONTROL CHARACTERS (CODES 001 TO 040 OCTAL)
; CAUSE A SPECIFIC ACTION TO BE TAKEN, AS FOLLOWS:
;
;    CHARACTER  CODE       ACTION TAKEN
;	SOH	001	SET CURRENT POSITION TO TOP LEFT OF PLOT (HOME)
;	STX	002	SET CURRENT POSITION TO TOP RIGHT OF SCREEN
;	ETX	003	IGNORED
;	EOT	004	PLOT CURRENT CONTENTS OF PLOT ARRAY, CLEAR PLOT
;			ARRAY, SET POSITION TOP LEFT AND DEFAULT 
;			CHARACTER SIZE
;	ENQ	005	SET Y POSITION TO TOP OF PLOT
;	ACK	006	IGNORED
;	BEL	007	ADD ONE UNIT TO CURRENT TEXT SIZE
;	BS	010	SET X POSITION BACK ONE CHARACTER SPACE 
;			(BACKSPACE)
;	HT	011	MOVE X POSITION FORWARD TO NEXT TAB STOP
;			(HORIZONTAL TAB)
;	LF	012	SET Y POSITION DOWN ONE LINE (LINE FEED)
;	VT	013	MOVE Y POSITION DOWN TO NEXT TAB STOP (VERTICAL
;			TAB)
;	FF	014	PLOT CURRENT CONTENTS OF PLOT ARRAY, CLEAR PLOT
;			ARRAY, SET Y POSITION TO TOP (FORM FEED)
;	CR	015	SET X POSITION TO LEFT OF PLOT (CARRIAGE RETURN)
;	SO	016	IGNORED
;	SI	017	IGNORED
;	DLE	020	MOVE Y POSITION UP TO PREVIOUS TAB STOP
;	DC1	021	SET Y POSITION UP ONE LINE
;	DC2	022	MOVE X POSITION BACKWARD TO PREVIOUS TAB STOP
;	DC3	023	SET X POSITION TO RIGHT MARGIN OF PLOT
;	DC4	024	SUBTRACT ONE UNIT FROM CURRENT TEXT SIZE
;	NAK	025	IGNORED
;	SYN	026	SET Y POSITION TO BOTTOM OF PLOT
;	ETB	027	RESET CURRENT TEXT SIZE TO DEFAULT (4)
;	CAN	030	PLOT CURRENT CONTENTS OF PLOT ARRAY & CLEAR IT
;	EM	031	SET CURRENT POSITION TO BOTTOM RIGTH OF PLOT
;	SUB	032	SET CURRENT POSITION TO BOTTOM LEFT OF PLOT 
;			(ORIGIN)
;	ESC	033	INTERPRET FOLLOWING CHARACTER AS TEXT (NOT  
;			CONTROL CHARACTER)
;	FS	034	INTERPRET FOLLOWING CHARACTER AS NEW TEXT SIZE
;			INDICATOR
;	GS	035	DRAW LINE (VECTOR) FROM CURRENT POSITION TO POINT
;			INDICATED BY NEXT 4 CHARACTERS (ENDPOINT BECOMES
;			NEW CURRENT POSITION)
;	RS	036	SET CURRENT POSITION TO POINT INDICATED BY NEXT
;			4 CHARACTERS
;	US	037	IGNORE NEXT 4 CHARACTERS (FOR COMPATIBILITY WITH
;			VT01 HANDLER)
;	SP	040	SET X POSITION FORWARD ONE CHARACTER SPACE 
;			(SPACE)
;

; THE "ESC" CHARACTER IS FOLLOWED BY ANY 7 BIT ASCII CHARACTER, WHICH IS
; VISUALIZED AS FOLLOWS: CODES 041 TO 176 (OCTAL) AS USUAL (UPPER AND
; LOWER CASE ASCII); CODE 040 IS A TRIANGLE; CODE 177 IS A SOLID BOX;
; AND CODES 000 TO 037 GENERATE RUNES FROM THE "ANGERTHAS MORIA" (SEE
; J.R.R. TOLKIEN, "THE LORD OF THE RINGS").
;
; THE "FS" CHARACTER IS FOLLOWED BY A CODE IN THE RANGE 101 TO 177
; (BIT 6 MUST BE ON) WHICH SETS THE CURRENT TEXT SIZE TO 1 TO 63
; (DECIMAL); OR BY CODE 100, WHICH SETS THE TEXT SIZE TO THE DEFAULT 
; (4).  CHARACTERS ARE ALWAYS CONSTRUCTED FROM A 5 X 7 GRID OF POINTS
; (THOUGH THE SPACING BETWEEN CHARACTERS IS 7 X 9); THE TEXT SIZE IS THE
; NUMBER OF VT01 UNITS BETWEEN EACH POINT OF THE GRID (BUT NOTE THAT THE
; RESOLUTION OF THE PRINTER IS 4 VT01 UNITS, SO TEXT SIZES NOT MULTIPLES
; OF 4 MAY PRODUCE DISTORTED CHARACTERS DUE TO ROUNDING ERRORS).
;
; THE "GS" AND "RS" CHARACTERS ARE FOLLOWED BY FOUR CHARACTERS WITH BIT
; 6 ON WHICH DEFINE THE X AND Y COORDINATES OF A POINT ON THE PLOT IN
; VT01 UNITS (WHICH RANGE FROM 0 TO 2047 DECIMAL, THOUGH THE LINE 
; PRINTER RESOLUTION IS ONLY 0 TO 511, I.E. 1 IN 4).  THE FOLLOWING 
; FORMAT IS USED:
;
;			BIT 6   5   4   3   2   1   0
;	CHARACTER 1	    1   *  X10  X9  X8  X7  X6
;	CHARACTER 2	    1   X5  X4  X3  X2  X1  X0
;	CHARACTER 3	    1   *  Y10  Y9  Y8  Y7  Y6
;	CHARACTER 4	    1   Y5  Y4  Y3  Y2  Y1  Y0
;
; WHERE "1" INDICATES THE BIT MUST BE ON, "*" INDICATES THE BIT IS
; IGNORED, AND X10-X0 IS THE 11 BIT X COORDINATE, Y10-Y0 IS THE 11 BIT
; Y COORDINATE.
;
; THE DESPOOLER TASK SUPPORTS FILES WITH NO CARRIAGE CONTROL, WITH
; IMPLIED CARRIAGE CONTROL (FD.CR), OR WITH FORTRAN CARRIAGE CONTROL
; (FD.FTN).  IN THE LAST CASE, ALL CARRIAGE CONTROL CHARACTERS (NULL,
; SPACE, +, 1, 0, AND $) ARE ACCEPTED.  THE RECORD SIZE OF THE INPUT FILE
; CANNOT EXCEED 150 BYTES; HOWEVER, ONLY 73 CHARACTERS OF STANDARD SIZE
; WILL FIT ON ONE LINE.
;

; THE FORMAT OF THE PARAMETER BLOCK RECEIVED BY THE GRAPHIC DESPOOLER
; TASK BY THE VRCX$ DIRECTIVE IS AS FOLLOWS:
;
TASKN	=	0		;WD. 00 (B 00)--TASK NAME OF SENDER
				;WD. 01 (B 02)--SECOND HALF OF NAME
SPDEV	=	4		;WD. 02 (B 04)--DEVICE NAME OF PRINTER
SPUNIT	=	6		;WD. 03 (B 06)--UNIT NUMBER OF PRINTER
PRIO	=	7		;	(B 07)--PRIORITY OF PRINT REQUEST
COPS	=	10		;WD. 04 (B 10)--NO. OF COPIES TO PRINT
				;		(LOW 5 BITS) AND FORM 
				;		NUMBER (HIGH 3 BITS)
FLGS	=	11		;	(B 11)--FLAGS BYTE
DVNM	=	12		;WD. 05 (B 12)--DEVICE NAME FOR FILE
UNIT	=	14		;WD. 06 (B 14)--UNIT NO. FOR INPUT FILE
DID	=	16		;WD. 07 (B 16)--DIRECTORY ID OF FILE
				;WD. 10 (B 20)--(SECOND WORD)
				;WD. 11 (B 22)--(THIRD WORD)
FNAM	=	24		;WD. 12 (B 24)--FILE NAME OF INPUT FILE
				;WD. 13 (B 26)--(SECOND WORD)
				;WD. 14 (B 30)--(THIRD WORD)
FTYP	=	32		;WD. 15 (B 32)--FILE TYPE OF INPUT FILE
FVER	=	34		;WD. 16 (B 34)--VERSION NO. OF FILE
PRMLEN	=	36		;LENGTH OF PARAMETER BLOCK
;
; THE FORMAT OF THE DATA BLOCK SENT BY THE VSDR$ DIRECTIVE IS THE
; SAME EXCEPT THAT THE TASK NAME (FIRST 2 WORDS) IS NOT INCLUDED.
; NOTE THAT THE PRIORITY AND FORMS NUMBER ARE PRESENT ONLY FOR 
; COMPATIBILITY WITH THE MULTI-DEVICE OUTPUT DESPOOLER AND ARE
; IGNORED BY THE GRAPHIC DESPOOLER.
;
; BITS DEFINED IN THE FLAGS BYTE ARE AS FOLLOWS:
;
GRPH	=	200		;[07] GRAPHIC DESPOOLING REQUESTED
PRSV	=	100		;[06] PRESERVE (DON'T DELETE) INPUT FILE
DBLE	=	040		;[05] DOUBLE SIZE PLOT (1024 X 1024)
;
; THE DOUBLE SIZE OPTION ALLOWS A BIGGER GRAPH TO BE PRODUCED (ONE
; FULL PAGE WIDTH, INSTEAD OF THE USUAL HALF-PAGE WIDTH) WITHOUT, 
; HOWEVER, CHANGING THE RESOLUTION; EACH DOT IN THE PLOT IS SIMPLY
; PRINTED AS 4 DOTS IN A SQUARE.
;
; LINKS TO SGAS:
; (4K) RO LIBRARY: SYSRES -- FOR FCS ROUTINES
;
; TASK ATTRIBUTES: /AB /CP /DS /-FP /FX /HD /-MU /-PI /-PR /-TA /-TR
;
; LUN ASSIGNMENTS:
; SY:1 (INPUT FILE)
; LP:2 (OUTPUT PRINTER)
;
; TASKNAME:   SPG...
; PARTITION:  GEN
; POOL LIMIT: 40
; PRIORITY:   70 (SO AS NOT TO INTERFERE WITH THE VT01 HANDLER)
; STACK:      256
; UIC:        [1,1]
; UNITS:      2 (PLUS "MO")
;

	.SBTTL SYMBOL DEFINITIONS
;
; MACRO CALLS:
; RSXMAC:
	.MCALL	CALL,VRCX$S,ALUN$S,QIOW$S,WSIG$S,MOUT$S
	.MCALL	FSRSZ$,FDBDF$,FDRC$A,FDOP$A,FDBF$A
	.MCALL	FINIT$,OFNB$R,CLOSE$,DELET$,GET$
;
; DEFINITIONS:
;
INLUN	=	1		;INPUT FILE LUN
OUTLUN	=	2		;PRINT OUTPUT LUN
;
INEF	=	1		;INPUT FILE I/O EVENT FLAG
OUTEF	=	2		;PRINT OUTPUT I/O EVENT FLAG
;
DEFSIZ	=	4		;DEFAULT TEXT GRID SIZE IN VT01 UNITS
SCRSZX	=	2048.		;PLOT SIZE IN X DIRECTION (VT01 UNITS)
SCRSZY	=	2048.		;PLOT SIZE IN Y DIRECTION (VT01 UNITS)
TABX	=	8.		;NO. OF SPACES PER HORIZONTAL TAB
TABY	=	6		;NO. OF SPACES PER VERTICAL TAB
CXSPAC	=	7		;CHARACTER X SPACING
CYSPAC	=	9.		;CHARACTER Y SPACING
CWID	=	5		;CHARACTER GRID WIDTH
NLINES	=	512.		;NO. OF LINES OF NIBS IN ONE PLOT
NCOLS	=	64.		;NO. OF COLUMNS OF NIBS IN ONE LINE
LINLEN	=	150.		;MAXIMUM LINE LENGTH IN INPUT FILE
;
LF	=	12		;ASCII CODE FOR LINE FEED
FF	=	14		;ASCII CODE FOR FORM FEED
CR	=	15		;ASCII CODE FOR CARRIAGE RETURN
SPA	=	40		;ASCII CODE FOR SPACE
DEL	=	177		;ASCII CODE FOR DELETE (RUBOUT)
;
	FSRSZ$	1		;RESERVE SPACE FOR ONE OPEN FILE
;
; READ-ONLY INSTRUCTION AREA:
;
	.PSECT	SPGRO,RO
;

	.SBTTL INITIALIZATION CODE, MAINLINE CODE, AND TERMINATION
;
START::	FINIT$			;INITIALIZE FCS
GETFIL:	MOV	#PARMS,R5	;ADDRESS OF SPOOL FILE PARAMETER BLK
	VRCX$S	,R5		;RECEIVE PARAMETERS OR EXIT IF NONE
	BCC	1$		;WORKED!
	JSR	PC,DSWERR	;FAILED, PRINT ERROR MESSAGE
	BR	GETFIL		;TRY AGAIN
1$:	MOVB	COPS(R5),COPIES	;GET NUMBER OF COPIES TO PRINT
	BIC	#177740,COPIES	;RESTRICT TO 5 BITS
	MOVB	SPUNIT(R5),R4	;GET PRINTER DEVICE UNIT NO.
	ALUN$S	#OUTLUN,SPDEV(R5),R4;ASSIGN LUN FOR PRINTER
	BCC	2$		;WORKED OK
	JSR	PC,DSWERR	;PRINT ERROR CODE
	BR	GETFIL		;DO NEXT REQUEST
2$:	QIOW$S	#IO.ATT,#OUTLUN,#OUTEF,,#IOSB;ATTACH PRINTER DEVICE
	BCC	3$		;NO PROBLEMS IN QUEUING
	JSR	PC,DSWERR	;FAILED
	BR	GETFIL
3$:	TSTB	IOSB		;DID ATTACH WORK?
	BPL	5$		;YES
	CMPB	IOSB,#IE.DAA	;IS DEVICE ALREADY ATTACHED?
	BNE	4$		;NO, OTHER PROBLEMS
	WSIG$S			;YES, WAIT A WHILE
	BR	2$		;TRY AGAIN
4$:	JSR	PC,QIOERR	;TELL PEOPLE
	BR	GETFIL
5$:	MOV	#INFDB+F.FNB,R4	;ADDRESS OF FILE NAME BLOCK
	MOV	DVNM(R5),N.DVNM(R4);SET UP SPOOL DEVICE NAME,
	MOV	UNIT(R5),N.UNIT(R4);UNIT NUMBER,
	MOV	DID(R5),N.DID(R4);DIRECTORY ID,
	MOV	DID+2(R5),N.DID+2(R4)
	MOV	DID+4(R5),N.DID+4(R4)
	MOV	FNAM(R5),N.FNAM(R4);FILE NAME,
	MOV	FNAM+2(R5),N.FNAM+2(R4)
	MOV	FNAM+4(R5),N.FNAM+4(R4)
	MOV	FTYP(R5),N.FTYP(R4);FILE TYPE,
	MOV	FVER(R5),N.FVER(R4);AND FILE VERSION
	OFNB$R	#INFDB		;OPEN FILE BY FNB FOR READING
	BCC	6$		;WORKED OK
	JSR	PC,FDBERR	;CAN'T OPEN FILE, COMPLAIN
	BR	DETACH		;QUIT
6$:	MOV	SP,SAVESP	;SAVE STACK POINTER

BEGIN:	CLR	COUNTR		;CLEAR LINE CHARACTER COUNT
	CLRB	CRFLAG		;NO CARRIAGE RETURN NEEDED
	JSR	PC,RESSIZ	;RESET CHARACTER SIZE TO DEFAULT
	JSR	PC,TOPLFT	;GO TO TOP LEFT OF PLOT
	JSR	PC,CLRNBS	;CLEAR NIBS ARRAY
NEXT:	JSR	PC,GETCHR	;GET NEXT CHARACTER
	CMP	R0,#DEL		;IS IT A RUBOUT?	
	BEQ	NEXT		;YES, IGNORE IT
	CMP	R0,#SPA		;IS IT A CONTROL CHARACTER?
	BGT	1$		;NO, IT'S PRINTABLE
	ASL	R0		;MAKE IT A WORD OFFSET
	JSR	PC,@CNTRLS(R0)	;DISPATCH TO SUBROUTINE FROM TABLE
	BR	NEXT
1$:	JSR	PC,TEXT		;OUTPUT TEXT CHARACTER
	BR	NEXT
DONE:	JSR	PC,PLTOUT	;PLOT OUT CONTENTS OF NIB ARRAY
	DEC	COPIES		;COUNT ANOTHER COPY FINISHED
	BLE	1$		;DONE THEM ALL
	MOV	#INFDB,R0	;ADDRESS OF INPUT FDB
	CLR	R1		;HIGH ORDER BLOCK NO. ZERO
	MOV	#1,R2		;LOW ORDER BLOCK NO. 1
	CLR	R3		;BYTE OFFSET ZERO
	CALL	.POINT		;POINT TO BEGINNING OF FILE
	BCC	BEGIN		;SUCCEEDED
	JSR	PC,FDBERR	;FAILED, TELL PEOPLE
1$:	MOV	#PARMS,R5	;ADDRESS OF PARAMETER BLOCK
	BITB	#PRSV,FLGS(R5)	;IS PRESERVE FLAG ON?
	BEQ	2$		;NO
	CLOSE$	#INFDB		;YES, JUST CLOSE FILE
	BR	3$		
2$:	DELET$	#INFDB		;DELETE SPOOL FILE
3$:	BCC	DETACH		;WORKED
	JSR	PC,FDBERR	;PRINT ERROR CODE
DETACH:	QIOW$S	#IO.DET,#OUTLUN,#OUTEF,,#IOSB;DETACH PRINTER DEVICE
	BCC	1$		;QUEUE I/O WORKED OK
	JSR	PC,DSWERR	;FAILED, PRINT ERROR
	BR	2$		;NEXT REQUEST
1$:	TSTB	IOSB		;DID DETACH SUCCEED?
	BPL	2$		;YES, DONE
	JSR	PC,QIOERR	;PRINT ERROR MESSAGE
2$:	JMP	GETFIL		;DO ANOTHER REQUEST
;

	.SBTTL SUBROUTINE GETCHR -- GET NEXT CHARACTER FOR OUTPUT
;
; THIS ROUTINE RETURNS WITH R0 = CHARACTER CODE (MASKED TO 7 BITS)
;
GETCHR:	MOV	R3,-(SP)	;SAVE REGISTERS
	MOV	R4,-(SP)
	DEC	COUNTR		;COUNT ANOTHER CHARACTER
	BGT	NEWCHR		;STILL MORE, GET NEXT ONE FROM BUFFER
GETLIN:	TSTB	CRFLAG		;END OF BUFFER, NEED TO APPEND CR?
	BEQ	1$		;NO
	CLRB	CRFLAG		;NO CARRIAGE RETURN NEEDED ANY MORE
	MOVB	#CR,R0		;YES, GET CARRIAGE RETURN
	BR	XIT		;AND EXIT WITH IT
1$:	GET$	#INFDB		;GET NEXT LINE FROM FILE
	BCC	3$		;NO PROBLEMS
	CMPB	F.ERR(R0),#IE.EOF;REACHED END OF FILE?
	BEQ	2$		;YES, DONE
	JSR	PC,FDBERR	;NO, MORE SERIOUS ERROR (TELL PEOPLE)
2$:	MOV	SAVESP,SP	;RESTORE STACK TO START POINT
	BR	DONE		;FINISH UP
3$:	MOV	F.NRBD+2(R0),POINTR;SET BUFFER POINTER
	MOV	F.NRBD(R0),COUNTR;SET CHARACTER COUNT
	CLRB	LFFLAG		;NO LINE FEED NEEDED
	BITB	#FD.CR,F.RATT(R0);NORMAL CARRIAGE CONTROL?
	BNE	LFCR		;YES
	BITB	#FD.FTN,F.RATT(R0);FORTRAN CARRIAGE CONTROL?
	BEQ	NEWCHR		;NO CARRIAGE CONTROL
	MOVB	@POINTR,R0	;GET CARRAGE CONTROL (FIRST BYTE)
	INC	POINTR		;SKIP PAST IT
	DEC	COUNTR		;COUNT DOWN BUFFER SIZE
	MOV	#CARCTL,R4	;START OF CARRIAGE CONTROL TABLE
	MOV	#NCARCT,R3	;NO. OF CHARACTERS RECOGNIZED
4$:	CMPB	R0,(R4)+	;IS THIS THE ONE?
	BEQ	5$		;YES
	SOB	R3,4$		;NO, TRY THEM ALL

5$:	ASL	R3		;CONVERT INDEX TO WORD OFFSET
	ADD	R3,PC		;DISPATCH TO PROPER PLACE
	BR	LFCR		;SPACE OR OTHER
	BR	FFCR		;"1"
	BR	L2CR		;"0"
	BR	XXCR		;"+"
	BR	LFXX		;"$"
	BR	NEWCHR		;NULL
L2CR:	INCB	LFFLAG		;SET "EXTRA LINEFEED NEEDED" FLAG
	INC	COUNTR		;INCLUDE IT IN CHARACTER COUNT
LFCR:	MOVB	#LF,R0		;BEGIN WITH A LINE FEED
	BR	SETCR
FFCR:	MOVB	#FF,R0		;BEGIN WITH A FORM FEED
SETCR:	INCB	CRFLAG		;SET "CARRIAGE RETURN AT END" FLAG
	BR	UPCNT
LFXX:	MOVB	#LF,R0		;BEGIN WITH A LINE FEED
UPCNT:	INC	COUNTR		;INCLUDE STARTING CHARACTER IN COUNT
	BR	XIT
XXCR:	INCB	CRFLAG		;SET "CARRIAGE RETURN AT END" FLAG
NEWCHR:	TSTB	LFFLAG		;NEED A SECOND LINE FEED?
	BEQ	1$		;NO
	CLRB	LFFLAG		;YES, RESET FLAG
	MOVB	#LF,R0		;DELIVER A LINE FEED
	BR	XIT
1$:	TST	COUNTR		;ANY CHARACTERS LEFT?
	BLE	GETLIN		;NO
	MOVB	@POINTR,R0	;GET NEXT CHARACTER FROM BUFFER
	INC	POINTR		;ADVANCE BUFFER POINTER
XIT:	BIC	#177600,R0	;MASK DOWN TO 7 BITS
	MOV	(SP)+,R4	;RESTORE REGISTERS
	MOV	(SP)+,R3
	RTS	PC		;RETURN
;

	.SBTTL SUBROUTINES TO IMPLEMENT CONTROL CHARACTERS
;
; SUBROUTINE RESSIZ -- RESET CHARACTER SIZE TO DEFAULT
;
RESSIZ:	MOV	#DEFSIZ,TXTSIZ	;SET DEFAULT TEXT SIZE
	RTS	PC
;
; SUBROUTINE INCSIZ -- INCREMENT CHARACTER SIZE
;
INCSIZ:	INC	TXTSIZ		;ADD ONE TO TEXT SIZE
	RTS	PC
;
; SUBROUTINE DECSIZ -- DECREMENT CHARACTER SIZE
;
DECSIZ:	DEC	TXTSIZ		;SUBTRACT ONE FROM TEXT SIZE
	BGT	1$		;STILL NON-ZERO
	MOV	#1,TXTSIZ	;CAN'T GO BELOW 1
1$:	RTS	PC
;
; SUBROUTINES TOPLFT (SET POSITION TO TOP LEFT), LEFT (SET X POSITION
; TO LEFT), AND NULL
; NOTE: R1 IS MODIFIED BY ROUTINE TOPLFT.
;
TOPLFT:	JSR	PC,TOP		;SET Y TO TOP OF PLOT
LEFT:	CLR	XPOS		;SET X TO LEFT MARGIN
NULL:	RTS	PC		;RETURN
;
; SUBROUTINES TOPRGT (SET POSITION TO TOP RIGHT), RIGHT (SET X POSITION
; TO RIGHT), AND DECX (SUBTRACT CHARACTER WIDTH FROM X).
; NOTE: R1 IS MODIFIED BY THESE ROUTINES.
; 
TOPRGT:	JSR	PC,TOP		;SET Y TO TOP OF PLOT
RIGHT:	MOV	#SCRSZX,XPOS	;GET SCREEN WIDTH
DECX:	JSR	PC,XSIZE	;SET R1 = CHARACTER WIDTH
	SUB	R1,XPOS		;GO BACK ONE CHARACTER
	RTS	PC
;
; SUBROUTINE BOTLFT -- SET POSITION TO BOTTOM LEFT OF PLOT
;
BOTLFT:	CLR	XPOS		;SET X TO LEFT MARGIN
	CLR	YPOS		;SET Y TO BOTTOM
	RTS	PC
;
; SUBROUTINES BOTRGT (SET POSITION TO BOTTOM RIGHT) AND BOTTOM (SET
; Y POSITION TO BOTTOM)
; NOTE: R1 IS MODIFIED BY ROUTINE BOTRGT.
;
BOTRGT:	JSR	PC,RIGHT	;SET X TO RIGHT MARGIN
BOTTOM:	CLR	YPOS		;SET Y TO BOTTOM
	RTS	PC
;

; SUBROUTINE TOP (SET Y POSITION TO TOP) AND DECY (SUBTRACT 
; CHARACTER HEIGHT FROM Y).
; NOTE: R1 IS MODIFIED BY THESE ROUTINES.
;
TOP:	MOV	#SCRSZY,YPOS	;SET Y TO TOP OF SCREEN
DECY:	JSR	PC,YSIZE	;SET R1 = CHARACTER HEIGHT
	SUB	R1,YPOS		;GO DOWN ONE LINE
	RTS	PC
;
; SUBROUTINE BACKSP -- MOVE X POSITION BACK ONE CHARACTER SPACE
; NOTE: R1 IS MODIFIED BY THIS ROUTINE
;
BACKSP:	JSR	PC,DECX		;SUBTRACT CHARACTER WIDTH FROM X
	BGE	1$		;STILL OK
	CLR	XPOS		;TOO SMALL, SET LEFT MARGIN
1$:	RTS	PC
;
; SUBROUTINES UPLINE (MOVE Y POSITION UP ONE LINE) AND TESTY (RESET
; Y TO TOP IF VALUE EXCEED MAXIMUM).
; NOTE: R1 AND R3 ARE MODIFIED BY THESE ROUTINES.
;
UPLINE:	JSR	PC,YSIZE	;SET R1 = CHARACTER HEIGHT
	ADD	R1,YPOS		;GO UP ONE LINE
TESTY:	MOV	#SCRSZY,R3	;GET SCREEN HEIGHT
	SUB	R1,R3		;UP TOO HIGH?
	BLE	1$		;NO, OK
	MOV	R3,YPOS		;YES, SET MAXIMUM
1$:	RTS	PC
;
; SUBROUTINES LINEFD (MOVE Y POSITION DOWN ONE LINE) AND FORMFD
; (START A NEW PAGE)
; NOTE: ALL REGISTERS ARE MODIFIED BY THESE ROUTINES
;
LINEFD:	JSR	PC,DECY		;SUBTRACT CHARACTER HEIGHT FROM Y
	BGE	FFRET		;HAVEN'T REACHED BOTTOM YET
FORMFD:	JSR	PC,TOP		;GO TO TOP OF PLOT
	JSR	PC,PLTOUT	;PLOT OUT CURRENT PAGE AND START ANOTHER
FFRET:	RTS	PC
;
; SUBROUTINE INIT (INITIALIZE FOR A NEW PLOT)
; NOTE: ALL REGISTERS ARE MODIFIED BY THIS ROUTINE
;
INIT:	JSR	PC,RESSIZ	;RESET CHARACTER SIZE TO DEFAULT
	JSR	PC,TOPLFT	;SET POSITION TO TOP LEFT OF PLOT
	JSR	PC,PLTOUT	;PLOT OUT CURRENT PAGE & START NEW ONE
	RTS	PC
;

; SUBROUTINE TAB -- MOVE X FORWARD TO NET TAB STOP
; NOTE: R1, R2, R3, AND R5 ARE MODIFIED BY THIS ROUTINE
;
TAB:	JSR	PC,XSIZE	;SET R1 = CHARACTER WIDTH
	MOV	R1,R5		;SAVE IT
	MUL	#TABX,R5	;TIMES NO. OF CHARACTERS IN ONE TAB
	MOV	XPOS,R3		;GET CURRENT X POSITION
	ADD	R5,R3		;ADD ONE TAB LENGTH
	CLR	R2		;(HIGH ORDER ZERO)
	DIV	R5,R2		;DIVIDE BY TAB LENGTH
	MUL	R2,R5		;TIMES TAB LENGTH AGAIN
	MOV	R5,XPOS		;NEW X POSITION
	JSR	PC,TESTX	;SET TO RIGHT MARGIN IF PAST IT
	RTS	PC
;
; SUBROUTINE VERTAB -- MOVE Y DOWN TO NEXT TAB STOP
; NOTE: REGISTERS R0, R1, R2, AND R3 ARE MODIFIED BY THIS ROUTINE
;
VERTAB:	JSR	PC,YSIZE	;SET R1 = CHARACTER HEIGHT
	MUL	#TABY,R1	;MULTIPLY BY NO. OF LINES IN ONE TAB
	MOV	YPOS,R3		;GET CURRENT Y POSITION
	DEC	R3		;MINUS ONE UNIT
	CLR	R2		;(HIGH ORDER ZERO)
	DIV	R1,R2		;DIVIDE BY TAB DISTANCE
	MUL	R2,R1		;MULTIPLY BY TAB DISTANCE
	MOV	R1,YPOS		;SET NEW Y POSITION
	BGE	1$		;STILL ABOVE BOTTOM OF PAGE
	JSR	PC,FORMFD	;START A NEW PAGE
1$:	RTS	PC
;
; SUBROUTINE BKTAB -- MOVE X BACK TO PREVIOUS TAB STOP.
; NOTE: R1, R2, AND R3 ARE MODIFIED BY THIS ROUTINE.
;
BKTAB:	JSR	PC,XSIZE	;SET R1 = CHARACTER WIDTH
	MUL	#TABX,R1	;TIMES NO. OF CHARACTERS IN ONE TAB
	MOV	XPOS,R3		;GET CURRENT X POSITION
	DEC	R3		;MINUS ONE UNIT
	CLR	R2		;(HIGH ORDER ZERO)
	DIV	R1,R2		;DIVIDE BY TAB LENGTH
	MUL	R2,R1		;MULTIPLY BY IT AGAIN
	MOV	R1,XPOS		;SET NEW X POSITION
	BGE	1$		;NOT AT LEFT MARGIN YET
	CLR	XPOS		;TOO SMALL, SET IT TO LEFT MARGIN
1$:	RTS	PC
;

; SUBROUTINE UPTAB -- MOVE Y UPWARD TO PREVIOUS TAB STOP
; NOTE: R1, R2, R3, AND R5 ARE MODIFIED BY THIS ROUTINE
;
UPTAB:	JSR	PC,YSIZE	;SET R1 = CHARACTER HEIGHT
	MOV	R1,R5		;SAVE IT
	MUL	#TABY,R5	;MULTIPLY BY NO. OF LINES IN ONE TAB
	MOV	YPOS,R3		;GET CURRENT Y POSITION
	ADD	R5,R3		;MOVE UP BY TAB DISTANCE
	CLR	R2		;(HIGH ORDER ZERO)
	DIV	R5,R2		;DIVIDE BY TAB DISTANCE
	MUL	R2,R5		;MULTIPLY BY IT AGAIN
	MOV	R5,YPOS		;SET NEW Y POSITION
	JSR	PC,TESTY	;IF TOO BIG, SET TO TOP OF PLOT
	RTS	PC
;
; SUBROUTINE ESCAPE -- TREAT NEXT CHARACTER AS TEXT TO DISPLAY
; NOTE: ALL REGISTERS ARE MODIFIED BY THIS ROUTINE
;
ESCAPE:	JSR	PC,GETCHR	;GET NEXT CHARACTER INTO R0
	JSR	PC,TEXT		;DISPLAY IT
	RTS	PC
;
; SUBROUTINE SETSIZ -- SET CHARACTER SIZE TO GIVEN VALUE
; NOTE: R0 IS MODIFIED BY THIS ROUTINE
;
SETSIZ:	JSR	PC,GETCHR	;GET NEXT CHARACTER INTO R0
	BITB	#100,R0		;MAKE SURE BIT 6 IS ON
	BEQ	SETSIZ		;IF NOT, IGNORE IT
	BIC	#177700,R0	;RESTRICT TO RANGE 0 TO 63
	BNE	1$		;NON-ZERO
	MOV	#DEFSIZ,R0	;ZERO IMPLIES DEFAULT
1$:	MOV	R0,TXTSIZ	;SET TEXT SIZE
	RTS	PC
;
; SUBROUTINE MOVE -- SET NEW CURRENT PLOT POSITION
; NOTE: R0 AND R5 ARE MODIFIED BY THIS ROUTINE
;
MOVE:	JSR	PC,GET2C	;GET X COORDINATE INTO R5
	MOV	R5,XPOS		;SET X POSITION
	JSR	PC,GET2C	;GET Y COORDINATE INTO R5
	MOV	R5,YPOS		;SET Y POSITION
	RTS	PC
;

; SUBROUTINE GET2C -- GET 2 CHARACTERS AND CONVERT THEM TO 11
; BIT COORDINATE
; R0 IS MODIFIED BY THIS ROUTINE.  R5 CONTAINS COORDINATE ON EXIT.
;
GET2C:	JSR	PC,GETCHR	;GET NEXT CHARACTER INTO R0
	BITB	#100,R0		;CHECK THAT BIT 6 IS ON
	BEQ	GET2C		;IF NOT, IGNORE IT
	ASH	#6,R0		;SHIFT LEFT 6 BITS
	BIC	#174077,R0	;MASK OUT HIGH ORDER 5 BITS
	MOV	R0,R5		;SAVE IT
1$:	JSR	PC,GETCHR	;GET ANOTHER CHARACTER INTO R0
	BITB	#100,R0		;CHECK BIT 6
	BEQ	1$		;IF ZERO, TRY AGAIN
	BIC	#177700,R0	;MASK OUT LOW ORDER 6 BITS
	BIS	R0,R5		;COMBINE WITH HIGH ORDER
	RTS	PC
;
; SUBROUTINE XSIZE -- GET CHARACTER WIDTH IN VT01 UNITS
; RETURNS WITH RESULT IN R1.
;
XSIZE:	MOV	TXTSIZ,R1	;GET TEXT SIZE
	MUL	#CXSPAC,R1	;TIMES CHARACTER X SPACING
	RTS	PC
;
; SUBROUTINE YSIZE -- GET CHARACTER HEIGHT IN VT01 UNITS
; RETURNS WITH RESULT IN R1.
;
YSIZE:	MOV	TXTSIZ,R1	;GET TEXT SIZE
	MUL	#CYSPAC,R1	;TIMES CHARACTER Y SPACING
	RTS	PC
;
; SUBROUTINE IGNORE -- IGNORE NEXT 4 CHARACTERS
; R0 AND R5 ARE MODIFIED BY THIS ROUTINE
;
IGNORE:	JSR	PC,GET2C	;GET 2 CHARACTERS...
	JSR	PC,GET2C	;...TWICE
	RTS	PC
;

	.SBTTL SUBROUTINES TEXT, SPACE, AND TESTX
;
; SUBROUTINE TEXT DISPLAYS THE CHARACTER WHOSE CODE IS IN R0. (MODIFIES
; ALL REGISTERS).
; SUBROUTINE SPACE MOVES X FORWARD ONE CHARACTER SPACE. (MODIFIES R1 AND
; R3).
; SUBROUTINE TESTX SETS X TO THE RIGHT MARGIN IF IT EXCEEDS IT.
; (MODIFIES R1 AND R3).
;
TEXT:	MOV	R0,R3		;GET CHARACTER CODE
	MOV	#CWID,R2	;SET CHARACTER GRID WIDTH
	MUL	R2,R3		;MULTIPLY CODE BY BYTES IN ONE CHARACTER
	ADD	#CHRTBL,R3	;ADD START OF CHARACTER TABLE
	MOV	XPOS,R4		;GET STARTING X POSITION
	CLR	-(SP)		;RESERVE SPACE ON STACK
1$:	MOV	YPOS,R5		;SET STARTING (BOTTOM) Y POSITION
	MOVB	(R3)+,(SP)	;GET MASK BYTE FOR THIS X POSITION
2$:	BEQ	4$		;NO MORE POINTS LEFT IN THIS MASK
	BPL	3$		;DON'T DISPLAY THIS POINT
	MOV	R5,R0		;GET Y COORDINATE
	ASH	#-2,R0		;CONVERT TO 9 BIT FORM FOR PRINTER
	MOV	R4,R1		;GET X COORDINATE
	ASH	#-2,R1		;MAKE IT 9 BITS TOO
	JSR	PC,SETNIB	;SET THE PROPER NIB AT THAT X & Y
3$:	ADD	TXTSIZ,R5	;GO UP ONE GRID POINT
	ASLB	(SP)		;GET NEXT BIT IN MASK
	BR	2$		;LOOP
4$:	ADD	TXTSIZ,R4	;GO RIGHT ONE GRID POINT
	SOB	R2,1$		;DO ALL HORIZONTAL POSITIONS
	TST	(SP)+		;CLEAN UP STACK
SPACE:	JSR	PC,XSIZE	;SET R1 = CHARACTER WIDTH
	ADD	R1,XPOS		;MOVE RIGHT ONE SPACE
TESTX:	MOV	#SCRSZX,R3	;GET SCREEN WIDTH
	SUB	R1,R3		;MINUS ONE CHARACTER WIDTH
	CMP	XPOS,R3		;PAST RIGHT MARGIN?
	BLE	1$		;NO, OK
	MOV	R3,XPOS		;YES, SET TO RIGHT MARGIN
1$:	RTS	PC
;

	.SBTTL SUBROUTINE VECTOR -- DRAW VECTOR BETWEEN TWO POINTS
;
; THIS ROUTINE DRAWS A LINE FROM THE CURRENT POSITION TO A SPECIFIED
; POINT (WHICH BECOMES THE NEW CURRENT POSITION).  THE CODE IS
; OPTIMIZED FOR THE SPECIAL CASES OF A POINT, A HORIZONTAL OR VERTICAL 
; LINE, OR A DIAGONAL LINE.
;
; ALL REGISTERS ARE MODIFIED BY THIS ROUTINE.
;
VECTOR:	ASR	XPOS		;CONVERT CURRENT X POSITION...
	ASR	XPOS		;...TO 9 BIT PRINTER FORMAT
	ASR	YPOS		;DO SAME FOR Y
	ASR	YPOS
	JSR	PC,GET2C	;GET X COORDINATE OF ENDPOINT
	MOV	R5,R4		;SAVE IT IN R4
	MOV	R4,-(SP)	;PUSH IT ON STACK FOR LATER
	ASH	#-2,R4		;CONVERT IT TO 9 BIT PRINTER FORMAT
	JSR	PC,GET2C	;GET Y COORDINATE OF ENDPOINT
	MOV	R5,-(SP)	;SAVE IT ON STACK ALSO
	ASH	#-2,R5		;CONVERT IT TO 9 BITS TOO
	MOV	R4,R2		;GET FINAL X
	MOV	R5,R3		;ALSO FINAL Y
	SUB	XPOS,R2		;FIND DELTA X
	BNE	4$		;NON-ZERO
	MOV	YPOS,R2		;GET STARTING Y POSITION
	SUB	R2,R3		;CALCULATE DELTA Y
	BNE	1$		;NON-ZERO
	MOV	R4,R1		;IT'S A POINT: SET X VALUE
	MOV	R5,R0		;ALSO Y VALUE
	JSR	PC,SETNIB	;TURN ON PROPER NIB
	BR	7$		;ALL DONE
1$:	BGT	2$		;FINAL Y BIGGER THAN INITIAL
	NEG	R3		;OTHER WAY AROUND: NEGATE DELTA Y
	MOV	R5,R2		;START AT FINAL Y POSITION
2$:	INC	R3		;ADD ONE FOR LOOP COUNT
3$:	MOV	R2,R0		;SET Y VALUE
	MOV	R4,R1		;SET X VALUE
	JSR	PC,SETNIB	;TURN ON NIB AT THAT X & Y
	INC	R2		;GO TO NEXT Y
	SOB	R3,3$		;DO ALL
	BR	7$		;ALL DONE
4$:	SUB	YPOS,R3		;CALCULATE DELTA Y
	BNE	ANGLED		;NON-ZERO (ANGLED LINE)
	MOV	XPOS,R3		;GET STARTING X POSITION
	TST	R2		;IS FINAL X BIGGER THAN INITIAL?
	BGT	5$		;YES
	NEG	R2		;NO, NEGATE DELTA X
	MOV	R4,R3		;START AT FINAL X POSITION
5$:	INC	R2		;ADD ONE FOR LOOP COUNT
6$:	MOV	R5,R0		;SET Y COORDINATE
	MOV	R3,R1		;ALSO X
	JSR	PC,SETNIB	;TURN ON A NIB
	INC	R3		;GO TO NEXT X POSITION
	SOB	R2,6$		;DO ALL OF THEM
7$:	BR	VECEND		;DONE

ANGLED:	MOV	R4,-(SP)	;PUSH FINAL X
	MOV	R5,-(SP)	;PUSH FINAL Y
	MOV	R2,R4		;GET DELTA X
	SXT	R2		;NOW R2=-1 IF NEGATIVE, 0 IF POSITIVE
	BPL	1$		;FINAL X IS BIGGER THAN INITIAL
	NEG	R4		;OTHER WAY, NEGATE DELTA X
1$:	MOV	R3,R5		;GET DELTA Y
	SXT	R3		;NOW R3=-1 IF NEGATIVE, 0 IF POSITIVE
	BPL	2$		;FINAL Y IS BIGGER THAN INITIAL
	NEG	R5		;OTHER WAY, NEGATE DELTA Y
2$:	BIS	#1,R2		;NOW R2=+1 OR -1 (SIGN OF DELTA X)
	BIS	#1,R3		;NOW R3=+1 OR -1 (SIGN OF DELTA Y)
	CLR	-(SP)		;SET FLAG FOR X IS LONG LEG
	CMP	R4,R5		;BUT IS IT?
	BGT	XLONG		;YES, ABS(DELTA X) .GT. ABS(DELTA Y)
	INC	(SP)		;NO, SET FLAG FOR Y IS LONG LEG
	MOV	R3,-(SP)	;PUSH SIGN OF DELTA Y
	TST	R2		;IS DELTA X POSITIVE?
	BGT	3$		;YES
	NEG	(SP)		;NO, NEGATE DELTA Y
	MOV	6(SP),R2	;STARTING X = FINAL X
	MOV	4(SP),R3	;STARTING Y = FINAL Y
	BR	4$
3$:	MOV	XPOS,R2		;STARTING X = INITIAL X
	MOV	YPOS,R3		;STARTING Y = INITIAL Y
4$:	CMP	R4,R5		;DOES ABS(DELTA X) = ABS(DELTA Y)?
	BNE	YLONG		;NO (Y IS LONGER)
	MOV	(SP)+,R4	;YES (DIAGONAL): POP SIGN OF DELTA Y
	INC	R5		;SET UP LOOP COUNT
5$:	MOV	R2,R1		;SET X COORDINATE
	MOV	R3,R0		;ALSO Y
	JSR	PC,SETNIB	;SET PROPER NIB
	INC	R2		;NEXT X POSITION
	ADD	R4,R3		;UPDATE Y IN PROPER DIRECTION
	SOB	R5,5$		;DO WHOLE LINE
	BR	POPNEW		;FINISH UP
XLONG:	MOV	R2,-(SP)	;PUSH SIGN OF DELTA X
	TST	R3		;IS DELTA Y POSITIVE?
	BGT	1$		;YES
	NEG	(SP)		;NO, NEGATE DELTA X
	MOV	6(SP),R3	;STARTING X = FINAL X
	MOV	4(SP),R2	;STARTING Y = FINAL Y
	BR	2$
1$:	MOV	XPOS,R3		;STARTING X = INITIAL X
	MOV	YPOS,R2		;STARTING Y = INITIAL Y
2$:	MOV	R4,-(SP)	;SAVE ABS(DELTA X)
	MOV	R4,-(SP)	;TWICE
	MOV	R5,R4		;GET ABS(DELTA Y)
	BR	GENRAL		;GO TO GENERAL LINE DRAWER

YLONG:	MOV	R5,-(SP)	;SAVE ABS(DELTA Y)
	MOV	R5,-(SP)	;TWICE
;
; AT THIS POINT, REGISTERS ARE SET AS FOLLOWS (WHERE S=SHORT LEG,
; L=LONG LEG COORDINATE):
;    R2 = STARTING S VALUE
;    R3 = STARTING L VALUE
;    R4 = ABS(DELTA S)
;  (SP) = ABS(DELTA L)
; 2(SP) = ABS(DELTA L)
; 4(SP) = SIGN OF DELTA L (+1 OR -1)
; 6(SP) = 0 IF L=X, 1 IF L=Y
;
GENRAL:	ASL	(SP)		;MULTIPLY ABS(DELTA L) BY 2
				;(AVOID DIVIDE OVERFLOW)
	CLR	R5		;LOW ORDER PART OF ABS(DELTA S) IS ZERO
	DIV	(SP)+,R4	;DIVIDE 65536*ABS(DELTA S) BY
				;2*ABS(DELTA L)
	ASL	R4		;MULTIPLY BY 2 GIVING 65536 *
				;ABS(DELTA S) / ABS(DELTA L)
	MOV	(SP)+,R5	;GET ABS(DELTA L)
	MOV	R4,-(SP)	;PUSH RESLUT OF DIVIDE (LOW ORDER
				;S INCREMENT)
	CLR	R4		;CLEAR LOW ORDER S VALUE
	INC	R5		;ADD ONE FOR LOOP COUNT
;
; REGISTERS NOW ARE SET AS FOLLOWS:
;    R2 = HIGH ORDER S VALUE
;    R3 = L VALUE
;    R4 = LOW ORDER S VALUE
;    R5 = LOOP COUNT
;  (SP) = LOW ORDER S INCREMENT
; 2(SP) = L INCREMENT (+1 OR -1)
; 4(SP) = 0 IF L=X, 1 IF L=Y
;
1$:	TST	4(SP)		;IS Y THE LONG LEG?
	BEQ	2$		;NO, X
	MOV	R2,R1		;YES, GET X VALUE
	MOV	R3,R0		;ALSO Y
	BR	3$
2$:	MOV	R2,R0		;GET Y VALUE
	MOV	R3,R1		;ALSO X
3$:	JSR	PC,SETNIB	;SET APPROPRIATE NIB
	ADD	2(SP),R3	;UPDATE L VALUE
	TST	R4		;WAS LOW ORDER S .GT. 32767?
	BPL	4$		;NO
	DEC	R2		;YES, UNDO THE ROUND-UP DONE LAST TIME
4$:	ADD	(SP),R4		;UPDATE LOW ORDER S
	BPL	5$		;LESS THAN 32767
	INC	R2		;GREATER, ROUND UP HIGH ORDER S
5$:	ADC	R2		;ADD CARRY TO HIGH ORDER ALSO
	SOB	R5,1$		;LOOP OVER ALL POINTS
	CMP	(SP)+,(SP)+	;REMOVE INCREMENTS FROM STACK
POPNEW:	ADD	#6,SP		;REMOVE FLAG, FINAL Y, & X FROM STACK
VECEND:	MOV	(SP)+,YPOS	;SET NEW Y POSITION
	MOV	(SP)+,XPOS	;SET NEW X POSITION
	RTS	PC		;DONE
;

	.SBTTL SUBROUTINES SETNIB AND PLTOUT
;
; SUBROUTINE SETNIB -- SET NIB AT GIVEN X & Y COORDINATE
; ENTERED WITH R0 = Y COORDINATE (LV11 UNITS -- 0 TO 511)
;	       R1 = X COORDINATE (LV11 UNITS)
; R0 AND R1 ARE MODIFIED BY THIS ROUTINE
;
SETNIB:	COM	R0		;0 BECOMES 511, 511 BECOMES 0 (511-Y)
	ASH	#7,R1		;SHIFT X TO BITS 15-7
	ASHC	#6,R0		;SHIFT COMBINED 18 BIT X & Y 6 BITS LEFT
	ASH	#-13.,R1	;BOTTOM 3 BITS: MOVE TO BITS 2-0
	BIC	#177770,R1	;MASK OUT OTHER JUNK
	BIC	#100000,R0	;ALSO EXTRACT TOP 15 BITS
	NEG	R1		;NOW A SHIFT COUNT (0 TO -7)
	MOV	R1,-(SP)	;PUSH IT ON STACK
	MOV	#200,R1		;SET UP BIT MASK
	ASH	(SP)+,R1	;SHIFT TO PROPER BIT POSITION
	BISB	R1,NIBS(R0)	;SET PROPER BIT IN APPROPRIATE NIB BYTE
	MOV	#1,NOTBLK	;SET "PLOT NOT BLANK" FLAG
	RTS	PC		;RETURN
;
; SUBROUTINE PLTOUT -- PLOT OUT NIB ARRAY ON PRINTER, THEN CLEAR IT
; THIS ROUTINE MODIFIES ALL REGISTERS
;
PLTOUT:	MOV	#PARMS,R5	;ADDRESS OF DESPOOLER PARAMETER BLOCK
	TST	NOTBLK		;IS PLOT ALL BLANK?
	BEQ	1$		;YES, DON'T WASTE PAPER & TIME
	QIOW$S	#IO.WLB,#OUTLUN,#OUTEF,,#IOSB,,<#FRMFD,#1,#0>
				;PRINT FORM FEED
	BCC	2$		;NO PROBLEMS
	JSR	PC,DSWERR	;QUEUE I/O FAILED, TELL PEOPLE
1$:	BR	CLRNBS		;GIVE UP ON THIS PLOT
2$:	TSTB	IOSB		;DID I/O SUCCEED?
	BPL	3$		;YES
	JSR	PC,QIOERR	;NO, INFORM THE OUTSIDE WORLD
	BR	CLRNBS		;THEN GIVE UP
3$:	MOV	#NLINES,R3	;NO. OF LINES OF NIBS
	MOV	#NIBS,R2	;START OF NIB ARRAY
4$:	MOV	#NIBLIN,R0	;START OF NIB LINE BUFFER
	BITB	#DBLE,FLGS(R5)	;DOUBLE SIZE PLOT WANTED?
	BEQ	7$		;NO, SINGLE IS OK
	MOV	R5,-(SP)	;YES, SAVE PARAMETER BLOCK ADDRESS
	MOV	#NCOLS,R1	;NO. OF COLUMNS OF NIBS PER LINE

5$:	MOVB	(R2)+,R5	;GET BYTE OF NIBS
	MOV	R5,R4		;DUPLICATE
	ASH	#-4,R4		;EXTRACT TOP 4 BITS
	BIC	#177760,R4	;REMOVE JUNK
	BIC	#177760,R5	;ALSO GET LOW 4 BITS
	MOVB	DBLCVT(R4),(R0)+;CONVERT TOP HALF TO DOUBLE FORMAT...
	MOVB	DBLCVT(R5),(R0)+;...AND BOTTOM HALF, & STORE IN BUFFER
	SOB	R1,5$		;DO WHOLE LINE
	MOV	(SP)+,R5	;RESTORE PARAMETERS ADDRESS
	QIOW$S	#IO.WLB,#OUTLUN,#OUTEF,,#IOSB,,<#NIBLIN,#2*NCOLS,#'+>
				;PLOT LINE
	BCC	6$		;QIO WORKED
	JSR	PC,DSWERR	;FAILED, PRINT ERROR MESSAGE
	BR	CLRNBS		;GIVE UP
6$:	TSTB	IOSB		;DID I/O SUCCEED?
	BPL	10$		;YES, PLOT SAME LINE AGAIN
	JSR	PC,QIOERR	;NO, COMPLAIN
	BR	CLRNBS		;STOP PLOTTING
7$:	MOV	#NCOLS,R1	;NO. OF COLUMNS OF NIBS PER LINE
8$:	MOVB	(R2)+,(R0)+	;COPY NIBS TO BUFFER
	SOB	R1,8$		;(FILLS ONE-HALF LINE)
	MOV	#NCOLS,R1	;GET NO. OF COLUMNS AGAIN
9$:	CLRB	(R0)+		;CLEAR REST OF NIBS...
	SOB	R1,9$		;...ON LINE
10$:	QIOW$S	#IO.WLB,#OUTLUN,#OUTEF,,#IOSB,,<#NIBLIN,#2*NCOLS,#'+>
				;PLOT LINE
	BCC	11$		;QUEUE I/O WORKED
	JSR	PC,DSWERR	;FAILED, TELL PEOPLE
	BR	CLRNBS		;QUIT
11$:	TSTB	IOSB		;DID I/O SUCCEED?
	BPL	12$		;YES
	JSR	PC,QIOERR	;NO, PRINT ERROR MESSAGE
	BR	CLRNBS		;GIVE UP
12$:	DEC	R3		;COUNT ANOTHER LINE
	BLE	CLRNBS		;IF ALL DONE, QUIT
	MOV	R3,R1		;NO. OF LINES REMAINING
	MUL	#NCOLS/2,R1	;NO. OF WORDS LEFT IN NIB ARRAY
	MOV	R2,R0		;CURRENT PLACE IN NIB ARRAY
13$:	TST	(R0)+		;IS NEXT WORD NON-ZERO?
	BNE	4$		;YES, STILL MORE STUFF TO OUTPUT
	SOB	R1,13$		;NO, KEEP LOOKING
CLRNBS:	MOV	#NIBS,R2	;START OF NIB ARRAY
	MOV	#NCOLS*<NLINES/2>,R1;NO. OF WORDS TOTAL
1$:	CLR	(R2)+		;CLEAR NIBS ARRAY
	SOB	R1,1$		;(ALL)
	CLR	NOTBLK		;PLOT IS NOW BLANK
	RTS	PC		;RETURN
;

	.SBTTL ERROR MESSAGE PRINTING ROUTINES
;
; SUBROUTINE DSWERR -- PRINT DIRECTIVE ERROR
;
DSWERR:	MOV	R1,-(SP)	;SAVE R1
	MOV	@#$DSW,R1	;GET DSW
	BIS	#177400,R1	;MAKE HIGH BYTE NEGATIVE
	JSR	PC,ERRMSG	;PRINT MESSAGE
	MOV	(SP)+,R1	;RESTORE R1
	RTS	PC		;RETURN
;
; SUBROUTINE QIOERR -- PRINT I/O ERROR MESSAGE FOR QIO
;
QIOERR:	MOV	R1,-(SP)	;SAVE R1
	CLR	R1		;MAKE HIGH BYTE POSITIVE
	BISB	IOSB,R1		;SET LOW BYTE = I/O ERROR CODE
2$:	JSR	PC,ERRMSG	;PRINT MESSAGE
	MOV	(SP)+,R1	;RESTORE R1
	RTS	PC		;RETURN
;
; SUBROUTINE FDBERR -- PRINT I/O ERROR MESSAGE FOR FCS ROUTINES
; ENTERED WITH R0 = FDB ADDRESS
; 
FDBERR:	MOV	R1,-(SP)	;SAVE R1
	MOV	F.ERR(R0),R1	;GET ERROR CODE
	JSR	PC,ERRMSG	;PRINT MESSAGE
	MOV	(SP)+,R1	;RESTORE R1
	RTS	PC		;RETURN
;

; SUBROUTINE ERRMSG -- PRINT DIRECTIVE OR I/O ERROR MESSAGE
; ENTERED WITH R1 = ERROR CODE (LOW BYTE) AND FLAG (HIGH BYTE)
;		    (FLAG POSITIVE=I/O ERROR, NEGATIVE=DIRECTIVE ERROR)
;
ERRMSG:	MOV	R3,-(SP)	;SAVE REGISTERS
	MOV	R4,-(SP)
	MOV	R5,-(SP)
	MOV	#PARMS,R5	;ADDRESS OF PARAMETERS BLOCK
	MOV	SP,R4		;SAVE STACK POSITION
	MOVB	R1,R3		;GET ERROR CODE (SIGN EXTEND TO 16 BITS)
	MOV	R3,-(SP)	;PUSH IT
	MOV	#DSWF,-(SP)	;PUSH ADDRESS OF DSW MESSAGE
	TST	R1		;IS IT A DIRECTIVE ERROR?
	BMI	1$		;YES
	MOV	#IOSF,(SP)	;NO, CHANGE TO I/O ERROR MESSAGE
1$:	MOV	SP,R3		;"MO" PARAMETERS ON STACK
	MOUT$S	#ERSTR,R3,,,#SY$STM;OUTPUT ERROR MESSAGE
	MOV	R4,SP		;RESTORE STACK
	MOV	#DBSF,-(SP)	;PUSH ADDRESS OF DOUBLE MESSAGE
	BITB	#DBLE,FLGS(R5)	;TEST DOUBLE PRECISION FLAG
	BNE	2$		;IT'S ON
	MOV	#NDBF,(SP)	;NOT ON, CHANGE TO NOT-DOUBLE MESSAGE
2$:	MOV	#DELF,-(SP)	;PUSH ADDRESS OF DELETE MESSAGE
	BITB	#PRSV,FLGS(R5)	;TEST PRESERVE FLAG
	BEQ	3$		;NOT ON
	MOV	#NDEF,(SP)	;ON, CHANGE TO NOT-DELETE MESSAGE
3$:	MOVB	COPS(R5),-(SP)	;PUSH NO. OF COPES & FORM TYPE
	BIC	#177740,(SP)	;EXTRACT NO. OF COPIES
	MOVB	COPS(R5),R3	;NOW GET FORM TYPE...
	ASH	#-5,R3		;...INTO BITS 0-2
	BIC	#177770,R3	;ELIMINATE OTHER JUNK
	MOV	R3,-(SP)	;PUSH FORM TYPE
	CLR	-(SP)		;PUSH...
	BISB	PRIO(R5),(SP)	;...PRIORITY OF OUTPUT SELECTION
	CLR	-(SP)		;PUSH...
	BISB	SPUNIT(R5),(SP)	;...PRINTER UNIT NO.
	MOV	R5,-(SP)	;PUSH...
	ADD	#SPDEV,(SP)	;...PRINTER DEVICE NAME
	MOV	TASKN+2(R5),-(SP);PUSH SENDING TASK NAME
	MOV	TASKN(R5),-(SP)	;(2 WORDS)
	MOV	SP,R3		;"MO" PARAMETERS ON STACK
	MOUT$S	#PRSTR,R3,,,#SY$STM;OUTPUT PARAMETERS MESSAGE
	MOV	R4,SP		;RESTORE STACK
	MOV	FVER(R5),-(SP)	;PUSH FILE VERSION
	MOV	FTYP(R5),-(SP)	;PUSH FILE TYPE
	MOV	FNAM+4(R5),-(SP);PUSH FILE NAME
	MOV	FNAM+2(R5),-(SP)
	MOV	FNAM(R5),-(SP)	;(3 WORDS)
	MOV	DID+2(R5),-(SP)	;PUSH DIRECTORY ID
	MOV	DID(R5),-(SP)	;(2 WORDS)
	MOV	UNIT(R5),-(SP)	;PUSH DEVICE UNIT NO.
	MOV	R5,-(SP)	;PUSH ADDRESS...
	ADD	#DVNM,(SP)	;...OF DEVICE NAME
	MOV	SP,R3		;"MO" PARAMETERS ON STACK
	MOUT$S	#FLSTR,R3,,,#SY$STM;OUTPUT FILE NAME MESSAGE
	MOV	R4,SP		;RESTORE STACK
	MOV	(SP)+,R5	;RESTORE REGISTERS
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	RTS	PC		;RETURN
;

	.SBTTL DATA AND CONSTANT STORAGE
;
; READ/WRITE DATA AREA:
;
	.PSECT	SPGRW,D
;
COPIES:	.WORD	0		;NO. OF COPIES TO PRINT
SAVESP:	.WORD	0		;PLACE TO SAVE STACK POINTER
COUNTR:	.WORD	0		;BYTE COUNTER FOR INPUT FILE RECORDS
LFFLAG:	.BYTE	0		;EXTRA LINEFEED NEEDED FLAG
CRFLAG:	.BYTE	0		;CARRIAGE RETURN NEEDED FLAG
POINTR:	.WORD	0		;BYTE POINTER FOR INPUT FILE RECORDS
TXTSIZ:	.WORD	0		;CURRENT TEXT SIZE IN VT01 UNITS
XPOS:	.WORD	0		;CURRENT X POSITION IN VT01 UNITS
YPOS:	.WORD	0		;CURRENT Y POSITION IN VT01 UNITS
NOTBLK:	.WORD	0		;PLOT ARRAY NOT BLANK FLAG
IOSB:	.BLKW	2		;I/O STATUS BLOCK FOR PRINTER I/O
;
; DESPOOLER PARAMETER BLOCK:
;
PARMS:	.BLKW	PRMLEN		;FILLED BY RECEIVE DATA
;
; INPUT (SPOOL) FILE DESCRIPTOR BLOCK:
;
INFDB:	FDBDF$
	FDRC$A	FD.PLC,LINEBF,LINLEN;LOCATE MODE, BUFFER ADDR. & LENGTH
	FDOP$A	INLUN		;LUN #
	FDBF$A	INEF		;EVENT FLAG #
;
; INPUT LINE BUFFER:
;
LINEBF:	.BLKB	LINLEN		;LENGTH LINLEN
;
; OUTPUT PLOT BUFFER:
;
NIBLIN:	.BLKB	2*NCOLS		;LENGTH 2 * NCOLS
;
; NIB ARRAY FOR STORAGE OF ONE PAGE PLOT:
;
	.PSECT	NIBSRW,D
NIBS:	.BLKB	NCOLS*NLINES	;NCOLS BY NLINES BYTES
;

; READ-ONLY DATA AREA:
;
	.PSECT	SPGRD,RO,D
;
FRMFD:	.WORD	FF		;FORM FEED
.MOLUN::.BLKW	1		;"MO" LUN # (FILLED IN BY TKB)
;
; SINGLE TO DOUBLE SIZE NIB CONVERSION TABLE:
;
DBLCVT:	.BYTE	000		;0000
	.BYTE	003		;0001
	.BYTE	014		;0010
	.BYTE	017		;0011
	.BYTE	060		;0100
	.BYTE	063		;0101
	.BYTE	074		;0110
	.BYTE	077		;0111
	.BYTE	300		;1000
	.BYTE	303		;1001
	.BYTE	314		;1010
	.BYTE	317		;1011
	.BYTE	360		;1100
	.BYTE	363		;1101
	.BYTE	374		;1110
	.BYTE	377		;1111
;
; "MO" STRING DESCRIPTOR:
;
ERSTR:	.WORD	ERSTRL		;ERROR MESSAGE STRING
	.WORD	ERSTRA
;
PRSTR:	.WORD	PRSTRL		;PARAMETER STRING
	.WORD	PRSTRA
;
FLSTR:	.WORD	FLSTRL		;FILE STRING
	.WORD	FLSTRA
;

; DISPATCH TABLE FOR CONTROL CHARACTERS:
;
CNTRLS:	.WORD	NULL		;(000) NUL
	.WORD	TOPLFT		;(001) SOH
	.WORD	TOPRGT		;(002) STX
	.WORD	NULL		;(003) ETX
	.WORD	INIT		;(004) EOT
	.WORD	TOP		;(005) ENQ
	.WORD	NULL		;(006) ACK
	.WORD	INCSIZ		;(007) BEL
	.WORD	BACKSP		;(010) BS
	.WORD	TAB		;(011) HT
	.WORD	LINEFD		;(012) LF
	.WORD	VERTAB		;(013) VT
	.WORD	FORMFD		;(014) FF
	.WORD	LEFT		;(015) CR
	.WORD	NULL		;(016) SO
	.WORD	NULL		;(017) SI
	.WORD	UPTAB		;(020) DLE
	.WORD	UPLINE		;(021) DC1
	.WORD	BKTAB		;(022) DC2
	.WORD	RIGHT		;(023) DC3
	.WORD	DECSIZ		;(024) DC4
	.WORD	NULL		;(025) NAK
	.WORD	BOTTOM		;(026) SYN
	.WORD	RESSIZ		;(027) ETB
	.WORD	PLTOUT		;(030) CAN
	.WORD	BOTRGT		;(031) EM
	.WORD	BOTLFT		;(032) SUB
	.WORD	ESCAPE		;(033) ESC
	.WORD	SETSIZ		;(034) FS
	.WORD	VECTOR		;(035) GS
	.WORD	MOVE		;(036) RS
	.WORD	IGNORE		;(037) US
	.WORD	SPACE		;(040) SP
;

; CHARACTER GENERATOR MASK TABLE
;
; CODES 000 TO 037 (NORMALLY CONTROL CHARACTERS) ARE VISUALIZED AS RUNES
; FROM THE "ANGERTHAS MORIA".
;
CHRTBL:	.BYTE	376,004,010,360,000	;(000) SHORT "A" RUNE
	.BYTE	376,024,050,360,000	;(001) LONG "A" RUNE
	.BYTE	376,042,124,210,000	;(002) "B" RUNE
	.BYTE	376,020,040,100,200	;(003) "CH" RUNE
	.BYTE	376,024,050,120,040	;(004) "D" RUNE
	.BYTE	376,010,020,040,376	;(005) SHORT "E" RUNE
	.BYTE	000,010,024,376,000	;(006) "F" RUNE
	.BYTE	376,024,022,010,006	;(007) "G" RUNE
	.BYTE	202,104,050,020,000	;(010) "H" RUNE
	.BYTE	104,104,174,104,104	;(011) "I" RUNE
	.BYTE	376,030,024,042,300	;(012) "J" RUNE
	.BYTE	376,020,020,010,006	;(013) "K" RUNE
	.BYTE	300,040,376,010,006	;(014) "L" RUNE
	.BYTE	376,124,050,000,000	;(015) "M" RUNE
	.BYTE	016,020,376,020,016	;(016) "N" RUNE
	.BYTE	360,010,004,010,360	;(017) SHORT "O" RUNE
	.BYTE	376,024,010,000,000	;(020) "P" RUNE
	.BYTE	376,004,010,004,002	;(021) "KW" RUNE
	.BYTE	010,004,376,004,010	;(022) "R" RUNE
	.BYTE	200,100,076,100,200	;(023) "S" RUNE
	.BYTE	376,004,010,020,040	;(024) "T" RUNE
	.BYTE	210,124,042,124,210	;(025) SHORT "U" RUNE
	.BYTE	210,124,042,376,000	;(026) "V" RUNE
	.BYTE	010,024,342,024,010	;(027) "W" RUNE
	.BYTE	006,010,020,000,376	;(030) "KH" RUNE
	.BYTE	174,010,020,040,174	;(031) "Y" RUNE
	.BYTE	200,100,376,100,200	;(032) "Z" RUNE
	.BYTE	376,024,050,120,376	;(033) LONG "E" RUNE
	.BYTE	360,010,374,010,360	;(034) SPECIAL "O" RUNE
					;      (AS IN AUGHT, LOG)
	.BYTE	040,020,010,004,376	;(035) "TH" RUNE
	.BYTE	020,252,104,252,020	;(036) LONG "U" RUNE
					;      (AS IN RULE, TOOL)
	.BYTE	210,124,342,124,210	;(037) SPECIAL "U" RUNE 
					;      (AS IN BOOK)
;

; CODE 040 IS VISUALIZED AS A TRIANGLE, CODES 041 TO 077 AS SPECIAL 
; ASCII CHARACTERS
;
	.BYTE	100,120,104,120,100	;(040) TRIANGLE
	.BYTE	000,000,276,000,000	;(041) !
	.BYTE	000,016,000,016,000	;(042) "
	.BYTE	050,376,050,376,050	;(043) #
	.BYTE	110,124,376,124,044	;(044) $
	.BYTE	306,046,020,310,306	;(045) %
	.BYTE	154,222,254,100,240	;(046) &
	.BYTE	010,014,006,002,000	;(047) CLOSING SINGLE QUOTE
	.BYTE	000,070,104,202,000	;(050) (
	.BYTE	000,202,104,070,000	;(051) )
	.BYTE	050,020,174,020,050	;(052) *
	.BYTE	020,020,174,020,020	;(053) +
	.BYTE	000,000,240,140,000	;(054) ,
	.BYTE	020,020,020,020,020	;(055) -
	.BYTE	000,000,300,300,000	;(056) .
	.BYTE	300,040,020,010,006	;(057) /
	.BYTE	174,242,222,212,174	;(060) 0
	.BYTE	000,204,376,200,000	;(061) 1
	.BYTE	344,222,222,222,214	;(062) 2
	.BYTE	104,202,222,222,154	;(063) 3
	.BYTE	060,050,044,376,040	;(064) 4
	.BYTE	116,212,212,212,162	;(065) 5
	.BYTE	170,224,222,222,140	;(066) 6
	.BYTE	002,342,022,012,006	;(067) 7
	.BYTE	154,222,222,222,154	;(070) 8
	.BYTE	014,222,222,122,074	;(071) 9
	.BYTE	000,000,154,154,000	;(072) :
	.BYTE	000,000,254,154,000	;(073) ;
	.BYTE	020,050,104,202,000	;(074) <
	.BYTE	050,050,050,050,050	;(075) =
	.BYTE	000,202,104,050,020	;(076) >
	.BYTE	000,004,002,262,014	;(077) ?
;

; CODES 100 TO 137 ARE UPPER CASE LETTERS
;
	.BYTE	174,202,272,252,074	;(100) @
	.BYTE	370,044,042,044,370	;(101) A
	.BYTE	376,222,222,222,154	;(102) B
	.BYTE	174,202,202,202,104	;(103) C
	.BYTE	202,376,202,202,174	;(104) D
	.BYTE	376,222,222,202,202	;(105) E
	.BYTE	376,022,022,002,002	;(106) F
	.BYTE	174,202,202,222,362	;(107) G
	.BYTE	376,020,020,020,376	;(110) H
	.BYTE	000,202,376,202,000	;(111) I
	.BYTE	100,200,200,200,176	;(112) J
	.BYTE	376,020,050,104,202	;(113) K
	.BYTE	376,200,200,200,200	;(114) L
	.BYTE	376,004,030,004,376	;(115) M
	.BYTE	376,004,010,020,376	;(116) N
	.BYTE	376,202,202,202,376	;(117) O
	.BYTE	376,022,022,022,014	;(120) P
	.BYTE	174,202,242,102,274	;(121) Q
	.BYTE	376,022,062,122,214	;(122) R
	.BYTE	104,212,222,242,104	;(123) S
	.BYTE	002,002,376,002,002	;(124) T
	.BYTE	176,200,200,200,176	;(125) U
	.BYTE	016,060,300,060,016	;(126) V
	.BYTE	376,100,040,100,376	;(127) W
	.BYTE	306,050,020,050,306	;(130) X
	.BYTE	006,010,360,010,006	;(131) Y
	.BYTE	302,242,222,212,206	;(132) Z
	.BYTE	000,376,202,202,000	;(133) [
	.BYTE	006,010,020,040,300	;(134) \
	.BYTE	000,202,202,376,000	;(135) ]
	.BYTE	040,020,010,020,040	;(136) CARROT
	.BYTE	200,200,200,200,200	;(137) UNDERSCORE
;

; CODES 140 TO 176 ARE LOWER CASE LETTERS; CODE 177 IS VISUALIZED
; AS A SOLID BOX
;
	.BYTE	000,002,006,014,010	;(140) OPENING SINGLE QUOTE
	.BYTE	100,250,250,250,120	;(141) SMALL "A"
	.BYTE	000,366,210,210,160	;(142) SMALL "B"
	.BYTE	000,160,210,210,220	;(143) SMALL "C"
	.BYTE	000,160,210,210,366	;(144) SMALL "D"
	.BYTE	000,160,250,250,260	;(145) SMALL "E"
	.BYTE	010,374,012,002,004	;(146) SMALL "F"
	.BYTE	020,250,250,250,324	;(147) SMALL "G"
	.BYTE	000,366,010,010,360	;(150) SMALL "H"
	.BYTE	000,220,364,200,000	;(151) SMALL "I"
	.BYTE	000,100,200,200,172	;(152) SMALL "J"
	.BYTE	376,040,060,110,200	;(153) SMALL "K"
	.BYTE	000,202,376,200,000	;(154) SMALL "L"
	.BYTE	370,010,360,010,360	;(155) SMALL "M"
	.BYTE	000,370,010,010,360	;(156) SMALL "N"
	.BYTE	160,210,210,210,160	;(157) SMALL "O"
	.BYTE	000,330,050,050,020	;(160) SMALL "P"
	.BYTE	010,024,024,170,200	;(161) SMALL "Q"
	.BYTE	010,360,010,010,020	;(162) SMALL "R"
	.BYTE	020,250,250,250,100	;(163) SMALL "S"
	.BYTE	010,376,210,200,100	;(164) SMALL "T"
	.BYTE	000,170,200,200,370	;(165) SMALL "U"
	.BYTE	070,100,200,100,070	;(166) SMALL "V"
	.BYTE	370,100,040,100,370	;(167) SMALL "W"
	.BYTE	210,120,040,120,210	;(170) SMALL "X"
	.BYTE	030,240,240,240,130	;(171) SMALL "Y"
	.BYTE	210,310,250,230,210	;(172) SMALL "Z"
	.BYTE	020,020,154,202,202	;(173) OPENING BRACES
	.BYTE	000,000,376,000,000	;(174) VERTICAL BAR
	.BYTE	202,202,154,020,020	;(175) CLOSING BRACES
	.BYTE	060,010,020,040,030	;(176) TILDA (SQUIGGLE)
	.BYTE	376,376,376,376,376	;(177) BLACK BOX
;

; CARRIAGE CONTROL TABLE:
;
CARCTL:	.BYTE	0		;NO CARRIAGE CONTROL
	.ASCII	'$+01'		;STANDARD CARRIAGE CONTROLS
NCARCT	=	.-CARCTL	;NO. OF CARRIAGE CONTROLS RECOGNIZED
; 
; STRINGS:
;
DBSF:	.ASCII	' /DB'
NDBF:	.ASCII	'/-DB'
;
DELF:	.ASCII	' /DE'
NDEF:	.ASCII	'/-DE'
;
DSWF:	.ASCII	'DSW'
IOSF:	.ASCII	'I/O'
;
ERSTRA:	.ASCII	'SPG... -- GRAPHIC DESPOOLING ERROR; %3A ERROR CODE %D'
ERSTRL	=	.-ERSTRA
PRSTRA:	.ASCII	'  SENDER %2R OUT-DEV %2A%O PRIO %D FORM %D COPS %D'
	.ASCII	' FLAGS %4A %4A'
PRSTRL	=	.-PRSTRA
FLSTRA:	.ASCII	'  DEVICE %2A%O: DIRECTORY ID (%P,%P) FILE %X'
FLSTRL	=	.-FLSTRA
;
	.END	START