[h316.git] / programs / libtest / src / faculty.asm

* RECURSIVE FACULTY CALCULATION - RECURSIVE STACK DEMO
* 
* 
* AUTHOR:
* 
* PHILIPP HACHTMANN
* 
* 
* VERSIONS:
* 
*               1.0 - INITIAL AND FINAL VERSION (22.12.2007)
* 
* 
* PURPOSE:
* 
* TO DEMONSTRATE THE SOFTWARE STACK'S ABILITIES.
* THE PROGRAM RECURSIVELY CALCULATES THE FACULTY OF A NUMBER SUPPLIED
* BY THE USER. RETURN ADDRESSES AND LOCAL DATA OF THE RECURSIVE ROUTINE
* ARE PUSHED TO AND POPPED FROM THE STACK.
* 
* 
* USAGE:
* 
* JUST ASSEMBLE, LOAD AND EXECUTE.
* 
* THE FACULTY ROUTINE CAN ALSO BE ACCESSED BY OTHER PROGRAMS. IT CAN
* BE CALLED WITH
*               JST     FACLTY
* AND THE ARGUMENT IN THE A-REGISTER. THE RESULT WILL BE IN THE A-REGISTER
* AFTERWARDS.
* 
*
* 
********************************************************************************
* 
* 
**** GLOBAL SETTINGS
* 
	SUBR	FACLTY,FAK	EXPORT RECURSIVE ROUTINE
	REL			RELOCATEABLE MODE
	ORG	'0		COUNT FROM ZERO
*
* 
********************************************************************************
*
* 
**** MAIN ROUTINE
* 
MAIN	CALL	S$INIT	INITIALIZE STACK POINTER
*
	CALL	F$W1	WRITE TO ASR
	DAC	BANR	POINTER TO BANNER FORMAT
	CALL	F$CB
* 
AGIN	CALL	F$W1	WRITE TO ASR
	DAC	FMT1	USING THIS FORMAT STRING
	CALL	F$CB	CLOSE BUFFERS
* 
	CALL	F$R1	READ FROM ASR
	DAC	FMT2	WITH THIS FORMAT
	CALL	F$AR	ARGUMENT PROCESSING ROUTINE
	DEC	1	NUMBER OF WORDS IN ARGUMENT
	DAC	NUM	POINTER TO ARGUMENT
	CALL	F$CB	CLOSE BUFFERS
* 
	LDA	NUM	LOAD DATA
	JST	FAK2	RUN RECURSIVE FACULTY ROUTINE
	STA	NUM	SAVE RESULT BACK TO DATA
* 
	CALL	F$W1	WRITE TO ASR
	DAC	FMT3	USING THIS FORMAT STRING
	CALL	F$AR	ARGUMENT PROCESSING ROUTINE
	DEC	1	NUMBER OF WORDS IN ARGUMENT
	DAC	NUM	POINTER TO ARGUMENT
	CALL	F$CB	CLOSE BUFFERS
* 
	CALL	F$W1
	DAC	FMT4	READY MESSAGE
	CALL	F$CB
* 
	HLT		HALT SYSTEM
	JMP	AGIN	DO IT AGAIN - AND AGAIN....
* 
* 
********************************************************************************
* 
*  
**** RECURSIVE FACULTY CALCULATION!
* 
*       CALL FAK
* 
FAK	DAC	**
	STA	ARG1
	LDA	FAK	RETURN ADDRESS!
	STA	RET	SAVE :-)
	CALL	S$PUSM
	DAC	ARG1
	DEC	2	2 WORDS TO SAVE
* 
	LDA	ARG1
	SUB	=1	MINUS 1
	SNZ
	JMP	NDY	WE ARE AT LEVEL 1, SO RETURN 1
	JST	FAK	CALL RECURSIVELY!!!
	CALL	S$POPM	RESTORE MEMORY
	DAC	ARG1
	DEC	2
	CALL	M$11	NORMAL MULTIPLY
	DAC	ARG1
REST	JMP*	RET	RETURN THROUGH ANOTHER DOOR
* 
NDY	CALL	S$POPM	RESTORE MEMORY
	DAC	ARG1
	DEC	2
	LDA	ARG1	SHOULD BE 1
	JMP*	RET
* 
* 
********************************************************************************
* 
*  
**** RECURSIVE FACULTY CALCULATION! - ALTERNATIVE IMPLEMENTATION
* 
*       CALL FAK
* 
FAK2	DAC	**
	STA	ARG
