PDP-10 Archive: fortran-compiler/opgnta.mac from BB-4157E-BM

Trailing-Edge - PDP-10 Archives - BB-4157E-BM - fortran-compiler/opgnta.mac
There are 12 other files named opgnta.mac in the archive. Click here to see a list.
	TITLE	OPGNTA - CODE GENERATION TABLES FOR FORTRAN-10
	SUBTTL	S. MURPHY/SRM/HPW/DCE/RDH/TFV/RVM	15-Oct-81		

;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED
;  OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.

;COPYRIGHT (C) 1972,1981 BY DIGITAL EQUIPMENT CORPORATION
; Authors: S. MURPHY/SRM/HPW/DCE/RDH/TFV

	INTERN	OPGNTV
	OPGNTV= BYTE (3)0(9)6(6)0(18)^D127	; Version Date:	15-Oct-81

	SUBTTL	Revision History

Comment \

***** Revision History *****

113	-----	-----	ADD GENERATORS FOR DABS IN LINE
114	-----	-----	ADD GENERATORS FOR EXPONENTATION IN LINE
115	-----	-----	TREAT "NEG-SAME-IMMED" (UNDER OPGETA,OPGETI)
			THE SAME AS "NEG-IMMED"
116	-----	-----	ADD GENERATORS FOR EXPONEN TO MEMORY IN LINE
117	-----	-----	REMOVE GENERATORS FOR SQUARE,CUBE,P4 (THEY
			ARE NOW PART OF "EXPCIOP")
118	-----	-----	ADD GENERATORS FOR IN LINE DP EXPONEN AND
			FOR IN LINE EXPONEN OF AN IMMEDIATE LOOP INDEX
119	264	15974	FIX KI COMPLEX DIVIDE TO MEMORY, (JNT)

***** Begin Version 5A *****

120	611	23662	MULTIPLY OF COMPLEX CONSTANT BY POWER OF TWO
			PLUS 1 IS NOT IMPLEMENTED., (DCE)

***** Begin Version 5B *****

121	677	25573	ADD TABLES FOR PARAMETER CHECKING., (DCE)

***** Begin Version 6 *****

122	750	TFV	1-Jan-80	------
	Remove Debug:Parameter switch (edit 677)

123	761	TFV	1-Mar-80	-----
	Rework tables to handle /GFLOATING
	Remove all KA ops

127	1135	RVM	15-Oct-81
	Make conversion from DOUBLE PRECISION to COMPLEX do rounding.

***** End Revision History *****

\

	SUBTTL	CODE GENERATORS
;

;[761] Get definitions of GFAD, GFSB, GFMP, GFDV
	SEARCH GFOPDF		;[761] OPDEFS FOR GFLOATING INSTRUCTIONS

	HISEG
	INTERN	OPGETI		;base of get arg into a reg
	INTERN	OPGSET		;BASE OF TABLE FOR INITIALIZATION
				; OF LOGICAL VALS
	INTERN	OPGARI		;BASE OF TABLE FOR ARITH OPS, KI10
	INTERN	OPGARG		;[761] BASE OF TABLE FOR ARITH OPS, gfloating
	INTERN	OPGTCG		;[761] BASE OF TABLE FOR TYPE-CONVERSIONS, gfloating
	INTERN	OPGTCI		;BASE OF TABLE FOR TYPE-CONVERSIONS ON KI10
	INTERN	OPGSTI		;BASE OF TABLE FOR "STORE" - KI10
	INTERN	OPGASI		;BASE OF TABLE FOR ASSIGNMENT STMNT-KI10
	INTERN	OPGASR		; SPECIAL CASE FOR ASSIGNMENT OF RIGHT HALF
				; OF AOBJN WD
	INTERN	OPASIN		;TABLE FOR ASSIGN STMNT
	INTERN	OPGBOO		;BASE OF TABLE FOR BOOLEAN OPS
	INTERN	OPGREL		;BASE OF TABLE FOR RELATIONALS
	INTERN	OPGSPG		;[761] base of table for p2mul, p2pl1mul 
				;  for gfloating
	INTERN	OPGILF		;BASE OF TABLE FOR IN-LINE-FNS (WHEN
				; THE ARG IS ALREADY IN REGFORCOMP)
	INTERN	OPGILI		; (WHEN ARG1 IS REGFORCOMP,ARG2 IS IMMED)
	INTERN	OPGIL1		;BASE OF TABLES FOR IN-LINE-FNS WHEN
				; ARG IS NOT IN REGFORCOMP: ABS AND SIGN
	INTERN	OPGN1I		;base of table for neg when in rfc
	INTERN	OPGN2I		;BASE OF TABLE FOR NEG WHEN ARG NOT IN RFC
	INTERN	OPGSPI		;BASE OF TABLE FOR P2MUL,P2PL1MUL -
				; KI10
	INTERN	OPGSPM		;BASE OF TABLE FOR P2MUL ETC DONE TO MEMORY
	INTERN	OPGSTC		;BASE OF TABLE FOR A "STORECLS" NODE
	INTERN	OPGSTD		;BASE OF TABLE FOR "STORECLS"- DOUBL-P
	INTERN	OPGVTS		;BASE OF TABLE FOR TRANSFER OF CONTROL
				; ON A GIVEN VAL OF A GIVEN VAR
	INTERN	OPGALT		;BASE OF TABLE FOR TRANSFER OF CONTROL
				; TO ONE LABEL IF A GIVEN VAR IS TRUE
				; AND TO ANOTHER IF IT IS FALSE
	INTERN	OPGAIF		;BASE OF TABLE FOR ARITH-IF STMNTS IN WHICH
				; THE VAL MUST BE COMPUTED AND TESTED
	INTERN	OPGCGO		;BASE OF TABLE FOR COMPUTED GOTO
	INTERN	OPGCGI		; FOR COMPUTED GOTO WHEN THE VAR IS IN THE
				; RIGHT HALF OF A REG CONTAINING DO-LOOP CTL
	INTERN	OPGIOL		;TO GENERATE A CALL TO IOLST.
	INTERN	OPGMTO		;		TO MTOP.
	INTERN	OPGIN		;		TO IN.
	INTERN	OPGENC		;		TO ENC.
	INTERN	OPGDEC		;		TO DEC.
	INTERN	OPGOUT		;		TO OUT.
	INTERN	OPGWTB		;		TO WTB.
	INTERN	OPGRTB		;		TO RTB.
	INTERN	OPGNLI		;		TO NLI.
	INTERN	OPGNLO		;		TO NLO.
	INTERN	OPGOPE		;		TO OPEN.
	INTERN	OPGFND		;		TO FIND.
	INTERN	OPGRLS		;		TO RELEAS.
	INTERN	OPGCLO		;		TO CLOS.
	INTERN	OPGLIB		;		TO MATH LIBRARY FUNCTION
	INTERN	OPGADJ		;		TO ADJ.
	INTERN	OPGPAU		;ENTRY TO GENERATE CODE FOR PAUSE
	INTERN	OPGSTP		;ENTRY TO GENERATE CODE FOR STOP
	INTERN	OPGEXI		;ENTRY TO GENERATE CODE FOR THE EXIT AT END
				; OF A MAIN PROGRAM
	INTERN	OPGRES		; TO GENERATE CODE FOR CALL TO RESET
	INTERN	OPGFIN		; TO GENERATE CALL TO FOROTS FIN.
	INTERN	OPP21I		; MULTIPLY IMMED MODE BY POWER OF 2+1
	INTERN	OPGPHR		; TO PUSH REGS FOR REG SAVE FOR SFN
	INTERN	OPGPPR		; TO POP REGS FOR REG RESTORE FOR SFN

	INTERN	OPGDBF		; TO GENERATE DABS IN LINE WHEN ARG IN
				; REGFORCOMP
	INTERN	OPGDB1		; TO GENERATE DABS IN LINE WHEN ARG NOT
				; IN REGFORCOMP
	INTERN	OPGEX		; TO GENERATE EXPONENTATION IN LINE
	INTERN	OPGEXS		;	to self
	INTERN	OPGEXM		;	to memory
	INTERN	OPGXPI		;	AOBJN
	INTERN	OPGXG		;[761]  EXPONENTIATION IN LINE, GFLOATING
	INTERN	OPGXGS		;[761] 	TO SELF
	INTERN	OPGXGM		;[761] 	TO MEMORY

