第19章　陣列 ( Array )

陣列簡介

陣列 ( array ) 是許多資料類型相同的資料集合在一起所形成的一種資料結構。在組合語言裏，可以用任何已知的資料類型或是自行宣告的結構體定義一個陣列，在陣列中的每一筆資料都稱為元素 ( element )，每個元素都以「,」分隔。例如定義一個 10 以下質數所形成的陣列，如下：

prime1  DB      2,3,5,7
love    DB      "I love my wife so much!"

prime1 就是一個陣列，由四個元素組成，每個元素的資料類型都是 BYTE。雖然在第三章時，就知道 love 是一個字串，但是它也符合由許多資料類型相同的資料形成的集合，因此字串也可以看成是陣列。像 love 就是由 23 個元素，每個元素都是一個位元組形成的陣列。

假如陣列內的元素太多，在定義陣列時可以用跨越多行，只有第一行需要宣告資料類型，且每一行都以「,」結尾，從第二行起直接寫陣列中的元素即可。例如底下的例子，prime2 是小於 50 的質數所組成的陣列：

prime2  DB      2,3,5,7,11,13,
                17,19,23,29,31,
                37,41,43,47

如果陣列裏有重複的元素，在定義時可以用 DUP 假指令。如果不確定元素之值的話也可以用「?」表示。例如底下的例子：

array1  DW  10 DUP (3)              ;10 個 3，但每個 3 都是字組
series  DD  5 DUP (1,2,3)           ;3 個雙字組：1、2、3 重複 5 次
buffer  DB  256 DUP (?),256 DUP (1) ;256 個未初始的數值及 256 個 1，每個元素都是位元組

最特別的是陣列也可以是由位址組成的，例如底下的例子：

str_sunday      DB      0dh,0ah,"Sunday$"
str_monday      DB      0dh,0ah,"Monday$"
str_tuesday     DB      0dh,0ah,"Tuesday$"
str_wednesday   DB      0dh,0ah,"Wednesday$"
str_thursday    DB      0dh,0ah,"Thursday$"
str_friday      DB      0dh,0ah,"Friday$"
str_saturday    DB      0dh,0ah,"Saturday$"
week            DW      OFFSET str_sunday,OFFSET str_monday,OFFSET str_tuesday,
                        OFFSET str_wednesday,OFFSET str_thursday,
                        OFFSET str_friday,OFFSET str_saturday

上面的 week 就是一個陣列，它由七個元素組成，而每個元素都各自是一個字串的位址，而這七個字串卻又是星期幾的英文單字。

陣列的大小

如果不講清楚，陣列的大小可能是指陣列裏有幾個元素，也有可能是陣列佔用了幾個位元組。MASM 裏有三個運算子，能夠在不同的時機裏運用以計算陣列的大小：①LENGTHOF 可以取得陣列有多少元素；②TYPE 可以取得每個元素佔有多少個位元組；③SIZEOF 可以取得一個陣列總共佔有多少位元組。看底下的例子：

                                                    ;TYPE  LENGTHOF  SIZEOF
array1  DW  10 DUP (3)                              ;  2      10        20
series  DD  5 DUP (1,2,3)                           ;  4      15        60
buffer  DB  256 DUP (?),256 DUP (1)                 ;  1     512       512
love    DB  "I love my wife so much!"               ;  1      23        23
week    DW  OFFSET str_sunday,OFFSET str_monday,    ;  2       7        14
            OFFSET str_tuesday,OFFSET str_wednesday,
            OFFSET str_thursday,OFFSET str_friday,OFFSET str_saturday

存取陣列中的元素

要存取陣列中的元素，必須使用位址，至少有兩種方式可以存取陣列中的元素：①直接定址和②間接定址。

用直接定址存取陣列

使用直接定址存取陣列裏的元素，用下面的式子：

陣列名稱[常數]
[陣列名稱+常數]

在高階語言中，此常數其實就是索引，索引可以想成是從零開始的第幾個元素；但在組合語言裏，此常數不一定是索引值，而是距離陣列的起始位址多少個位元組。來看看底下的例子，可能會比較明白。假設定義 prime2 陣列為小於 50 的所有質數，如下程式：

prime2  DB      2,3,5,7,11,13,17,19,23,29,31,37,41,43,47
        mov     al,prime2[3]

因為 prime2 是以「DB」定義陣列，因此每個元素佔用一個位元組，請參考下圖，第零個元素是 2、第一個元素是 3、第二個元素是 5……依此類推。( 注意，在組合語言裏，陣列的元素由 0 開始 ) 如果用「mov al,prime2[3]」讀取 prime2 陣列的第三個元素，顯然 AL 會變成 7。

