將二進制轉換為十進制的匯編代碼不輸出正確答案

Question

我正在為我的大學作業用自定義匯編語言編寫一個程序，它應該使用 ASCII 將二進制轉換為十進制。 這是我的代碼：

// Clear memory
MOV BX, 0x00
MOV [0xA0],BX
MOV [0xA1],BX
MOV [0xA2],BX
MOV [0xA3],BX
MOV [0xA4],BX

// If equal to 1, write 8 to A0. Else move on
CALL readtobx
CMP BX,0x31
JEQ bxisone_eight

// If equal to 0, write nothing. Else, write E and halt
CMP BX,0x30
JNE error
JMP wrote8bit

bxisone_eight:
MOV BX,0x08
MOV [0xA0],BX
wrote8bit:

// If equal to 1, write 4 to A1. Else move on
CALL readtobx
CMP BX,0x31
JEQ bxisone_four

// If equal to 0, write nothing. Else, write E and halt
CMP BX,0x30
JNE error
MOV BX,0x00
CALL writebx
JMP wrote4bit

bxisone_four:
MOV BX,0x04
MOV [0xA1],BX
JMP wrote4bit

wrote4bit:

// If equal to 1, write 2 to A2. Else move on
CALL readtobx
CMP BX,0x31
JEQ bxisone_two

// If equal to 0, write nothing. Else, write E and halt
CMP BX,0x30
JNE error
MOV BX,0x00
CALL writebx
JMP wrote2bit

bxisone_two:
MOV BX,0x02
MOV [0xA2],BX
JMP wrote2bit

wrote2bit:
// If equal to 1, write 1 to A3. Else move on
CALL readtobx
CMP BX,0x31
JEQ bxisone_one

// If equal to 0, write nothing. Else, write E and halt
CMP BX,0x30
JNE error
MOV BX,0x00
CALL writebx
JMP wrote4bit

bxisone_one:
MOV BX,0x01
MOV [0xA3],BX
JMP wrote1bit

wrote1bit:

// Add all the numbers together 
MOV BX,0x00
ADD BX,[0xA0]
ADD BX,[0xA1]
ADD BX,[0xA2]
ADD BX,[0xA3]

MOV AX,0x0A
CMP AX,BX
JGE write10first
ADD BX,0x30
CALL writebx

HALT

error:
  MOV BX,0x45
  CALL writebx
  HALT

writebx:
  MOV AX,[0xF2]
  CMP AX,0x0
  JNE writebx
  MOV [0xF0],BX 
  MOV AX,0x10
  MOV [0xF2],AX  // Set OSR to 1
  RET

readtobx:
  MOV AX,[0xF5]
  CMP AX,0x00 // See if value is zero
  JEQ readtobx
  MOV BX,[0xF3]
  MOV AX,0x01
  MOV [0xF5],BX
  MOV AX,0x00
  MOV [0XF5],AX
  RET

write10first:
   SUB BX,0x0A
   MOV BX,[0xA4]
   ADD BX,0x30
   CALL writebx
   MOV BX,[0xA4]
   ADD BX,0x30
   CALL writebx
   HALT

然而，我似乎從來沒有得到我想要的結果。
澄清一下，標志writebx和readtobx是 output BX 使用代碼到控制台的結果。 那不是問題所在。

以下是操作碼：

00  NOP     
01  MOV AX,BX
02  MOV AX,[BX]
03  MOV AX,[AX]
04  MOV AX,SP
05  MOV AX,byte
06  MOV AX,[byte]
07  MOV AX,word
08  MOV AX,[word]
09  MOV BX,AX
0A  MOV BX,[AX]
0B  MOV BX,[BX]
0C  MOV BX,SP
0D  MOV BX,byte
0E  MOV BX,[byte]
0F  MOV BX,word
10  MOV BX,[word]
11  MOV SP,AX
12  MOV SP,BX
13  MOV SP,byte
14  MOV SP,[byte]
15  MOV SP,word
16  MOV SP,[word]
17  MOV [AX],BX
18  MOV [BX],AX
19  MOV [byte],AX
1A  MOV [word],AX
1B  MOV [byte],BX
1C  MOV [word],BX
1D  MOV [byte],SP
1E  MOV [word],SP
20  ADD AX,byte
21  ADD AX,[byte]
22  ADD AX,BX
23  ADD BX,byte
24  ADD BX,[byte]
25  ADD BX,AX
28  SUB AX,byte
29  SUB AX,[byte]
2A  SUB AX,BX
2B  SUB BX,byte
2C  SUB BX,[byte]
2D  SUB BX,AX
30  OR AX,byte
31  OR AX,[byte]
32  OR AX,BX
33  OR BX,byte
34  OR BX,[byte]
35  OR BX,AX
36  AND AX,byte
37  AND AX,[byte]
38  AND AX,BX
39  AND BX,byte
3A  AND BX,[byte]
3B  AND BX,AX
40  MUL AX,byte
41  MUL BX,byte
42  MUL AX,BX
43  MUL BX,AX
44  MUL AX,[byte]
45  MUL BX,[byte]
46  DIV AX,byte
47  DIV BX,byte
48  DIV AX,BX
49  DIV BX,AX
4A  DIV AX,[byte]
4B  DIV BX,[byte]
4C  MOD AX,byte
4D  MOD BX,byte
4E  MOD AX,BX
4F  MOD BX,AX
50  MOD AX,[byte]
51  MOD BX,[byte]
52  SHL AX
53  SHL BX
54  SHR AX
55  SHR BX
56  INC AX
57  INC BX
58  DEC AX
59  DEC BX
5A  NEG AX
5B  NEG BX
5C  NOT AX
5D  NOT BX
60  CMP AX,byte
61  CMP AX,[byte]
62  CMP AX,BX
63  CMP BX,byte
64  CMP BX,[byte]
65  CMP BX,AX
70  JMP AX
71  JMP BX
72  JMP [AX]
73  JMP [BX]
74  JMP byte
75  JMP [byte]
76  JMP word
77  JMP [word]
78  JEQ AX
79  JEQ [AX]
7A  JEQ BX
7B  JEQ [BX]
7C  JEQ byte
7D  JEQ [byte]
7E  JEQ word
7F  JEQ [word]
80  JNE AX
81  JNE [AX]
82  JNE BX
83  JNE [BX]
84  JNE byte
85  JNE [byte]
86  JNE word
87  JNE [word]
88  JL AX
89  JL [AX]
8A  JL BX
8B  JL [BX]
8C  JL byte
8D  JL [byte]
8E  JL word
8F  JL [word]
90  JGE AX
91  JGE [AX]
92  JGE BX
93  JGE [BX]
94  JGE byte
95  JGE [byte]
96  JGE word
97  JGE [word]
A0  PUSH AX
A1  PUSH BX
A2  PUSH byte
A3  PUSH [byte]
A4  PUSH word
A8  POP AX
A9  POP BX
B0  CALL AX
B1  CALL BX
B2  CALL [AX]
B3  CALL [BX]
B4  CALL byte
B5  CALL [byte]
B6  CALL word
B7  CALL [word]
BA  RET
EE  HALT

