Bab 10: Prosedur & Modul Program

; Near procedure (default, segmen kode sama)
nama_prosedur PROC NEAR
    ; ... isi prosedur ...
    RET
nama_prosedur ENDP

; Far procedure (segmen kode berbeda)
nama_prosedur PROC FAR
    ; ... isi prosedur ...
    RET
nama_prosedur ENDP

CETAK_KARAKTER PROC NEAR
    ; Input:  DL = karakter yang akan dicetak
    ; Output: tidak ada
    ; Mengubah: AX, DX (disimpan dan dikembalikan)

    PUSH AX              ; ① simpan register yang akan dipakai
    PUSH DX              ; ② urutan push: AX, DX

    MOV  AH, 02h         ; fungsi DOS: cetak karakter
    ; DL sudah berisi karakter dari pemanggil
    INT  21h

    POP  DX              ; ③ urutan pop: DX, AX (kebalikan!)
    POP  AX              ; ④ register dikembalikan ke nilai semula
    RET
CETAK_KARAKTER ENDP

; Prosedur: CETAK_ANGKA
; Input:  AL = angka (0-9)
; Output: mencetak angka tersebut ke layar
; Mengubah: AX, DX (disave/direstore)

CETAK_ANGKA PROC NEAR
    PUSH AX
    PUSH DX

    ADD  AL, 30h          ; konversi angka 0-9 ke ASCII '0'-'9'
    MOV  DL, AL           ; DL = karakter ASCII
    MOV  AH, 02h          ; fungsi cetak karakter
    INT  21h

    POP  DX
    POP  AX
    RET
CETAK_ANGKA ENDP


; === Program Utama ===
    MOV  AL, 7             
    CALL  CETAK_ANGKA       ; mencetak '7' ke layar

    MOV  AL, 3             ; parameter: angka 3
    CALL  CETAK_ANGKA       ; mencetak '3' ke layar

.data
    panjang dw 15             ; parameter 1 (global)
    lebar   dw 8              ; parameter 2 (global)
    luas    dw ?              ; hasil (global)

.code
; Prosedur: HITUNG_LUAS
; Membaca: panjang, lebar (variabel global)
; Menulis: luas (variabel global)

HITUNG_LUAS PROC NEAR
    PUSH AX
    PUSH BX

    MOV  AX, panjang      ; AX = panjang
    MOV  BX, lebar        ; BX = lebar
    MUL  BX               ; DX:AX = panjang × lebar
    MOV  luas, AX         ; simpan hasil (asumsi tidak overflow)

    POP  BX
    POP  AX
    RET
HITUNG_LUAS ENDP


; === Program Utama ===
    MOV  panjang, 15        ; set parameter
    MOV  lebar, 8          ; set parameter
    CALL  HITUNG_LUAS       ; hasil: luas = 120

; Prosedur: TAMBAH
; Parameter [BP+4]: bilangan pertama (word)
; Parameter [BP+6]: bilangan kedua   (word)
; Return: AX = hasil penjumlahan

TAMBAH PROC NEAR
    PUSH BP                ; ① simpan BP pemanggil
    MOV  BP, SP           ; ② BP = SP (BP sekarang menunjuk stack frame)

    MOV  AX, [BP+4]      ; ③ AX = parameter 1
    ADD  AX, [BP+6]      ; ④ AX += parameter 2

    POP  BP                ; ⑤ kembalikan BP pemanggil
    RET  4                ; ⑥ kembali & bersihkan 4 byte parameter
TAMBAH ENDP


; === Program Utama ===
    PUSH 25                ; push parameter 2 (kedua dulu!)
    PUSH 17                ; push parameter 1
    CALL  TAMBAH           ; AX = 17 + 25 = 42
    ; RET 4 di dalam prosedur sudah membersihkan stack

.model small
.stack 100h

.data
    pesan1  db 'Halo dari prosedur!$'
    pesan2  db 'Prosedur membuat kode rapi.$'
    newline db 0Dh, 0Ah, '$'  ; CR + LF

.code
; === PROSEDUR-PROSEDUR ===

