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