; CALL.MAC - FORTRAN-COMPATIBLE CALL MACROS
;
; SYSTEMS: RSX-11D/M
; AUTHOR: M. KELLOGG
; DATE: 24-DEC-75
;
; THESE MACROS GENERATE FORTRAN-COMPATIBLE CALLS AND ARGUMENT LISTS.
; 3 MACROS ARE PROVIDED:
;
;	CALL: GENERATES A CALL WITH ARGUMENT LIST IN PSECT $ARG$$
;	ARGLST: GENERATES AN ARGUMENT LIST IN THE CURRENT PSECT.
;	CALLS: GENERATES A CALL WITH ARGUMENT LIST ON THE STACK.
;
;	NOTE: ALL THESE MACROS ALLOW FOR AN ARGUMENT 'CS' AT THE
;	END OF THE ARGUMENT LIST. IF ONE OF THESE MACROS IS
;	CALLED FROM A NON-BLANK PSECT, THE PSECT NAME MUST BE
;	SUPPLIED AS 'CS'.  IF THE MACRO IS CALLED FROM THE BLANK
;	PSECT, 'CS' MAY BE OMITTED.


; CALL - CALL SUBROUTINE
;
;	THIS MACRO CAN BE USED IN TWO WAYS:
;
;    1)	CALL SUBR
;
;	THIS FORM GENERATES A JSR PC,SUBR.  NO ARGUMENT LIST IS
;	GENERATED.
;
;    2)	CALL SUBR,<ARG1,ARG2,...,ARGN>,CS
;	
;	THIS FORM GENERATES A FORTRAN-COMPATIBLE ARGUMENT LIST IN
;	THE PSECT $ARG$$, AND CALLS SUBR WITH R5 POINTING TO THE
;	ARGUMENT LIST.  FOUR TYPES OF ARGUMENT MAY BE USED:
;
;    1)	VARIABLE:  THIS IS ANY LEGAL MACRO-11 EXPRESSION, AND
;	NORMALLY WILL INDICATE THE ADDRESS OF A VARIABLE.  IT IS
;	ASSEMBLED AS THE OPERAND OF A .WORD STATEMENT IN THE ARGUMENT
;	LIST.
;
;	EXAMPLES: X, FLAG, TABLE+4
;
;    2)	ADDRESS EXPRESSION: THIS IS AN OPERAND WHICH INDICATES A
;	HARDWARE ADDRESSING MODE (EXCEPT RELATIVE; IN THIS CASE THE
;	OPERAND IS CONSIDERED A VARIABLE).  A MOV INSTRUCTION IS
;	GENERATED TO PLACE THE OPERAND IN THE ARGUMENT LIST.
;
;	EXAMPLES:  R0, (R0), 4(R5), TABL(R1), @#ADDR
;
;	NOTE:  OPERANDS OF THE FORM '#EXPR' ASSEMBLE NORMALLY BUT
;	ARE FLAGGED WITH A WARNING MESSAGE, SINCE THEY WERE USED AS
;	LITERALS IN A PREVIOUS VERSION OF CALL.  NORMALLY, 'EXPR'
;	SHOULD BE USED INSTEAD OF '#EXPR', SINCE IT PRODUCES THE
;	SAME EFFECT BUT GENERATES LESS CODE.
;
;    3)	LITERAL:  THIS IS AN OPERAND OF THE FORM '=EXPR'.  THE VALUE
;	OF 'EXPR' IS PLACED IN A LITERAL TABLE IN THE PSECT $LIT$$,
;	AND THE ADDRESS OF THE LITERAL IS PLACED IN THE ARGUMENT
;	LIST.  EXPR MUST NOT CONTAIN AN EXTERNAL GLOBAL REFERENCE.
;
;	EXAMPLES:  =3, =LGTH, =NUMBER+6
;
;    4)	NULL:  THE VALUE -1 (177777 OCTAL) IS PLACED IN THE ARGUMENT
;	LIST FOR A NULL ARGUMENT.

	.MACRO	CALL	SUB,ARGS,CS
	.MCALL	CTA$,TYP$,LIT$
	.NARG	$$$T3
	.IF	GT,$$$T3-1
	.PSECT	$ARG$$