但如果用 SYMDEB 載入程式反組譯後，「mov al,prime2[3]」會變成「MOV AL,[prime2+03]」。事實上，prime2 是某個位址，該位址就是 prime2 陣列的起始位址；而中括號內的 03 代表相對於 prime2 起始位址後的三個位元組 ( 可看成是相對於 prime2 的偏移位址 )；而把一個位址放在一對中括號內，代表該位址裏面所儲存的數值。所以「MOV AL,[prime2+3]」也會使 AL 變成 7。

這樣看來，「prime2[3]」與「[prime2+3]」其實是一樣的意思。

但是如果把陣列宣告為 DW 資料類型，程式如下：

prime2  DW      2,3,5,7,11,13,17,19,23,29,31,37,41,43,47
        mov     ax,prime2[3]

在記憶體內的排列情形變成下圖的樣子，每個元素的佔據兩個位元組 ( 即一個字組 )，執行完「mov ax,prime2[3]」後，AX 變成 500h，即十進位的 1280

顯然在第二個例子中，如果要取得第三個元素，不能用「mov ax,prime2[3]」。那有沒有方法取得第 n 個元素的數值呢 ( n 由零開始 )？當然是有的，而且很簡單。公式變成：

陣列名稱[n×(TYPE 陣列名稱)]
[陣列名稱+n×(TYPE 陣列名稱)]

上面的 n 代表第幾個元素，從零開始；而 TYPE 能計算出陣列中的每個元素佔用多少位元組。例如底下的例子

prime2  DW      2,3,5,7,11,13,17,19,23,29,31,37,41,43,47
        mov     ax,prime2[?]

要取得質數 7，它是第三個元素 ( 注意，2 是第零個、3 是第一個……依此類推 )，因為 prime2 是以 DW 定義的，故 TYPE prime2 為 2，因此 ? 為 6，寫成「mov ax,prime2[6]」或是「mov ax,[prime2+6]」都能讀取第三個元素，使得 AX 變為 7。

事實上，組合語言真正的寫法應該是「mov ax,[prime2+6]」，寫成「mov ax,prime2[6]」是為了配合高階語言而不得不的寫法。不過沒關係，對於組譯器，ML.EXE，來說，它都可以接受這兩種寫法，組譯後的結果也都一樣。

用間接定址存取陣列

使用間接定址存取陣列中的元素，用底下的式子：

陣列名稱[暫存器]
[陣列名稱+暫存器]

這兩條式子是一樣的，這裏的暫存器必須是基底暫存器 ( 就是 BX )、索引暫存器 ( 就是 SI 或 DI ) 或指標暫存器 ( 就是 BP 或 SP )，不過因為 BP 一般會在堆疊框中當作基底使用，故使用 BX、SI、DI 較好。假如程式有宣告「.386」，那麼任何一個 32 位元的通用暫存器 ( 例如 EAX、EBX、ECX、EDX ) 都可以。

「陣列名稱[暫存器]」的原理與直接定址類似，陣列名稱會被組譯器「翻譯」陣列的起始位址，再加上暫存器內的數值就變成元素所在的位址。例如底下的例子：

prime2  DW      2,3,5,7,11,13,17,19,23,29,31,37,41,43,47
        mov     bx,3            ;要取得第 3 個元素
        shl     bx,1            ;「SHL BX,1」相當於使BX乘以2，因為每個元素佔兩個位元組
        mov     ax,prime2[bx]   ;相當於 prime2[6]，後來AX會變成7

如果有需要，間接定址也可以同時使用兩個暫存器，但這兩個暫存器一個必須是 BX、BP 二者中的一個，另一個也必須是 SI、DI 二者中的一個。也就是說在「[]」內如果有兩個暫存器，那麼必須一個是索引暫存器（SI、DI），另一個是基底暫存器（BX、BP），不能同時是索引暫存器，或同時是基底暫存器。假設有宣告「.386」假指令的話，這兩個暫存器就沒有限制。例如底下的例子：

prime2  DW      2,3,5,7,11,13,17,19,23,29,31,37,41,43,47
        mov     si,2
        mov     di,si
        mov     bx,4
        mov     ax,prime2[bx][si]
        mov     cx,prime2[bx+si]
        mov     dx,[prime2+bx+si]
        mov     ax,prime2[si+di]

倒數第四道∼倒數第二道指令其實都是存取同一位址，因此 AX、CX、DX 都等於 7。對組合語言來說，「mov dx,[prime2+bx+si]」是最好的寫法，但是 ML.EXE 一樣能接受其他兩種寫法，組譯後的結果也一樣。上面程式中的最後一條指令「mov ax,prime2[si+di]」是不合 x86 指令的語法，因為不能同時使用兩個索引暫存器。

.MODEL          SMALL,STDCALL
.386
prime2  DW      2,3,5,7,11,13,17,19,23,29,31,37,41,43,47
        mov     ecx,2
        mov     edx,4
        mov     ax,prime2[ecx][edx]

上面的例子已經有「.386」假指令，就不限定只能用 EBX、EBP、ESI、EDI 等基底暫存器或索引暫存器，連通用暫存器都能在間接定址中使用。

