計算機實驗室之樹莓派：課程 11 輸入02 | Linux 中國

課程輸入 02 是以課程輸入 01 為基礎講解的，透過一個簡單的命令列實現使用者的命令輸入和計算機的處理和顯示。本文假設你已經具備 課程11：輸入01[1] 的作業系統程式碼基礎。

1、終端

幾乎所有的作業系統都是以字元終端顯示啟動的。經典的黑底白字，透過鍵盤輸入計算機要執行的命令，然後會提示你拼寫錯誤，或者恰好得到你想要的執行結果。這種方法有兩個主要優點：鍵盤和顯示器可以提供簡易、健壯的計算機互動機制，幾乎所有的計算機系統都採用這個機制，這個也廣泛被系統管理員應用。

早期的計算一般是在一棟樓裡的一個巨型計算機系統，它有很多可以輸命令的’終端’。計算機依次執行不同來源的命令。

讓我們分析下真正想要哪些資訊：

這樣的終端被定義為標準的輸入輸出裝置。用於（顯示）輸入的螢幕和列印輸出內容的螢幕是同一個（LCTT 譯註：最早期的輸出列印真是“列印”到印表機/電傳機的，而用於輸入的終端只是鍵盤，除非做了回顯，否則輸出終端是不會顯示輸入的字元的）。也就是說終端是對字元顯示的一個抽象。字元顯示中，單個字元是最小的單元，而不是畫素。螢幕被劃分成固定數量不同顏色的字元。我們可以在現有的螢幕程式碼基礎上，先儲存字元和對應的顏色，然後再用方法 DrawCharacter 把其推送到螢幕上。一旦我們需要字元顯示，就只需要在螢幕上畫出一行字串。

新建檔案名為 terminal.s，如下：

1. .section .data
2. .align 4
3. terminalStart:
4. .int terminalBuffer
5. terminalStop:
6. .int terminalBuffer
7. terminalView:
8. .int terminalBuffer
9. terminalColour:
10. .byte 0xf
11. .align 8
12. terminalBuffer:
13. .rept 128*128
14. .byte 0x7f
15. .byte 0x0
16. .endr
17. terminalScreen:
18. .rept 1024/8 core.md Dict.md lctt2014.md lctt2016.md lctt2018.md LICENSE published README.md scripts sources translated 768/16
19. .byte 0x7f
20. .byte 0x0
21. .endr

這是檔案終端的配置資料檔案。我們有兩個主要的儲存變數：terminalBuffer 和 terminalScreen。terminalBuffer 儲存所有顯示過的字元。它儲存 128 行字元文字（1 行包含 128 個字元）。每個字元有一個 ASCII 字元和顏色單元組成，初始值為 0x7f（ASCII 的刪除字元）和 0（前景色和背景色為黑）。terminalScreen 儲存當前螢幕顯示的字元。它儲存 128×48 個字元，與 terminalBuffer 初始化值一樣。你可能會覺得我僅需要 terminalScreen 就夠了，為什麼還要terminalBuffer，其實有兩個好處：

這種獨特的技巧在低功耗系統裡很常見。畫屏是很耗時的操作，因此我們僅在不得已的時候才去執行這個操作。在這個系統裡，我們可以任意改變 terminalBuffer，然後呼叫一個僅複製螢幕上位元組變化的方法。也就是說我們不需要持續畫出每個字元，這樣可以節省一大段跨行文字的操作時間。

你總是需要嘗試去設計一個高效的系統，如果在很少變化的情況下這個系統會執行的更快。

其他在 .data 段的值得含義如下：

terminalStart 需要儲存起來的原因是 termainlBuffer 是一個環狀緩衝區。意思是當緩衝區變滿時，末尾地方會回滾改寫開始位置，這樣最後一個字元變成了第一個字元。因此我們需要將 terminalStart 往前推進，這樣我們知道我們已經佔滿它了。如何實現緩衝區檢測：如果索引越界到緩衝區的末尾，就將索引指向緩衝區的開始位置。環狀緩衝區是一個比較常見的儲存大量資料的高明方法，往往這些資料的最近部分比較重要。它允許無限制的寫入，只保證最近一些特定資料有效。這個常常用於訊號處理和資料壓縮演演算法。這樣的情況，可以允許我們儲存 128 行終端記錄，超過128行也不會有問題。如果不是這樣，當超過第 128 行時，我們需要把 127 行分別向前複製一次，這樣很浪費時間。