;
;DEFINE THE CODE GENERATION TABLES AND DISPATCH TABLE
;
;ELEMENTS IN THE DISPATCH TABLE ARE AOBJN PTRS TO THE PIECE OF CODE 
; TO BE GENERATED OR EITHER OF THE FLAGS
;	ILG -  FOR ILLEGAL ENTRY (EG THE ENTRY FOR A1SAMEFLG AND 
;		A1IMMEDFLG BOTH SET
;	IGN - FOR NO CODE NEED BE GENERATED FOR THIS NODE
;
	IGN=0
	ILG=1
;
;DEFINE CODE GENERATORS FOR EACH OPERATION
;EACH WORD OF CODE TO BE GENERATED IS REPRESENTED BY A 2 WD ENTRY
;	L.H. OF WD 0 - SPECIFIES WHETHER TO ADD A SPECIFIED "REG FOR
;			COMP" INTO THE REG FIELD OF THE PATTERN WD
;	R.H. OF WD 0 - SPECIFIES WHERE TO GET THE "MEMREF" FIELD (BITS
;		13-36) OF THE INSTRUCTION FROM
;	WD 1 - PATTERN FOR INSTRUCTION TO BE GENERATED
;
;DEFINE POSSIBLE VALS FOR LEFT AND  RIGHT HALVES OF WD 0
	FRPTN=0			;FROM PATTERN WD
	FRRFC=1			;FROM "REGFORCOMP"
	IMFN=2			;USE THE IMPLICIT-FN-NAME PTED TO BY TREEPTR
	WD1IMF=3		;USE THE IMPLICIT-FN NAME POINTED TO
				; BY THE RH OF THE PATTERN WD
	RGIMFN=4		;USE THE IMPLICIT FN NAME POINTED TO BY
				; THE RH OF THE PATTERN WD INDEXED BY
				; THE "REGFORCOMP" (IE DIFFERENT
				; LIBRARY ROUTINES ARE CALLED DEPENDING
				; ON WHICH REG THE ARG IS IN)
	A1CNST=5		;ARG1 IMMED CNST
	A2CNST=6		;ARG2 IMMED CNST
	A1CNNG=7		;USE NEG OF IMMED CNST ARG1
	A2CNNG=10		;USE NEG OF IMMED CNST ARG2
	PTRA2=11			;USE ARG2PTR FIELD OF PARENT
	NGPTR2=12		;USE THE NEGATIVE OF THE ARG2PTR FIELD OF
				; PARENT
	P2PTR2=13		;USE 2**(VAL OF ARG2PTR)-1 (USED FOR
				; P2DIV)
	A1LAB=14		;USE THE LABEL INDICATED BY A1LABEL
	A2LAB=15		;USE THE LABEL INDICATEC BY A2LABEL
	A3LAB=16		;USE THE LABEL INDICATED BY A3LABEL
	FROMC1=17		;USE THE CONTENTS OF THE GLOBAL C1H, 
				; THIS ADDRESS FIELD WILL HAVE NO
				; SYMBOLIC REPRESENTATION
	PARTMP=20		;USE THE TMP INDICATED BY THE TARGET
				; OF PARENT (IGNORE INDIRECT AND INDEX
				; BITS IN THE TARGET)
	FROMA1=21		;USE TARGET FIELD OF ARG1
	FROMA2=22		;USE TARGET FIELD OF ARG2
	FROMPA=23		;USE TARGET FIELD OF PARENT (TREEPTR)
;
;
;
;DISPATCH TABLE FOR 'GET ARG INTO A REG' - 
;TO GENERATE CODE FOR THE KI10
OPGETI:	-1,,GA		;NO FLAGS, SINGLE PREC
	-1,,GA
	-1,,GA2KI		;NO FLAGS, DOUBLEPREC, 
	-1,,GA2KI		;NO FLAGS, COMPLEX
	-1,,GAIMI		;IMMED - INTEGER 
	-1,,GAIMRL		;IMMED - REAL
	-2,,GAIM2		;IMMED, DOUBL-PREC - RARELY GENERATED
	-2,,GAIM2		;IMMED COMPLEX
	IGN			;IGNORE (ARG SAMEFLG SET)
	IGN
	IGN
	IGN
	IGN			;ARG SAME AND ARG IMMED FLAGS WILL BOTH BE
				; SET WHEN A REGCONTENTS WHICH IS LOOP CTL VAR
				; IS AN ARG UNDER A RELATIONAL (IGNORE)
	IGN
	IGN
	IGN
	-1,,GANG		;NEG OF ARG
	-1,,GANG
	-1,,GANG2I		;NEG OF DOUBLE-WD ARG - 
	-2,,GNGCM		;NEG OF COMPLEX ARG
	-1,,GNGIMI		;NEG OF IMMED CNST - INTEGER
	-1,,GNGIMR		;NEG OF IMMED CNST - REAL
	-2,,GNGIM2		;NEG OF IMMED DOUBLE-WD
	-2,,GNGIM2
	-1,,GANGSM		;NEG OF VAL ALREADY IN DESIRED REG
	-1,,GANGSM
	-1,,GNGS2I		;NEG OF DOUBLE-WD ARG ALREADY IN DESIRED
				; REG
	-2,,GNGSCM		;NEG OF COMPLEX ARG ALREADY IN DESIRED 
				; REG
		;SAME-IMMED NEGATED - TREAT AS IMMED NEGATED (IGNORE
		; THE "SAMEFLG") - OCCURS WHEN BB ALLOCATOR HAS FOUND
		; AN IMMED CNST THAT WAS LEFT IN A REG AND THEN
		; LATER A NEGFLG WAS MOVED OVER THAT CNST IN CGETVAL
	-1,,GNGIMI		;NEG OF IMMED CNST - INTEGER
	-1,,GNGIMR		;NEG OF IMMED CNST - REAL
	-2,,GNGIM2		;NEG OF IMMED DOUBLE-WD
	-2,,GNGIM2


	-1,,GANT		;NOT OF ARG 
	-1,,GANT
	-2,,GANT2		;NOT OF DOUBLE-WD ARG 
	-2,,GANT2
	-1,,GNTIMI		;NOT OF IMMED CNST - INTEGER
	ILG			;NOT OF IMMED CNST - REAL
	ILG			;NOT OF IMMED, DOUBLE-WD
	ILG	
	-1,,GANTSM		;NOT OF VAL ALREADY IN THE DESIRED REG
	-1,,GANTSM
	-2,,GNTS2		;NOT OF DOUBLE-WD ARG - 
	-2,,GNTS2
;NOTE THAT ALL "GETA1OPIX" VALS ABOVE THIS PT ARE ILLEGAL
; (INVOLVING EITHER BOTH NEG AND NOT OR SAME AND IMMED)
;

;
;
;DEFINE CODE GENERATORS FOR GETTING ARG1 INTO A REG
;
;
	GA=.		;GET ARG INTO REG
;
	FRRFC,,FROMA1
	MOVE	0,0
;
;
;
;
	GA2KI=.		;DOUBLE-PREC KI
	FRRFC,,FROMA1
	DMOVE	0,0
;
;GET IMMED ARGS
	GAIMI=.		;IMMED - INTEGER
	FRRFC,,A1CNST
	MOVEI	0,0
;
	GAIMRL=.	;IMMED - REAL
	GAIM2=.		;IMMED DOUBLE-WD (next 2 instrs)
	FRRFC,,A1CNST
	MOVSI	0,0
;
	FRRFC,,FRPTN
	MOVEI	1,0
;
;
; GET NOT OF ARG
;
	GANT=.			;GET NOT OF ARG
	FRRFC,,FROMA1
	SETCM	0,0
;
	GANT2=.			;GET NOT OF DOUBLE-PREC ARG (next 2 instrs)
	FRRFC,,FROMA1
	SETCM	0,0
	FRRFC,,FROMA1
	SETCM	1,1
;
	GNTIMI=.		;NOT OF AN IMMED CNST - INTEGER
	FRRFC,,A1CNST
	SETCMI	0,0
;
;
;
	GANTSM=.			;NOT OF AN ARG ALREADY IN DESIRED REG
	GNTS2=.			; NOT OF A DOUBLE-WD ARG ALREADY IN 
				; DESIRED REG (next 2 instrs)
	FRRFC,,FRPTN
	SETCA	0,0
;
	FRRFC,,FRPTN
	SETCA	1,0
;
;
;GET NEG ARG
;
	GANG=.			;NEG OF ARG
	GNGCM=.			;NEG OF A COMPLEX ARG (next 2 instrs)
	FRRFC,,FROMA1
	MOVN	0,0
;
	FRRFC,,FROMA1
	MOVN	1,1
;
;
	GANG2I=.		;NEG OF DOUBLE-WD ARG FOR KI10
	FRRFC,,FROMA1
	DMOVN	0,0
;
;
	GNGIMI=.		;NEG OF AN IMMED ARG - INTEGER
	FRRFC,,A1CNST
	MOVNI	0,0
;
	GNGIMR=.		;NEG OF AN IMMED ARG - REAL
	GNGIM2=.		;NEG OF AN IMMED ARG - DOUBLE-WD (next 2 instrs)
	FRRFC,,A1CNNG
	MOVSI	0,0
;
	FRRFC,,FRPTN
	MOVEI	1,0
;
;
;
	GANGSM=.		;NEG OF ARG ALREADY IN DESIRED REG
	GNGSCM=.		;NEG OF COMPLEX ARG ALREADY IN SAME REG (next 2 instrs)
	FRRFC,,FRRFC
	MOVN	0,0
;
	FRRFC,,FRRFC
	MOVN	1,1
;
;
;
;
	GNGS2I=.		;NEG OF DOUBLE-WD ARG ALREADY IN REG 
				; FOR KI10
	FRRFC,,FRRFC
	DMOVN	0,0
;
;


;
;TABLE FOR CODE GENERATION FOR INITIALIZATION OF LOGICAL VALUES
;
OPGSET:	-1,,FLSMEM		;SET MEM LOC FALSE
	-1,,FLSREG		;SET REG FALSE
	-1,,TRMEM		;SET MEM LOC TRUE
	-1,,TRREG		;SET REG TRUE
;
;	CODE GENERATORS FOR LOGICAL INIT
	FLSMEM=.
	FRPTN,,FROMPA
	SETZM	0,0
;
	FLSREG=.
	FRRFC,,FRPTN
	SETZ	0,0
;
	TRMEM=.
	FRPTN,,FROMPA
	SETOM	0,0
;
	TRREG=.
	FRRFC,,FRPTN
	SETO	0,0
;


;
;TABLE FOR CODE GENERATORS FOR EXPONENTIATION IN LINE
;
;FOR KI/KL
OPGEX:	-1,,OPGEX1		;INTEGER MULTIPLY BY MEMORY
	-1,,OPGEX2		;REAL MULTIPLY BY MEMORY
	-1,,OPGEX7		;DP MULTIIPLY BY MEMORY
	ILG			;(COMPLEX EXPONEN NOT DONE IN LINE)
OPGEXS:	-1,,OPGEX3		;INTEGER MULTIPLY BY SELF
	-1,,OPGEX4		;REAL MULTIPLY BY SELF
	-1,,OPGEX8		;DP MULTIPLY BY SELF
	ILG			;(COMPLEX EXPONEN NOT DONE IN LINE)
OPGEXM:	-1,,OPGEX5		;INTEGER MUL TO MEMORY
	-1,,OPGEX6		;REAL MULTIPLY TO MEMORY
	ILG			;DP IS NEVER DONE TO MEMORY
	ILG			;COMPLEX EXPONEN NOT DONE IN LINE
;
;[761] FOR GFLOATING
OPGXG:	-1,,OPGEX1		;INTEGER MULTIPLY BY MEMORY
	-1,,OPGEX2		;REAL MULTIPLY BY MEMORY
	-1,,OPGXG1		;DP MULTIIPLY BY MEMORY
	ILG			;(COMPLEX EXPONEN NOT DONE IN LINE)
OPGXGS:	-1,,OPGEX3		;INTEGER MULTIPLY BY SELF
	-1,,OPGEX4		;REAL MULTIPLY BY SELF
	-1,,OPGXG2		;DP MULTIPLY BY SELF
	ILG			;(COMPLEX EXPONEN NOT DONE IN LINE)
OPGXGM:	-1,,OPGEX5		;INTEGER MUL TO MEMORY
	-1,,OPGEX6		;REAL MULTIPLY TO MEMORY
	ILG			;DP IS NEVER DONE TO MEMORY
	ILG			;COMPLEX EXPONEN NOT DONE IN LINE

;
	OPGEX1=.

	FRRFC,,FROMA1
	IMUL	0,0
;
	OPGEX2=.

	FRRFC,,FROMA1
	FMPR	0,0
;
	OPGEX3=.

	FRRFC,,FRRFC
	IMUL	0,0
;
	OPGEX4=.

	FRRFC,,FRRFC
	FMPR	0,0
;
	OPGEX5=.
	FRRFC,,FROMA1
	IMULM	0,0
;
	OPGEX6=.
	FRRFC,,FROMA1
	FMPRM	0,0
;
	OPGEX7=.
	FRRFC,,FROMA1
	DFMP	0,0		;DP IS DONE IN LINE FOR KI ONLY
;
	OPGEX8=.
	FRRFC,,FRRFC
	DFMP	0,0
;
	OPGXG1=.		;[761]
	FRRFC,,FROMA1
	GFMP	0,0
;
	OPGXG2=.		;[761]
	FRRFC,,FRRFC
	GFMP	0,0
;
;
; FOR EXPONEN OF AN IMMED LOOP INDEX(IE RIGHT HALF OF AOBJN)
;
OPGXPI:	-1,,OPGEX9
;
	OPGEX9=.
	FRRFC,,A1CNST
	IMULI	0,0
;
;TABLE FOR CODE GENERATION FOR ARITH OPERATIONS
;
;FOR KI10
OPGARI:	-1,,ADFX
	-1,,ADFL
	-1,,ADDPKI
	-2,,ADCM
	-1,,SBFX
	-1,,SBFL
	-1,,SBDPKI
	-2,,SBCM
	-1,,MLFX
	-1,,MLFL
	-1,,MLDPKI
	-2,,MLCM
	-1,,DVFX
	-1,,DVFL
	-1,,DVDPKI
	-2,,DVCM
;  FOR OPERATIONS TO MEMORY
	-1,,ADFXM
	-1,,ADFLM
	-2,,ADDPMI
	-2,,ADCMM
	-1,,SBFXM
	-1,,SBFLM
	-2,,SBDPMI
	-2,,SBCMM
	-1,,MLFXM
	-1,,MLFLM
	-2,,MLDPMI
	-2,,MLCMM
	-1,,DVFXM
	-1,,DVFLM
	-2,,DVDPMI
	-2,,DVCMM
;  FOR OPERATIONS PERFORMED IMMEDIATE
	-1,,ADFXI
	-1,,ADFLI
	ILG			;DOUBLE-PREC IMMED IS ILLEGAL
	-1,,ADCMI
	-1,,SBFXI
	-1,,SBFLI
	ILG			;DOUBLE-PREC IMMED IS ILLEGAL
	-1,,SBCMI
	-1,,MLFXI
	-1,,MLFLI
	ILG			;DOUBLE-PREC IMMED IS ILLEGAL
	-2,,MLCMI
	-1,,DVFXI
	-1,,DVFLI
	ILG			;DOUBLE-PREC IMMED IS ILLEGAL
	-2,,DVCMI
;FOR OPERATIONS TO BOTH (NOTE THAT WE DESIGNATE OP TO BOTH BY SETTING
; BOTH THE "OP TO MEMORY" AND "IMMEDIATE" FLAGS)
	-1,,ADFXB	;INTEGER ADD TO BOTH
	-1,,ADFLB	;REAL ADD TO BOTH
	-2,,ADDPMI	;DP ADD TO BOTH ON KI10 SAME AS DP ADD TO MEM
	-2,,ADCMB	;COMPLEX ADD TO BOTH
	-1,,SBFXB	;INTEGER SUBTRACT TO BOTH
	-1,,SBFLB	;REAL SUBTRACTB TO BOTH
	-2,,SBDPMI	;DP SUB TO BOTH ON KI10 SAME AS DP SUB TO MEM
	-2,,SBCMB	;COMPLEX SUBTRACT TO BOTH
	-1,,MLFXB	;INTEGER MULTIPLY TO BOTH
	-1,,MLFLB	;REAL MULTIPLY TO BOTH
	-2,,MLDPMI	;DP MUL TO BOTH ON KI10 SAME AS DP MUL TO MEM
	ILG		;COMPLEX MULTIPLY TO BOTH NOT IMPLEMENTED
	-1,,DVFXB	;INTEGER DIVIDE TO BOTH
	-1,,DVFLB	;REAL DIVIDE TO BOTH
	-2,,DVDPMI	;DP DIV TO BOTH ON KI10 SAME AS DP DIV TO MEM
	ILG		;COMPLEX DIVIDE TO BOTH NOT IMPLEMENTED
;
;[761] FOR GFLOATING
OPGARG:	-1,,ADFX
	-1,,ADFL
	-1,,ADDPGF
	-2,,ADCM
	-1,,SBFX
	-1,,SBFL
	-1,,SBDPGF
	-2,,SBCM
	-1,,MLFX
	-1,,MLFL
	-1,,MLDPGF
	-2,,MLCM
	-1,,DVFX
	-1,,DVFL
	-1,,DVDPGF
	-2,,DVCM
;  FOR OPERATIONS TO MEMORY
	-1,,ADFXM
	-1,,ADFLM
	-2,,ADDPMG
	-2,,ADCMM
	-1,,SBFXM
	-1,,SBFLM
	-2,,SBDPMG
	-2,,SBCMM
	-1,,MLFXM
	-1,,MLFLM
	-2,,MLDPMG
	-2,,MLCMM
	-1,,DVFXM
	-1,,DVFLM
	-2,,DVDPMG
	-2,,DVCMM
;  FOR OPERATIONS PERFORMED IMMEDIATE
	-1,,ADFXI
	-1,,ADFLI
	ILG			;DOUBLE-PREC IMMED IS ILLEGAL
	-1,,ADCMI
	-1,,SBFXI
	-1,,SBFLI
	ILG			;DOUBLE-PREC IMMED IS ILLEGAL
	-1,,SBCMI
	-1,,MLFXI
	-1,,MLFLI
	ILG			;DOUBLE-PREC IMMED IS ILLEGAL
	-2,,MLCMI
	-1,,DVFXI
	-1,,DVFLI
	ILG			;DOUBLE-PREC IMMED IS ILLEGAL
	-2,,DVCMI
;FOR OPERATIONS TO BOTH (NOTE THAT WE DESIGNATE OP TO BOTH BY SETTING
; BOTH THE "OP TO MEMORY" AND "IMMEDIATE" FLAGS)
	-1,,ADFXB	;INTEGER ADD TO BOTH
	-1,,ADFLB	;REAL ADD TO BOTH
	-2,,ADDPMG	;DP ADD TO BOTH ON KI10 SAME AS DP ADD TO MEM
	-2,,ADCMB	;COMPLEX ADD TO BOTH
	-1,,SBFXB	;INTEGER SUBTRACT TO BOTH
	-1,,SBFLB	;REAL SUBTRACTB TO BOTH
	-2,,SBDPMG	;DP SUB TO BOTH ON KI10 SAME AS DP SUB TO MEM
	-2,,SBCMB	;COMPLEX SUBTRACT TO BOTH
	-1,,MLFXB	;INTEGER MULTIPLY TO BOTH
	-1,,MLFLB	;REAL MULTIPLY TO BOTH
	-2,,MLDPMG	;DP MUL TO BOTH ON KI10 SAME AS DP MUL TO MEM
	ILG		;COMPLEX MULTIPLY TO BOTH NOT IMPLEMENTED
	-1,,DVFXB	;INTEGER DIVIDE TO BOTH
	-1,,DVFLB	;REAL DIVIDE TO BOTH
	-2,,DVDPMG	;DP DIV TO BOTH ON KI10 SAME AS DP DIV TO MEM
	ILG		;COMPLEX DIVIDE TO BOTH NOT IMPLEMENTED
;
;
;DEFINE CODE GENERATORS FOR THE ARITHMETIC OPERATIONS
;
;FOR INTEGER, REAL, AND COMPLEX OPERATIONS
	ADFX=.			;ADD INTEGER
	FRRFC,,FROMA2
	ADD	0,0
;
	ADFL=.			;ADD FLOATING PT
	ADCM=.			;ADD COMPLEX (next 2 instrs)
	FRRFC,,FROMA2
	FADR	0,0
;
	FRRFC,,FROMA2
	FADR	1,1
;
;
	SBFX=.			;SUBTRACT INTEGER
	FRRFC,,FROMA2
	SUB	0,0
;
	SBFL=.			;SUBTRACT FLOATING PT
	SBCM=.			;SUBTRACT COMPLEX (next 2 instrs)
	FRRFC,,FROMA2
	FSBR	0,0
;
	FRRFC,,FROMA2
	FSBR	1,1
;
;
	MLFX=.			;MULTIPLY INTEGER
	FRRFC,,FROMA2
	IMUL	0,0
;
	MLFL=.			;MULTIPLY REAL
	FRRFC,,FROMA2
	FMPR	0,0
;
	MLCM=.			;MULTIPLY COMPLEX (next 2 instrs)
	FRPTN,,FROMA2
	MOVEI	16,0
;
	FRPTN,,RGIMFN
	PUSHJ	17,CMMLTB
;
;
	DVFX=.			;INTEGER DIVIDE
	FRRFC,,FROMA2
	IDIV	0,0
;
	DVFL=.			;REAL DIVIDE
	FRRFC,,FROMA2
	FDVR	0,0
;
	DVCM=.			;COMPLEX DIVIDE (next 2 instrs)
	FRPTN,,FROMA2
	MOVEI	16,0
;
	FRPTN,,RGIMFN
	PUSHJ	17,CMDVTB
;
;
;FOR INTEGER,REAL AND COMPLEX OPERATIONS PERFORMED TO MEMORY
	ADFXM=.			;INTEGER ADD TO MEMORY
	FRRFC,,FROMA2
	ADDM	0,0
;
	ADFLM=.			;ADD FLOATING PT TO MEMORY
	ADCMM=.			;ADD COMPLEX TO MEMORY (next 2 instrs)
	FRRFC,,FROMA2
	FADRM	0,0
;
	FRRFC,,FROMA2
	FADRM	1,1
;
;
	SBFXM=.
	FRRFC,,FROMA2
	SUBM	0,0
;
	SBFLM=.			;SUBTRACT FLOATING PT TO MEMORY
	SBCMM=.			;SUBTRACT COMPLEX TO MEMORY (next 2 instrs)
	FRRFC,,FROMA2
	FSBRM	0,0
;
	FRRFC,,FROMA2
	FSBRM	1,1
;
;
	MLFXM=.			;INTEGER MULTIPLY TO MEMORY
	FRRFC,,FROMA2
	IMULM	0,0
;
	MLFLM=.			;REAL MULTIPLY TO MEMORY
	FRRFC,,FROMA2
	FMPRM	0,0
;
	MLCMM=.			;COMPLEX MULTIPLY TO MEMORY (next 2 instrs)
	FRPTN,,FROMA2
	MOVEI	16,0
;
	FRPTN,,RGIMFN
	PUSHJ	17,CMMLMT
;
	DVFXM=.			;INTEGER DIVIDE TO MEMORY
	FRRFC,,FROMA2
	IDIVM	0,0
;
	DVFLM=.			;REAL DIVIDE TO MEMORY
	FRRFC,,FROMA2
	FDVRM	0,0
;
	DVCMM=.			;COMPLEX DIVIDE TO MEMORY (next 2 instrs)
	FRPTN,,FROMA2
	MOVEI	16,0
;
	FRPTN,,RGIMFN
	PUSHJ	17,CMDVMT
;
;
;	INTEGER,REAL AND COMPLEX OPERATIONS PERFORMED IMMEDIATE
	ADFXI=.
	FRRFC,,A2CNST
	ADDI	0,0
;
	ADFLI=.			;ADD FLOATING IMMEDIATE
	ADCMI=.			;ADD IMMED TO COMPLEX
	FRRFC,,A2CNST
	FADRI	0,0
;
	SBFXI=.
	FRRFC,,A2CNST
	SUBI	0,0
;
	SBFLI=.				;SUB FLOATING IMMED
	SBCMI=.				;SUB IMMED FROM COMPLEX
	FRRFC,,A2CNST
	FSBRI	0,0
;
	MLFXI=.			;INTEGER MULTIPLY IMMEDIATE
	FRRFC,,A2CNST
	IMULI	0,0
;
	MLFLI=.			;REAL MULTIPLY IMMEDIATE
	FRRFC,,A2CNST
	FMPRI	0,0
;
	MLCMI=.			;COMPLEX VAR MULTIPLIED BY AN IMMED CONST
	FRRFC,,A2CNST		; (next 2 instrs)
	FMPRI	0,0
;
	FRRFC,,A2CNST
	FMPRI	1,0
;
	DVFXI=.			;INTEGER DIVIDE IMMED
	FRRFC,,A2CNST
	IDIVI	0,0
;
	DVFLI=.			;REAL DIVIDE IMMED
	FRRFC,,A2CNST
	FDVRI	0,0
;
	DVCMI=.			;COMPLEX VAR DIVIDED BY AN IMMED CNST
	FRRFC,,A2CNST		; (next 2 instrs)
	FDVRI	0,0
;
	FRRFC,,A2CNST
	FDVRI	1,0
;
;
;
;
;FOR INTEGER,REAL, AND COMPLEX OPERATIONS TO BOTH
;
	ADFXB=.		;INTEGER ADD TO BOTH
	FRRFC,,FROMA2
	ADDB	0,0
;
	ADFLB=.		;REAL ADD TO BOTH
	ADCMB=.		;COMPLEX ADD TO BOTH (NEXT 2 INSTRS)
	FRRFC,,FROMA2
	FADRB	0,0
;
	FRRFC,,FROMA2
	FADRB	1,1
;
	SBFXB=.		;INTEGER SUBTRACT TO BOTH
	FRRFC,,FROMA2
	SUBB	0,0
;
	SBFLB=.		;REAL SUBTRACT TO BOTH
	SBCMB=.		;COMPLEX SUBTRACT TO BOTH (next 2 instrs)
	FRRFC,,FROMA2
	FSBRB	0,0
;
	FRRFC,,FROMA2
	FSBRB	1,1
;
	MLFXB=.		;INTEGER MULTIPLY TO BOTH
	FRRFC,,FROMA2
	IMULB	0,0
;
	MLFLB=.		;REAL MULTIPLY TO BOTH
	FRRFC,,FROMA2
	FMPRB	0,0
;
;	(COMPLEX MULTIPLY TO BOTH NOT IMPLEMENTED)
;
	DVFXB=.	;INTEGER DIVIDE TO BOTH
	FRRFC,,FROMA2
	IDIVB	0,0
;
	DVFLB=.	;REAL DIVIDE TO BOTH
	FRRFC,,FROMA2
	FDVRB	0,0
;
;	(COMPLEX DIVIDE TO BOTH NOT IMPLEMENTED)
;
;
;
;FOR DOUBLE-PREC OPS ON KI10
;
	ADDPKI=.		; add double-prec
	ADDPMI=.		; (to memory - next 2 instrs)
	FRRFC,,FROMA2
	DFAD	0,0
;
	FRRFC,,FROMA2
	DMOVEM	0,0
;
;
	SBDPKI=.		;SUB DOUBLE-PREC
	SBDPMI=.		; (TO MEMORY - next 2 instrs)
	FRRFC,,FROMA2
	DFSB	0,0
;
	FRRFC,,FROMA2
	DMOVEM	0,0
;
;
	MLDPKI=.		;MUL DOUBLE-PREC
	MLDPMI=.		; (TO MEMORY - next 2 instrs)
	FRRFC,,FROMA2
	DFMP	0,0
;
	FRRFC,,FROMA2
	DMOVEM	0,0
;
;
	DVDPKI=.		;DIV DOUBLE-PREC
	DVDPMI=.		; (TO MEMORY - next 2 instrs)
	FRRFC,,FROMA2
	DFDV	0,0
;
	FRRFC,,FROMA2
	DMOVEM	0,0
;FOR GLOATING DP OPS ON KL10
;
	ADDPGF=.		; add double-prec
	ADDPMG=.		; ( to memory - next 2 instrs)
	FRRFC,,FROMA2
	GFAD	0,0
;
	FRRFC,,FROMA2
	DMOVEM	0,0
;
;
	SBDPGF=.		;SUB DOUBLE-PREC
	SBDPMG=.		; (TO MEMORY - next 2 instrs)
	FRRFC,,FROMA2
	GFSB	0,0
;
	FRRFC,,FROMA2
	DMOVEM	0,0
;
;
	MLDPGF=.		;MUL DOUBLE-PREC
	MLDPMG=.		; (TO MEMORY - next 2 instrs)
	FRRFC,,FROMA2
	GFMP	0,0
;
	FRRFC,,FROMA2
	DMOVEM	0,0
;
;
	DVDPGF=.		;DIV DOUBLE-PREC
	DVDPMG=.		; (TO MEMORY - next 2 instrs)
	FRRFC,,FROMA2
	GFDV	0,0
;
	FRRFC,,FROMA2
	DMOVEM	0,0
;
;
;

;
;SET UP TABLES OF IMPLICIT FUNCTION NAMES
; FOR EACH OPERATION HAVE A DIFFERENT FN CORRESPONDING
; TO EACH REGISTER BETWEEN 2 AND 14
;
;	COMPLEX MULTIPLY
CMMLTB:	SIXBIT "CFM.0"
	SIXBIT "CFM.1"
	SIXBIT "CFM.2"
	SIXBIT "CFM.3"
	SIXBIT "CFM.4"
	SIXBIT "CFM.5"
	SIXBIT "CFM.6"
	SIXBIT "CFM.7"
	SIXBIT "CFM.10"
	SIXBIT "CFM.11"
	SIXBIT "CFM.12"
	SIXBIT "CFM.13"
	SIXBIT "CFM.14"
;	COMPLEX DIVIDE
CMDVTB:	SIXBIT "CFD.0"
	SIXBIT "CFD.1"
	SIXBIT "CFD.2"
	SIXBIT "CFD.3"
	SIXBIT "CFD.4"
	SIXBIT "CFD.5"
	SIXBIT "CFD.6"
	SIXBIT "CFD.7"
	SIXBIT "CFD.10"
	SIXBIT "CFD.11"
	SIXBIT "CFD.12"
	SIXBIT "CFD.13"
	SIXBIT "CFD.14"
;	COMPLEX MULTIPLY TO MEMORY
CMMLMT:	SIXBIT "CMM.0"
	SIXBIT "CMM.1"
	SIXBIT "CMM.2"
	SIXBIT "CMM.3"
	SIXBIT "CMM.4"
	SIXBIT "CMM.5"
	SIXBIT "CMM.6"
	SIXBIT "CMM.7"
	SIXBIT "CMM.10"
	SIXBIT "CMM.11"
	SIXBIT "CMM.12"
	SIXBIT "CMM.13"
	SIXBIT "CMM.14"
;	COMPLEX DIVIDE TO MEMORY
CMDVMT:	SIXBIT "CDM.0"
	SIXBIT "CDM.1"
	SIXBIT "CDM.2"
	SIXBIT "CDM.3"
	SIXBIT "CDM.4"
	SIXBIT "CDM.5"
	SIXBIT "CDM.6"
	SIXBIT "CDM.7"
	SIXBIT "CDM.10"
	SIXBIT "CDM.11"
	SIXBIT "CDM.12"
	SIXBIT "CDM.13"
	SIXBIT "CDM.14"


;
;DISPATCH TABLE FOR TYPE-CONVERSION OPERATIONS
;
;
;FOR KI10
OPGTCI:	IGN		;FROM LOGICAL,	TO INTEG
	IGN		;		TO REAL
	-1,,RLDP	;		TO DOUBLE-PREC
	-1,,RLCMP	;		TO COMPLEX
	IGN		;FROM CONTROL,	TO INTEG
	IGN		;		TO REAL
	-1,,RLDP	;		TO DOUBLE-PREC
	-1,,RLCMP	;		TO COMPLEX
	IGN		;FROM DOUBLE-OCTAL,	TO INTEG
	IGN		;			TO REAL
	IGN		;			TO DOUBLE-PREC
	IGN		;			TO COMPLEX
	IGN		;FROM LITERAL
	IGN
	IGN
	IGN
	IGN		;FROM INTEG,	TO INTEG
	-1,,INRLI	;		TO REAL
	-1,,INDP	;		TO DOUBLE-PREC
	-2,,INCMI	;		TO COMPLEX
	-1,,RLINI	;FROM REAL,	TO INTEGER
	IGN		;		TO REAL
	-1,,RLDP	;		TO DOUBLE PREC
	-1,,RLCMP	;		TO COMPLEX
	-1,,DPIN	;FROM DOUBLE-PREC,	TO INTEGER
	-1,,DPRLI	;			TO REAL
	IGN		;			TO DOUBLE-PREC
	-2,,DPCMP	;[1135]			TO COMPLEX
	-1,,RLINI	;FROM COMPLEX,		TO INTEGER
	IGN		;			TO REAL
	-1,,CMPDP	;			TO DOUBLE-PREC
	IGN		;			TO COMPLEX
;[761] FOR GFLOATING DP
OPGTCG:	IGN		;FROM LOGICAL,	TO INTEG
	IGN		;		TO REAL
	-1,,RLGF	;		TO DOUBLE-PREC
	-1,,RLCMP	;		TO COMPLEX
	IGN		;FROM CONTROL,	TO INTEG
	IGN		;		TO REAL
	-1,,RLGF	;		TO DOUBLE-PREC
	-1,,RLCMP	;		TO COMPLEX
	IGN		;FROM DOUBLE-OCTAL,	TO INTEG
	IGN		;			TO REAL
	IGN		;			TO DOUBLE-PREC
	IGN		;			TO COMPLEX
	IGN		;FROM LITERAL
	IGN
	IGN
	IGN
	IGN		;FROM INTEG,	TO INTEG
	-1,,INRLI	;		TO REAL
	-1,,INGF	;		TO DOUBLE-PREC
	-2,,INCMI	;		TO COMPLEX
	-1,,RLINI	;FROM REAL,	TO INTEGER
	IGN		;		TO REAL
	-1,,RLGF	;		TO DOUBLE PREC
	-1,,RLCMP	;		TO COMPLEX
	-1,,GFIN	;FROM DOUBLE-PREC,	TO INTEGER
	-1,,GFRLI	;			TO REAL
	IGN		;			TO DOUBLE-PREC
	-2,,GFCMP	;			TO COMPLEX
	-1,,RLINI	;FROM COMPLEX,		TO INTEGER
	IGN		;			TO REAL
	-1,,CMPGF	;			TO DOUBLE-PREC
	IGN		;			TO COMPLEX
;
;CODE GENERATORS FOR TYPE CONVERSIONS
;
;
;
;
;
	INDP=.		;INTEGER TO DOUBLE-PREC
	FRPTN,,RGIMFN
	PUSHJ	17,DFLTT
;
;
;
;
	RLCMP=.		;REAL TO COMPLEX
	RLDP=.		;REAL TO DOUBLE-PREC
	CMPDP=.		;COMPLEX TO DOUBLE PREC (ACROSS ASSIGNMENT)
	FRRFC,,FRPTN
	MOVEI	1,0
;
;
;[1135]	Make DOUBLE PRECISION to COMPLEX conversion do rounding.
	DPCMP=.		;DOUBLE PREC TO COMPLEX (ACROSS ASSIGNMENT)
	FRPTN,,RGIMFN
	PUSHJ	17,SNGLT
	FRRFC,,FRPTN
	MOVEI	1,0
;
;
	DPIN=.		;FROM DOUBLE-PREC TO INTEGER
	FRPTN,,RGIMFN
	PUSHJ	17,IDFIXT
;
;
;
;
	DPRLI=.		;FROM DOUBLE PREC TO REAL ON KI10 (USE NEXT 1 INSTR)
	FRPTN,,RGIMFN
	PUSHJ	17,SNGLT
;
;
	INRLI=.		;FROM INTEGER TO REAL ON KI10 (NEXT 1 INSTR)
	INCMI=.		;FROM INTEGER TO COMPLEX ON KI10 (NEXT 2 INSTRS)
	FRRFC,,FRRFC
	FLTR	0,0
;
	FRRFC,,FRPTN
	SETZ	1,0
;
;
	RLINI=.		;FROM REAL TO INTEGER ON KI10
	FRRFC,,FRRFC
	FIX	0,0
;
;
;[761] FOR GFLOATING DP
	INGF=.
	FRRFC,,RGIMFN
	EXTEND	0,GFLTRT
;
;
	RLGF=.
	CMPGF=.
	FRRFC,,RGIMFN
	EXTEND	0,GDBLET
;
;
	GFIN=.
	FRRFC,,RGIMFN
	EXTEND	0,GFIXT
;
;
	GFCMP=.			; (next 2 instrs)
	GFRLI=.
	FRRFC,,RGIMFN
	EXTEND	0,GSNGLT
;
	FRRFC,,FRPTN
	MOVEI	1,0
;
;
;
;SET UP SIXBIT FN NAMES FOR THE LIBRARY FNS USED FOR TYPE-CONVERSIONS - 
; THE OUTPUT MODULE EXPECTS
; TO BE GIVEN A PTR TO THE SIXBIT FOR A FUNCTION NAME
FLOATT:	SIXBIT	"FLT.0"
	SIXBIT	"FLT.1"
	SIXBIT	"FLT.2"
	SIXBIT	"FLT.3"
	SIXBIT	"FLT.4"
	SIXBIT	"FLT.5"
	SIXBIT	"FLT.6"
	SIXBIT	"FLT.7"
	SIXBIT	"FLT.10"
	SIXBIT	"FLT.11"
	SIXBIT	"FLT.12"
	SIXBIT	"FLT.13"
	SIXBIT	"FLT.14"
;
DFLTT:	SIXBIT	"DFL.0"
	SIXBIT	"DFL.1"
	SIXBIT	"DFL.2"
	SIXBIT	"DFL.3"
	SIXBIT	"DFL.4"
	SIXBIT	"DFL.5"
	SIXBIT	"DFL.6"
	SIXBIT	"DFL.7"
	SIXBIT	"DFL.10"
	SIXBIT	"DFL.11"
	SIXBIT	"DFL.12"
	SIXBIT	"DFL.13"
	SIXBIT	"DFL.14"
;
IFIXT:	SIXBIT	"IFX.0"
	SIXBIT	"IFX.1"
	SIXBIT	"IFX.2"
	SIXBIT	"IFX.3"
	SIXBIT	"IFX.4"
	SIXBIT	"IFX.5"
	SIXBIT	"IFX.6"
	SIXBIT	"IFX.7"
	SIXBIT	"IFX.10"
	SIXBIT	"IFX.11"
	SIXBIT	"IFX.12"
	SIXBIT	"IFX.13"
	SIXBIT	"IFX.14"
;
IDFIXT:	SIXBIT	"IDF.0"
	SIXBIT	"IDF.1"
	SIXBIT	"IDF.2"
	SIXBIT	"IDF.3"
	SIXBIT	"IDF.4"
	SIXBIT	"IDF.5"
	SIXBIT	"IDF.6"
	SIXBIT	"IDF.7"
	SIXBIT	"IDF.10"
	SIXBIT	"IDF.11"
	SIXBIT	"IDF.12"
	SIXBIT	"IDF.13"
	SIXBIT	"IDF.14"
SNGLT:	SIXBIT	"SNG.0"
	SIXBIT	"SNG.1"
	SIXBIT	"SNG.2"
	SIXBIT	"SNG.3"
	SIXBIT	"SNG.4"
	SIXBIT	"SNG.5"
	SIXBIT	"SNG.6"
	SIXBIT	"SNG.7"
	SIXBIT	"SNG.10"
	SIXBIT	"SNG.11"
	SIXBIT	"SNG.12"
	SIXBIT	"SNG.13"
	SIXBIT	"SNG.14"
GDBLET:	SIXBIT	"GDB.0"
	SIXBIT	"GDB.1"
	SIXBIT	"GDB.2"
	SIXBIT	"GDB.3"
	SIXBIT	"GDB.4"
	SIXBIT	"GDB.5"
	SIXBIT	"GDB.6"
	SIXBIT	"GDB.7"
	SIXBIT	"GDB.10"
	SIXBIT	"GDB.11"
	SIXBIT	"GDB.12"
	SIXBIT	"GDB.13"
	SIXBIT	"GDB.14"
GFIXT:	SIXBIT	"GFX.0"
	SIXBIT	"GFX.1"
	SIXBIT	"GFX.2"
	SIXBIT	"GFX.3"
	SIXBIT	"GFX.4"
	SIXBIT	"GFX.5"
	SIXBIT	"GFX.6"
	SIXBIT	"GFX.7"
	SIXBIT	"GFX.10"
	SIXBIT	"GFX.11"
	SIXBIT	"GFX.12"
	SIXBIT	"GFX.13"
	SIXBIT	"GFX.14"
GFLTRT:	SIXBIT	"GFL.0"
	SIXBIT	"GFL.1"
	SIXBIT	"GFL.2"
	SIXBIT	"GFL.3"
	SIXBIT	"GFL.4"
	SIXBIT	"GFL.5"
	SIXBIT	"GFL.6"
	SIXBIT	"GFL.7"
	SIXBIT	"GFL.10"
	SIXBIT	"GFL.11"
	SIXBIT	"GFL.12"
	SIXBIT	"GFL.13"
	SIXBIT	"GFL.14"
GSNGLT:	SIXBIT	"GSN.0"
	SIXBIT	"GSN.1"
	SIXBIT	"GSN.2"
	SIXBIT	"GSN.3"
	SIXBIT	"GSN.4"
	SIXBIT	"GSN.5"
	SIXBIT	"GSN.6"
	SIXBIT	"GSN.7"
	SIXBIT	"GSN.10"
	SIXBIT	"GSN.11"
	SIXBIT	"GSN.12"
	SIXBIT	"GSN.13"
	SIXBIT	"GSN.14"

;
;DISPATCH TABLE FOR STORE VALUE
;
;FOR KI10
OPGSTI:	-1,,ST
	-1,,ST2I
;
;CODE GENERATORS TO STORE A VAL
	ST=.
	FRRFC,,FROMPA
	MOVEM	0,0
;
;
;
	ST2I=.
	FRRFC,,FROMPA
	DMOVEM	0,0
;
;
;
;
;DISPATCH TABLE FOR "ASSIGNMENT STMNT STORE VALUE"
;
;
;FOR KI10
OPGASI:	-1,,ST
	-1,,ST
	-1,,ST2I
	-1,,ST2I
;	FOR NEG OF ARG
	-1,,STNG
	-1,,STNG
	-1,,STNG2I		;STORE NEG OF DOUBLE-PREC
	-2,,STNCPX		; NEG OF COMPLEX
;	FOR NOT OF ARG
	-1,,STNT
	-1,,STNT
	-2,,STNT2
	-2,,STNT2
; 
;WHEN STORING THE RIGHT HALF OF A REGCONTENTS WHICH WAS USED AS AN AOBJN WD
OPGASR:	-1,,STAOBJ
;
;
;CODE GENERATORS TO STORE NEG OR NOT OF A VALUE
	STNG=.
	STNCPX=.		;STORE NEG OF COMPLEX (NEXT 2 INSTRS)
	FRRFC,,FROMPA
	MOVNM	0,0
;
	FRRFC,,FROMPA
	MOVNM	1,1
;
	STNT=.			;STORE NOT OF ARG
	FRRFC,,FROMPA
	SETCAM	0,0
;
;
;
	STNG2I=.		;STORE NEG OF ARG - DOUBLE-PREC KI10
	FRRFC,,FROMPA
	DMOVNM	0,0
;
	STNT2=.			;STORE NOT OF DOUBLE-WD ARG (next 2 instrs)
	FRRFC,,FROMPA
	SETCAM	0,0
;
	FRRFC,,FROMPA
	SETCAM	1,1
;
;
;CODE GENERATOR FOR THE SPECIAL CASE OF STORING THE RIGHT HALF OF AN AOBJN WD
; (WHICH CONTAINS A LOOP INDEX)
STAOBJ:	FRRFC,,FROMPA
	HRRZM	0,0


;
;FOR ASSIGN STATEMENT
;
OPASIN:	-2,,ASSIGN
;
	ASSIGN=.		;ALWAYS USE REG 1 (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI	1,0
;
	FRPTN,,FROMA1
	MOVEM	1,0
;

;
;DISPATCH TABLE FOR BOOLEAN OPERATIONS
;
;	COMPUTED IN A REG
OPGBOO:	-1,,ANDRG
	-1,,ORRG
	-1,,EQVRG
	-1,,XORRG
;	COMPUTED TO MEMORY
	-1,,ANDMEM
	-1,,ORMEM
	-1,,EQVMEM
	-1,,XORMEM
;	COMPUTED IMMEDIATE
	-1,,ANDIMM
	-1,,ORIMM
	-1,,EQVIMM
	-1,,XORIMM
;	OPERATIONS TO BOTH REG AND MEMORY
	-1,,ANDBO
	-1,,ORBO
	-1,,EQVBO
	-1,,XORBO
;	OPERATIONS INCLUDING NOT OF 2ND ARG
	-1,,ANDNOT
	-1,,ORNOT
	-1,,XORRG		;EQV WITH NOT X IS SAME AS XOR X
	-1,,EQVRG		;XOR WITH NOT X = EQV WITH X
;	OPERATIONS TO MEMORY INCLUDING NOT OF 2ND ARG
	-1,,ANDNTM
	-1,,ORNTM
	-1,,XORMEM
	-1,,EQVMEM
;	COMPUTED IMMEDIATE WITH NOT OF THE 2ND ARG
	-1,,ANDNTI
	-1,,ORNTI
	-1,,XORIMM	;XOR WITH NOT OF ARG IS SAME AS EQV WITH ARG
	-1,,EQVIMM
;	OPERATIONS TO "BOTH" WITH NOT OF 2ND ARG
	-1,,ANDNTB
	-1,,ORNTB
	-1,,XORBO	;EQV WITH NOT IS SAME AS XOR
	-1,,EQVBO	;XOR WITH NOT IS SAME AS EQV
;
;
;
;DEFINE CODE GENERATORS FOR BOOLEAN OPS
;
	ANDRG=.
	FRRFC,,FROMA2
	AND	0,0
;
	ORRG=.
	FRRFC,,FROMA2
	IOR	0,0
;
	EQVRG=.
	FRRFC,,FROMA2
	EQV	0,0
;
	XORRG=.
	FRRFC,,FROMA2
	XOR	0,0
;
	ANDMEM=.
	FRRFC,,FROMA2
	ANDM	0,0
;
	ORMEM=.
	FRRFC,,FROMA2
	IORM	0,0
;
	EQVMEM=.
	FRRFC,,FROMA2
	EQVM	0,0
;
	XORMEM=.
	FRRFC,,FROMA2
	XORM	0,0
;
	ANDBO=.		;AND TO BOTH
	FRRFC,,FROMA2
	ANDB	0,0
;
	ORBO=.		;OR TO BOTH
	FRRFC,,FROMA2
	IORB	0,0
;
	EQVBO=.		;EQV TO BOTH
	FRRFC,,FROMA2
	EQVB	0,0
;
	XORBO=.
	FRRFC,,FROMA2
	XORB	0,0
;
	ANDIMM=.
	FRRFC,,A2CNST
	ANDI	0,0
;
	ORIMM=.
	FRRFC,,A2CNST
	IORI	0,0
;
	EQVIMM=.
	FRRFC,,A2CNST
	EQVI	0,0
;
	XORIMM=.
	FRRFC,,A2CNST
	XORI	0,0
;
	ANDNOT=.
	FRRFC,,FROMA2
	ANDCM	0,0
;
	ORNOT=.
	FRRFC,,FROMA2
	ORCM	0,0
;
	ANDNTM=.
	FRRFC,,FROMA2
	ANDCMM	0,0
;
	ORNTM=.
	FRRFC,,FROMA2
	ORCMM	0,0
;
	ANDNTI=.	;AND WITH NOT OF AN IMMED
	FRRFC,,A2CNST
	ANDCMI	0,0
;
	ORNTI=.		;OR WITH NOT OF AN IMMED
	FRRFC,,A2CNST
	ORCMI	0,0
;
	ANDNTB=.	;AND WITH NOT OF ARG TO BOTH
	FRRFC,,FROMA2
	ANDCMB	0,0
;
	ORNTB=.		;OR WITH NOT OF ARG TO BOTH
	FRRFC,,FROMA2
	ORCMB	0,0

;
;DISPATCH TABLE FOR RELATIONALS
;
;	WHERE ARGS ARE SINGLE-WD - AND ARG2 NOT IMMED
OPGREL:	ILG		;MODE 0 ILLEGAL
	-1,,CMSPL
	-1,,CMSPE
	-1,,CMSPLE
	ILG		;MODE 4 IS ILLEGAL
	-1,,CMSPGE
	-1,,CMSPN
	-1,,CMSPG
;	FOR ARG2 IMMED
	ILG		;MODE 0 IS ILLEGAL
	-1,,CMIML
	-1,,CMIME
	-1,,CMIMLE
	ILG		;MODE 4 IS ILLEGAL
	-1,,CMIMGE
	-1,,CMIMN
	-1,,CMIMG
;	FOR ARGS DOUBLE-WD
	ILG		;MODE 0 IS ILLEGAL
	-3,,CMDPL
	-2,,CMDPE
	-3,,CMDPLE
	ILG		;MODE 4 IS ILLEGAL
	-3,,CMDPGE
	-3,,CMDPN
	-3,,CMDPG
;	ARG2 IMMED AND DOUBLE-WD BOTH
	ILG	;MODE 0 IS ILLEGAL
	-3,,CDPIL
	-2,,CDPIE
	-3,,CDPILE
	ILG	;MODE 4 IS ILLEGAL
	-3,,CDPIGE
	-3,,CDPIN
	-3,,CDPIG
;
;
;CODE GENERATORS FOR RELATIONALS
;
;	TO COMPARE SINGLE-WD ARGS
	CMSPL=.
	FRRFC,,FROMA2
	CAML	0,0
;
	CMSPE=.
	FRRFC,,FROMA2
	CAME	0,0
;
	CMSPLE=.
	FRRFC,,FROMA2
	CAMLE	0,0
;
	CMSPGE=.
	FRRFC,,FROMA2
	CAMGE	0,0
;
	CMSPN=.
	FRRFC,,FROMA2
	CAMN	0,0
;
	CMSPG=.
	FRRFC,,FROMA2
	CAMG	0,0
;
;	TO COMPARE WITH AN IMMED CNST SPECIFIED BY ARG2
	CMIML=.
	FRRFC,,A2CNST
	CAIL	0,0
;
	CMIME=.
	FRRFC,,A2CNST
	CAIE	0,0
;
	CMIMLE=.
	FRRFC,,A2CNST
	CAILE	0,0
;
	CMIMGE=.
	FRRFC,,A2CNST
	CAIGE	0,0
;
	CMIMN=.
	FRRFC,,A2CNST
	CAIN	0,0
;
	CMIMG=.
	FRRFC,,A2CNST
	CAIG	0,0
;
;	TO COMPARE DOUBLE-WD ARGS
	CMDPL=.		; (next 3 instrs)
	FRRFC,,FROMA2
	CAMN	0,0
;
	FRRFC,,FROMA2
	CAMGE	1,1
;
	FRRFC,,FROMA2
	CAMLE	0,0
;
	CMDPE=.		; (next 3 instrs)
	FRRFC,,FROMA2
	CAMN	0,0
;
	FRRFC,,FROMA2
	CAME	1,1
;
	CMDPLE=.		; (next 3 instrs)
	FRRFC,,FROMA2
	CAMN	0,0
;
	FRRFC,,FROMA2
	CAMG	1,1
;
	FRRFC,,FROMA2
	CAMLE	0,0
;
	CMDPGE=.		; (next 3 instrs)
	FRRFC,,FROMA2
	CAMN	0,0
;
	FRRFC,,FROMA2
	CAML	1,1
;
	FRRFC,,FROMA2
	CAMGE	0,0
;
	CMDPN=.		; (next 3 instrs)
	FRRFC,,FROMA2
	CAMN	0,0
;
	FRRFC,,FROMA2
	CAME	1,1
;
	FRPTN,,FRPTN
	SKIPA
;
	CMDPG=.		; (next 3 instrs)
	FRRFC,,FROMA2
	CAMN	0,0
;
	FRRFC,,FROMA2
	CAMLE	1,1
;
	FRRFC,,FROMA2
	CAMGE	0,0
;
;
;	TO COMPARE DOUBLE-WD IMMED - THIS IS USED ONLY FOR THE CASE
;   	  OF A COMPLEX BEING COMPARED TO 0 , BUT ITS EASIER TO HAVE THE ENTRIES
;		IN THE TABLE THAN TO DIFFERENTIATE COMPLEX-IMMED FROM 
;		REAL-IMMED
	CDPIL=.		; (next 3 instrs)
	FRRFC,,A2CNST
	CAIN	0,0
;
	FRRFC,,FRPTN
	CAIGE	1,0
;
	FRRFC,,A2CNST
	CAILE	0,0
;
	CDPIE=.		; (next 3 instrs)
	FRRFC,,A2CNST
	CAIN	0,0
;
	FRRFC,,FRPTN
	CAIE	1,0
;
	CDPILE=.		; (next 3 instrs)
	FRRFC,,A2CNST
	CAIN	0,0
;
	FRRFC,,FRPTN
	CAIG	1,0
;
	FRRFC,,A2CNST
	CAILE	0,0
;
	CDPIGE=.		; (next 3 instrs)
	FRRFC,,A2CNST
	CAIN	0,0
;
	FRRFC,,FRPTN
	CAIL	1,0
;
	FRRFC,,A2CNST
	CAIGE	0,0
;
	CDPIN=.		; (next 3 instrs)
	FRRFC,,A2CNST
	CAIN	0,0
;
	FRRFC,,FRPTN
	CAIE	1,0
;
	FRPTN,,FRPTN
	SKIPA
;
	CDPIG=.		; (next 3 instrs)
	FRRFC,,A2CNST
	CAIN	0,0
;
	FRRFC,,FRPTN
	CAILE	1,0
;
	FRRFC,,A2CNST
	CAIGE	0,0
;



;
;DISPATCH TABLE FOR NEGNOT NODES
; HAVE 2 TABLES - ONE FOR THE CASE WHERE THE VAL HAS BEEN FETCHED
; INTO THE RFC BY GETA2OPIX, THE OTHER FOR THE CASE WHERE IT HAS NOT
;
;NOTE THAT MANY OF THE CODE GENERATORS REFERRED TO ARE ALSO USED FOR
; THE 'OPGETI' ENTRIES AND MAY BE FOUND IN THAT PART OF THE
; LISTING (APPROX LOCS 160-205)
; ALSO, SOME OF THE CODE GENERATORS FOR OPS 'TO MEMORY' ARE ALSO
; USED FOR THE 'OPGASI' ENTRIES AND MAY BE FOUND WITH THEM
; (APPROX LOCS 1244-1263)
;
;IF VAL IS ALREADY IN RFC
;
; KI10
OPGN1I:	-1,,GANGSM		;NEG OF INTEGER
	-1,,GANGSM		; REAL
	-1,,GNGS2I		; DOUBLE-PREC
	-2,,GNGSCM		; COMPLEX
;
	-1,,GANTSM		;NOT OF INTEGER
	-1,,GANTSM		; REAL
	-2,,GNTS2		; DOUBLE-PREC
	-2,,GNTS2		; COMPLEX
;
;		TO MEMORY
	-1,,STNG		;NEG OF INTEGER
	-1,,STNG		; REAL
	-3,,STNG2I		; DOUBLE-PREC
	-2,,STNCPX		; COMPLEX
;
	-1,,STNT		;NOT OF INTEGER
	-1,,STNT		; REAL
	-2,,STNT2		; DOUBLE-PREC
	-2,,STNT2		; COMPLEX
;
;
;WHEN THE ARG IS NOT YET IN RFC
;
; KI10
OPGN2I:	-1,,GANG		;NEG OF INTEGER
	-1,,GANG		; REAL
	-1,,GANG2I		; DOUBLE-PREC
	-2,,GNGCM		; COMPLEX
;
	-1,,GANT		;NOT OF INTEGER
	-1,,GANT		; REAL
	-2,,GANT2		; DOUBLE-PREC
	-2,,GANT2		; COMPLEX
;
;	 TO MEMORY
	-1,,NEGM		;NEG OF INTEGER
	-1,,NEGM		; REAL
	-2,,NEG2IM		; DOUBLE-PREC
	-2,,NEGCMM		; COMPLEX
;
	-1,,NOTM		;NOT OF INTEGER
	-1,,NOTM		; REAL
	-2,,NOT2M		; DOUBLE-PREC
	-2,,NOT2M		; COMPLEX
;
;	 IMMEDIATE
	-1,,GNGIMI		;NEG OF INTEGER
	-1,,GNGIMR		;REAL
	ILG			;DOUBLE-PREC (ILLEGAL)
	-2,,GNGIM2		;COMPLEX
;
	-1,,GNTIMI		;NOT OF IMMED CNST INTEGER
	ILG			; REAL
	ILG			; DOUBLE-PREC
	ILG			; COMPLEX
;
;
;
;NOTE THAT MOST OF THE CODE GENERATORS REFERENCED ABOVE  ARE EITHER WITH
; "OPGETI" OR WITH  "OPGASI"
;THE FOLLOWING CODE GENERATORS ARE FOR NEG/NOT PERFORMED FROM MEMORY TO 
; MEMORY
;
	NEGM=.			;NEG OF INTEGER/REAL
	NEGCMM=.		;NEG OF COMPLEX (NEXT 2 INSTRS)
	FRPTN,,FROMA2
	MOVNS	0,0
;
	FRPTN,,FROMA2
	MOVNS	0,1
;
;
	NEG2IM=.		;NEG OF DOUBLE-PREC ( next 2 instrs )
	FRRFC,,FROMA2
	DMOVN	0,0
;
	FRRFC,,FROMA2
	DMOVEM	0,0
;
;
	NOTM=.			;NOT OF INTEGER/REAL
	NOT2M=.			;NOT OF DOUBLE-PREC/COMPLEX (NEXT 2 INSTRS)
	FRPTN,,FROMA2
	SETCMM	0,0
;
	FRPTN,,FROMA2
	SETCMM	0,1
;

;
;DISPATCH TABLE FOR COMPUTATION OF P2MUL,P2DIV  AND P2PL1MUL
;
;FOR KI10
	;MULTIPLY BY POWER OF 2
OPGSPI:	-1,,P2MFX
	-1,,P2MFL
	ILG
	-2,,P2MCM
	; WHEN ARG WAS NEGATED
	-1,,P2MFX
	-1,,P2MFL
	ILG
	-2,,P2MCM
	;DIVIDE BY A POWER OF 2
	-3,,P2DFX
	-1,,P2DFL
	ILG
	-2,,P2DCM
	; WHEN ARG WAS NEGATED
	-3,,P2DFX
	-1,,P2DFL
	ILG
	-2,,P2DCM
	;FOR MULTIPLY BY POWER OF 2 PLUS 1
	-2,,P21FX
	-2,,P21FL
	ILG
	-4,,P21CM
	; WHEN ARG WAS NEGATED
	-2,,P21NFX
	-2,,P21NFL
	ILG
	-4,,P21NCM
;[761] FOR GFLOATING DP
	;MULTIPLY BY POWER OF 2
OPGSPG:	-1,,P2MFX
	-1,,P2MFL
	ILG
	-2,,P2MCM
	; WHEN ARG WAS NEGATED
	-1,,P2MFX
	-1,,P2MFL
	ILG
	-2,,P2MCM
	;DIVIDE BY A POWER OF 2
	-3,,P2DFX
	-1,,P2DFL
	ILG
	-2,,P2DCM
	; WHEN ARG WAS NEGATED
	-3,,P2DFX
	-1,,P2DFL
	ILG
	-2,,P2DCM
	;FOR MULTIPLY BY POWER OF 2 PLUS 1
	-2,,P21FX
	-2,,P21FL
	ILG
	-4,,P21CM
	; WHEN ARG WAS NEGATED
	-2,,P21NFX
	-2,,P21NFL
	ILG
	-4,,P21NCM
;
;DISPATCH TABLE FOR MULT BY A POWER OF 2 PLUS 1  WHEN "A1IMMEDFLG" WAS
; SET (THIS IS THE ONLY OPERATOR FOR WHICH IMMEDFLG IS SIGNIFICANT)
OPP21I:	-2,,P21IFX	;IMMED, FIXED POINT
	-2,,P21IFL	;IMMED, FLOATING POINT
	ILG		;IMMED DOUBLE-PREC SHOULD NEVER OCCUR
	-2,,P21ICM	;IMMED, COMPLEX
;	  (P2PL1MUL NEGATED)
	-2,,P21INX	;IMMED,NEGATED,FIXED PT
	-2,,P21INL	;IMMED,NEGATED,FLOATING PT
	ILG		;IMMED, DOUBLE-PREC IS ILLEGAL
	-2,,P21INM	;IMMED, NEGATED, COMPLEX
;
;
;
;DISPATCH TABLE FOR SPECIAL OPS DONE TO MEMORY.
;
;	P2MUL SHOULD NEVER BE DONE TO MEMORY
OPGSPM:	ILG
	ILG
	ILG
	ILG
;	(P2MUL NEGATED - SHOULD NEVER BE DONE TO MEMORY)
	ILG
	ILG
	ILG
	ILG
;	P2DIV SHOULD NEVER BE DONE TO MEMORY
	ILG
	ILG
	ILG
	ILG
;	(P2DIV NEGATED)
	ILG
	ILG
	ILG
	ILG
;	MULTIPLY BY A POWER OF 2 PLUS ONE
	-2,,P21MFX
	-2,,P21MFL
	ILG		;DOUBLE PREC OPS ARE NEVER DONE TO MEMORY
	-4,,P21MCM
;	MULTIPLY THE NEG OF A NUMBER BY A POWER OF TWO PLUS ONE
	-2,,P21MNX
	-2,,P21MNL
	ILG		;DOUBLE PREC OPS ARE NEVER DONE TO MEMORY
	-4,,P21MNC
;
;
;
;
;CODE GENERATORS FOR MULTIPLICATION BY A POWER OF 2
;
	P2MFX=.			;FIXED POINT MULTIPLY BY A POWER OF 2
	P21FX=.			;FIXED POINT MULTIPLY BY A POWER OF 2
				; PLUS 1 (USE NEXT 2 INSTRS)
	FRRFC,,PTRA2
	ASH	0,0
;
	FRRFC,,FROMA1
	ADD	0,0
;
;
;
	P21NFX=.		;FIXED PT MULTIPLY BY POWER OF 2 PLUS
				; 1 WHEN ARG WAS NEGATED (NEXT 2 INSTRS)
	FRRFC,,PTRA2
	ASH	0,0
;
	FRRFC,,FROMA1
	SUB	0,0
;
;
;
	P2MFL=.			;FLOATING MULTIPLY BY A POWER OF 2
				; (USE THE 1 NEXT INSTR)
	P21FL=.			;FLOATING POINT MULTIPLY BY A POWER OF 2
				; PLUS 1 (USE NEXT 2 INSTRS)
	FRRFC,,PTRA2
	FSC	0,0
;
	FRRFC,,FROMA1
	FADR	0,0
;
;
	P21NFL=.		;FLOATING PT MULTIPLY BY POWER OF 2 PLUS
				; ONE WHEN ARG WAS NEGATED (NEXT 2 INSTRS)
	FRRFC,,PTRA2
	FSC	0,0
;
	FRRFC,,FROMA1
	FSBR	0,0
;
;
;
;
;
	P2MCM=.			;MULTIPLY A COMPLEX BY POWER OF 2
				; (USE NEXT 2 INSTRS)
	P21CM=.			;MULTIPLY A COMPLEX BY A POWER OF 2 PLUS
				; 1 (USE NEXT 4 INSTRS)
	FRRFC,,PTRA2
	FSC	0,0
;
	FRRFC,,PTRA2
	FSC	1,0
;
	FRRFC,,FROMA1
	FADR	0,0
;
	FRRFC,,FROMA1
	FADR	1,1
;
;
	P21NCM=.		;COMPLEX MULTIPLIED BY POWER OF 2 PLUS 1
				; WHEN ARG WAS NEGATED (next 4 instrs)
	FRRFC,,PTRA2
	FSC	0,0
;
	FRRFC,,PTRA2
	FSC	1,0
;
	FRRFC,,FROMA1
	FSBR	0,0
;
	FRRFC,,FROMA1
	FSBR	1,1
;
;
	P2DFX=.			;FIXED PT DIVIDE BY A POWER OF 2
				; (USE NEXT 3 INSTRS)
	FRPTN,,FRRFC
	SKIPGE	0
;
	FRRFC,,P2PTR2
	ADDI	0,0
;
	FRRFC,,NGPTR2
	ASH	0
;
;
	P2DFL=.			;FLOATING PT DIVIDE BY A POWER OF 2
	P2DDPI=.		;DOUBLE-PREC DIVIDE BY A POWER OF 2
				; ON THE KI10
	FRRFC,,NGPTR2
	FSC	0,0
;
	FRPTN,,FRPTN
	JFCL	(5)
;
;
	P2DCM=.			;COMPLEX DIVIDE  BY A POWER OF 2 
				; (USE THE NEXT 2 INSTRS)
	FRRFC,,NGPTR2
	FSC	0,0
;
	FRRFC,,NGPTR2
	FSC	1,0
;
;
;
	P2MDPI=.		;DOUBLE-PREC MULTIPLY BY A POWER OF 2 FOR
				; THE KI10 (USE THE 2 NEXT INSTR)
	P21DPI=.		;DOUBLE-PREC MULTIPLY BY A POWER OF 2 PLUS 
				; 1 FOR KI10 (USE NEXT 3 INSTRS)
	FRRFC,,PTRA2
	FSC	0,0
;
	FRPTN,,FRPTN
	JFCL	(5)
;
	FRRFC,,FROMA1
	DFAD	0,0
;
;
	P21NDI=.		;DOUBLE-PREC MULTP BY POWER OF 2 PLUS 1
				; ON KI10 WHEN ARG WAS NEGATED
	FRRFC,,PTRA2
	FSC	0,0
;
	FRPTN,,FRPTN
	JFCL	(5)
;
	FRRFC,,FROMA1
	DFSB	0,0
;
;
;
;CODE GENERATORS FOR MULTIPLY OF AN IMMED MODE ITEM BY A POWER OF 2 PLUS 1
;
	P21IFX=.	;FIXED PT IMMED CNST MULTIPLIED BY A POWER OF
			; 2 PLUS 1 (next 2 instrs)
	FRRFC,,PTRA2
	ASH	0,0
;
	FRRFC,,A1CNST
	ADDI	0,0
;
;
	P21IFL=.	;FLOATING PT IMMED MULTIPLIED BY POWER OF 2 PLUS 1
	FRRFC,,PTRA2	; (next 2 instrs)
	FSC	0,0
;
	FRRFC,,A1CNST
	FADRI	0,0
	P21ICM=.	;COMPLEX IMMED, MULTIPLIED BY POWER OF 2 PLUS 1
	FRRFC,,PTRA2	;(next 2 instrs)
	FSC	0,0
;
	FRRFC,,A1CNST
	FADRI	0,0
;
;
	P21INX=.	;FIXED PT IMMED, NEGATED AND MULTIPLIED
	FRRFC,,PTRA2	; (next 2 instrs)
	ASH	0,0
;
	FRRFC,,A1CNST
	SUBI	0,0
;
;
	P21INL=.	;FLOATING PT IMMED NEGATED AND MULTIPLIED
	FRRFC,,PTRA2	; (next 2 instrs)
	FSC	0,0
;
	FRRFC,,A1CNST
	FSBRI	0,0
;
	P21INM=.	;COMPLEX NEGATED MULTIPLIED BY
			;POWER OF TWO PLUS 1 (next 2 instrs)
	FRRFC,,PTRA2
	FSC	0,0
;
	FRRFC,,A1CNST
	FSBRI	0,0
;
;
;CODE GENERATORS FOR MULT BY A POWER OF 2 PLUS 1 DONE TO MEMORY
;
	P21MFX=.	;MULTIPLY FIXED PT BY A POWER OF 2 PLUS 1 TO MEMORY
	FRRFC,,PTRA2	; (next 2 instrs)
	ASH	0,0
;
	FRRFC,,FROMA1
	ADDM	0,0
;
	P21MNX=.	;MULTIPLY A FIXED PT WHICH IS NEGATED BY A POWER OF
			; 2 PLUS 1 LEAVING RESULT IN MEMORY (next 2 instrs)
	FRRFC,,PTRA2
	ASH	0,0
;
	FRRFC,,FROMA1
	SUBM	0,0
;
;
	P21MFL=.	;MULTIPLY FLOATING PT BY A POWER OF 2 PLUS 1 TO MEMORY
	FRRFC,,PTRA2	; (next 2 instrs)
	FSC	0,0
;
	FRRFC,,FROMA1
	FADRM	0,0
;
	P21MNL=.	;MULTIPLY A FLOATING PT WHICH IS NEGATED BY A POWER OF
			; 2 PLUS 1 LEAVING RESULT IN MEMORY (next 2 instrs)
	FRRFC,,PTRA2
	FSC	0,0
;
	FRRFC,,FROMA1
	FSBRM	0,0
;
;
	P21MCM=.	;MULTIPLY A COMPLEX BY A POWER OF 2 PLUS 1 TO MEMORY
	FRRFC,,PTRA2	; (next 4 instrs)
	FSC	0,0
;
	FRRFC,,PTRA2
	FSC	1,0
;
	FRRFC,,FROMA1
	FADRM	0,0
;
	FRRFC,,FROMA1
	FADRM	1,1
;
	P21MNC=.	;MULTIPLY A NEGATED COMPLEX BY A POWEROF 2 PLUS
			; ONE TO MEMORY (next 4 instrs)
	FRRFC,,PTRA2
	FSC	0,0
;
	FRRFC,,PTRA2
	FSC	1,0
;
	FRRFC,,FROMA1
	FSBRM	0,0
;
	FRRFC,,FROMA1
	FSBRM	1,1
;


;
;TABLES FOR FUNCTIONS FOR WHICH CODE IS GENERATED IN LINE (ABS,SIGN,
; DIM,MOD,MAX,MIN)
;
;
;WHEN THE VAL FOR ARG1 IS ALREADY IN THE REG FOR COMPUTATION
OPGILF:	-1,,ABS
	ILG		;RESERVE THIS SLOT FOR IABS IN A LATER RELEASE
			; (NEED TO BE ABLE TO GENERATE LABELS TO HANDLE)
	-3,,SIGN
	-3,,DIM
	-2,,MOD		;IN RELEASE 1, MOD MUST MOVE THE VAL FROM REG+1 TO REG
	-2,,MAX
	-2,,MIN

OPGDBF:	-2,,IDABS		;DABS WHEN ARG IN REGFORCOMP ON KI
;
;FOR DIM,MOD,MAX,MIN WHEN ARG2 IS IMMEDIATE
OPGILI:	ILG			;SHOULD NEVER SEE ABS WITH A2IMMED
	ILG			;SHOULD NEVER SEE IABS WITH A2IMMED
	ILG			;SHOULD NEVER SEE SIGN WITH A2IMMED
	-3,,DIMI
	-2,,MODI
	-2,,MAXI
	-2,,MINI
;FOR ABS,IABS, AND SIGN - WHEN THE VAL IS NOT YET IN REGFORCOMP
OPGIL1:	-1,,ABS1
	ILG		;IABS NOT HANDLED IN RELEASE 1
	-3,,SIGN1

OPGDB1:	-3,,IDABS1		;DABS WHEN VAL NOT IN REGFORCOMP ON KI

;
;CODE GENERATORS FOR IN LINE FNS
	ABS=.			;FOR ABS, USE NEXT 1 INSTR
	SIGN=.			;FOR SIGN, USE NEXT 3 INSTRS
	FRRFC,,FRRFC
	MOVM	0,0
;
	FRPTN,,FROMA2
	SKIPGE	0,0
;
	FRRFC,,FRRFC
	MOVNS	0,0
;
;
	DIM=.			;FOR DIM, USE NEXT 3 INSTRS
	FRRFC,,FROMA2
	CAMG	0,0
;
	FRRFC,,FRRFC
	TDZA	0,0
;
	FRRFC,,FROMA2
	FSBR	0,0
;
;
	MOD=.			;FOR MOD, USE NEXT 2 INSTRS
	FRRFC,,FROMA2
	IDIV	0,0
;
	FRRFC,,FRRFC
	MOVE	0,1
;
;
	MAX=.			;FOR MAX, USE NEXT 2 INSTRS
	FRRFC,,FROMA2
	CAMGE	0,0
;
	FRRFC,,FROMA2
	MOVE	0,0
;
;
	MIN=.			;FOR MIN, USE NEXT 2 INSTRS
	FRRFC,,FROMA2
	CAMLE	0,0
;
	FRRFC,,FROMA2
	MOVE	0,0
;
;
	DIMI=.			;DIM FOR ARG2 IMMED CNST
	FRRFC,,A2CNST
	CAIG	0,0
;
	FRRFC,,FRRFC
	TDZA	0,0
;
	FRRFC,,A2CNST
	FSBRI	0,0
;
;
	MODI=.			;MOD WITH ARG2 IMMED (NEXT 2 INSTRS)
	FRRFC,,A2CNST
	IDIVI	0,0
;
	FRRFC,,FRRFC
	MOVE	0,1
;
;
	MAXI=.			;MAX WITH ARG2 IMMED
	FRRFC,,A2CNST
	CAIGE	0,0
;
	FRRFC,,A2CNST
	MOVEI	0,0
;
;
	MINI=.			;MIN WITH ARG2 IMMED
	FRRFC,,A2CNST
	CAILE	0,0
;
	FRRFC,,A2CNST
	MOVEI	0,0
;
;
;
	ABS1=.			;FOR ABS WHEN ARG IS NOT IN REG (1 INST)
	SIGN1=.			; SIGN WHEN ARG IS NOT IN REG (3 INSTRS)
	FRRFC,,FROMA1
	MOVM	0,0
;
	FRPTN,,FROMA2
	SKIPGE	0
;
	FRRFC,,FRRFC
	MOVNS	0,0

;
; FOR DABS IN LINE
;
	IDABS=.			; FOR DABS WHEN ARG IN REGFORCOMP
				; ON KI (next 2 instrs)

	FRPTN,,FRRFC
	SKIPGE	0,0
;
	FRRFC,,FRRFC
	DMOVN	0,0
;
;
;
;
	IDABS1=.		;FOR DABS WHEN ARG NOT IN
				;REGFORCOMP ON KI (next 3 instrs)
	FRRFC,,FROMA1
	DMOVE	0,0
;
	FRPTN,FRRFC
	SKIPGE	0,0
;
	FRRFC,,FRRFC
	DMOVN	0,0
;

;
;TABLES FOR GENERATION OF CODE FOR A "STORECLS" NODE (IE A NODE WHICH
;SPECIFIES THAT SOME VAL IS TO BE STORED IN A TEMPORARY)
;
;
;DISPATCH TABLE
OPGSTC:	-2,,STARVL		;STORE VAL OF AN ARRAY ELEMENT
	-1,,STRRFC		; STORE VAL OF AN ARRAY ELEM WHEN ITS ALREADY
				; IN THE "REG-FOR-COMP"
	-2,,STARAD		;STORE PTR TO AN ARRAY ELEM
	-1,,STRRFC		; STORE PTR TO AN ARRAY ELEM WHEN THAT
				; PTR IS ALREADY IN A REG
;    FOR STORING THE VALUE OF AN ELEMENT IN A DOUBLE-WD ARRAY
OPGSTD:	-2,,STDI		;TO STORE DOUBLE-WD ON KI10
	-1,,STDIS		; DOUBLE-WD, KI10, WHEN VAL IS ALREADY IN 
				; REG-FOR-COMP
;
;
;
;
;CODE GENERATORS
;
	STARVL=.		;TO STORE THE CONTENTS OF AN ARRAY ELEM
	FRRFC,,FROMA2		; (next 2 instrs)
	MOVE	0,0
;
	STRRFC=.		; (TO STORE A VAL ALREADY IN REGFORCOMP)
	FRRFC,,PARTMP
	MOVEM	0,0
;
;
	STARAD=.		;TO STORE A PTR TO AN ARRAY ELEM
	FRRFC,,FROMA2		; (next 2 instrs)
	MOVEI	0,0
;
	FRRFC,,PARTMP
	MOVEM	0,0
;
;
;    CODE GENERATORS FOR STORING DOUBLE-WD VALS
	STDI=.			; (next 2 instrs)
	FRRFC,,FROMA2
	DMOVE	0,0
;
	STDIS=.		; KI10 WHEN VAL ALREADY IN REG
	FRRFC,,PARTMP
	DMOVEM	0,0
;
;



;
;DISPATCH TABLES FOR GENERATION OF INSTRUCTIONS FOR TRANSFERS OF CONTROL
;
;
;DISPATCH TABLE  FOR TRANSFER OF CONTROL WHEN A SPECIFIED
; VARIABLE HAS THE SPECIFIED VALUE TRUE OR FALSE
OPGVTS:		-2,,TSTMFL		;TRANSFER ON A MEMLOC FALSE
		-1,,TSTRFL		;TRANSFER ON A REG CONTENTS FALSE
		-2,,TSTMTR		;TRANSFER ON A MEMLOC TRUE
		-1,,TSTRTR		;TRANSFER ON A REG TRUE
;
;DISPATCH TABLE FOR TRANSFER TO THE LABEL INDICATED BY A1NODE IF
;  A SPECIFIED VARIABLE IS TRUE, TO THE LABEL INDICATED BY A2NODE IF
; IT IS FALSE
OPGALT:		-3,,ALTMEM		;TRANSFER DEPENDS ON A VAL IN MEM
		-2,,ALTREG		; ON A VAL IN A REG
;
;CODE GENERATORS FOR TRANSFERS OF CONTROL
;
	TSTMFL=.		;TRANSFER ON A MEMLOC FALSE
	FRPTN,,FROMPA		; (next 2 instrs)
	SKIPL	0,0
;
	FRPTN,,A1LAB
	JRST	0
;
	TSTRFL=.		;TRANSFER ON A REG CONTENTS FALSE
	FRRFC,,A1LAB
	JUMPGE	0,0
;
	TSTMTR=.		;TRANSFER ON A MEMLOC TRU
	FRPTN,,FROMPA		; (next 2 instrs)
	SKIPGE	0,0
;
	FRPTN,,A1LAB
	JRST	0
;
	TSTRTR=.		;TRANSFER ON A REG TRUE
	FRRFC,,A1LAB
	JUMPL	0,0
;
	ALTMEM=.		;TRANSFER TO A1LAB IF MEMLOC IS TRUE,
				; TO A2LAB IF FALSE (next 3 instrs)
	FRPTN,,FROMPA
	SKIPGE	0,0
;
	FRPTN,,A1LAB
	JRST	0,0
;
	FRPTN,,A2LAB
	JRST	0,0
;
	ALTREG=.		;TRANSFER TO A1LAB IF REG IS TRUE, TO
				; A2LAB IF FALSE (next 2 instrs)
	FRRFC,,A1LAB
	JUMPL	0,0
;
	FRPTN,,A2LAB
	JRST	0,0

	INTERN DOSTC		;STORE THE CONTROL WORD
	INTERN	OPGDOS
	INTERN	OPGDOE
	INTERN DOSTI

DOSTI:	-1,,DOSTH

DOSTC:	-1,,STCDO	;TO STORE THE CT WHEN IT IS IN A REG
	-1,,STCDO1	;TO STORE THE CT WHEN IT IS IN THE LEFT HALF OF
			; A REG (IN AOBJN FORM)

STCDO=.
	FRRFC,,FROMA1
	MOVEM 0,0

STCDO1=.
	FRRFC,,FROMA1
	HLREM	0,0
;


OPGDOS:	-1,,DOENS


OPGDOE:	-1,,DOEN11
	ILG
	-1,,RDOEND
	-2,,CDOEND


DOEN11=.
	FRRFC,,A1LAB
	AOBJN 0,0

DOSTH=.
	FRRFC,,FROMA1
	HRRZM 0,0

RDOEND=.
	FRRFC,,A1LAB
	AOJL 0,0

DOENS=.
	FRRFC,,FROMA1
	AOS 0,0

CDOEND=.			; (next 2 instrs)
	FRPTN,,FROMA1
	AOSGE 0

	FRPTN,,A1LAB
	JRST 0





;
;
;TABLES FOR CODE GENERATION OF CODE FOR ARITHMETIC IF STATEMENTS
;
;
;DISPATCH TABLE FOR GENERATION OF CODE FOR ARITHMETIC-IF STMNTS IN WHICH
; THE VAL OF THE EXPRESSION MUST BE ENTIRELY COMPUTED AND THEN TESTED
;
;	IF NO 2 OF THE LABELS ARE EQUAL TO EACHOTHER
OPGAIF:	-4,,AI2NN	;NONE OF THE 3 LABELS IS THE NEXT STMNT, VAL IS NOT IN REG
	-3,,AI2NNR	;NONE OF THE LABELS IS NXT, VAL IS IN A REG
	-3,,AI2NL	;LESS LABEL IS ON NEXT STMNT (VAL NOT IN REG)
	-2,,AI2NLR	;LESS LABEL IS ON NEXT STMNT (VAL IS IN A REG)
	-3,,AI2NE	;EQL LABEL IS NEXT (VAL IS NOT IN A REG)
	-2,,AI2NER	;EQL LABEL IS NEXT (VAL IS IN A REG)
	-3,,AI2NG	;GTR LABEL IS NEXT (VAL IS NOT IN A REG)
	-2,,AI2NGR	;GTR LABEL IS NEXT (VAL IS IN A REG)
;
;	IF LESS LABEL IS EQUAL TO EQL LABEL
	-3,,I2LEN	;NONE OF THE LABELS IS NEXT (VAL IS NOT ON REG)
	-2,,I2LENR	;NONE OF THE LABELS IS NEXT (VAL IS IN A REG)
	-2,,I2LEL	;LESS (AND EQL) LABEL IS NEXT (VAL NOT IN A REG)
	-1,,I2LELR	;LESS (AND EQL) LABEL IS NEXT (VAL IS IN A REG)
	-2,,I2LEL	;EQL (AND LESS) LABEL IS NEXT (VAL NOT IN REG)
	-1,,I2LELR	;EQL (AND LESS) LABEL IS NEXT (VAL IS IN REG)
	-2,,I2LEG	;GTR LABEL IS NEXT (VAL NOT IN REG)
	-1,,I2LEGR	;GTR LABEL IS NEXT (VAL IS IN REG)
;
;	IF LESS LABEL IS EQUAL TO GTR LABEL
	-3,,I2LGN	;NONE OF THE LABELS IS NEXT (VAL IS NOT ON REG)
	-2,,I2LGNR	;NONE OF THE LABELS IS NEXT (VAL IS IN A REG)
	-2,,I2LGL	;LESS (AND GTR)  LABEL IS NEXT (VAL NOT IN A REG)
	-1,,I2LGLR	;LESS (AND GTR)  LABEL IS NEXT (VAL IS IN A REG)
	-2,,I2LGE	;EQL  LABEL IS NEXT (VAL NOT IN REG)
	-1,,I2LGER	;EQL  LABEL IS NEXT (VAL IS IN REG)
	-2,,I2LGL	;GTR (AND LESS) LABEL IS NEXT (VAL NOT IN REG)
	-1,,I2LGLR	;GTR (AND LESS) LABEL IS NEXT (VAL IS IN REG)
;
;	IF GTR LABEL IS EQUAL TO EQL LABEL
	-3,,I2GEN	;NONE OF THE LABELS IS NEXT (VAL IS NOT ON REG)
	-2,,I2GENR	;NONE OF THE LABELS IS NEXT (VAL IS IN A REG)
	-2,,I2GEL	;LESS  LABEL IS NEXT (VAL NOT IN A REG)
	-1,,I2GELR	;LESS  LABEL IS NEXT (VAL IS IN A REG)
	-2,,I2GEG	;EQL (AND GTR)  LABEL IS NEXT (VAL NOT IN REG)
	-1,,I2GEGR	;EQL (AND GTR)  LABEL IS NEXT (VAL IS IN REG)
	-2,,I2GEG	;GTR (AND EQL) LABEL IS NEXT (VAL NOT IN REG)
	-1,,I2GEGR	;GTR (AND EQL) LABEL IS NEXT (VAL IS IN REG)
;
;
;CODE GENERATORS FOR ARITHMETIC-IF STMNTS IN WHICH THE VAL OF THE EXPRESSION
; MUST BE COMPUTED AND TESTED
;
;	IF NO 2 OF THE LABELS ARE EQUAL TO EACHOTHER
;
	AI2NN=.		;NONE OF THE LABELS IS NEXT, VAL NOT IN REG (next 4 instrs)
	AI2NG=.		;GTR LABEL NXT, VAL NOT IN REG (NEXT 3 INSTRS ONLY)
	FRRFC,,FROMA1
	SKIPGE	0,0
;
	FRPTN,,A1LAB
	JRST	0
;
	FRRFC,,A2LAB
	JUMPE	0,0
;
	FRPTN,,A3LAB
	JRST	0
;
;
	AI2NNR=.	;NONE OF THE LABELS IS NEXT, VAL IS IN REG (next 3 instrs)
	AI2NGR=.	;GTR LABEL NEXT, VAL IN REG (USE NEXT 2 INSTRS ONLY)
	FRRFC,,A1LAB
	JUMPL	0,0
;
	FRRFC,,A2LAB
	JUMPE	0,0
;
	FRPTN,,A3LAB
	JRST	0
;
;
	AI2NL=.		;LESS LABEL IS NEXT, VAL NOT IN REG
	FRRFC,,FROMA1	; (next 3 instrs)
	SKIPN	0,0
;
	FRPTN,,A2LAB
	JRST	0
;
	FRRFC,,A3LAB
	JUMPG	0,0
;
;
	AI2NLR=.	;LESS LABEL IS NEXT, VAL IS IN REG
	FRRFC,,A2LAB	; (next 2 instrs)
	JUMPE	0,0
;
	FRRFC,,A3LAB
	JUMPG	0,0
;
;
	AI2NE=.		;EQL LABEL IS NEXT, VAL NOT IN REG
	FRRFC,,FROMA1	; (next 3 instrs)
	SKIPGE	0,0
;
	FRPTN,,A1LAB
	JRST	0
;
	FRRFC,,A3LAB
	JUMPG	0,0
;
;
	AI2NER=.	;EQL LABEL IS NEXT VAL IS IN REG
	FRRFC,,A1LAB	; (next 2 instrs)
	JUMPL	0,0
;
	FRRFC,,A3LAB
	JUMPG	0,0
;
;
;	IF LESS AND EQL LABELS ARE EQUAL TO EACHOTHER
;
	I2LEN=.		;NONE OF THE LABELS IS NEXT , VAL NOT IN REG (next 3 instrs)
	I2LEG=.		;GTR LABEL NEXT, VAL NOT IN REG (USE THE NEXT 2 INSTRS ONLY)
	FRPTN,,FROMA1
	SKIPG	0,0
;
	FRPTN,,A1LAB
	JRST	0
;
	FRPTN,,A3LAB
	JRST	0
;
;
	I2LENR=.	;NONE OF THE LABELS IS NEXT, VAL IS IN A REG (next 2 instrs)
	I2LEGR=.	;GTR LABEL NEXT, VAL IN REG (USE THE NEXT INSTR ONLY)
	FRRFC,,A1LAB
	JUMPLE	0,0
;
	FRPTN,,A3LAB
	JRST	0
;
;
	I2LEL=.		;LESS (AND EQL) LABEL IS NEXT, VAL NOT IN REG
	FRPTN,,FROMA1
	SKIPLE	0,0
;
	FRPTN,,A3LAB
	JRST	0
;
;
	I2LELR=.	;LESS (AND EQL) LABEL IS NEXT, VAL IS IN REG
	FRRFC,,A3LAB
	JUMPG	0,0
;
;
;	IF GTR LABEL IS EQUAL TO EQL LABEL
;
	I2GEN=.		;NONE OF THE LABELS IS NEXT, VAL NOT IN REG (next 3 instrs)
	I2GEL=.		;LESS LABEL IS NEXT, VAL NOT IN REG (USE NEXT 2 INSTS ONLY)
	FRPTN,,FROMA1
	SKIPL	0,0
;
	FRPTN,,A3LAB
	JRST	0
;
	FRPTN,,A1LAB
	JRST	0
;
;
	I2GENR=.	;NONE OF THE LABELS IS NEXT,VAL IS IN REG (next 2 instrs)
	I2GELR=.	;LESS LABEL IS NEXT, VAL IS IN REG (USE NEXT INSTR ONLY)
	FRRFC,,A3LAB
	JUMPGE	0,0
;
	FRPTN,,A1LAB
	JRST	0
;
;
	I2GEG=.		;GTR (AND EQL) LABEL IS NEXT (next 2 instrs)
	FRPTN,,FROMA1
	SKIPGE	0,0
;
	FRPTN,,A1LAB
	JRST	0
;
;
	I2GEGR=.	;GTR (AND EQL) LABEL IS NEXT, VAL IS IN REG
	FRRFC,,A1LAB
	JUMPL	0,0
;
;
;	IF LESS LABEL IS EQUAL TO GTR LABEL
;
	I2LGN=.		;NONE OF THE LABELS IS NEXT, VAL NOT IN REG (next 3 instrs)
	I2LGE=.		;EQL LABEL NEXT, VAL NOT IN REG (USE NEXT 2 INSTRS ONLY)
	FRPTN,,FROMA1
	SKIPE	0,0
;
	FRPTN,,A1LAB
	JRST	0
;
	FRPTN,,A2LAB
	JRST	0
;
;
	I2LGNR=.	;NONE OF THE LABELS IS NEXT, VAL IS IN REG (next 2 instrs)
	I2LGER=.	;EQL LABEL NEXT, VAL IN REG (USE NEXT INSTR ONLY)
	FRRFC,,A1LAB
	JUMPN	0,0
;
	FRPTN,,A2LAB
	JRST	0
;
;
	I2LGL=.		;LESS (AND GTR) LABEL IS NEXT, VAL NOT IN REG
	FRPTN,,FROMA1	; (next 2 instrs)
	SKIPN	0,0
;
	FRPTN,,A2LAB
	JRST	0
;
;
	I2LGLR=.	;LESS (AND GTR) LABEL IS NEXT, VAL IS IN REG
	FRRFC,,A2LAB
	JUMPE	0,0
;

;
;FOR COMPUTED GOTO - TO TEST THE RANGE OF THE VAL COMPUTED
; ALWAYS USE REGISTER 1
OPGCGO:	-3,,CGOTS
;
	CGOTS=.		; (next 3 instrs)
	FRPTN,,FROMA1
	SKIPLE	01,0
;
	FRPTN,,FROMC1
	CAILE	01,0
;
	FRPTN,,A1LAB
	JRST	0,0
;
;  FOR COMPUTED GOTO WHEN THE VAR IS IN THE RH OF  A REG CONTAINING
;  THE DO LOOP CONTROL
OPGCGI:	-4,,CGOITS
;
	CGOITS=.		; (next 4 instrs)
	FRPTN,,A1CNST		;GENERATE "MOVEI 1,0(LOOPREG)
	MOVEI	1,0
;
	FRPTN,,A1LAB
	JUMPLE	1,0
;
	FRPTN,,FROMC1
	CAILE	1,0
;
	FRPTN,,A1LAB
	JRST	0,0
;
;


	INTERN 	OPGIIN
	INTERN	OPGMVL
	INTERN	OPINDI
	INTERN	DVALU
	INTERN	OPINSI
	INTERN	CRETN
	INTERN	MOVRET
	INTERN	POPRET

;FOR PROLOGUE , EPILOGUE AND SUBROUTINE RETURN

	;TO SAVE THE EPILOGUE ADDRESS

OPGIIN:	-1,,MOVIIA

OPGMVL:	-2,,MVLAB

	;MOVE INDIRECT THROUGH 16

	;FOR THE KI 10 

OPINDI:	-1,,GAI
	-1,,GAI
	-1,,GA2KII
	-1,,GA2KII

	;MAKE VALUES TO ADD FOR MULTIPLE RETURNS

DVALU:	-1,,DATER

	;SIMPLE RETURN

POPRET:	-1,,POPIT

	;MOVE THE RETURN I VALUE TO AC 1

MOVRET:	-1,,MOVRTN

	;STORE INDIRECT THROUGH 16


	;FOR THE KI 10

OPINSI:	-1,,STI
	-1,,ST2II


	;FOR A RETURN I

CRETN:	-5,,LGRET

MOVIIA=.
	FRRFC,,FROMC1
	MOVEI 0,0(16)

MVLAB=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 1,0

	FRPTN,,FROMA1
	MOVEM 1,0

GAI=.
	FRRFC,,FROMC1
	MOVE 0,0(16)


GA2KII=.
	FRRFC,,FROMC1
	DMOVE 0,(16)

DATER=.
	FRPTN,,FROMC1
	0

STI=.
	FRRFC,,FROMC1
	MOVEM 0,0(16)


ST2II=.
	FRRFC,,FROMC1
	DMOVEM 0,(16)


LGRET=.			; (next 5 instrs)
	FRPTN,,A1LAB
	JUMPLE 1,0

	FRPTN,,FROMC1
	CAILE 1,0

	FRPTN,,A1LAB
	JRST

	FRPTN,,A2LAB
	MOVE 1,@0(1)

	FRPTN,,FRPTN
	HRRM 1,0(17)

POPIT=.
	FRPTN,,FRPTN

	POPJ 17,0

MOVRTN=.
	FRPTN,,FROMC1
	MOVE 1,0

	;FOR SUBROUTINE OR FUNCTION CALL

	INTERN CALLER
	INTERN OPGSFN

CALLER:	-2,,CALLIT
	-1,,CNOARG

OPGSFN:	-2,,CALLAB	;FOR STATEMENT FUNCTION REF

CALLIT=.		; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

CNOARG=.
	FRPTN,,FROMA1
	PUSHJ 17,0

CALLAB=.		; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

	FRPTN,,A2LAB
	PUSHJ 17,0



;
;TO GENERATE CODE TO CALL FOROTS ROUTINES
;
;DISPATCH ENTRIES
OPGIOL:	-2,,IOLSTC
OPGMTO:	-2,,MTOPC
OPGIN:	-2,,INC
OPGENC:	-2,,ENCC
OPGDEC:	-2,,DECC
OPGOUT:	-2,,OUTC
OPGWTB:	-2,,WTBC
OPGRTB:	-2,,RTBC
OPGNLI:	-2,,NLIC
OPGNLO:	-2,,NLOC
OPGADJ:	-2,,ADJOP
OPGLIB:	-2,,LIBCAL
OPGOPE:	-2,,OPENC
OPGFND:	-2,,FINDC
OPGRLS:	-2,,RELSC
OPGCLO:	-2,,CLOC
OPGFIN:	-1,,FINC
;
;   CODE GENERATORS
	IOLSTC=.		; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI	16,0
;
	FRPTN,,WD1IMF
	PUSHJ	17,IOLSTT
;
MTOPC=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

	FRPTN,,WD1IMF
	PUSHJ 17,MTOPT

INC=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

	FRPTN,,WD1IMF
	PUSHJ 17,INT

ENCC=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

	FRPTN,,WD1IMF
	PUSHJ 17,ENCT

DECC=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

	FRPTN,,WD1IMF
	PUSHJ 17,DECT

OUTC=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

	FRPTN,,WD1IMF
	PUSHJ 17,OUTT

WTBC=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

	FRPTN,,WD1IMF
	PUSHJ 17,WTBT

RTBC=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

	FRPTN,,WD1IMF
	PUSHJ 17,RTBT

NLIC=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

	FRPTN,,WD1IMF
	PUSHJ 17,NLIT

NLOC=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

	FRPTN,,WD1IMF
	PUSHJ 17,NLOT

ADJOP=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

	FRPTN,,WD1IMF
	PUSHJ 17,ADJT

LIBCAL=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVE 16,0

	FRPTN,,IMFN
	PUSHJ 17,0

OPENC=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

	FRPTN,,WD1IMF
	PUSHJ 17,OPENT


FINDC=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

	FRPTN,,WD1IMF
	PUSHJ 17,FINDT

RELSC=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

	FRPTN,,WD1IMF
	PUSHJ 17,RELST

CLOC=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI 16,0

	FRPTN,,WD1IMF
	PUSHJ 17,CLOST

FINC=.
	FRPTN,,WD1IMF
	PUSHJ 17,FINT

	
;
;SET UP THE SIXBIT FOR THE NAMES OF THE FOROTS ROUTINES
;
IOLSTT:	SIXBIT	"IOLST."
MTOPT:	SIXBIT	"MTOP."
INT:	SIXBIT	"IN."
OUTT:	SIXBIT	"OUT."
ENCT:	SIXBIT	"ENC."
DECT:	SIXBIT	"DEC."
NLIT:	SIXBIT	"NLI."
NLOT:	SIXBIT	"NLO."
WTBT:	SIXBIT	"WTB."
RTBT:	SIXBIT	"RTB."
ADJT:	SIXBIT	"ADJ."
OPENT:	SIXBIT	"OPEN."
FINDT:	SIXBIT	"FIND."
CLOST:	SIXBIT	"CLOSE."
RELST:	SIXBIT	"RELEA."
FINT:	SIXBIT	"FIN."




;TO GENERATE CODE FOR A PAUSE STATEMENT
OPGPAU:	-2,,PAUSEC
	PAUSEC=.		; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI	16,0
;
	FRPTN,,WD1IMF
	PUSHJ	17,PAUSET
;
PAUSET:	SIXBIT	"PAUS."
;
;
;
;
;FOR STOP
;
OPGSTP:	-2,,STOPCD
	STOPCD=.		; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI	16,0
;
	FRPTN,,WD1IMF
	PUSHJ	17,STOPT
;
STOPT:	SIXBIT	"STOP."
;
;FOR THE EXIT AT THE END OF THE PROGRAM
;
OPGEXI:	-2,,EXITCD
EXITCD=.			; (next 2 instrs)
	FRPTN,,A1LAB
	MOVEI	16,0
;
	FRPTN,,WD1IMF
	PUSHJ	17,EXITT
;
;
EXITT:	SIXBIT	"EXIT."
;
;
;
;TO GENERATE CODE FOR THE INITIAL CALL TO RESET.
OPGRES:	-3,,RESCD
;
	RESCD=.			; (next 3 instrs)
	FRPTN,,FRPTN
	JFCL	0
;
	FRPTN,,WD1IMF
	JSP	16,RESETT
;
	FRPTN,,FRPTN
	0
;
RESETT:	SIXBIT	"RESET."


;
;TO GENERATE PUSH AND POP REGISTER SAVE AND RESTORES
;FOR STATEMENT FUNCTIONS
OPGPPR:	-1,,POPRG

	POPRG=.
	FRPTN,,FRRFC
	POP 17,0

OPGPHR:	-1,,PSHR

	PSHR=.
	FRPTN,,FRRFC
	PUSH 17,0

	END