應用一

上一章，小木偶介紹了一個程式叫做「WHATDAY.ASM」，能計算西元某年某月某日是星期幾。最後計算出星期幾時，使用「.IF/.ELSEIF/.ELSE/.ENDIF」指令取得星期幾的字串位址，才將其顯示在螢光幕上。

這一章小木偶不用冗長的「.IF/.ELSIF/.ELSE/.ENDIF」假指令，而是用陣列的方式取出星期幾的字串位址。改寫後的程式稱為「WHATDAY1.ASM」，原始碼如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
.MODEL          SMALL,STDCALL
.386
DATE            STRUCT
  year          DW      ?       ;西元年份
  month         DB      ?       ;月份
  day           DB      ?       ;日
DATE            ENDS
;*******************************************************************************
.STACK
;*******************************************************************************
.DATA
today           DATE    {?}
str0            DB      "Input year : $"
str1            DB      0dh,0ah,"Input month : $"
str2            DB      0dh,0ah,"Input day : $"
str_sunday      DB      0dh,0ah,"Sunday$"
str_monday      DB      0dh,0ah,"Monday$"
str_tuesday     DB      0dh,0ah,"Tuesday$"
str_wednesday   DB      0dh,0ah,"Wednesday$"
str_thursday    DB      0dh,0ah,"Thursday$"
str_friday      DB      0dh,0ah,"Friday$"
str_saturday    DB      0dh,0ah,"Saturday$"
week            DW      OFFSET str_sunday,OFFSET str_monday,OFFSET str_tuesday,
                        OFFSET str_wednesday,OFFSET str_thursday,
                        OFFSET str_friday,OFFSET str_saturday
error_message   DB      0dh,0ah,"Input Arabic numerals only.$"
;*******************************************************************************
.CODE
;-------------------------------------------------------------------------------
print_string    PROC    pStr:WORD
                mov     dx,pStr
                mov     ah,9
                int     21h
                ret
print_string    ENDP
;-------------------------------------------------------------------------------
;輸入0∼65535的十進位整數。
;返回：CX＝00，發生錯誤
;　　　CX非零，輸入正確，AX＝使用者輸入的數值
input           PROC
                LOCAL   value:WORD
                mov     cx,5            ;最多輸入五位
                mov     value,0         ;使value歸零
.WHILE cx
                mov     ah,1            ;DOS服務程式，鍵盤輸入字元
                int     21h             ;AL＝輸入字元的ASCII碼
     .IF (al>="0")&&(al<="9")
                sub     al,"0"
                mov     dx,value
                shl     value,3         ;8*value
                shl     dx,1            ;2*value
                cbw
                add     value,dx        ;value＝8*value+2*value＝10*value
                add     value,ax        ;value＝value＋AX
     .ELSEIF al==0dh
                jmp     finish
     .ELSE
                jmp     short quit1
     .ENDIF
                dec     cx
.ENDW
finish:         mov     ax,value
                mov     cx,1
                jmp     short quit2
quit1:          xor     cx,cx
quit2:          ret
input           ENDP
;-------------------------------------------------------------------------------
;計算某年某月某一天是星期幾
;輸入：pdate：DATE結構體的位址，其中year、month、day必須已填入正確日期
;輸出：AX＝星期幾：0＝星期日、1＝星期一，2＝星期二……
;      AX＝-1，輸入錯誤的DATE結構體
what_day_is     PROC    pdate:WORD
                LOCAL   w:WORD
                ;ASSUME  si:PTR DATE
;what_day_is利用Zeller's公式求出某個日期是星期幾，以W表示
;W={C/4－2*C＋Y＋Y/4＋13*(M＋1)/5＋D－1} Mod 7
;  月份：1月 2月 3月 4月 5月 6月 7月 8月 9月 10月 11月 12月
;  --------------------------------------------------------
;     M＝13  14  3   4   5   6   7   8   9   10   11   12
;     A＝ 1   1  0   0   0   0   0   0   0    0    0    0
;  B＝四位數字年份－A
;  C＝B的前兩位數(千位數和百位數所組成的兩位數)
;  Y＝B的後兩位數(十位數和個位數所組成的兩位數)
;  D＝日
                mov     si,pdate
                mov     cl,100
                movzx   bx,(DATE PTR [si]).month
                mov     ax,(DATE PTR [si]).year
                cmp     bx,2    ;檢查是否為元月份或二月份
                ja      not_adj
                add     bx,12   ;如果月份為元月份或二月份，要調整成前一年的13月、
                dec     ax      ;14月，亦即月份變成13月、14月同時年份減一
