.TITLE	PDPARS - PLOT DESCRIPTION FILE PARSER
;
;	CALLS:
;	  INITIALISATION - 
;		INITPD FDB,PT1,PT2
;			FDB	FDB FOR (OPEN'D) INPUT FILE
;			PT1,PT2	POINTERS TO TWO POINT BLOCK AREAS
;
;	  START-UP -
;		PARSPD SETUP,HEADER,MOVE,PDRAW,DRAW,POINT,CHARS
;
;		THE ABOVE ARGUMENTS ARE ROUTINE ADDRESSES
;		SETUP IS CALLED TO SETUP A POINT BLOCK. OTHER
;		ROUTINES ARE CALLED TO HANDLE THE APPROPRIATE TYPE
;		OF PLOT OBJECT. A ROUTINE ADDRESS MAY
;		BE OMITTED (OR SPECIFIED AS 0) TO INDICATE THAT
;		NO CALL IS NECESSARY.
;

	.SBTTL	>DEFINITIONS
;
	.MCALL	CALL,RETURN,RECALL,ENTER,LEAVE
	.MCALL	EXCHS,EXCHR
	.MCALL	PSTR,POCT,POCTB
	.MCALL	READ$,WAIT$,FDBK$R
	.MCALL	PDFDEF,HDDEF
;
;
	HDDEF		;HEADER DISPLACEMENTS
	PDFDEF		;PDF TYPE CODES
;
;
;	DISPLACEMENTS IN  BRANCH TABLE:
;
DXLATE=0
DTEST=2
DMOVE=4
DPRIM=6
DDRAW=10
DPOINT=12
DCHAR=14
DFIN=16
;
;
CR=15
LF=12
;
;
;
;	PARAMETER BLOCK DISPLACEMENTS
;
PDINT==0	;INTENSITY (BYTE)
PDTYPE==1	;LINE TYPE (BYTE)
;
PDUNIT==0	;LINES TYPE 7 - NUMBER OF UNITS PER BIT (BYTE)
PDDCNT==3	;		NUMBER OF BITS IN DASH VECTOR (BYTE)
PDDASH==4	;		DASH VECTOR START
;
PDPTR==2	;CHARACTERS -	CHARACTER STRING POINTER
PDSIZE==4	;		CHARACTER SIZE
PDANN==6	;		ANNOTATION ANGLE
PDORNT==10	;		ORIENTATION ANGLE
PDSLNT==12	;		SLANT ANGLE

	.SBTTL	>INITIALISATION
;
;	MOV	#FDB,-(SP)	;FILE MUST BE OPEN
;	MOV	#PTBLK0,-(SP)
;	MOV	#PTBLK1,-(SP)
;	CALL	PDINIT
;
PDINIT::ENTER	R0,R1,R2
	MOV	10(SP),NXTBLK	;SET UP POINT BLOCK POINTERS
	MOV	12(SP),CURBLK	;..
	MOV	14(SP),R0	;GET FDB
	MOV	R0,INFDB	;SAVE FOR FUTURE REFERENCE
	MOV	#BUF0,CURBUF	;SET UP BUFFER POINTERS
	MOV	#BUF1,NXTBUF	;..
	FDBK$R	R0,,#1000,#WORD01,,#INSTAT ;SET UP BUF LENGTH AND STAT BLK
	READ$	R0,CURBUF,,,,,,IOERR	;READ HEADER BLOCK
	WAIT$	R0,,,IOERR		;AND WAIT FOR COMPLETE
	MOV	#STABS,R2		;COPY SIZE TABLE OUT OF HEADER
	MOV	CURBUF,R0
	ADD	#HDSTAB,R0
	MOV	#4*10,R1
1$:	MOV	(R0)+,(R2)+
	SOB	R1,1$
	CALL	CHINIT		;INITIALISE CHARACTER GENERATOR
	MOV	(R0)+,LOGX	;GET SORT DESCRIPTION
	SXT	SORTF		;IF SORTED
	BMI	3$		;NOT SORTED
	MOV	(R0)+,LOGY	;SORTED, GET REST OF DESCRIPTION
	MOV	(R0)+,R1	;NUMBER OF STRIPS
	MOV	R1,NX
	MOV	(R0)+,R2	;NUMBER OF ROWS
	MOV	R2,NY
	MUL	R2,R1		;NUMBER OF PANES
	MOV	#SRTPTR,R2	;SORT POINTER ARRAY
2$:	MOV	(R0)+,(R2)+	;COPY FROM HEADER
	SOB	R1,2$		;ONE WORD AT A TIME
	BR	4$		;FINISHED
3$:	MOV	#2,SRTLST	;NO SORTING, FAKE SORT LIST
	CLR	SRTLST+2
4$:	LEAVE
	MOV	(SP)+,4(SP)	;SQUEEZE STACK
	ADD	#4,SP		;POP ARGS OFF STACK
CLEARC:	CLC
NOOP:	RETURN

	.SBTTL	>PARSER INITIAL ENTRY
;
;	MOV	#RECT,R0 ;ADDRESS OF AREA DESCRIPTION
;			 ;IN FORM XLO,YLO,XHI,YHI
;	CALL	PDPARS
;	.WORD	XLATE	;ADDRESS OF ROUTINE TO SETUP POINT BLOCKS
;	.WORD	TEST	;ADDRESS OF ROUTINE TO TEST IF BOX IS PLOTTABLE (OR 0)
;	.WORD	MOVE	;ADDRESS OF ROUTINE TO HANDLE MOVES (OR 0)
;	.WORD	PDRAW	;ADDRESS OF ROUTINE TO HANDLE PRIMITIVE LINES (OR 0)
;	.WORD	DRAW	;ADDRESS OF ROUTINE TO HANDLE GENERAL LINES AND ELLIPSES
;			;(OR 0)
;	.WORD	POINT	;ADDRESS OF ROUTINE TO HANDLE POINTS (OR 0)
;	.WORD	CHARS	;ADDRESS OF ROUTINE TO HANDLE HARDWARE TEXT STRINGS (OR 0)
;
PDPARS::ENTER	R0,R1,R2,R3,R4,R5
	MOV	14(SP),R1		;DISPATCH ADDR INTO R1
	MOV	(R1)+,PDXLAT
	MOV	(R1)+,PDTEST
	BNE	1$
	MOV	#CLEARC,PDTEST
1$:	MOV	#NOOP,R2
	MOV	(R1)+,PDMOVE
	BNE	2$
	MOV	R2,PDMOVE
2$:	MOV	(R1)+,PDPRIM
	BNE	3$
	MOV	R2,PDPRIM
3$:	MOV	(R1)+,PDDRAW
	BNE	4$
	MOV	R2,PDDRAW
4$:	MOV	(R1)+,PDPOIN
	BNE	5$
	MOV	R2,PDPOIN
5$:	CLRB	SIMULF
	MOV	(R1)+,PDCHAR
	BNE	6$
	COMB	SIMULF
;
;	SET UP LIST OF PANES TO PARSE. (EACH IDENTIFIED BY ITS FIRST BLOCK)
;
6$:	TST	SORTF			;SORTED FILE?
	BNE	14$			;NO, USE FAKE LIST SET UP DURING INIT
	MOV	(R0)+,R1		;GET X0
	MOV	(R0)+,R2		;Y0
	MOV	(R0)+,R3		;X1
	MOV	(R0)+,R4		;Y1
	MOV	LOGX,R5			;AMOUNT TO SHIFT X
	NEG	R5			;(SHIFT RIGHT)
	ASH	R5,R1			;LOW X PANE
	BPL	7$			;BETTER BE >0
	CLR	R1			;OTHERWISE SET TO 0
7$:	ASH	R5,R3			;HIGH X PANE
	CMP	NX,R3			;BETTER BE IN RANGE
	BHI	8$			;BRANCH IF OK
	MOV	NX,R3			;SET TO HIGHEST PANE
	DEC	R3			;..
8$:	MOV	LOGY,R5			;SAME FOR Y CO-ORDINATES
	NEG	R5
	ASH	R5,R2
	BPL	9$			;BETTER BE >0
	CLR	R2			;OTHERWISE SET TO 0
9$:	ASH	R5,R4
	CMP	NY,R4			;BETTER BE IN RANGE
	BHI	10$			;OK
	MOV	NY,R4			;SET TO MAX
	DEC	R4			;..
10$:	MOV	NY,R5			;COMPUTE ADDRESS OF FIRST PANE
	MUL	R1,R5			;IN POINTER ARRAY
	ADD	R2,R5
	ASL	R5			;CONVERT TO DISPLACEMENT
	ADD	#SRTPTR,R5		;AND ADDRESS
	SUB	R1,R3			;NUMBER OF BLOCKS TO DO
	BMI	16$			;NONE!!!
	INC	R3			;ACTUAL NUMBER OF PANES
	SUB	R2,R4			;SAME IN Y DIMENSION
	BMI	16$
	INC	R4
	MOV	NY,R1			;NUMBER OF ROWS
	SUB	R4,R1			;NUMBER OF ROWS NOT SELECTED
	ASL	R1			;DISTANCE IN ARRAY TO NEXT SELECTED ROW
	MOV	#SRTLST,R0		;OUTPUT LIST
11$:	MOV	R4,R2			;GET NUMBER OF ROWS
12$:	MOV	(R5)+,(R0)		;COPY POINTER
	BEQ	13$			;NOTHING THERE
	TST	(R0)+			;PUT ONE IN, SO INCREMENT OUTPUT POINTER
13$:	SOB	R2,12$			;REPEAT FOR ALL ROWS IN THIS STRIP
	ADD	R1,R5			;ADVANCE TO NEXT STRIP
	SOB	R3,11$			;AND CONTINUE
	CLR	(R0)			;FLAG END OF LIST
;
;
;	PARSE EACH PANE IN LIST
;
14$:	MOV	#SRTLST,R0		;GET LIST POINTER
	CLR	INBLK			;NEVER USE HIGH WORD OF BLOCK NUMBER
15$:	MOV	(R0)+,INBLK+2		;SET UP TO READ FIRST BLOCK IN PANE
	BEQ	16$			;NO PANES LEFT
	CALL	PARSE			;PARSE PANE
	BR	15$			;ON TO NEXT PANE
16$:	LEAVE				;RETURN TO CALLER
	ADD	#DFIN,(SP)
	RETURN

	.SBTTL	>PARSER LOOP
;
PARSE:	ENTER	R0,R1,R2,R3,R4,R5
	MOV	SP,SPSAVE
	CLRB	EOFF			;NO EOF YET
	READ$	INFDB,CURBUF,,#INBLK,,,,IOERR	;GET INPUT RECORD
	CLR	BUFCNT			;BUFFER IS CURRENTLY EMPTY
	MOV	NXTBLK,R4
	MOV	CURBLK,R5		;INITIAL POINT BLOCKS
;
PARLUP:	CALL	PDIN		;READ A WORD
	MOV	R0,MODE		;SAVE MODE
	BIC	#-400,R0	;GET TYPE
	CMP	#CEOF,R0	;END OF FILE?
	BEQ	PFIN		;YES
	SUB	#CMIN,R0	;IS IT BIG ENOUGH
	BMI	1$
	CMP	#CMAX-CMIN,R0	;IS IT SMALL ENOUGH?
	BHIS	2$		;IN RANGE
1$:	CALL	PERR		;NO. PERR NEVER RETURNS
2$:	ASL	R0		;CONVERT TO DISPLACEMENT
	CALL	@PTAB(R0)	;AND CALL ROUTINE
	BR	PARLUP		;CONTINUE PARSING
;
;	COMES HERE AT EOF OR ERROR
;
PFIN:	LEAVE			;RESTORE REGISTERS
	RETURN			;AND RETURN THERE
;
;
;	DISPATCH TABLE FOR TYPES
;
PTAB:	.WORD	PPRIM		;10 - POINT
	.WORD	PLINE		;11 - LINE
	.WORD	PPOINT		;12 - POINT
	.WORD	PELLC		;13 - ELLIPSE CLOCKWISE
	.WORD	PELLCC		;14 - ELLIPSE COUNTER-CLOCKWISE
	.REPT	3
		.WORD	PERR	;15-17 - UNASSIGNED
	.ENDR
	.WORD	PHCHAR		;20 - HARDWARE CHARACTER STRING
	.WORD	PSCHAR		;21 - SOFTWARE CHARACTER STRING
;
	.IIF NE .-PTAB-<CMAX-CMIN+1*2>, .ERROR
;

	.SBTTL	>ERRONEOUS TYPE
;
;	CALLED IF A TYPE OTHER THAN THOSE EXPECTED IS READ
;
PERR:	CALL	ERRGO		;SET UP FOR ERROR
	PSTR	^*/INVALID TYPE IN PLOT FILE./<CR><LF>*
	PSTR	^*/BLOCK=/*
	TST	BLKNO		;HIGH ORDER WORD
	BEQ	1$		;IF ZERO, IGNORE IT
	POCT	BLKNO		;NON-ZERO, PRINT IT
	PSTR	^*/,/*
1$:	POCT	BLKNO+2		;PRINT LOW ORDER WORD
	PSTR	^*/ WORD /*
	MOV	BUFCNT,R5	;GET NUMBER OF WORDS LEFT IN BUFFER
	COM	R5		;SUBTRACT IT FROM NUMBER OF WORDS IN BUFFER
	ADD	BLKLN,R5	;..
	ASL	R5		;CONVERT TO BYTES
	POCT	R5		;PRINT IT
	PSTR	^*/ TYPE MODE IS /*
	POCTB	MODE		;WHERE WE CLEVERLY STASHED IT
	PSTR	^*/,/*
	POCTB	MODE+1
	PSTR	^*<CR><LF>*
ERRFIN:	MOV	SPSAVE,SP	;GET STACK POINTER
	JMP	PFIN		;RETURN

	.SBTTL	>PARSE INDIVIDUAL ROUTINES
;
	.SBTTL	>  CHARACTERS
;
;
;	HARDWARE CHARACTERS
;
PHCHAR:	TSTB	SIMULF			;SHOULD WE SIMULATE?
	BNE	PSIM			;YES, GO DO THAT INSTEAD
	CALL	GTINT			;NO, JUST PASS IT ALL TO HIM
	CALL	GETXY
	CALL	PDIN			;LENGTH OF CHARACTER STRING
	MOV	R0,R2
	MOV	R2,-(SP)		;SAVE WHILE WE READ CHARACTERS
	MOV	#CBUF,R3		;CHARACTER BUFFER
	MOV	R3,DATA+PDPTR		;TELL HIM WHERE IT IS
	ASR	R2			;NUMBER OF WORDS
	ADC	R2			;ROUNDED UP
1$:	CALL	PDIN			;GET WORD
	MOV	R0,(R3)+		;SAVE IT AWAY
	SOB	R2,1$			;AND ON TO NEXT
	MOV	#DATA,R3		;DATA BLOCK FOR HIM
	MOV	(SP)+,R2		;GET BACK CHARACTER COUNT
	CALL	@PDCHAR			;GO PLOT AWAY
	RETURN
;
;	SIMULATED HARDWARE CHARACTERS
;
PSIM:	CALL	GTINT			;GET INTENSITY AND TYPE
	CLRB	DATA+PDTYPE		;PASS TYPE 0 AT HIM
	ASH	#4,R0			;TABLE OFFSET
	ADD	#STABS,R0		;TABLE ADDRESS
	MOV	R0,R3			;SAVE FOR A BIT
	CALL	GETCXY			;STUFF X AND Y ONTO STACK FOR CHGEN
	MOV	R3,-(SP)		;AND TABLE ADDRESS FOR CHSET
	CALL	PDIN			;GET NUMBER OF CHARACTERS
	MOV	R0,CHCNT		;SAVE FOR GETCHR
	BR	GENCHR			;GO GENERATE CHARACTERS
;
;	SOFTWARE CHARACTERS
;
PSCHAR:	CALL	GTINT			;GET INTENSITY/TYPE
	CALL	GETCXY			;PUSH X AND Y ON STACK
	MOV	#SIMTAB,-(SP)		;AND CHSET TABLE ADDRESS
	CALL	PDIN			;GET LENGTH
	MOV	R0,CHCNT		;AND SAVE
	MOV	#SIMTAB+2,R2		;GET SIZE/ANGLE PARAMETERS
	MOV	#7,R1			;7 WORDS OF THEM
1$:	CALL	PDIN
	MOV	R0,(R2)+
	SOB	R1,1$

;
;	NOW GENERATE CHARACTERS. TOP OF STACK POINTS TO
;		TABLE (FOR CHSET)
;		Y
;		X
;
GENCHR:	MOV	(SP)+,R0		;TABLE ADDRESS
	CALL	CHSET			;SET UP CHARACTER PARAMETERS
	MOV	(SP)+,R1		;GET Y
	MOV	(SP)+,R0		;AND X
	MOV	#DATA,R3		;DATA BLOCK ADDRSS
	CALL	1$			;GO GENERATE CHARACTERS
	RETURN
;
1$:	CALL	CHVEC			;START UP CHARACTER VECTOR GENERATEION
2$:	DEC	CHCNT			;ONE LESS CHARACTER
	BPL	4$		;IF ANY
3$:	TST	(SP)+			;FLUSH CORETURN
	RETURN				;AND RETURN TO GENCHR
;
4$:	ENTER	R0
	CALL	PDIN			;GET WORD
	MOVB	R0,R2			;ISOLATE LOW BYTE
	SWAB	R0
	MOVB	R0,CHBUF		;SAVE OTHER ONE
	LEAVE
	RECALL
	DEC	CHCNT
	BMI	3$			;NO CHARACTERS LEFT
	MOVB	CHBUF,R2
	RECALL
	BR	2$

	.SBTTL	>  LINES OF VARIOUS FORMS
;
PPRIM:	MOV	PDPRIM,PDXY	;SET UP FOR PRIMITIVE DRAWS
	BR	XYLUP		;READ XY PAIRS
;
PELLC:	MOV	#1,-(SP)	;FLAG TYPE
	BR	LINE0		;OTHERWISE, LIKE LINE
;
PELLCC:	MOV	#-1,-(SP)	;FLAG TYPE
	BR	LINE0		;AND HANDLE LIKE LINE
;
PLINE:	CLR	-(SP)		;FLAG TYPE
LINE0:	CALL	GTINT		;GET INTENSITY/TYPE
	CMPB	PDINT(R3),#7	;TYPE 7 (DASHING INCLUDED)?
	BNE	LINE1		;NO, JUST GO READ PAIRS
	CALL	PDIN		;GET SPECS: BITS // UNITS/BIT
	MOV	R0,PDUNIT(R3)	;STORE AWAY
	MOVB	PDDCNT(R3),R1	;GET # OF BITS IN VECTOR
	ADD	#17,R1		;ROUND UP
	ASH	#-4,R1		;TO NEAREST WORD
	ADD	#PDDASH,R3	;DASH VECTOR ADDRESS
1$:	CALL	PDIN		;READ A WORD
	MOV	R0,(R3)+	;SAVE IT
	SOB	R1,1$		;AND CONTINUE WITH REST OF VECTOR
	MOV	#DATA,R3
LINE1:	MOV	(SP)+,R2	;GET LINE FORM
	MOV	PDDRAW,PDXY	;SET UP TO DRAW
	BR	XYLUP		;AND GO
;
PPOINT:	MOV	#DATA,R3	;GET DATA BLOCK ADDRESS
	MOVB	MODE+1,(R3)	;STORE INTENSITY
	CLRB	PDTYPE(R3)	;FOR NEATNESS
	MOV	PDPOIN,PDXY	;SET UP FOR POINT DRAWING
	BR	XYLUP
;
;
;	XYLUP REPETITIVELY READS XY PAIRS AND CALLS EITHER MOVE
;	OR THE ROUTINE SET UP PREVIOUSLY
;
XYLUP:	CALL	GETXY		;GET AN XY PAIR
	TST	BLANKF		;INTENSIFIED?
	BNE	1$		;NO
	CALL	@PDXY		;YES, CALL SET UP ROUTINE
	BR	2$		;AND ON TO NEXT ONE
1$:	CALL	@PDMOVE		;UNINTENSIFIED, JUST MOVE THERE
2$:	TST	EOLF		;MORE?
	BEQ	XYLUP		;YES
	RETURN

	.SBTTL	>GTINT
;
;	GTINT - EXTRACTS INTENSITY AND TYPE FROM MODE
;		R0 IS SET TO THE TYPE
;		R3 IS SET UP TO POINT AT DATA
;
GTINT:	MOV	#DATA,R3	;GET DATA BLOCK ADDRESS
	CLR	R0
	BISB	MODE+1,R0	;GET INTENSITY
	ASH	#-3,R0		;IN LOW BITS
	MOVB	R0,(R3)		;STORE IN DATA BLOCK
	MOVB	MODE+1,R0
	BIC	#-10,R0		;ISOLATE TYPE BITS
	MOVB	R0,PDTYPE(R3)	;SAVE
	RETURN

	.SBTTL	>GETXY
;
;	GETXY - READS AN X/Y PAIR, SETTING UP
;		BLANKF AND EOLF FROM SIGN BITS,
;		FLIPS POINT BLOCKS, AND PASSES
;		POINTS TO USER TRANSLATION ROUTINE
;		R0 IS DESTROYED; R4 AND R5 ARE FLIPPED
;
GETXY:	ENTER	R1		;SAVE REGISTERS
	EXCHR	R4,R5		;FLIP POINT BLOCKS
	CALL	GETXY0		;GET X AND Y INTO R0/R1
	CALL	@PDXLAT		;CALL TRANSLATE
	LEAVE			;RESTORE REGS
	RETURN
;
;	GETCXY-	READS AN X/Y PAIR AS ABOVE AND PUSHES
;		THEM ONTO THE STACK. R0, R1, AND R2 ARE
;		DESTROYED
;
GETCXY:	MOV	(SP)+,R2
	CALL	GETXY0		;GET INTO REGISTERS 0/1
	MOV	R0,-(SP)	;PUSH X
	MOV	R1,-(SP)	;AND Y
	JMP	(R2)
;
;	GETXY0- READS AN X/Y PAIR AS ABOVE AND LEAVES
;		IT IN REGISTERS O AND 1
;
GETXY0:	ENTER	R2
	CALL	PDIN		;GET X
	MOV	R0,R2		;SAVE TEMPORARILY
	SXT	BLANKF		;NOTE INTENSIFICATION
	CALL	PDIN		;GET Y
	MOV	R0,R1
	SXT	EOLF		;NOTE IF LAST PAIR
	MOV	R2,R0		;GET INTO RIGHT REGS FOR XLATE
	MOV	#100000,R2	;MASK OUT SIGN BIT
	BIC	R2,R0		;IN X
	BIC	R2,R1		;AND Y
	LEAVE
	RETURN

	.SBTTL	>PDIN - READ A WORD
;
;	PDIN - READS A WORD FROM PDF INTO R0
;		OTHER REGS ARE UNAFFECTED
;
PDIN:	DEC	BUFCNT		;ANYTHING THERE?
	BLT	1$		;NO, READ NEW RECORD
	MOV	@BUFPTR,R0	;GET WORD
	ADD	#2,BUFPTR	;AND ADVANCE POINTER
	RETURN
;
1$:	TSTB	EOFF		;EOF NOTICED?
	BNE	FAKEOF		;YES, FAKE IT
	WAIT$	INFDB,,,IOERR	;WAIT FOR READ IN PROGRESS TO FINISH
	MOV	INBLK,BLKNO	;GET BLOCK NUMBER
	MOV	INBLK+2,BLKNO+2	;..
	MOV	INSTAT+2,R0	;LENGTH OF READ
	ASR	R0		;CONVERT TO WORDS
	MOV	R0,BLKLN	;SAVE IT
	MOV	R0,BUFCNT	;AND INITIALISE BUFCNT ACCORDINGLY
	MOV	CURBUF,BUFPTR	;SET UP DATA POINTER
	TST	SORTF		;SORTED FILE?
	BMI	2$		;NO
	DEC	BUFCNT		;CORRECT FOR LINK WORD
	DEC	BLKLN		;AND IN SAVED LENGTH
	MOV	CURBUF,R0	;GET BUFFER ADDRESS
	MOV	776(R0),INBLK+2	;GET LINK TO NEXT BLOCK
	BLE	3$		;IF ANY
	READ$	INFDB,NXTBUF,,#INBLK,,,,IOERR ;READ NEXT BLOCK
	BR	4$
2$:	INC	INBLK+2		;POINT AT NEXT RECORD
	READ$	INFDB,NXTBUF	;READ NEW RECORD
	BCC	4$		;NO ERROR
	CMPB	#IE.EOF,F.ERR(R0) ;EOF?
	BEQ	3$		;YES, WE CAN HANDLE IT
	CALL	IOERR		;NO, SOMETHING SERIOUS
3$:	MOVB	#-1,EOFF	;FLAG EOF
4$:	EXCHS	CURBUF,NXTBUF,R0 ;EXCHANGE BUFFERS
	BR	PDIN		;AND TRY READ AGAIN

;
;	COMES HERE IF UNEXPECTED EOF IS FOUND
;
FAKEOF:	CALL	ERRGO		;SAY SOMETHING ABOUT IT
	PSTR	^*/UNEXPECTED EOF/<CR><LF>*
	JMP	ERRFIN

;
ERRGO:	CALL	ERRPFX
	PSTR	^*/PDPARS - /*
	RETURN

	.SBTTL	>VARIABLES
;
;
;	I/O
;
INFDB:	.BLKW	1	;POINTS TO FDB OF INPUT FILE
INBLK:	.BLKW	2	;NEXT RECORD NUMBER
WORD01:	.WORD	0,1	;FOR REWINDING FILE
BLKNO:	.BLKW	2	;CURRENT RECORD NUMBER
;
INSTAT:	.BLKW	2	;STATUS BLOCK
;
BLKLN:	.BLKW	1	;SAVE BLOCK LENGTH
;
CURBUF:	.BLKW	1	;POINTER TO BUFFER BEING PROCESSED
NXTBUF:	.BLKW	1	;POINTER TO BUFFER BEING READ
;
BUFCNT:	.BLKW	1	;AMOUNT LEFT IN BUFFER (WORDS)
BUFPTR:	.BLKW	1	;POINTER TO CURRENT WORD IN BUFFER
;
EOFF:	.BLKW	1	;(BYTE) FLAG SET IF EOF HAS BEEN DETECTED
;
;
;	POINT BLOCKS
;
CURBLK:	.BLKW	1	;USED TO STORE POINT BLOCK
NXTBLK:	.BLKW	1	;ADDRESS FROM PDINIT
;
;
;	TRANSFER ADDRESSES
;
PDXLAT::.BLKW	1
PDTEST::.BLKW	1
PDMOVE::.BLKW	1
PDPRIM::.BLKW	1
PDDRAW::.BLKW	1
PDPOIN::.BLKW	1
PDCHAR::.BLKW	1
PDXY:	.BLKW	1
;
;
;	MISCELLANEOUS VARIABLES
;
;
BLANKF:	.BLKW	1	;SET IF CURRENT POINT IS BLANKED
EOLF:	.BLKW	1	;SET IF CURRENT POINT IS LAST
;
MODE:	.BLKW	1	;CURRENT TYPEMODE WORD
;
CHCNT:	.BLKW	1	;LENGTH OF CHARACTER STRING
CHBUF:	.BLKB	1	;(BYTE) NEXT CHARACTER TO FEED CHVEC
SIMULF:	.BLKB	1	;(BYTE) FLAG SET IF SHOULD SIMULATE CHARS
;
SPSAVE:	.BLKW	1	;STACK POINTER AFTER ENTRY AND REGSAVE

;
;	CHARACTER SPECIFICATION TABLES
;
SIMTAB:	.WORD	-1
	.BLKW	7	;FOR SOFTWARE CHARACTERS
STABS:	.BLKW	4*10	;HEADER TABLES COPIED HERE
;
;
;	BUFFERS
;
DATA:	.BLKW	20	;PARAMETER BLOCK PASSED TO PO RTNS
CBUF:	.BLKW	100	;USED TO HOLD CHARACTER STRINGS AND HEADERS
BUF0:	.BLKW	400	;READ BUFFER
BUF1:	.BLKW	400	;READ BUFFER
;
;
;	SORT STUFF
;
SORTF:	.BLKW	1	;-1 IF NOT SORTED, OTHERWISE 0
LOGX:	.BLKW	1	;LOG WIDTH OF PANE
LOGY:	.BLKW	1	;LOG HEIGHT OF PANE
NX:	.BLKW	1	;NUMBER OF STRIPS
NY:	.BLKW	1	;NUMBER OF ROWS
;
SRTPTR:	.BLKW	4*10	;SORT ARRAY
SRTLST:	.BLKW	4*10+1	;LIST OF POINTERS TO PARSE (TERMINATED BY 0)
;
;
	.END