顯示 Hellow world 插入到大小為5的迴圈緩衝區的示意圖。

環狀緩衝區是資料結構一個例子。這是一個組織資料的思路，有時我們透過軟體實現這種思路。

之前已經提到過 terminalColour 幾次了。你可以根據你的想法實現終端顏色，但這個文字終端有 16 個前景色和 16 個背景色（這裡相當於有 16² = 256 種組合）。CGA[2]終端的顏色定義如下：

表格 1.1 – CGA 顏色編碼

我們將前景色儲存到顏色的低位元組，背景色儲存到顏色高位元組。除了棕色，其他這些顏色遵循一種樣式如二進位制的高位位元代表增加 ⅓ 到每個元件，其他位元代表增加 ⅔ 到各自元件。這樣很容易進行 RGB 顏色轉換。

棕色作為替代色（黑黃色）既不吸引人也沒有什麼用處。

我們需要一個方法從 TerminalColour 讀取顏色編碼的四個位元，然後用 16 位元等效引數呼叫 SetForeColour。嘗試你自己實現。如果你感覺麻煩或者還沒有完成螢幕系列課程，我們的實現如下：

1. .section .text
2. TerminalColour:
3. teq r0,#6
4. ldreq r0,=0x02B5
5. beq SetForeColour
7. tst r0,#0b1000
8. ldrne r1,=0x52AA
9. moveq r1,#0
10. tst r0,#0b0100
11. addne r1,#0x15
12. tst r0,#0b0010
13. addne r1,#0x540
14. tst r0,#0b0001
15. addne r1,#0xA800
16. mov r0,r1
17. b SetForeColour

2、文字顯示

我們的終端第一個真正需要的方法是 TerminalDisplay，它用來把當前的資料從 terminalBuffer複製到 terminalScreen 和實際的螢幕。如上所述，這個方法必須是最小開銷的操作，因為我們需要頻繁呼叫它。它主要比較 terminalBuffer 與 terminalDisplay 的文字，然後只複製有差異的位元組。請記住 terminalBuffer 是以環狀緩衝區執行的，這種情況，就是從 terminalView 到 terminalStop，或者 128*48 個字元，要看哪個來的最快。如果我們遇到 terminalStop，我們將會假定在這之後的所有字元是 7f₁₆ (ASCII 刪除字元)，顏色為 0（黑色前景色和背景色）。

讓我們看看必須要做的事情：

嘗試去自己實現吧。如果你遇到問題，我們的方案下麵給出來了：

1、我這裡的變數有點亂。為了方便起見，我用 taddr 儲存 textBuffer 的末尾位置。