not_adj:        div     cl      ;年份＝B＝AX
                movzx   cx,ah   ;CX＝Y
                movzx   dx,al   ;DX＝C
                mov     w,cx    ;W＝Y
                shr     cx,2    ;CX＝Y/4
                add     w,cx    ;W＝Y＋Y/4
                mov     cx,dx
                shr     cx,2    ;CX＝C/4
                shl     dx,1    ;DX＝2*C
                movzx   ax,(DATE PTR [si]).day
                add     w,cx    ;W＝C/4＋Y＋Y/4
                sub     w,dx    ;W＝C/4－2*C＋Y＋Y/4
                add     w,ax    ;W＝C/4－2*C＋Y＋Y/4＋D
                inc     bx      ;BX＝M＋1
                mov     cx,50dh ;CL＝13，CH＝5
                mov     ax,bx
                mul     cl
                div     ch
                cbw             ;AX＝13*(M＋1)/5
                add     ax,w
                mov     cx,7
                dec     ax      ;AX＝C/4－2*C＋Y＋Y/4＋13*(M＋1)/5＋D－1
                cwd
                idiv    cx      ;因為DX:AX有可能是負數，因此用IDIV
                cmp     dx,0    ;如果DX:AX是負數所得餘數(存於DX)也是負數
                jge     ok
                add     dx,cx   ;因此餘數要加上七，確保為正數
ok:             mov     ax,dx
                ret
what_day_is     ENDP
;-------------------------------------------------------------------------------
                .STARTUP
                INVOKE  print_string,OFFSET str0
                call    input
                jcxz    error
                mov     today.year,ax
                INVOKE  print_string,OFFSET str1
                call    input
                jcxz    error
                mov     today.month,al
                INVOKE  print_string,OFFSET str2
                call    input
                jcxz    error
                mov     today.day,al
                INVOKE  what_day_is,OFFSET today
                mov     bx,ax        ;AX＝0：星期日，1：星期一，2：星期二……
                shl     bx,1         ;因為week裏的每個元素佔用2個位元組
                mov     dx,week[bx]  ;DX＝星期幾的字串
                INVOKE  print_string,dx
                mov     al,0
                jmp     short exit
error:          INVOKE print_string,OFFSET error_message
                mov     al,1
exit:           .EXIT   al
;*******************************************************************************
END

WHATDAY1.ASM 中的第 23∼25 行定義了 week 陣列，這個陣列裏共有 7 個元素，每個元素都代表一個字串的位址，而這些字串都是星期幾的英文單字。用 SYMDEB 載入 WHATDAY1.SYM 及 WHATDAY1.EXE，輸入「d str_sunday」很容易可以觀察七個星期幾的字串以及 week 陣列的樣子：( 有關 SYMDEB 及 MAPSYM 的用法，請參考第七章，此外要先設好路徑，執行 SYMDEB、MAPSYM 才不會出錯 )

E:\DOS\WHATDAY>ml /Zf /Fm whatday1.asm [Enter] →「/Fm」建立 WHATDAY1.MAP 檔，「/Zf」宣告所有符號名稱為「PIBLIC」
Microsoft (R) Macro Assembler Version 6.11       要宣告「PUBLIC」的符號才能寫入 WHATDAY1.MAP 裏
Copyright (C) Microsoft Corp 1981-1993.  All rights reserved.

 Assembling: whatday1.asm

Microsoft (R) Segmented Executable Linker  Version 5.31.009 Jul 13 1992
Copyright (C) Microsoft Corp 1984-1992.  All rights reserved.

Object Modules [.obj]: whatday1.obj 
Run File [whatday1.exe]: "whatday1.exe"
List File [nul.map]: "whatday1.map" /m
Libraries [.lib]: 
Definitions File [nul.def]:
E:\DOS\WHATDAY>mapsym whatday1 [Enter] →製作 WHATDAY1.SYM 檔
Microsoft (R) Symbol File Generator  Version 4.00
Copyright (C) Microsoft Corp 1984, 1985.  All rights reserved.

	Program entry point at 0000:00be

E:\DOS\WHATDAY>symdeb whatday1.sym whatday1.exe [Enter] →載入 WHATDAY1.SYM 及 WHATDAY1.EXE 除錯
Microsoft (R) Symbolic Debug Utility  Version 4.00       就能以原始碼的符號名除錯
Copyright (C) Microsoft Corp 1984, 1985.  All rights reserved.

Processor is [80286]
-d str_sunday [Enter]
157C:0030                                      0D 0A 53 75              ..Su
157C:0040  6E 64 61 79 24 0D 0A 4D-6F 6E 64 61 79 24 0D 0A  nday$..Monday$..
157C:0050  54 75 65 73 64 61 79 24-0D 0A 57 65 64 6E 65 73  Tuesday$..Wednes
157C:0060  64 61 79 24 0D 0A 54 68-75 72 73 64 61 79 24 0D  day$..Thursday$.
157C:0070  0A 46 72 69 64 61 79 24-0D 0A 53 61 74 75 72 64  .Friday$..Saturd
157C:0080  61 79 24 3C 00 45 00 4E-00 58 00 64 00 6F 00 78  ay$<.E.N.X.d.o.x
157C:0090  00 0D 0A 49 6E 70 75 74-20 41 72 61 62 69 63 20  ...Input Arabic 
157C:00A0  6E 75 6D 65 72 61 6C 73-20 6F 6E 6C 79 2E 24 00  numerals only.$.
157C:00B0  00 00 00 00 00 00 00 00-00 00 00 00              ............
-