* 
	LDA	ARG
	CAS	=1	COMPARE
	JMP	AGO	A > 1 : DO IT AGAIN!
	NOP		A = 1 : RETURN WITH A=1
	NOP		A < 1 : RETURN WITH A=0
	JMP*	FAK2	RETURN.
* 
AGO	LDA	FAK2	LOAD RETURN ADDRESS
	CALL	S$PUSH	PUSH IT TO THE STACK
	LDA	ARG	LOAD ARGUMENT
	CALL	S$PUSH	PUSH IT TO THE STACK
* 
	SUB	=1	SUBSTRACT ONE.
	JST	FAK2	CALL RECURSIVELY!
*
	CALL	S$POPM	RESTORE MEMORY
	DAC	RET	COMFORTABLE REVERSE ORDER
	DEC	2	COPY TWO WORDS FROM STACK
* 
	CALL	M$11	CALL INTEGER MULTIPLICATION
	DAC	ARG	THIS IS THE ORIGINAL ARG AGAIN.
	JMP*	RET	RETURN THROUGH ANOTHER DOOR
* 
* 
****************************************
* 
* 
**** VARIABLES AND CONSTANTS
* 
ARG1	DEC	0
RET	DEC	0	RETURN ADDRESS BUFFER USED BY FAK
ARG	DEC	0	ARGUMENT BUFFER USED BY FAK
*
NUM	DEC	0	ARGUMENT BUFFER USED BY THE MAIN ROUTINE
* 
BANR	BCI	20,(34H0RECURSIVE FACULTY CALCULATION 1.0)
FMT1	BCI	10,(7H INPUT:) PROMPT FORMAT
FMT2	BCI	10,(I1)
FMT3	BCI	10,(7HRESULT:,I7)	OUTPUT FORMAT
FMT4	BCI	10,(7H0READY.)		END MESSAGE
* 
* 
********************************************************************************
* 
* 
**** END OF PROGRAM
* 
	END
* 
* 
********************************************************************************
Commit	Line	Data
8fac3a64	1	* RECURSIVE FACULTY CALCULATION - RECURSIVE STACK DEMO
	2	*
	3	*
	4	* AUTHOR:
	5	*
	6	* PHILIPP HACHTMANN
	7	*
	8	*
	9	* VERSIONS:
	10	*
	11	* 1.0 - INITIAL AND FINAL VERSION (22.12.2007)
	12	*
	13	*
	14	* PURPOSE:
	15	*
	16	* TO DEMONSTRATE THE SOFTWARE STACK'S ABILITIES.
	17	* THE PROGRAM RECURSIVELY CALCULATES THE FACULTY OF A NUMBER SUPPLIED
	18	* BY THE USER. RETURN ADDRESSES AND LOCAL DATA OF THE RECURSIVE ROUTINE
	19	* ARE PUSHED TO AND POPPED FROM THE STACK.
	20	*
	21	*
	22	* USAGE:
	23	*
	24	* JUST ASSEMBLE, LOAD AND EXECUTE.
	25	*
	26	* THE FACULTY ROUTINE CAN ALSO BE ACCESSED BY OTHER PROGRAMS. IT CAN
	27	* BE CALLED WITH
	28	* JST FACLTY
	29	* AND THE ARGUMENT IN THE A-REGISTER. THE RESULT WILL BE IN THE A-REGISTER
	30	* AFTERWARDS.
	31	*
