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