我知道這是一個很大的問題，但我們將不勝感激！

我試過多次重寫我的代碼，更改配置和其他，但我所做的一切似乎都不起作用。

Answer 1

審查

// If equal to 0, write nothing. CMP BX,0x30 JNE error MOV BX,0x00 CALL writebx

對於 4 位、2 位和 1 位，如果輸入的數字為“0”，則 output 為 null 字節。 為什么是這樣？ 你不會為 8 位做這件事。 這與你的評論相矛盾。

 JMP wrote4bit wrote4bit: ... JMP wrote2bit wrote2bit: ... JMP wrote1bit wrote1bit:

跳轉到緊隨其后的 label 始終是冗余操作。 執行可能會失敗。

 MOV AX,0x0A CMP AX,BX JGE write10first

此代碼以相反的方式工作。 如果 10 大於或等於該數字，則意味着該數字小於 10，您不希望在前面加上“1”數字。
不用再用AX了，可以把BX比作一個字節：

CMP  BX,0x0A
JGE  write10first

 MOV AX,0x01 MOV [0xF5],BX MOV AX,0x00 MOV [0XF5],AX

為什么這段代碼加載AX然后寫入BX？ 要么MOV AX,0x01是多余的，要么MOV [0xF5],BX做錯了。

 SUB BX,0x0A MOV BX,[0xA4] ADD BX,0x30 CALL writebx MOV BX,[0xA4] ADD BX,0x30 CALL writebx

由 0x0A 減去的內容會立即被隨后的 BX 加載丟失。 而 0xA4 位置僅在 0 處初始化，因此此代碼將 output 為“00”而不是“1？” 你需要的。
下一個代碼可以工作：

MOV [0xA4],BX
MOV BX,0x31
CALL writebx
MOV BX,[0xA4]
ADD BX,0x26        // -10 +48 is +38
CALL writebx

改寫

因為我看到你的代碼重復了很多次，所以我決定編寫這個使用循環並將二進制數字的輸入委托給子例程的版本。 我的代碼也沒有將 4 位數字存儲在 4 個單獨的 memory 變量中，而是隨着它的推移添加數字的權重。

 MOV  BX,0x00
 MOV  [0xA0],BX   // result = 0
 MOV  BX,0x08
nextdigit:
 CALL inputdigit  // -> BX
 SHR  BX          // 8 -> 4 -> 2 -> 1 -> 0
 CMP  BX,0x00
 JNE  nextdigit

 MOV  BX,[0xA0]   // result is [0,15]
 CMP  BX,0x0A
 JL   onedigit
twodigits:
 MOV  BX,0x31     // print "1"
 CALL writebx
 MOV  BX,[0xA0]   // result is [10,15]
 SUB  BX,0x0A
onedigit:
 ADD  BX,0x30
 CALL writebx
 HALT

// IN (BX) OUT (BX)
inputdigit:
 MOV  [0xA1],BX   // temp is {8,4,2,1}
 CALL readtobx
 CMP  BX,0x30
 JEQ  done        // "0" does not add anything
 CMP  BX,0x31
 JNE  error
 MOV  BX,[0xA1]   // "1" adds one of {8,4,2,1}
 ADD  [0xA0],BX
done:
 MOV  BX,[0xA1]
 RET

error:
 MOV  BX,0x45     // "E"
 CALL writebx
 HALT

writebx:
 MOV  AX,[0xF2]
 CMP  AX,0x00
 JNE  writebx
 MOV  [0xF0],BX 
 MOV  AX,0x10
 MOV  [0xF2],AX   // Set OSR to 1
 RET

readtobx:
 MOV  AX,[0xF5]
 CMP  AX,0x00     // See if value is zero
 JEQ  readtobx
 MOV  BX,[0xF3]
 MOV  AX,0x01      ???????????
 MOV  [0xF5],BX    ???????????
 MOV  AX,0x00
 MOV  [0xF5],AX
 RET