用汇编语言实现递归 - 爱吱声

LEN_OF_OUTPUT equ 10
, S) q/ G" C. ]# s; S
5 ^5 h4 o: Q* }' A0 i( r+ k
section .data ;
4 u7 b) o5 Z+ }# S$ y8 r. Q$ j2 F. Y
userMsg db 'Please enter a single-digit number: ' ;
, |/ u+ A1 \* A$ H
lenUserMsg equ $-userMsg ;
- S) {+ {( v: @1 G' ?
disp1Msg db 'The factorial of '$ N7 f/ S0 l" ]) \* o1 X& F$ s/ W
lenDisp1Msg equ $-disp1Msg
- a# ~/ N" r6 t/ Y4 ]. u+ d
disp2Msg db ' is '/ ?! y+ _# \( J& Y5 @4 q
lenDisp2Msg equ $-disp2Msg 7 B7 D# B6 X1 t6 n3 q
errMsg db 'Wrong input. Only one-digit number can be accepted.',0x0a6 I2 p8 l2 o! E J2 e
lenErrMsg equ $-errMsg
$ K: x/ d+ s4 d6 k. u
: O2 R b' |9 I" w9 ^2 z
section .bss ;
/ T! H( d q9 Z! d! W8 S
num resb 1
# P3 G3 R6 X8 I( L; d
result resd 1
4 p6 e# W, H6 S6 u( m+ F
buffer resb LEN_OF_OUTPUT+1
5 a! }( V7 c" g; Y9 P
. Z I6 x& c* u, ~
section .text ;& d9 h$ y# [; J e$ V
global _start
. N6 b: \1 l' v3 Y9 O1 @5 E: n
$ m8 t/ g4 X9 x9 X% C
_start: ;* y& |7 b2 f! A* o
mov eax, 4
; V: ^4 k7 Y/ \) ^% H- D
mov ebx, 1
K& H6 b( V; D: Z) ~' @
mov ecx, userMsg
1 B* @5 f: L3 g1 ^. c3 q
mov edx, lenUserMsg
+ e1 H. G- c, _/ C2 s3 U
int 80h. e" y8 g" Q; z1 ~; F3 X. H
. Z0 v( L; v2 S( `
; read user's input
$ d3 V6 A% p* n; B
mov eax, 39 Z4 K9 o9 {) F! m, Y
mov ebx, 02 }4 H( }0 ?3 u* y
mov ecx, num
@" v9 R: H9 S% j. _
mov edx, 1 ; length of input buffer
" y) N% H* z f6 G
int 80h
5 W3 c- G( r9 y* I5 T. e* G
+ f3 E* _) d2 w: n* Q8 h
mov eax, [num]
6 P$ x# g }' V; I {
and eax, 0xFF
1 e" }8 t1 j- ]5 Y/ m$ ~
sub eax, 0x301 Z# I% O4 t, @6 w e
jl ERROR1 d8 i# h. K0 m! l4 y' C; h+ H
cmp eax, 10+ p2 C1 z- s( ]; @
jl DO_CALC; R9 |& F2 ?9 g6 v3 E, c0 s
ERROR:6 h$ G; x' M; l2 q4 ^" o8 p7 [1 q1 \
mov eax, 4
7 [5 X1 |4 p% i; O+ B6 E9 O
mov ebx, 1& |& ~( m6 K) ]) I$ b
mov ecx, errMsg
5 l- _, q" A7 A
mov edx, lenErrMsg) { @, A, a( h' C4 `9 u
int 80h
2 h6 ?# A9 i& M+ ?5 ~9 [
jmp EXIT- q: [# J1 ^' K* b x
) ~) q7 g3 k9 S2 F6 B3 Q
/ B% }4 H$ A1 A/ h. m. t2 H9 \( I
DO_CALC:* t7 h3 X5 I& D3 C' a
call factorial2 A% ]0 M9 p# \9 a
; The parameter is in eax. After calling, the result will be stored in eax.3 q9 p% i( I, w9 h' B
mov [result], eax ; Save the result8 P( Q/ i4 `) x8 B9 U4 S" o
: j9 ? H# y, G' v
; print result
}" K# S7 [$ P" E
mov eax, 4
! v7 P3 P9 x0 j& y1 n
mov ebx, 1
F( I* @& p) E
mov ecx, disp1Msg
6 A9 _' j l9 s6 \7 E" x: Z2 h
mov edx, lenDisp1Msg, }5 M% L& i& s# a- b, C6 ^& n9 [
int 80h + V% `8 Z5 }; I* |
mov eax, 4/ w- _' Z/ ?, w6 z" X
mov ebx, 1
( y7 X% e1 l: `' j" G" w
mov ecx, num4 N6 g1 D, ?, {' A) x5 G% f5 ^! n& n" I
mov edx, 1
; a1 d3 I! ~8 c9 p
int 80h 7 C8 X9 m+ {5 m. c$ I& b
mov eax, 4+ @/ E0 \6 i4 E4 y
mov ebx, 1" x2 y4 b) O M. j% u5 }" C
mov ecx, disp2Msg3 H; p$ {* c/ M k* S# h
mov edx, lenDisp2Msg
# U" K5 t/ U2 c& X# ]8 Z3 n/ v
int 80h
) b4 E |/ y2 D' }0 |
% K0 E3 v; y# O( b# [7 f5 w8 o; ~" R
; output number, I4 R% Q" B3 h4 w8 Z1 B5 K" X! x
mov eax, [result] ; VALUE THAT I WANT TO CONVERT AND DISPLAY2 H4 x6 \* O z% j9 G- D
mov byte [buffer+LEN_OF_OUTPUT],0x0a% u @8 n$ E6 w% i' `+ ]
lea esi,[buffer+LEN_OF_OUTPUT]
mov ebx,10
) [4 U0 a# C! m
ASC_LOOP:, _9 G- p3 q" I+ b+ d
mov edx,0 ; clear dx prior to dividing edx:eax by bx
4 `. C$ M( ^, z; y: u* X, K E
div ebx ;DIV EAX/10" Q4 r" `( H+ R% m2 s; [
add edx,0x30 ;ADD 48 TO REMAINDER TO GET ASCII CHARACTER OF NUMBER 6 I' E9 ^ C0 Z; j
dec esi ; store characters in reverse order
" \9 U# n/ `! W a
mov [esi],dl
1 a6 x: t+ d! N' n; c$ X
cmp eax,0 * Q9 U3 A* a E% N" r/ F$ {% P4 N
jz END_ASC ;IF AX=0, END THE PROCEDURE OF NUMBER TO ASCII' ] V' B+ }' D
jmp ASC_LOOP ;ELSE REPEAT
6 }9 a' R- p+ ^& n0 y
END_ASC:
. n! p/ \* }% J) z8 L
mov eax, 4
! q/ v% E4 j$ v5 B: j: h
mov ebx, 1
+ o' `% X6 [- }; v4 N2 K
mov ecx, esi
1 p, f2 r. t5 W5 Z+ {
lea edx,[buffer+LEN_OF_OUTPUT+1], |( R; `2 Q6 R
sub edx, ecx/ n$ T- h( p: M- |% y5 P: ~- E% H
int 80h ; i- G: Q6 F) r2 I! }$ Q& m
$ y) K8 T$ \; x% `) E8 P
; Exit code4 Q Y& @1 c* D$ C6 }. @
EXIT:8 M/ [5 B% x0 Z% P2 m
mov eax, 1+ d3 e/ t, q. i9 ?' ?7 s
mov ebx, 0
| {. ?# [! d ]& x
int 80h# L" J% G5 n. }' h
; f4 C1 @$ Z. `7 H
9 m/ S+ v! ]: n4 A
$ a9 |% S5 A! \/ g! w$ E R q
; Factorial function using recursion5 l: [; c k" {, `
factorial:
" T1 K5 p9 f0 J$ l
; Check if eax is 0 (base condition)2 ~" Y6 H" j* t6 X
cmp eax, 0; T2 Q5 S6 l I6 C( a
jz end_recursion
" ?8 V4 }) ]4 Q% w/ J0 B" Z
. S' ?/ b( q9 e7 l4 N, C
; Save the current value of eax# M' V$ O9 q0 T, y
push eax4 _8 ~; k) L# e7 j9 ^
( u' ^' i& V$ @" A( a) l0 d
; Decrement eax and call factorial function recursively
% X, P6 M" x+ S. m
dec eax
" n! r# ~6 L7 b
call factorial
2 |% s" ?% _: v+ ?: |4 ?
: g$ t0 K8 }. j* b8 ^& l6 v
; Multiply the result returned in eax with the saved value of eax# o: H- r" X# p8 ?: N T5 [
pop ebx
/ v9 W* @. o+ Q% O; G) I
imul eax, ebx" {5 V* x4 ^/ n0 {+ w3 c2 v" x4 K
. |# u R$ Q W6 O
ret
0 W6 T' a1 R/ H( s$ L# |# Q+ w
. x. J2 y! Y; ?8 \1 H1 h8 j
end_recursion:4 j0 \0 |8 I. a, w
; Return 1 when eax is 0 (base condition)
, l3 \/ u/ j+ T5 p" b7 v- A4 Z* C
mov eax, 1
" S; @" g7 G) E
ret

复制代码