觀察上面傾印記憶體的內容，在位址 157C:0083 處以白色標示的就是 week 陣列的第零個元素，也就是 str_sunday 字串 ( 以白色標示 ) 的位址；以紅色標示的就是 week 陣列的第一個元素，也就是 str_monday 字串 ( 以紅色標示 ) 的位址……。

假如執行 WHATDAY1.EXE 時，我們輸入的日期是「西元2022年八月二日」，呼叫完第 138 行的 what_day_is 副程式後，返回時的回傳值存於 AX，AX 為二，亦即星期二。接下來第 139 行，把 AX 之值放入 BX 裏，主要目的是要用 BX 作為間接定址的基底暫存器。不過這時 BX 內的數值還要修正，因為 week 陣列中的每個元素都佔兩個位元組，所以 BX 還要乘以二，第 140 行的「SHL BX,1」就是讓 BX 乘以二，得到 BX 為四，亦即距離 week 陣列起始位址四個位元組，見下圖左邊的部份。

而 week 是一陣列，起始位址是 0083H ( 標示白色的 3C 00 )；而 BX＝4，因此「week[bx]」的意思其實就是記憶體位址 0087 內的數值，查閱位址 0087 內的數值是 004E，因此執行完「mov dx,week[bx]」後，DX＝004E。004E 所指向的位址，就是「0dh,0ah,"Tuesday$"」字串。

WHATDAY1.ASM 其他部份都和前一章的 WHATDAY.ASM 類似，就不贅述。底下再看另外一個例子。

應用二

位址組成的陣列，不只可以處理資料，也能當作跳躍的目的地，甚至是用於呼叫副程式。底下的 FUNC.ASM 就是利用具有不同功能的數個副程式的位址組成陣列，FUNC.ASM 可以讓使用者選擇執行哪個功能，然後以陣列中的元素為目的地呼叫相對應的副程式。

FUNC.ASM 有四個功能：Ⓞ退出程式；①清除螢幕；②印出一個字串；③十六進位數變十進位。這四個功能各自由一個副程式負責，分別是 exit、cls、pnt、h2d，第一個 exit 其實不算是副程式，它是一個位址，執行到此位址就會呼叫 AH＝4CH/INT 21H。但不論如何，與副程式位址一樣，都是位址，這四個位址組成 func 陣列。我們先來看看 FUNC.ASM 的原始程式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
.MODEL          SMALL,STDCALL
.386
;*******************************************************************************
.STACK
;*******************************************************************************
.DATA
menu    DB      0dh,0ah,"0:Exit",
                0dh,0ah,"1:Clear screen",
                0dh,0ah,"2:Print a message",
                0dh,0ah,"3:Hexadecimal to Decimal",
                0dh,0ah,"Your selection is : $"
func    DW      OFFSET exit,OFFSET cls,OFFSET pnt,OFFSET h2d
string  DB      9,9,"I learn assembly language.$"
prompt  DB      0dh,0ah,"Input Hexadecimal : $"
;*******************************************************************************
.CODE
;-------------------------------------------------------------------------------
print_string    PROC    pStr:WORD
                mov     dx,pStr
                mov     ah,9
                int     21h
                ret
print_string    ENDP
;-------------------------------------------------------------------------------
;input_hex讓使用者輸入十六進位數，其數值在0∼65535(或FFFFh)之間
;輸入：pStr：使用者輸入的數值變成字串，存於pStr所指的位址之中
;輸出：CX＝0，輸入錯誤
;　　　CX＝其他數，正確，AX＝輸入的數值，CX＝使用者輸入的字串尾端位址
input_hex       PROC    pStr:WORD
                LOCAL   value:WORD
                xor     cx,cx
                mov     si,pStr
                mov     value,cx        ;使value歸零
                mov     WORD PTR [si],0a0dh
                add     si,2
                mov     cx,4            ;一個字組的十六進位數最多有四位
.WHILE cx
                mov     ah,1            ;DOS服務程式，鍵盤輸入字元
                int     21h             ;AL＝輸入字元的ASCII碼
                mov     [si],al
        .IF al==0dh
                jmp     short finish
        .ELSEIF (al>="0")&&(al<="9")
                sub     al,"0"
        .ELSEIF (al>="A")&&(al<="F")
                sub     al,37h
        .ELSEIF (al>="a")&&(al<="f")
                and     BYTE PTR [si],0dfh
                sub     al,57h
        .ELSE
                xor     cx,cx
                jmp     short quit
        .ENDIF
                inc     si
                shl     value,4
                cbw                     ;使AH變為0
                add     value,ax        ;value＝value＋AX
                dec     cx