; CETAK_STR: Cetak string yang diakhiri '$'
; Input:  DX = offset string
CETAK_STR PROC NEAR
    PUSH AX
    MOV  AH, 09h
    INT  21h
    POP  AX
    RET
CETAK_STR ENDP

; CETAK_NEWLINE: Pindah ke baris baru
CETAK_NEWLINE PROC NEAR
    PUSH DX
    LEA  DX, newline
    CALL  CETAK_STR        ; prosedur memanggil prosedur!
    POP  DX
    RET
CETAK_NEWLINE ENDP


; === PROGRAM UTAMA ===
mulai:
    MOV  AX, @data
    MOV  DS, AX

    LEA  DX, pesan1       ; parameter via register
    CALL  CETAK_STR

    CALL  CETAK_NEWLINE     ; pindah baris baru

    LEA  DX, pesan2
    CALL  CETAK_STR

    MOV  AH, 4Ch
    INT  21h

end mulai

; Prosedur: KALI
; Input:  AX = pengali (a), BX = pengali (b)
; Output: AX = a × b
; Catatan: hanya untuk bilangan positif kecil

KALI PROC NEAR
    PUSH CX
    PUSH DX

    MOV  CX, BX           ; CX = b (banyaknya penjumlahan)
    MOV  DX, 0             ; DX = akumulator hasil
    JCXZ kali_selesai      ; jika b = 0, hasil = 0

kali_ulang:
    ADD  DX, AX           ; DX += a
    LOOP kali_ulang         

kali_selesai:
    MOV  AX, DX           ; AX = hasil

    POP  DX
    POP  CX
    RET
KALI ENDP


; === Pemanggilan ===
    MOV  AX, 7             ; a = 7
    MOV  BX, 6             ; b = 6
    CALL  KALI             ; AX = 42

; Prosedur: FAKTORIAL
; Input:  AX = n (bilangan bulat ≥ 0)
; Output: AX = n!
; Mengubah: BX, CX (disave/direstore)

FAKTORIAL PROC NEAR
    PUSH BX
    PUSH CX

    CMP  AX, 1             ; base case: n ≤ 1?
    JBE   fakt_base        ; ya, 1! = 1 dan 0! = 1

    ; Recursive case: n! = n × (n-1)!
    MOV  CX, AX           ; CX = n (simpan untuk dikalikan nanti)
    DEC  AX                ; AX = n - 1
    PUSH CX                ; simpan n di stack (aman dari CALL)
    CALL  FAKTORIAL         ; AX = (n-1)!
    POP  CX                ; CX = n (ambil kembali)
    MUL  CX                ; DX:AX = (n-1)! × n
    JMP  fakt_selesai

fakt_base:
    MOV  AX, 1             ; 0! = 1! = 1

fakt_selesai:
    POP  CX
    POP  BX
    RET
FAKTORIAL ENDP


; === Pemanggilan: hitung 5! ===
    MOV  AX, 5             ; n = 5
    CALL  FAKTORIAL         ; AX = 120

; Deklarasi makro: CETAK_CHAR
CETAK_CHAR MACRO karakter
    PUSH AX
    PUSH DX
    MOV  DL, karakter
    MOV  AH, 02h
    INT  21h
    POP  DX
    POP  AX
ENDM

; Pemanggilan makro (diassembler menjadi kode inline)
    CETAK_CHAR 'A'           ; assembler ganti dengan isi makro, DL='A'
    CETAK_CHAR 'B'           ; assembler ganti dengan salinan lain, DL='B'
    CETAK_CHAR 'C'           ; assembler ganti dengan salinan lain, DL='C'

; Setelah assemble, hasilnya sama seperti menulis:
;   PUSH AX / PUSH DX / MOV DL,'A' / MOV AH,02h / INT 21h / POP DX / POP AX
;   PUSH AX / PUSH DX / MOV DL,'B' / MOV AH,02h / INT 21h / POP DX / POP AX
;   PUSH AX / PUSH DX / MOV DL,'C' / MOV AH,02h / INT 21h / POP DX / POP AX