$$$=.
	CTA$	<ARGS>
	.IRP	ARG,<ARGS>
	.IF	B,ARG
	.WORD	-1
	.IFF
	TYP$	$$$T1,ARG
	.IF	EQ,$$$T1-67	;VARIABLE
	.WORD	ARG
	.IFF
	.IF	LT,$$$T1	;LITERAL
	.PSECT	$LIT$$
	LIT$	<ARG>,$$$T2
	.PSECT	$ARG$$
	.WORD	$$$T2
	.IFF			;ADDRESS EXPR
	.IF	EQ,$$$T1-27
	.ERROR	;WARNING - POSSIBLE LITERAL WITH '#';
	.PRINT	;CHANGE '#' TO '=';
	.ENDC
$$$T2=.
	.WORD	-1
	.PSECT	CS
	MOV	ARG,$$$T2
	.PSECT	$ARG$$
	.ENDC
	.ENDC
	.ENDC
	.ENDM
	.PSECT	CS
	MOV	#$$$,R5
	.ENDC
	JSR	PC,SUB
	.ENDM	CALL


; ARGLST - GENERATE ARGUMENT LIST
;
;	ARGLST <ARG1,ARG2,...,ARGN>,CS
;
;	THIS MACRO GENERATES A FORTRAN-COMPATIBLE ARGUMENT LIST.
;	ARGUMENT TYPES (1), (3), AND (4), ABOVE MAY BE USED. ARGUMENT
;	TYPE (2) GENERATES AN ERROR MESSAGE AND PUTS THE VALUE -1
;	INTO THE ARGUMENT LIST (AS FOR A NULL ARGUMENT).

	.MACRO	ARGLST	ARGS,CS
	.MCALL	CTA$,TYP$,LIT$
	CTA$	<ARGS>
	.IRP	ARG,<ARGS>
	.IF	B,ARG
	.WORD	-1
	.IFF
	TYP$	$$$T1,ARG
	.IF	EQ,$$$T1-67
	.WORD	ARG
	.IFF
	.IF	LT,$$$T1
	.PSECT	$LIT$$
	LIT$	<ARG>,$$$T2
	.PSECT	CS
	.WORD	$$$T2
	.IFF
	.ERROR	;ILLEGAL ARGUMENT ADDRESSING TYPE;
	.WORD	-1
	.ENDC
	.ENDC
	.ENDC
	.ENDM
	.ENDM	ARGLST


; CALLS - CALL SUBROUTINE WITH ARG LIST ON STACK
;
;	CALLS SUBR,<ARG1,ARG2,...,ARGN>,CS
;
;	THIS MACRO PUSHES A FORTRAN-COMPATIBLE ARGUMENT LIST ONTO
;	THE STACK AND CALLS SUBR WITH R5 POINTING TO THE ARGUMENT 
;	LIST.  THE STACK IS CLEANED ON RETURN FROM THE SUBROUTINE.
;	ARGUMENT TYPES (2), (3), AND (4) ABOVE ARE SUPPORTED.  IF IT
;	IS DESIRED TO PLACE THE ADDRESS OF A VARIABLE ON THE ARGUMENT
;	LIST, THE FORM '#VAR' SHOULD BE USED FOR THE ARGUMENT.  THE
;	FORM 'VAR' PLACES THE VALUE STORED IN VAR ON THE STACK.

	.MACRO	CALLS	SUB,ARGS,CS
	.MCALL	AGL$
	AGL$	CS,ARGS
	MOV	SP,R5
	JSR	PC,SUB
	.IF	GT,$$$T1-1
	ADD	#$$$T1*2+2,SP
	.MEXIT
	.ENDC
	.IF	GT,$$$T1
	CMP	(SP)+,(SP)+
	.IFF
	TST	(SP)+
	.ENDC
	.ENDM	CALLS


; INTERNAL MACRO SUPPORT

