programs/libtest/src/faculty.asm

   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 *
  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 ********************************************************************************