在第六章已經稍稍提過無號數 ( unsigned number ) 與有號數 ( signed number )，前者沒有正負號，一般可視為正數；後者有正負號，以最高位元表示其符號，最高位元為零，表示正數；為一表示負數。這一章小木偶將探討有號數，並設計一程式可以輸入兩個有號數，然後以這兩數做加減運算，並將結果顯示在螢光幕上。
在數學上表示負數很簡單，只要在數值前加上「－」號即可，例如 －88。但在電腦上要表示負數該怎麼辦呢？其實有許多種方式，有號量數 ( 原碼 )、二補數等等方法，不論哪一種方法都是用最高位元表示正號或負號，這最高位元也稱為符號位元。如果是八位元的數值，第七位元就是符號位元；如果是十六位元的數值，第十五位元就是符號位元。在電腦領域裏，最低位元是第零位元。如下圖中的 S 就代表符號位元：
有一種表示有號數的方法稱為「有號量數」，它表示正負數的方式很直覺，就是把正數的符號位元變成一就行了，例如 5 的八位元二進位數是「0000 1001」，－5 就是「1000 1001」。這樣的表示方式雖簡單，但運算起來就很複雜了。例如我們知道 5＋(－5﹚＝0，但是如果以有號量數計算卻無法得到零，必須把異號數的加法改成減法運算才行。但如果要算同號數的加法運算，就真的只要用加法。所以假設用有號量數表示有號數，做加法運算前還要先檢查這兩數是否為異號數。顯然用這種方式表示有號數，要進行運算是很麻煩的，多數電腦不採用這種方法。
另一種表示有號數的方法是用「二補數」，這也是現今大多數電腦所採用的方式，也包含 x86/x64 相容電腦。
大多數電腦用二補數法表示有號數，意思就是某數的二補數，就是其負值。先來說說，怎麼去計算某數的二補數呢？其實並不難，利用底下的步驟，很容易就能算出來：
舉幾個例子來試試看：
第一個例子，求八位元 52h 的二補數，如下圖：
故 52h 的二補數是 AEh |
再舉另一個例子，求八位元 9Bh 的二補數，如下圖：
故 9Bh 的二補數是 65h |
另外還有一種方式也能計算某數的二補數：
例如下面要求 52h 的二補數，過程如下：
①由最低位元開始向高位元，如果是 0 就照抄，直到出現 1，第一次出現的 1 也照抄。
②反轉剩下的位元，最後的結果就是 52h 的二補數。
由上面兩種方法都能計算出來，52h 的二補數為 AEh，9Bh 的二補數是 65h。現在已經知道如何計算某數的二補數，但是這有什麼用途呢？。
仔細觀察後，可以發現二補數有幾個性質：
回想國中時學正負數，如果兩數相加為零，這兩個數必是一正一負，例如 ＋58 和 －58，它們等值異號，互為相反數 ( 在數學上，兩數之和為零的，這兩數就互為相反數 )。另外，如果把 －58 再取負號，結果又變成 ＋58。
某數與其二補數，恰好都符合上面的規律，因此我們把某數與其二補數當成兩個相反數，也就是說，52h 取其負值是 AEh，9Bh 取其負值是 65h。大多數的現代電腦裏，用二補數代替負數。
瞭解了以二補數表示負數後，要如何把十六進位的有號數轉換成十進位數呢？這可以分三部分來說：
如果最高位元為 0，表示為正數，那麼就照無號數的方式計算。可以參考附錄二的說明，用多個 16 的冪次方之和求得。例如八位元的有號數 63h 變成十進位為何？如右圖所示，先看最高位元是 0，因此是正數。再把它變成 6×161＋3×160＝99，因此 63h＝99d。也可以把 63h 轉換成二進位，0110 0011，於是變成 26＋25＋21＋20，加起來也是 99。
上面的方法是我們人類使用紙筆在腦袋中計算的過程，在電腦中必須用第七章的方法，以連續除以十所得的餘數組合起來，就是十進位數字字串。
如果最高位元為 1，表示為負數，不可直接計算；必須先取其二補數，然後再依無號數方式運算，最後再加上負號。這原理是這樣的，有號數若為負數，雖然我們不知道這數是什麼，但是將其變為二補數之後，就是原數的相反數，就變成正數了，再依無號數方式將這個正數變成十進位數，最後再加上負號。
例如要把八位元的有號數 84h 變成十進位，如右圖。第一步，先把它變成二進位，「1000 0100」檢查最高位元為 1，得知為負數。第二步將其變成二補數，0111 1100，再把這個二補數變成十進位數，26＋25＋24＋23＋22，加起來是 124，最後再加上負號，因此 84h＝－124。
同樣的，在電腦裏計算過程是先把這個負數做二補數運算，使它變成正數，然後以連續除以十所得的餘數組合起來，就是十進位數字字串，最後在此數字字串前加上負號，就大功告成了。
這不必解釋，該數就是 0。例如八位元的有號數，0000 0000，就代表零。
宣告有號數的方法是使用下面四個假指令：
變數名 SBYTE 初始值 變數名 SWORD 初始值 變數名 SDWORD 初始值 變數名 QWORD 初始值
SBYTE、SWORD、SDWORD 中的「S」是 sign 的意思，比較特別的是沒有「SQWORD」來宣告四字組的有號數。設計程式時依據有號數的範圍決定使用哪一種假指令，它們的範圍如下表：
| 種類 | 假指令 | 名稱 | 長度 ( 位元組 ) | 所能表示的整數範圍 |
| 無號數 | DB、BYTE | 位元組 | 1 | 0∼255 |
| DW、WORD | 字組 | 2 | 0∼65,535 | |
| DD、DWORD | 雙字組 | 4 | 0∼4,294,967,295 | |
| DQ、QWORD | 四字組 | 8 | 0∼18,446,744,073,709,551,615 | |
| 有號數 | SBYTE | 位元組 | 1 | －128∼127 |
| SWORD | 字組 | 2 | －32,768∼32,767 | |
| SDWORD | 雙字組 | 4 | －2,147,483,648∼2,147,483,647 |
觀察上表，得知無號數的位元數越多，所能表示的範圍也越大；有號數也是一樣。但是在相同位元時，正數與負數大約各佔一半，因此有號數所能表示的正數範圍較無號數小。
雖然在上表中，用不同的假指令宣告有號數和無號數，但是實際上組譯器並不太在乎這種區別，例如你也可以用 DB/DW/DD 宣告有號數，反過來也可以用 SBYTE/SWORD/SDWROD 宣告無號數，下面的例子都是正確的宣告：
x DB -1 y DW -100 z SWORD 65535
此外要知道的是，無號數或有號數的判別方式其實完全由程式決定，並非由宣告時決定，這也就是為何組譯器不太在乎 DB/BYTE 與 SBYTE 的區別。例如某個位元組是 0FFh 其實可以表示無號數的 255，也可以表示有號數的 －1，完全看程式如何解釋。下圖是一個位元組的有號數與無號數示意圖，可以看得出來：
口說無憑，底下的程式碼，左邊的會把 0FFh 當成無號數，即 0FFh＝255，執行後會在螢光幕上顯示 255；而右邊的程式會把 0FFh 當成有號數，即 0FFh＝－1，執行後會在螢光幕上顯示 －1：
.MODEL SMALL,C
.386
;*************************************************
.DATA
x DB 0FFh
ten DB 10
string DB 6 DUP (?),"$"
;*************************************************
.CODE
.STARTUP
mov al,x
mov cx,3
mov bx,OFFSET string+SIZEOF string-2
.WHILE cx
xor ah,ah
div ten
add ah,"0"
mov [bx],ah
.BREAK .IF al==0
dec bx
dec cx
.ENDW
mov dx,bx
mov ah,9
int 21h
.EXIT
;*************************************************
END |
.MODEL SMALL,C
.386
;*************************************************
.DATA
x DB 0FFh
ten DB 10
string DB 6 DUP (?),"$"
;*************************************************
.CODE
.STARTUP
mov al,x
neg al
mov cx,3
mov bx,OFFSET string+SIZEOF string-2
.WHILE cx
xor ah,ah
div ten
add ah,"0"
mov [bx],ah
.BREAK .IF al==0
dec bx
dec cx
.ENDW
dec bx
mov BYTE PTR [bx],"-"
mov dx,bx
mov ah,9
int 21h
.EXIT
;*************************************************
END |
左邊的程式，其實與第七章的 DECIMAL.ASM 類似，只是把十六進位數值由位元組改成字組，其餘均相同。而右邊的程式則多了 NEG 指令和在字串前加上「－」號。
以二補數表示有號數的優點雖然多，但是有個小缺點，我們只要小心處理這個缺點，並不會造成太大的困擾。這個缺點是什麼呢？先來看底下的例子。
如果要計算十進位的兩數 96＋92，我們都知道，答案是 188，那麼在電腦裏是如何計算的呢？首先把這兩數變成二進位，分別是 0110 0000 ( 96d＝60h )、0101 1100 ( 92d＝5Ch )，加起來變成 1011 1100，結果變成負數，如右圖。很明顯的可以看出來，這是因為兩個數的第六位元都是一，相加之後進位到符號位元，以致使兩數之和變成負數。像這種情形，運算的結果超過所能表示的範圍，就稱為溢位。以這個例子來說，八位元所能表示的有號數範圍是 －128∼127，而 96＋92 是 188，超過了 127，這樣的情形就是溢位。
還有一種情形，兩個負數相加，也有可能造成溢位。例如 －80＋(－90) ( －80d＝B0h、－90＝A6h )，結果應該是 －170，如果以有號數運算結果如右圖，可以發現符號位元變成 0，結果為正數。這是因為結果小於 －128，超過了有號數的範圍，因此造成溢位。
減法也有可能溢位，例如 96－(－92)，結果應該是 188，超過 －128∼127 的範圍；另一種情形是像 －96－92，結果是 －188，也超過 －128∼127 的範圍。
整理之後發現，如果使很大的兩正數相加，或是很小的兩負數相加，就有可能發生溢位；或是使很大的正數減很小的負數，或很小的負數減很大的正數，都有可能發生溢位。那麼是否有方法能夠處理這種溢位錯誤呢？事實上，CPU 在設計時就已經考慮這個問題了。當運算發生溢位時，CPU 會自動設定溢位旗標 ( overflow flag )，使溢位旗標變成一，在 DEBUG/SYMDEB 裏顯示 OV；如果沒發生溢位，就會清除溢位旗標，使溢位旗標變成零，DEBUG/SYMDEB 顯示 NV。在設計程式時，就能夠依據溢位旗標的狀態，考慮如何處理溢位的問題。
NEG 指令是用來計算二補數的指令，它的語法是
NEG 目的運算元
NEG 會計算目的運算元的二補數，然後再存回目的運算元，目的運算元會被破壞。目的運算元可以是八或十六位元的暫存器或變數，若在 80386 等級以上的 CPU，目的運算元可以使用三十二位元的暫存器或變數。
NOT 指令是用來計算一補數的指令。一補數是把所有位元反轉，亦即一變零，零變一。NOT 的語法是
NOT 目的運算元
NOT 會計算目的運算元的一補數，然後再存回目的運算元，目的運算元會被破壞。目的運算元可以是八或十六位元的暫存器或變數，若在 80386 等級以上的 CPU，目的運算元可以使用三十二位元的暫存器或變數。
JO/JNO 指令是條件跳越，O 是指溢位的意思，NO 是沒有溢位；當運算發生溢位時，CPU 會設定溢位旗標，使之變為一；當運算沒發生溢位時，CPU 就清除溢位旗標，使之變為零。它的語法是：
JO 標記 JNO 標記
JO 是如果發生溢位，就跳到標記處執行；JNO 則是沒有溢位，才跳到標記處執行。
TEST 指令的語法是
TEST 目的運算元,來源運算元
TEST 指令和 AND 指令幾乎一樣，差別在於 TEST 僅僅做運算而已，不會把運算結果寫入目的運算元，換句話說，目的運算元不變。雖是如此，但 TEST 會改變旗標。TEST 會清除進位旗標與溢位旗標，會依據運算結果改變符號旗標、零值旗標、同位旗標。
我們可以藉由 TEST 的特性，檢查某個有號數是正數還是負數。例如底下的例子：
mov ax,0ffffh
test ax,8000h
jnz negative
positive: .
.
negative: .
如果 AX 是負數，那麼第 15 位元為 1，與 8000h 做 TEST 運算，而 8000h 的第 15 位元也是 1，故運算後結果不為零，就會跳躍到 negative 處。
COMPUTE 讓使用者輸入兩個在 －32768∼32767 範圍內的有號數，COMPUTE 會做加法和減法運算，在把結果印在螢幕上。組譯 COMPUTE.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 150 151 152
153 154 155 156
157 158 159 160
161 162 163 164
165 166 167 168
169 170 171 172
173 174 175 176
177 178 179 180
181 182 183 184
185 186 187 188
189 190 191 192
193 194 195 196
197 198 199 200
201 202 203 204
205 206 207 208
209 210 211 212
213 214 215 216
217 |
;任輸入兩數，n1與n2，COMPUTE會對此二數做加減法運算，然後印出答案來
.MODEL SMALL,C
.386
;*******************************************************************************
.STACK 256
;*******************************************************************************
.DATA
n1 SWORD ?
n2 SWORD ?
plus_or_minus DW 0
n_str DB 8 DUP (?),"$"
msg1 DB "Input a number (-32768~32767):$"
msg2 DB 0dh,0ah,"Error input.$"
crlf DB 0dh,0ah,"$"
buffer DB 9 DUP (?)
exit_code DB ?
;*******************************************************************************
.CODE
;-------------------------------------------------------------------------------
print_string PROC p_str:WORD
mov dx,p_str
mov ah,9
int 21h
ret
print_string ENDP
;-------------------------------------------------------------------------------
;get_number會把point所指位址的數字字串變成有號數存入AX
;輸入：point：數字字串之位址，此字串第一個位元組代表數字佔用多少位元組。
; 例如「03,2dh,33h,33h」，即「-33」，最後AX＝FFDFh
;輸出：進位旗標：CX＝0，錯誤
; CX＝1，正確，AX＝有號數
get_number PROC point:WORD
LOCAL n:SWORD
LOCAL sign:WORD
mov si,point
mov n,0
movzx cx,BYTE PTR [si] ;CX＝使用者輸入的位元組個數
;檢查使用者輸入的第一個位元組是否為"+"、"-"，如果是則使sign填入符號，並
;調整CX與SI，使其指向下一個位元組
inc si
cmp BYTE PTR [si],"-"
jne chk_positive
mov sign,2dh ;2dh="-"
jmp short adjust
chk_positive: mov sign,2bh ;2bh="+"，若使用者沒輸入符號，當成
cmp BYTE PTR [si],"+" ;正數，因此「mov sign,2bh」在 cmp
jne arabic_numeral ;之前
adjust: inc si ;如果使用者有輸入"+"、"-"，讓
dec cx ;SI指向下一位元組，CX減一
cmp cx,5 ;一個字組的十進位數最大為5位數
ja error ;若超過，表示輸入錯誤
arabic_numeral: cld
next: mov dx,n ;此行到下面三行，其實是計算10*n
shl n,3 ;10*n＝2*n+8*n，「shl n,3」亦即計算8*n
shl dx,1 ;計算2*n
add n,dx ;不使用MUL指令是因為MUL費時較多
jo ovflw
lodsb
sub al,"0"
;檢查使用者輸入的自是否為阿拉伯數字，必須在0∼9之間
cmp al,0
jb error
cmp al,9
ja error
cbw
add n,ax
jo ovflw ;如果溢位，表示不在-32768~32767
loop next
jmp ok
ovflw: .IF sign==2dh
cmp n,8000h
je ok
.ENDIF
error: sub cx,cx
jmp exit
ok: mov ax,n
.IF sign==2dh
neg ax
.ENDIF
mov cx,1
exit: ret
get_number ENDP
;-------------------------------------------------------------------------------
;hex2dec_str把十六進位數值變成十進位的字串
;輸入：n－十六進位數值
; sign－指定正負號。0：以n的最高位元決定正或負；"+"：n為正數；"-"：n為負數
; address－十進位字串的個位數
;輸出：AX－十進位字串起始位址
hex2dec_str PROC n:WORD,sign:WORD,address:WORD
LOCAL ten:WORD
mov ax,n
.IF sign==0
mov sign,2bh ;2bh="+"
test ax,8000h
jz positive0
mov sign,2dh ;2dh="-"
neg ax
.ELSEIF sign==2dh
neg ax
.ENDIF
positive0: mov cx,5
mov bx,address
mov ten,10
.WHILE cx
xor dx,dx
div ten
add dl,"0"
mov [bx],dl
.BREAK .IF ax==0
dec bx
dec cx
.ENDW
.IF sign==2dh
dec bx
mov BYTE PTR [bx],"-"
.ENDIF
mov ax,bx
ret
hex2dec_str ENDP
;-------------------------------------------------------------------------------
print_char PROC char:BYTE
mov dl,char
mov ah,2
int 21h
ret
print_char ENDP
;-------------------------------------------------------------------------------
expression PROC char:BYTE
;印出n1
INVOKE hex2dec_str,n1,0,OFFSET n_str+SIZEOF n_str-2
INVOKE print_string,ax
;印出「+」或「-」
INVOKE print_char,char
;如果n2為負數，那麼要印出「(」，否則不必
test n2,8000h
jz positive1
INVOKE print_char,"("
;印出n2
positive1: INVOKE hex2dec_str,n2,0,OFFSET n_str+SIZEOF n_str-2
INVOKE print_string,ax
;如果n2是負數，那麼要印出「)」，否則不必
test n2,8000h
jz positive2
INVOKE print_char,")"
;印出「=」
positive2: INVOKE print_char,"="
ret
expression ENDP
;-------------------------------------------------------------------------------
.STARTUP
;印出「Input a number (-32768~32767):」，並讓使用者輸入數字字串
INVOKE print_string,OFFSET msg1
mov ah,0ah
lea dx,buffer
mov buffer,7
int 21h
;把數字字串變成有號數，存於n1
INVOKE get_number,OFFSET buffer+1
jcxz err1
mov n1,ax
INVOKE print_string,OFFSET crlf ;換行
;印出「Input a number (-32768~32767):」，並讓使用者輸入數字字串
INVOKE print_string,OFFSET msg1
mov ah,0ah
lea dx,buffer
mov buffer,7
int 21h
;把數字字串變成有號數，存於n2
INVOKE get_number,OFFSET buffer+1
jcxz err1
mov n2,ax
INVOKE print_string,OFFSET crlf
jmp compute
err1: INVOKE print_string,OFFSET msg2
mov exit_code,1
jmp quit
;計算n1、n2之和，並印出結果來
;印出「n1+n2=」的運算式
compute: INVOKE expression,"+"
;計算AX=n1+n2，一般情形下，AX為有號數，但如果有溢位，要藉由
;plus_or_minus表示正負號，此處先假設為一般情形
mov plus_or_minus,0
mov ax,n1
add ax,n2
jno not_overflow1
;如果發生溢位，若n1、n2皆為負，AX亦為負；若n1、n2皆為正，AX亦為正
mov plus_or_minus,2bh ;2bh="+"
test n1,8000h
jz not_overflow1
mov plus_or_minus,2dh ;2dh="-"
;印出AX
not_overflow1: INVOKE hex2dec_str,ax,plus_or_minus,OFFSET n_str+SIZEOF n_str-2
INVOKE print_string,ax
;印出換行符號
INVOKE print_string,OFFSET crlf
;計算n1、n2之差，並印出結果來
;印出「n1-n2=」的運算式
INVOKE expression,"-"
;計算AX=n1-n2，一般情形下，AX為有號數，但如果有溢位，要藉由
;plus_or_minus表示正負號，此處先假設為一般情形
mov plus_or_minus,0
mov ax,n1
sub ax,n2
jno not_overflow2
;如果發生溢位，若n1、n2皆為負，AX亦為負；若n1、n2皆為正，AX亦為正
mov plus_or_minus,2bh ;2bh="+"
test n1,8000h
jz not_overflow2
mov plus_or_minus,2dh ;2dh="-"
;印出AX
not_overflow2: INVOKE hex2dec_str,ax,plus_or_minus,OFFSET n_str+SIZEOF n_str-2
INVOKE print_string,ax
mov exit_code,0
jmp quit
quit: .EXIT exit_code
;*******************************************************************************
END |
COMPUTE.ASM 共有兩百多行，是小木偶到目前所介紹過最大的程式了，但是有許多觀念在前面幾章都介紹過了，其中還有許多是註解，因此雖然程式較長，卻不會太難。
小木偶在撰寫 COMPUTE.ASM 時，盡量把副程式與其他副程式或主程式隔離。意思是只有幾個需要的參數傳給副程式，然後副程式執行過程只會用到這些參數，而不會再使用到其他資料；最後副程式執行完後，再把傳回值傳給主程式。這樣做的好處是①讓副程式單獨運作步牽涉其他程式容易修改維護，②較具有可讀性，③副程式能做成程式庫供給其他程式使用。底下來看看兩個重要的副程式。
get_number 是用來把使用者藉由 AH＝0AH/INT21H 輸入的字串轉換成十六進位有號數。所用參數只有一個，那就是字串位址。但使用 AH＝0AH/INT 21H 時，字串的第一個位元組是緩衝區大小減二，這個資料在 get_number 沒用著，所以 get_number 的參數，字串位址是由緩衝區的第二個位元組開始。見程式第 158、169 行，呼叫 get_number 時的參數是「OFFSET buffer+1」，這個參數在 get_number 裏叫做 point，第 35 行就把這個位址移到 SI 裏，而後用 SI 指向字串的每個位元組，以提取資料。
接下來 get_number 取得字串長度，因為在緩衝區中的字串長度是一個位元組表示，而待會要用 LOOP 迴圈，因此用 movzx 指令把這一個位元組擴充成 CX。
第 40∼51 行，檢查使用者是否輸入正負號，然後把正負號存入 sign 裏。假如使用者沒輸入正負號，就表示此數為正值；如果有輸入正負號，就依據使用者指定方式把正負號存入 sign，同時使 CX 減一並使 SI 指向下一個位元組。
第 44 行是指如果使用者有輸入負號，把 2Dh 存入 sign 後跳躍到使 CX 減一並使 SI 指向下一個位元組的地方，使用「jmp short adjust」。此處我們能夠很明確知道，adjust 離 jmp 指令很近，不超過 127 個位元組，因此是短程跳躍，就可以用「short」假指令加以指定。
接著會進入迴圈，在這迴圈裏，get_number 其實是把使用者輸入的字串都當成正數的每一位去計算。計算結果再依據使用者 sign 去調整正負數，如果是負數，就用 neg 調整；如果是正數就不必調整。
把一個阿拉伯數字組成的字串變成十六進位數並不難。例如使用者輸入「33」，在記憶體中會變成一個由 ASCII 碼組成的字串，「02、33h、33h」。2 是此數只有兩位數，這個 2 會存入 CX，當成迴圈要執行的次數。每次讀取這些阿拉伯數字時，先減去 30h，變成真正的數，3。減去後，這兩個 3 表面一樣但意義不同，前者代表 30，後者才是 3。所以前面的 3 要乘以 10，小木偶把這個數字先暫時存在 n 裏面。
瞭解了原理之後，接下來進入 LOOP 迴圈。get_number 用 SI 逐一指向字串的每個位元組，然後把它載入到 AL 裏，檢查 AL 是否在 0∼9 之間 ( 第 60∼64 行 )，如果是的話，把原先已讀的數值，就是 n，乘以十以後 ( 見第 53∼56 行 )，再加上 AX ( 第 66 行 )。此處小木偶不直接用 mul 指令，而是用把位元向左移及加法完成。這樣做的原因是為了增加運算速度。
原先的數值是保存在區域變數，n，裏面。在程式第 36 行就先假設 n 為零，這是因為第一次進入迴圈，什麼數值都未處理，因此為零。之後每讀一個阿拉伯數字，就要讓 n 先乘以十。乘以十的方式用數學式 10n＝2n＋8n，某數乘以二恰好可用「shl 某數,1」計算，某數乘以八可用「shl 某數,3」計算，然後再相加。因為 n 是字組，而 AL 僅佔一個位元組，因此第 65 行用 CBW 把 AL 擴充至 AX，再相加。
處理完所有阿拉伯數字後，就到第 76 行，把 n 移入 AX，檢查使用者是否輸入負數，如果是負數，就用 neg 指令把 AX 取二補數，就變成負數了。原因很簡單，例如，假設使用者輸入「－23」，get_number 只在第 40∼51 行讓 sign 變成負號，然後依正數方式求得 23，到了第 76 行取二補數時，AX 就變負數了。
如果一切都沒問題，傳回 CX 為一，而 AX 就是有號數；如果發生錯誤，例如使用者輸入了正負號及阿拉伯數字以外的字，CX 設為 0，AX 沒有意義。主程式藉由檢查 CX 得知使用者是否輸入正確的資料。
有幾種情形會錯誤發生：①使用者輸入了正負號及阿拉伯數字以外的字，②使用者輸入的數值超過範圍。前者在第 60∼64 行可以檢查而得知是否正確；後者則要靠是否溢位來檢查，溢位的發生可能在第 53∼56 行，n 乘以十的地方，或是在第 66 行，AX 要加在 n 的時候。比較特別的是，因為我們是以正數去計算，而有號數的範圍是 －32768∼32767 之間，負數個數比正數多一，就是多了 －32768。當使用者輸入 －32768 時，會造成溢位，但此數是在範圍內，在程式第 70∼73 行處理這件事。
hex2dec_str 是用來把十六進位數轉換成十進位數字字串，hex2dec_str 需要三個參數，第一個參數是此十六進位數，n。第二個參數 sign 是用來指定 n 是正數、還是負數，或者由 hex2dec_str 自行判斷。如要指定 n 是正數，就把 sign 指定為 2Bh (「＋」的 ASCII 碼是 2Bh )；如果指定 n 是負數，就把 sign 設為 2Dh (「－」的 ASCII 碼是 2Dh )；如果要由 hex2dec_str 自動判斷，sign 就設為 0。自行判斷的時候，是把 n 當成有號數，hex2dec_str 判斷方法是如果最高位元是一，n 為負數，最高位元是零，n 為正數。第三個參數是存放十進位數字字串的個位數位址。
例如，如果 n 為 FFFFh，sign 為 2Bh，表示 n 為正數，是無號數，hex2dec_str 執行後會得到十進位字串為 36h、35h、35h、33h、35h ( 即 65535 )。如果 n 為 FFFFh，sign 為 0 或 2Dh，得到的十進位字串是 2Dh、31h ( 即 －1 )。
hex2dec_str 的原理與第七章的 DECIMAL.ASM 相似，差別在於前者會檢查輸入數值的正負號。如果是正數，流程就跟 DECIMAL.ASM 一樣。如果是負數，不論是 sign 指定 2Dh 或 0，都先取 n 的二補數 ( 第 97 行與第 99 行 )，再依正數的流程處理，等計算好十進位字串後，於字串最前面加上「－」即可 ( 第114∼115行 )。可以參考前面有號數的負數變十進位數。
hex2dec_str 有傳回值，此傳回值是十進位字串的起始位址，傳回這個位址，能夠讓主程式很輕易的用 AH＝09H/INT 21H 印出十進位數字字串來。
JCXZ 指令用來檢查 CX 是否為零，如果 CX 等於零，就發生跳躍，跳到後面接的標記處繼續執行。其語法如下：
JCXZ 標記
類似的指令還有 JECXZ 與 JRCXZ，分別代表若 ECX 等於零、若 RCX 等於零時發生跳躍。
雖然 COMPUTE 限制使用者輸入的兩個數值要在 －32768∼32767 之間，但是兩數相加或相減，就有可能超過這個範圍，這就發生了溢位。如果程式設計單純，我們也可以在發生溢位時，就顯示錯誤訊息而結束程式，但也可以處理溢位並顯示正確結果。
例如程式第 183∼184 行，把兩數相加，即 n1＋n2，假如發生溢位，並不是計算結果有問題，而是結果超過有號數能表示的範圍，我們可以用指定正或負的方法呼叫 hex2dec_str，hex2dec_str 就能正確計算出結果來。發生溢位時，就檢查使用者輸入的兩數是正數，還是負數。如果為正，表示和也是正數，即使和的最高位元為一，在呼叫 hex2dec_str 的 sign 參數為「2Bh」；如果兩數為負，兩數相加也為負，hex2_dec_str 的 sign 就要指定為 2Dh。見程式第 186∼192 行。
兩數的減法也是如此，見程式第 201∼211 行，小木偶就不囉唆了。
這一章小木偶介紹了有號數加減法的運算，這其中牽涉到了二補數、溢位等觀念。最後做個回顧，下一章介紹有號數的乘除法。
在電腦中，某正數的二補數代表其負數；反過來也成立，亦即某負數的二補數代表其正數。計算某數的二補數，步驟如下：
還有一個方法也能計算二補數，步驟如下：
溢位是指運算結果超過所能表示的範圍，發生的原因有下面兩項：
運算結果發生溢位時，CPU 會把溢位旗標設為一，此動作稱為設定溢位旗標，DEBUG/SYMDEB 裏顯示 OV；運算結果沒發生溢位時，CPU 會把溢位旗標設為零，此動作稱為清除溢位旗標，DEBUG/SYMDEB 裏顯示 NV。程式可以藉由 JO 指令跳到如果溢位時如何處理，或是 JNO 指令跳到如果沒有溢位時如何處理。