.ENDW
finish:         mov     ax,value
                mov     cx,si
quit:           ret
input_hex       ENDP
;-------------------------------------------------------------------------------
cls             PROC
                mov     ax,619h         ;使用AH=06/INT 10H BIOS 服務程式
                mov     dx,184fh        ;捲動視窗的右下角是第24列、第79行
                xor     cx,cx           ;捲動視窗的左上角是第0列、第0行
                mov     bh,7            ;捲動後的前景色是白色，背景色是黑色
                int     10h
                mov     cx,1            ;設定CX＝1，讓主程式知道沒發生錯誤
                ret
cls             ENDP
;-------------------------------------------------------------------------------
pnt             PROC
                INVOKE  print_string,OFFSET string
                mov     cx,1            ;設定CX＝1，讓主程式知道沒發生錯誤
                ret
pnt             ENDP
;-------------------------------------------------------------------------------
h2d             PROC
                LOCAL   answer[16]:BYTE ;answer會儲存使用者輸入的字元，例如使用者輸
                LOCAL   ten:WORD        ;入cd0，answer會變成「0d,0a,"CD0h=03280d$"」
                mov     ten,10
                INVOKE  print_string,OFFSET prompt
                INVOKE  input_hex,ADDR answer   ;返回時，若CX＝0表示發生錯誤；
                jcxz    h2d_exit                ;若CX不為0，CX為input_hex已填入的
                mov     bx,cx                   ;字串結尾位址
                mov     WORD PTR [bx],"=h"      ;把"h="填入該位址
                add     bx,7                    ;把"d$"填入該位址後七個位元組處，
                mov     WORD PTR [bx],"$d"      ;為的是留下十進位數值的空間
                mov     cx,5
                dec     bx
        .WHILE cx
                xor     dx,dx
                div     ten
                add     dl,"0"
                mov     [bx],dl
                dec     bx
                dec     cx
        .ENDW
                lea     dx,answer
                INVOKE  print_string,dx         ;DX＝answer字串的位址
                mov     cx,1            ;設定CX＝1，讓主程式知道沒發生錯誤
h2d_exit:       ret
h2d             ENDP
;-------------------------------------------------------------------------------
                .STARTUP
select:         INVOKE  print_string,OFFSET menu
                mov     ah,1
                int     21h
                sub     al,"0"
                cmp     al,3            ;如果使用者選擇超過3的選項，重新再選一次
                ja      select
                cbw
                mov     bx,ax
                shl     bx,1
                call    func[bx]        ;呼叫cls、pnt、h2d三個副程式的其中一個
                jcxz    short exit      ;若CX＝0，表示發生錯誤
                jmp     select
exit:           .EXIT   al
;*******************************************************************************
END

FUNC.ASM 最主要架構是：

.DATA
func    DW      OFFSET exit,OFFSET cls,OFFSET pnt,OFFSET h2d
                .
                .
.CODE
;-------------------------------------------------------------------------------
cls             PROC
                .
                .
cls             ENDP
;-------------------------------------------------------------------------------
pnt             PROC
                .
                .
pnt             ENDP
;-------------------------------------------------------------------------------
h2d             PROC
                .
                .
h2d             ENDP
;-------------------------------------------------------------------------------
                .STARTUP
                .
                .
                mov     bx,ax           ;AX＝使用者選擇的功能，可能是0、1、2、3
                shl     bx,1
                call    func[bx]        ;呼叫cls、pnt、h2d三個副程式的其中一個
                .
                .
exit:           .EXIT   0

把主要架構寫出來，程式的運作方式就很清楚了。在資料區段裏定義了 func 陣列，裏面有四個元素，分別是四個副程式的進入點位址 ( 第零個元素比較特別，exit 並非副程式，是退出 func 程式的標記 )。而每個進入點的位址長度都是兩個位元組，因此用「DW」定義 func 陣列。

在上面的主要架構中，「.STARTUP」之後的程式很簡單沒有列出來，其主要目的是印出選單及讓使用者選擇 0∼3 四個選項，使用者選擇的數值會儲存在 AX 裏，但是間接定址的暫存器只能用 BX、BP、SI、DI 等，所以把 AX 之值移入 BX，再乘以二，接下來就是重點了。

間接呼叫與間接跳躍 ( Indirect Call and Indirect Jump )

事實上，CALL、JMP 不是只能呼叫或跳躍到固定的位址去，它們可以用「間接」的方式，讓呼叫或跳躍的目的地變得可依實際情況而改變。此處小木偶僅介紹間接呼叫，間接跳躍幾乎一樣，只不過將指令由 CALL 改成 JMP 而已，讀者可以自行嘗試。

間接呼叫和間接定址類似，可以使用常數與暫存器當做呼叫的目的地位址，其語法如下：