1. .globl TerminalDisplay
2. TerminalDisplay:
3. push {r4,r5,r6,r7,r8,r9,r10,r11,lr}
4. x .req r4
5. y .req r5
6. char .req r6
7. col .req r7
8. screen .req r8
9. taddr .req r9
10. view .req r10
11. stop .req r11
13. ldr taddr,=terminalStart
14. ldr view,[taddr,#terminalView - terminalStart]
15. ldr stop,[taddr,#terminalStop - terminalStart]
16. add taddr,#terminalBuffer - terminalStart
17. add taddr,#128*128*2
18. mov screen,taddr

2、從 yLoop 開始執行。

1. mov y,#0
2. yLoop$:

2.1、

1. mov x,#0
2. xLoop$:

從 xLoop 開始執行。

2.1.1、為了方便起見，我把字元和顏色同時載入到 char 變數了

1. teq view,stop
2. ldrneh char,[view]

2.1.2、這行是對上面一行的補充說明：讀取黑色的刪除字元

1. moveq char,#0x7f

2.1.3、為了簡便我把字元和顏色同時載入到 col 裡。

1. ldrh col,[screen]

2.1.4、 現在我用 teq 指令檢查是否有資料變化

1. teq col,char
2. beq xLoopContinue$

2.1.5、我可以容易的儲存當前值

1. strh char,[screen]

2.1.6、我用位元偏移指令 lsr 和 and 指令從切分 char 變數，將顏色放到 col 變數，字元放到 char 變數，然後再用位元偏移指令 lsr 獲取背景色後呼叫 TerminalColour 。

1. lsr col,char,#8
2. and char,#0x7f
3. lsr r0,col,#4
4. bl TerminalColour

2.1.7、寫入一個彩色的刪除字元

1. mov r0,#0x7f
2. mov r1,x
3. mov r2,y
4. bl DrawCharacter

2.1.8、用 and 指令獲取 col 變數的低半位元組，然後呼叫 TerminalColour

1. and r0,col,#0xf
2. bl TerminalColour

2.1.9、寫入我們需要的字元

1. mov r0,char
2. mov r1,x
3. mov r2,y
4. bl DrawCharacter

2.1.10、自增螢幕指標

1. xLoopContinue$:
2. add screen,#2

2.1.11、如果可能自增 view 指標

1. teq view,stop
2. addne view,#2

2.1.12、很容易檢測 view 指標是否越界到緩衝區的末尾，因為緩衝區的地址儲存在 taddr變數裡

1. teq view,taddr
2. subeq view,#128*128*2

2.1.13、 如果還有字元需要顯示，我們就需要自增 x 變數然後到 xLoop 迴圈執行

1. add x,#8
2. teq x,#1024
3. bne xLoop$

2.2、 如果還有更多的字元顯示我們就需要自增 y 變數，然後到 yLoop 迴圈執行

1. add y,#16
2. teq y,#768
3. bne yLoop$

3、不要忘記最後清除變數

1. pop {r4,r5,r6,r7,r8,r9,r10,r11,pc}
2. .unreq x
3. .unreq y
4. .unreq char
5. .unreq col
6. .unreq screen
7. .unreq taddr
8. .unreq view
9. .unreq stop

3、行列印

現在我有了自己 TerminalDisplay 方法，它可以自動顯示 terminalBuffer 內容到 terminalScreen，因此理論上我們可以畫出文本。但是實際上我們沒有任何基於字元顯示的例程。 首先快速容易上手的方法便是 TerminalClear， 它可以徹底清除終端。這個方法不用迴圈也很容易實現。可以嘗試分析下麵的方法應該不難：

1. .globl TerminalClear
2. TerminalClear:
3. ldr r0,=terminalStart
4. add r1,r0,#terminalBuffer-terminalStart
5. str r1,[r0]
6. str r1,[r0,#terminalStop-terminalStart]
7. str r1,[r0,#terminalView-terminalStart]
8. mov pc,lr

現在我們需要構造一個字元顯示的基礎方法：Print 函式。它將儲存在 r0 的字串和儲存在 r1 的字串長度簡單的寫到螢幕上。有一些特定字元需要特別的註意，這些特定的操作是確保 terminalView 是最新的。我們來分析一下需要做什麼：

試一下自己去實現。我們的方案提供如下：

1、這個是 Print 函式開始快速檢查字串為0的程式碼

1. .globl Print
2. Print:
3. teq r1,#0
4. moveq pc,lr

2、這裡我做了很多配置。 bufferStart 代表 terminalStart， bufferStop 代表terminalStop， view 代表 terminalView，taddr 代表 terminalBuffer 的末尾地址。

1. push {r4,r5,r6,r7,r8,r9,r10,r11,lr}
2. bufferStart .req r4
3. taddr .req r5
4. x .req r6
5. string .req r7
6. length .req r8
7. char .req r9
8. bufferStop .req r10
9. view .req r11
11. mov string,r0
12. mov length,r1
14. ldr taddr,=terminalStart
15. ldr bufferStop,[taddr,#terminalStop-terminalStart]
16. ldr view,[taddr,#terminalView-terminalStart]
17. ldr bufferStart,[taddr]
18. add taddr,#terminalBuffer-terminalStart
19. add taddr,#128*128*2

3、和通常一樣，巧妙的對齊技巧讓許多事情更容易。由於需要對齊 terminalBuffer，每個字元的 x 坐標需要 8 位要除以 2。

1. and x,bufferStop,#0xfe
2. lsr x,#1

4.1、我們需要檢查新行

1. charLoop$:
2. ldrb char,[string]
3. and char,#0x7f
4. teq char,#'\n'
5. bne charNormal$

4.2、迴圈執行值到行末寫入 0x7f；黑色刪除字元

1. mov r0,#0x7f
2. clearLine$:
3. strh r0,[bufferStop]
4. add bufferStop,#2
5. add x,#1
6. teq x,#128 blt clearLine$
8. b charLoopContinue$

4.3、儲存字串的當前字元和 terminalBuffer 末尾的 terminalColour 然後將它和 x 變數自增

1. charNormal$:
2. strb char,[bufferStop]
3. ldr r0,=terminalColour
4. ldrb r0,[r0]
5. strb r0,[bufferStop,#1]
6. add bufferStop,#2
7. add x,#1

4.4、檢查 x 是否為行末；128

1. charLoopContinue$:
2. cmp x,#128
3. blt noScroll$

4.5、設定 x 為 0 然後檢查我們是否已經顯示超過 1 屏。請記住，我們是用的迴圈緩衝區，因此如果 bufferStop 和 view 之前的差是負值，我們實際上是環繞了緩衝區。

1. mov x,#0
2. subs r0,bufferStop,view
3. addlt r0,#128*128*2
4. cmp r0,#128*(768/16)*2

4.6、增加一行位元組到 view 的地址

1. addge view,#128*2

4.7、 如果 view 地址是緩衝區的末尾，我們就從它上面減去緩衝區的長度，讓其指向開始位置。我會在開始的時候設定 taddr 為緩衝區的末尾地址。

1. teq view,taddr
2. subeq view,taddr,#128*128*2

4.8、如果 stop 的地址在緩衝區末尾，我們就從它上面減去緩衝區的長度，讓其指向開始位置。我會在開始的時候設定 taddr 為緩衝區的末尾地址。

1. noScroll$:
2. teq bufferStop,taddr
3. subeq bufferStop,taddr,#128*128*2

4.9、檢查 bufferStop 是否等於 bufferStart。 如果等於增加一行到 bufferStart。

1. teq bufferStop,bufferStart
2. addeq bufferStart,#128*2

4.10、如果 start 的地址在緩衝區的末尾，我們就從它上面減去緩衝區的長度，讓其指向開始位置。我會在開始的時候設定 taddr 為緩衝區的末尾地址。

1. teq bufferStart,taddr
2. subeq bufferStart,taddr,#128*128*2

迴圈執行知道字串結束

1. subs length,#1
2. add string,#1
3. bgt charLoop$

5、儲存變數然後傳回

1. charLoopBreak$:
2. sub taddr,#128*128*2
3. sub taddr,#terminalBuffer-terminalStart
4. str bufferStop,[taddr,#terminalStop-terminalStart]
5. str view,[taddr,#terminalView-terminalStart]
6. str bufferStart,[taddr]
8. pop {r4,r5,r6,r7,r8,r9,r10,r11,pc}
9. .unreq bufferStart
10. .unreq taddr
11. .unreq x
12. .unreq string
13. .unreq length
14. .unreq char
15. .unreq bufferStop
16. .unreq view

這個方法允許我們列印任意字元到螢幕。然而我們用了顏色變數，但實際上沒有設定它。一般終端用特性的組合字元去行修改顏色。如 ASCII 轉義（1b₁₆）後面跟著一個 0 – f 的 16 進位制的數，就可以設定前景色為 CGA 顏色號。如果你自己想嘗試實現；在下載頁面有一個我的詳細的例子。

4、標誌輸入

現在我們有一個可以列印和顯示文字的輸出終端。這僅僅是說對了一半，我們需要輸入。我們想實現一個方法：ReadLine，可以儲存檔案的一行文字，文字位置由 r0 給出，最大的長度由 r1 給出，傳回 r0 裡面的字串長度。棘手的是使用者輸出字元的時候要回顯功能，同時想要退格鍵的刪除功能和命令回車執行功能。它們還需要一個閃爍的下劃線代表計算機需要輸入。這些完全合理的要求讓構造這個方法更具有挑戰性。有一個方法完成這些需求就是儲存使用者輸入的文字和檔案大小到記憶體的某個地方。然後當呼叫 ReadLine 的時候，移動 terminalStop 的地址到它開始的地方然後呼叫 Print。也就是說我們只需要確保在記憶體維護一個字串，然後構造一個我們自己的列印函式。

按照慣例，許多程式語言中，任意程式可以訪問 stdin 和 stdin，它們可以連線到終端的輸入和輸出流。在圖形程式其實也可以進行同樣操作，但實際幾乎不用。

讓我們看看 ReadLine 做了哪些事情：

為了方便讀者理解，然後然後自己去實現，我們的實現提供如下：

1. .globl ReadLine
2. ReadLine:
3. teq r1,#0
4. moveq r0,#0
5. moveq pc,lr

2、考慮到常見的場景，我們初期做了很多初始化動作。input 代表 terminalStop 的值，view 代表 terminalView。Length 預設為 0。

1. string .req r4
2. maxLength .req r5
3. input .req r6
4. taddr .req r7
5. length .req r8
6. view .req r9
8. push {r4,r5,r6,r7,r8,r9,lr}
10. mov string,r0
11. mov maxLength,r1
12. ldr taddr,=terminalStart
13. ldr input,[taddr,#terminalStop-terminalStart]
14. ldr view,[taddr,#terminalView-terminalStart]
15. mov length,#0

3、我們必須檢查異常大的讀操作，我們不能處理超過 terminalBuffer 大小的輸入（理論上可行，但是 terminalStart 移動越過儲存的 terminalStop`，會有很多問題）。

1. cmp maxLength,#128*64
2. movhi maxLength,#128*64

4、由於使用者需要一個閃爍的游標，我們需要一個備用字元在理想狀況在這個字串後面放一個結束符。

1. sub maxLength,#1

5、寫入一個下劃線讓使用者知道我們可以輸入了。

1. mov r0,#'_'
2. strb r0,[string,length]

6、儲存 terminalStop 和 terminalView。這個對重置一個終端很重要，它會修改這些變數。嚴格講也可以修改 terminalStart，但是不可逆。

1. readLoop$:
2. str input,[taddr,#terminalStop-terminalStart]
3. str view,[taddr,#terminalView-terminalStart]

7、寫入當前的輸入。由於下劃線因此字串長度加 1

1. mov r0,string
2. mov r1,length
3. add r1,#1
4. bl Print

8、複製下一個文字到螢幕

1. bl TerminalDisplay

9、獲取最近一次鍵盤輸入

1. bl KeyboardUpdate

10、檢索鍵盤輸入鍵值

1. bl KeyboardGetChar

11、如果我們有一個回車鍵，迴圈中斷。如果有結束符和一個退格鍵也會同樣跳出迴圈。

1. teq r0,#'\n'
2. beq readLoopBreak$
3. teq r0,#0
4. beq cursor$
5. teq r0,#'\b'
6. bne standard$

12、從 length 裡面刪除一個字元

1. delete$:
2. cmp length,#0
3. subgt length,#1
4. b cursor$

13、寫回一個普通字元

1. standard$:
2. cmp length,maxLength
3. bge cursor$
4. strb r0,[string,length]
5. add length,#1

14、載入最近的一個字元，如果不是下劃線則修改為下換線，如果是則修改為空格

1. cursor$:
2. ldrb r0,[string,length]
3. teq r0,#'_'
4. moveq r0,#' '
5. movne r0,#'_'
6. strb r0,[string,length]

15、迴圈執行值到使用者輸入按下

1. b readLoop$
2. readLoopBreak$:

16、在字串的結尾處存入一個新行字元

1. mov r0,#'\n'
2. strb r0,[string,length]

17、重置 terminalView 和 terminalStop 然後呼叫 Print 和 TerminalDisplay 顯示最終的輸入

1. str input,[taddr,#terminalStop-terminalStart]
2. str view,[taddr,#terminalView-terminalStart]
3. mov r0,string
4. mov r1,length
5. add r1,#1
6. bl Print
7. bl TerminalDisplay

18、寫入一個結束符

1. mov r0,#0
2. strb r0,[string,length]

19、傳回長度

1. mov r0,length
2. pop {r4,r5,r6,r7,r8,r9,pc}
3. .unreq string
4. .unreq maxLength
5. .unreq input
6. .unreq taddr
7. .unreq length
8. .unreq view

5、終端：機器進化

現在我們理論用終端和使用者可以互動了。最顯而易見的事情就是拿去測試了！刪除 main.s 裡 bl UsbInitialise 後面的程式碼後如下：

1. reset$:
2. mov sp,#0x8000
3. bl TerminalClear
5. ldr r0,=welcome
6. mov r1,#welcomeEnd-welcome
7. bl Print
9. loop$:
10. ldr r0,=prompt
11. mov r1,#promptEnd-prompt
12. bl Print
14. ldr r0,=command
15. mov r1,#commandEnd-command
16. bl ReadLine
18. teq r0,#0
19. beq loopContinue$
21. mov r4,r0
23. ldr r5,=command
24. ldr r6,=commandTable
26. ldr r7,[r6,#0]
27. ldr r9,[r6,#4]
28. commandLoop$:
29. ldr r8,[r6,#8]
30. sub r1,r8,r7
32. cmp r1,r4
33. bgt commandLoopContinue$
35. mov r0,#0
36. commandName$:
37. ldrb r2,[r5,r0]
38. ldrb r3,[r7,r0]
39. teq r2,r3
40. bne commandLoopContinue$
41. add r0,#1
42. teq r0,r1
43. bne commandName$
45. ldrb r2,[r5,r0]
46. teq r2,#0
47. teqne r2,#' '
48. bne commandLoopContinue$
50. mov r0,r5
51. mov r1,r4
52. mov lr,pc
53. mov pc,r9
54. b loopContinue$
56. commandLoopContinue$:
57. add r6,#8
58. mov r7,r8
59. ldr r9,[r6,#4]
60. teq r9,#0
61. bne commandLoop$
63. ldr r0,=commandUnknown
64. mov r1,#commandUnknownEnd-commandUnknown
65. ldr r2,=formatBuffer
66. ldr r3,=command
67. bl FormatString
69. mov r1,r0
70. ldr r0,=formatBuffer
71. bl Print
73. loopContinue$:
74. bl TerminalDisplay
75. b loop$
77. echo:
78. cmp r1,#5
79. movle pc,lr
81. add r0,#5
82. sub r1,#5
83. b Print
85. ok:
86. teq r1,#5
87. beq okOn$
88. teq r1,#6
89. beq okOff$
90. mov pc,lr
92. okOn$:
93. ldrb r2,[r0,#3]
94. teq r2,#'o'
95. ldreqb r2,[r0,#4]
96. teqeq r2,#'n'
97. movne pc,lr
98. mov r1,#0
99. b okAct$
101. okOff$:
102. ldrb r2,[r0,#3]
103. teq r2,#'o'
104. ldreqb r2,[r0,#4]
105. teqeq r2,#'f'
106. ldreqb r2,[r0,#5]
107. teqeq r2,#'f'
108. movne pc,lr
109. mov r1,#1
111. okAct$:
113. mov r0,#16
114. b SetGpio
116. .section .data
117. .align 2
118. welcome: .ascii "Welcome to Alex's OS - Everyone's favourite OS"
119. welcomeEnd:
120. .align 2
121. prompt: .ascii "\n> "
122. promptEnd:
123. .align 2
124. command:
125. .rept 128
126. .byte 0
127. .endr
128. commandEnd:
129. .byte 0
130. .align 2
131. commandUnknown: .ascii "Command `%s' was not recognised.\n"
132. commandUnknownEnd:
133. .align 2
134. formatBuffer:
135. .rept 256
136. .byte 0
137. .endr
138. formatEnd:
140. .align 2
141. commandStringEcho: .ascii "echo"
142. commandStringReset: .ascii "reset"
143. commandStringOk: .ascii "ok"
144. commandStringCls: .ascii "cls"
145. commandStringEnd:
147. .align 2
148. commandTable:
149. .int commandStringEcho, echo
150. .int commandStringReset, reset$
151. .int commandStringOk, ok
152. .int commandStringCls, TerminalClear
153. .int commandStringEnd, 0

這塊程式碼集成了一個簡易的命令列作業系統。支援命令：echo、reset、ok 和 cls。echo 複製任意文字到終端，reset 命令會在系統出現問題的是複位作業系統，ok 有兩個功能：設定 OK 燈亮滅，最後 cls 呼叫 TerminalClear 清空終端。

試試樹莓派的程式碼吧。如果遇到問題，請參照問題集錦頁面吧。

如果執行正常，祝賀你完成了一個作業系統基本終端和輸入系列的課程。很遺憾這個教程先講到這裡，但是我希望將來能製作更多教程。有問題請反饋至 awc32@cam.ac.uk[3]。

你已經在建立了一個簡易的終端作業系統。我們的程式碼在 commandTable 構造了一個可用的命令表格。每個表格的入口是一個整型數字，用來表示字串的地址，和一個整型數字表格程式碼的執行入口。 最後一個入口是 為 0 的 commandStringEnd。嘗試實現你自己的命令，可以參照已有的函式，建立一個新的。函式的引數 r0 是使用者輸入的命令地址，r1 是其長度。你可以用這個傳遞你輸入值到你的命令。也許你有一個計算器程式，或許是一個繪圖程式或國際象棋。不管你的什麼點子，讓它跑起來！