ec6239e9	32	*
8fac3a64	33	*
	34	********************************************************************************
	35	*
	36	*
	37	**** GLOBAL SETTINGS
	38	*
	39	SUBR FACLTY,FAK EXPORT RECURSIVE ROUTINE
	40	REL RELOCATEABLE MODE
	41	ORG '0 COUNT FROM ZERO
	42	*
	43	*
	44	********************************************************************************
	45	*
	46	*
	47	**** MAIN ROUTINE
	48	*
	49	MAIN CALL S$INIT INITIALIZE STACK POINTER
	50	*
	51	CALL F$W1 WRITE TO ASR
	52	DAC BANR POINTER TO BANNER FORMAT
	53	CALL F$CB
	54	*
	55	AGIN CALL F$W1 WRITE TO ASR
	56	DAC FMT1 USING THIS FORMAT STRING
	57	CALL F$CB CLOSE BUFFERS
	58	*
	59	CALL F$R1 READ FROM ASR
	60	DAC FMT2 WITH THIS FORMAT
	61	CALL F$AR ARGUMENT PROCESSING ROUTINE
	62	DEC 1 NUMBER OF WORDS IN ARGUMENT
	63	DAC NUM POINTER TO ARGUMENT
	64	CALL F$CB CLOSE BUFFERS
	65	*
	66	LDA NUM LOAD DATA
	67	JST FAK2 RUN RECURSIVE FACULTY ROUTINE
	68	STA NUM SAVE RESULT BACK TO DATA
	69	*
	70	CALL F$W1 WRITE TO ASR
	71	DAC FMT3 USING THIS FORMAT STRING
	72	CALL F$AR ARGUMENT PROCESSING ROUTINE
	73	DEC 1 NUMBER OF WORDS IN ARGUMENT
	74	DAC NUM POINTER TO ARGUMENT
	75	CALL F$CB CLOSE BUFFERS
	76	*
	77	CALL F$W1
	78	DAC FMT4 READY MESSAGE
	79	CALL F$CB
	80	*
	81	HLT HALT SYSTEM
	82	JMP AGIN DO IT AGAIN - AND AGAIN....
	83	*
	84	*
	85	********************************************************************************
	86	*
	87	*
	88	**** RECURSIVE FACULTY CALCULATION!
	89	*
	90	* CALL FAK
	91	*
	92	FAK DAC **
	93	STA ARG1
	94	LDA FAK RETURN ADDRESS!
	95	STA RET SAVE :-)
	96	CALL S$PUSM
97	DAC ARG1
98	DEC 2 2 WORDS TO SAVE
99	*
100	LDA ARG1
101	SUB =1 MINUS 1
102	SNZ
103	JMP NDY WE ARE AT LEVEL 1, SO RETURN 1
104	JST FAK CALL RECURSIVELY!!!
105	CALL S$POPM RESTORE MEMORY
106	DAC ARG1
107	DEC 2
108	CALL M$11 NORMAL MULTIPLY
109	DAC ARG1
110	REST JMP* RET RETURN THROUGH ANOTHER DOOR
111	*
112	NDY CALL S$POPM RESTORE MEMORY
113	DAC ARG1
114	DEC 2
115	LDA ARG1 SHOULD BE 1
116	JMP* RET
117	*
118	*
119	********************************************************************************
120	*
121	*
122	**** RECURSIVE FACULTY CALCULATION! - ALTERNATIVE IMPLEMENTATION
123	*
124	* CALL FAK
125	*
126	FAK2 DAC **
127	STA ARG
128	*
129	LDA ARG
130	CAS =1 COMPARE
131	JMP AGO A > 1 : DO IT AGAIN!
132	NOP A = 1 : RETURN WITH A=1
133	NOP A < 1 : RETURN WITH A=0
134	JMP* FAK2 RETURN.
135	*
136	AGO LDA FAK2 LOAD RETURN ADDRESS
137	CALL S$PUSH PUSH IT TO THE STACK
138	LDA ARG LOAD ARGUMENT
139	CALL S$PUSH PUSH IT TO THE STACK
140	*
141	SUB =1 SUBSTRACT ONE.
142	JST FAK2 CALL RECURSIVELY!
143	*
144	CALL S$POPM RESTORE MEMORY
145	DAC RET COMFORTABLE REVERSE ORDER
146	DEC 2 COPY TWO WORDS FROM STACK
147	*
148	CALL M$11 CALL INTEGER MULTIPLICATION
149	DAC ARG THIS IS THE ORIGINAL ARG AGAIN.
150	JMP* RET RETURN THROUGH ANOTHER DOOR
151	*
152	*
153	****************************************
154	*
155	*
156	**** VARIABLES AND CONSTANTS
157	*
158	ARG1 DEC 0
159	RET DEC 0 RETURN ADDRESS BUFFER USED BY FAK
160	ARG DEC 0 ARGUMENT BUFFER USED BY FAK
161	*
162	NUM DEC 0 ARGUMENT BUFFER USED BY THE MAIN ROUTINE
163	*
164	BANR BCI 20,(34H0RECURSIVE FACULTY CALCULATION 1.0)
165	FMT1 BCI 10,(7H INPUT:) PROMPT FORMAT
166	FMT2 BCI 10,(I1)
167	FMT3 BCI 10,(7HRESULT:,I7) OUTPUT FORMAT
168	FMT4 BCI 10,(7H0READY.) END MESSAGE
169	*
170	*
171	********************************************************************************
172	*
173	*
174	**** END OF PROGRAM
175	*
176	END
177	*
178	*
179	********************************************************************************