CALL    暫存器
CALL    [暫存器]
CALL    常數[暫存器]                   ;或 CALL [常數+暫存器]
CALL    常數[暫存器一][暫存器二]        ;或 CALL [常數+暫存器一+暫存器二]

一般來說，上面的常數應該是一個陣列的名稱，而暫存器只能是 BX、BP、SI、DI；如果是有暫存器一、暫存器二，那麼基底暫存器 ( BX 或 BP ) 和索引暫存器 ( SI 或 DI ) 各選一個，不能同時是基底暫存器或同時是索引暫存器。例如底下的例子都是正確的：

call    bx
call    [bx]
call    func[si]
call    func[si][bp]
call    [func+si+bp]                    ;與「call func[si][bp]」相同

而底下的例子是錯誤的：

call    bx+si                           ;只能用一個暫存器
call    ax                              ;不能用 AX 暫存器
call    [cx]                            ;不能用 CX 暫存器
call    func[si+di]                     ;不能用兩個索引暫存器

如果已經宣告「.386」假指令，那麼 32 位元的通用暫存器、ESI、EDI、EBP 都能用在間接呼叫上，不受上面的限制。底下的例子都是正確的：

call    ecx
call    WORD PTR [eax]
call    func[esi][edi]

言歸正傳，我們已經明白了正確的間接呼叫語法，底下小木偶用 FUNC.ASM 當作例子說明間接呼叫是如何運作的。

跟 WHATDAY1.ASM 一樣，經過組譯、連結、製造 SYM 檔後，用 SYMDEB 載入 FUNC.SYM、FUNC.EXE 後，直接輸入：

E:\DOS\STRUCT>c:\tools\symdeb func.sym func.exe [Enter]
Microsoft (R) Symbolic Debug Utility  Version 4.00
Copyright (C) Microsoft Corp 1984, 1985.  All rights reserved.

Processor is [80286]
-u select [Enter] →反組譯讓使用者選擇功能的程式碼
_TEXT:select:
1564:00EF 680000         PUSH   0000
1564:00F2 E80BFF         CALL   _print_string@2 →因為在程式一開始宣告了「.MODEL SMALL,STDCALL」，STDCALL 會
1564:00F5 B401           MOV    AH,01             讓組譯器修改副程式名稱，參閱「第十章 PROTO 假指令」一節。
1564:00F7 CD21           INT    21
1564:00F9 2C30           SUB    AL,30                         ;'0'
1564:00FB 3C03           CMP    AL,03
1564:00FD 77F0           JA     select
-u [Enter]
1564:00FF 98             CBW
1564:0100 8BD8           MOV    BX,AX
1564:0102 D1E3           SHL    BX,1
1564:0104 FF975C00       CALL   [BX+005C]       →這一行其實就是 call func[bx]
1564:0108 E302           JCXZ   exit
1564:010A EBE3           JMP    select
_TEXT:exit:
1564:010C B44C           MOV    AH,4C                         ;'L'

位址第 0104 處的「CALL [BX+005C]」其實就是原始程式第 118 行「call func[bx]」反組譯的結果。陣列 func 代表著 005C 這個位址，在原始程式中，把「func[bx]」寫成「[func+bx]」是一樣的，組譯時 ML.EXE 會去計算 func 的位址，然後寫在目的檔內。我們驗證 func 是不是在 005C 處，輸入下面指令：

-d func l8 [Enter]
1575:0050                                      0C 01 7A 00              ..z. →果然在 005C 處
1575:0060  8A 00 94 00                                      ....

陣列 func 的第零個元素在位址 010C 處，依據原始程式是程式標記 exit: 處，上面以白色字標示的果真就是在 010C 處。再檢查看看第一個元素，輸入「u 7a」反組譯這段程式碼，果然跟原始程式的 cls 副程式一樣。

-u 7a [Enter]
_TEXT:_cls@0:
1564:007A B81806         MOV    AX,0618 
1564:007D BA4F18         MOV    DX,184F 
1564:0080 33C9           XOR    CX,CX 
1564:0082 B707           MOV    BH,07 
1564:0084 CD10           INT    10 
1564:0086 B90100         MOV    CX,0001 
1564:0089 C3             RET

在位址 007A 處是副程式 cls 的進入點，但是而 pnt、print_string 這些副程式也都如此，ML.EXE 為何要修改副程式名稱呢？這小木偶也不清楚，如有大神知道，尚不吝指教。

假設使用者選擇時按「2」這個按鍵，那麼 AX 內的數值就是 2。移入 BX 後再把 BX 乘以二，那麼 BX 就是 4 了。底下解釋間接呼叫，「call func[bx]」這道指令。參考右圖，func 陣列的位址是 005C，再加上 BX 相對於 func 起始位址的偏移位址就是 0060，而加上中括號後代表的卻是 0060 記憶體位址內的數值，因此 func[bx] 其實代表 008A ( 記得 func[bx] 與 [func+bx] 是一樣的意思 )，所以最後「call func[bx]」就變成「CALL 008A」了。