; AGL$ - GENERATE ARG LIST ON STACK
;	PUSHES ARGS (UP TO 16) ON THE STACK IN REVERSE ORDER, THEN
;	PUSHES ARG COUNT ON STACK.  $$$T1 IS SET TO THE NUMBER OF
;	ARGS.
;	RESERVED SYMBOLS:  $$$T7, $$$T8, $$$T9

	.MACRO	AGL$	CS,A,Z,C,D,E,F,G,H,I,J,K,L,M,N,O,P
	.MCALL	PSA$
	.NARG	$$$T1
$$$T1=$$$T1-1
	.IF	EQ,$$$T1-1
	.IIF	B,<A>	$$$T1=0
	.ENDC
	.IF	GT,$$$T1
	.IIF	GT,$$$T1-15.	PSA$	<P>,CS
	.IIF	GT,$$$T1-14.	PSA$	<O>,CS
	.IIF	GT,$$$T1-13.	PSA$	<N>,CS
	.IIF	GT,$$$T1-12.	PSA$	<M>,CS
	.IIF	GT,$$$T1-11.	PSA$	<L>,CS
	.IIF	GT,$$$T1-10.	PSA$	<K>,CS
	.IIF	GT,$$$T1-9.	PSA$	<J>,CS
	.IIF	GT,$$$T1-8.	PSA$	<I>,CS
	.IIF	GT,$$$T1-7	PSA$	<H>,CS
	.IIF	GT,$$$T1-6	PSA$	<G>,CS
	.IIF	GT,$$$T1-5	PSA$	<F>,CS
	.IIF	GT,$$$T1-4	PSA$	<E>,CS
	.IIF	GT,$$$T1-3	PSA$	<D>,CS
	.IIF	GT,$$$T1-2	PSA$	<C>,CS
	.IIF	GT,$$$T1-1	PSA$	<Z>,CS
	PSA$	<A>,CS
	MOV	#$$$T1,-(SP)
	.IFF
	CLR	-(SP)
	.ENDC
	.ENDM	AGL$

; PSA$ - PUSH ARGUMENT ON THE STACK
;	PUSHES ONE ARGUMENT ONTO THE STACK.  IF THE ARG IS A LITERAL,
;	GENERATES ITS VALUE IN PSECT $LIT$$ AND PUSHES ITS ADDRESS
;	ONTO THE STACK.
;	RESERVED SYMBOLS:  $$$T7, $$$T8, $$$T9

	.MACRO	PSA$	ARG,CS
	.MCALL	TYP$,LIT$
	.IF	B,ARG
	MOV	#-1,-(SP)
	.MEXIT
	.ENDC
	TYP$	$$$T8,ARG
	.IF	LT,$$$T8
	.PSECT	$LIT$$
	LIT$	<ARG>,$$$T7
	.PSECT	CS
	MOV	#$$$T7,-(SP)
	.IFF
	MOV	ARG,-(SP)
	.ENDC
	.ENDM	PSA$

; CTA$ - COUNT ARGUMENTS
;	COUNTS NUMBER OF ARGS IN ARG LIST AND GENERATES ARG COUNT
;	AS .BYTE N,0
;	RESERVED SYMBOL: $$$T9

	.MACRO	CTA$	ARGS
$$$T9=0
	.IRP	X,<ARGS>
$$$T9=$$$T9+1
	.ENDM
	.BYTE	$$$T9,0
	.ENDM	CTA$

; TYP$ - ARGUMENT TYPE
;	THIS MACRO IS SIMILAR TO .NTYPE, WITH THE ADDED FEATURE OF
;	RETURNING A TYPE OF -1 IF THE SECOND ARGUMENT IS A LITERAL
;	(=EXPR).

	.MACRO	TYP$	X,ARG
	.IRPC	C,ARG
	.IF	IDN,C,=
X=-1
	.MEXIT
	.ENDC
	.NTYPE	X,ARG
	.MEXIT
	.ENDM
	.ENDM	TYP$

; LIT$ - GENERATE LITERAL
;	THIS MACRO GENERATES A LITERAL WITH THE VALUE ARG AND RETURNS
;	ITS LOCATION IN L.
;	RESERVED SYMBOL: $$$T9

	.MACRO	LIT$	ARG,L
L=.
$$$T9'ARG
	.WORD	$$$T9
	.ENDM	LIT$