小木偶在撰寫這一章時，查閱網路上的資料，發現許多人發問「JMP BX」與「JMP [BX]」有何不同？假設你已經理解了「間接呼叫與間接跳躍」，就能解答這個問題了。前者是跳躍到 BX 所指的位址，後者是跳躍到 BX 所指位址的記憶體內容的位址。以上圖為例，假設 BX＝0060H，「JMP BX」就是跳到 0060H 的位址處，而「JMP [BX]」則會跳到 008AH 的位址處。


視窗內容向上捲動：AH＝06H/INT 10H
視窗內容向下捲動：AH＝07H/INT 10H

清除螢幕的方式有許多種，可以把視訊記憶體的內容都填入空白字元，這樣螢幕就變成空無一物，效果就相當於清除螢幕了。這一章小木偶要介紹另一種方法，將螢幕的內容向上捲動，如果捲動的行數超過螢幕最多顯示的行數，也能讓螢幕變空無一物。

所謂向上捲動的意思是最上面一列向上移到螢幕外面，因此原來最上面一列的內容就消失不見，而其下的每一列都向上移動一列，螢幕最底下會新移入一列空白列。當然也可以向上捲動不只一列，如果是向上捲動數列，這樣的話就是最上面數列移出螢幕外，螢幕底下回移進數列空白列。

BIOS 服務程式，AH＝06H/INT 10H 可以向上捲動螢幕數列，不僅如此，它捲動的範圍也可以僅限一個「視窗」內 ( 所謂視窗可以想成一個矩形 )，而在視窗外部則不受影響。AH＝07H/INT 10H 則是向下捲動螢幕數列，它的用法和 AH＝06H/INT 10H 都相同，差別只在於捲動方向，因此底下僅說明 AH＝06H/INT 10H 的用法：

視窗內容向上捲動
輸入：AH＝06H
　　　AL＝想要捲動的列數，若 AL＝0，表示清除視窗內容
　　　CH、CL＝左上角的列號與行號
　　　DH、DL＝右下角的列號與行號
　　　BH＝視窗底部新移進來的前景色與背景色
執行：INT 10H
返回：無

視窗內容向下捲動
輸入：AH＝07H
　　　AL＝想要捲動的列數，若 AL＝0，表示清除視窗內容
　　　CH、CL＝左上角的列號與行號
　　　DH、DL＝右下角的列號與行號
　　　BH＝視窗底部新移進來的前景色與背景色
執行：INT 10H
返回：無

先看下圖的情形，每一列都是阿拉伯數字，從 0 開始到 9，不斷重複。只有淡藍色所框住的矩形不同，但仔細觀察，會發現淡藍色框框內的每一列往上移兩列，就形成下面的圖形：

參考上圖，矩形所形成的「視窗」僅以左上角和右下角的座標就能畫得出來，左上角的座標放在 CX 暫存器裏，CH 是列號，CL 是行號。在數學上的平面座標以 ( x,y ) 來表示，x 是橫座標、y 是縱座標。在這裏小木偶也仿照數學上的直角座標系表示，CL 代表橫座標 ( 即行號 )，CH 代表縱座標 ( 即列號 )；對於 80×25 的文字模式而言，CL 範圍在 0∼79 之間，CH 在 0∼24 之間。如果是在 40×25 文字模式下，那麼 CL 範圍在 0~39 之間。

右下角座標存放在 DX 裏，和 CX 一樣。要往上捲動幾列存放在 AL 裏，假設 AL 為零，就會清除視窗內容。視窗底部新移進的內容都是空白，而其前景色與背景色存放於 BH 內。上圖所形成的視窗，是執行底下的程式造成的：

                mov     cx,904h         ;第九列第四行
                mov     dx,1014h        ;第十六列第二十行
                mov     ah,6
                mov     al,2            ;捲動兩行
                mov     bh,7
                int     10h

如果要清除螢幕，就可以把要捲動的視窗範圍設為整個螢幕。例如顯示模式 3 為 80×25 的文字模式，那麼就可以把 CX 設為 0，DX 設為 184Fh，AL 設為 0 或 25。( 18h＝24、4Fh＝79 )

AH＝06H/INT 10H 服務程式不僅能在文字模式中向上捲動，在圖形模式中也能向上捲動。如果是在圖形模式，要捲動的視窗仍以第幾列、第幾行的字元表示，不是以點表示。例如顯示模式 6 為 640×200的圖形模式中，當然也可以顯示字元，所顯示的字元每個都是 8×8，換句話說在顯示模式 6 的時候，最多可顯示 25列，每列 80 個字元。當要向上捲動而指定視窗範圍時，仍將它看作文字模式下指定 CX 與 DX。也就是說 CL、DL 範圍在 0∼79 之間，CH、DH 的範圍在 0∼24 之間。捲動時，視窗內的任何內容，包含文字或圖案都能捲動。