計算機實驗室之樹莓派：課程 9 螢幕04 | Linux 中國

螢幕04 課程基於螢幕03 課程來構建，它教你如何操作文字。假設你已經有了課程 8：螢幕03[1]的作業系統程式碼，我們將以它為基礎。

1、操作字串

能夠繪製文字是極好的，但不幸的是，現在你只能繪製預先準備好的字串。如果能夠像命令列那樣顯示任何東西才是完美的，而理想情況下應該是，我們能夠顯示任何我們期望的東西。一如既往地，如果我們付出努力而寫出一個非常好的函式，它能夠操作我們所希望的所有字串，而作為回報，這將使我們以後寫程式碼更容易。曾經如此複雜的函式，在 C 語言程式設計中只不過是一個 sprintf 而已。這個函式基於給定的另一個字串和作為描述的額外的一個引數而生成一個字串。我們對這個函式感興趣的地方是，這個函式是個變長函式。這意味著它可以帶可變數量的引數。引數的數量取決於具體的格式字串，因此它的引數的數量不能預先確定。

變長函式在彙編程式碼中看起來似乎不好理解，然而 ，它卻是非常有用和很強大的概念。

這個完整的函式有許多選項，而我們在這裡只列出了幾個。在本教程中將要實現的選項我做了高亮處理，當然，你可以嘗試去實現更多的選項。

函式透過讀取格式化字串來工作，然後使用下表的意思去解釋它。一旦一個引數已經使用了，就不會再次考慮它了。函式的傳回值是寫入的字元數。如果方法失敗，將傳回一個負數。

表 1.1 sprintf 格式化規則

除此之外，對序列還有許多額外的處理，比如指定最小長度，符號等等。更多資訊可以在 sprintf – C++ 參考[2] 上找到。

下麵是呼叫方法和傳回的結果的示例。

表 1.2 sprintf 呼叫示例

希望你已經看到了這個函式是多麼有用。實現它需要大量的程式設計工作，但給我們的回報卻是一個非常有用的函式，可以用於各種用途。

2、除法

雖然這個函式看起來很強大、也很複雜。但是，處理它的許多情況的最容易的方式可能是，編寫一個函式去處理一些非常常見的任務。它是個非常有用的函式，可以為任何底的一個有符號或無符號的數字生成一個字串。那麼，我們如何去實現呢？在繼續閱讀之前，嘗試快速地設計一個演演算法。

除法是非常慢的，也是非常複雜的基礎數學運算。它在 ARM 彙編程式碼中不能直接實現，因為如果直接實現的話，它得出答案需要花費很長的時間，因此它不是個“簡單的”運算。

最簡單的方法或許就是我在 課程 1：OK01[3] 中提到的“除法餘數法”。它的思路如下：

例如：

表 2.1 以 2 為底的例子

轉換

因此答案是 10001001₂

這個過程的不幸之外在於使用了除法。所以，我們必須首先要考慮二進制中的除法。

我們複習一下長除法

假如我們想把 4135 除以 17。

1. 0243 r 4
2. 17)4135
3. 0 0 × 17 = 0000
4. 4135 4135 - 0 = 4135
5. 34 200 × 17 = 3400
6. 735 4135 - 3400 = 735
7. 68 40 × 17 = 680
8. 55 735 - 680 = 55
9. 51 3 × 17 = 51
10. 4 55 - 51 = 4

答案：243 餘 4

首先我們來看被除數的最高位。我們看到它是小於或等於除數的最小倍數，因此它是 0。我們在結果中寫一個 0。

接下來我們看被除數倒數第二位和所有的高位。我們看到小於或等於那個數的除數的最小倍數是 34。我們在結果中寫一個 2，和減去 3400。

接下來我們看被除數的第三位和所有高位。我們看到小於或等於那個數的除數的最小倍數是 68。我們在結果中寫一個 4，和減去 680。

最後，我們看一下所有的餘位。我們看到小於餘數的除數的最小倍數是 51。我們在結果中寫一個 3，減去 51。減法的結果就是我們的餘數。

在彙編程式碼中做除法，我們將實現二進位制的長除法。我們之所以實現它是因為，數字都是以二進位制方式儲存的，這讓我們很容易地訪問所有重要位的移位操作，並且因為在二進制中做除法比在其它高進制中做除法都要簡單，因為它的數更少。

1. 1011 r 1
2. 1010)1101111
3. 1010
4. 11111
5. 1010
6. 1011
7. 1010
8. 1

這個示例展示瞭如何做二進位制的長除法。簡單來說就是，在不超出被除數的情況下，盡可能將除數右移，根據位置輸出一個 1，和減去這個數。剩下的就是餘數。在這個例子中，我們展示了 1101111₂ ÷ 1010₂ = 1011₂ 餘數為 1₂。用十進製表示就是，111 ÷ 10 = 11 餘 1。

你自己嘗試去實現這個長除法。你應該去寫一個函式 DivideU32 ，其中 r0 是被除數，而 r1 是除數，在 r0 中傳回結果，在 r1 中傳回餘數。下麵，我們將完成一個有效的實現。

1. function DivideU32(r0 is dividend, r1 is divisor)
2. set shift to 31
3. set result to 0
4. while shift ≥ 0
5. if dividend ≥ (divisor << shift) then
6. set dividend to dividend - (divisor lt shift)
7. set result to result + 1
8. end if
9. set result to result << 1
10. set shift to shift - 1
11. loop
12. return (result, dividend)
13. end function

這段程式碼實現了我們的標的，但卻不能用於彙編程式碼。我們出現的問題是，我們的暫存器只能儲存 32 位，而 divisor << shift 的結果可能在一個暫存器中裝不下（我們稱之為上限溢位）。這確實是個問題。你的解決方案是否有上限溢位的問題呢？

幸運的是，有一個稱為 clz（計數前導零count leading zeros）的指令，它能計算一個二進製表示的數字的前導零的個數。這樣我們就可以在上限溢位發生之前，可以將暫存器中的值進行相應位數的左移。你可以找出的另一個最佳化就是，每個迴圈我們計算 divisor << shift 了兩遍。我們可以透過將除數移到開始位置來改進它，然後在每個迴圈結束的時候將它移下去，這樣可以避免將它移到別處。

我們來看一下進一步最佳化之後的彙編程式碼。

1. .globl DivideU32
2. DivideU32:
3. result .req r0
4. remainder .req r1
5. shift .req r2
6. current .req r3
8. clz shift,r1
9. lsl current,r1,shift
10. mov remainder,r0
11. mov result,#0
13. divideU32Loop$:
14. cmp shift,#0
15. blt divideU32Return$
16. cmp remainder,current
18. addge result,result,#1
19. subge remainder,current
20. sub shift,#1
21. lsr current,#1
22. lsl result,#1
23. b divideU32Loop$
24. divideU32Return$:
25. .unreq current
26. mov pc,lr
28. .unreq result
29. .unreq remainder
30. .unreq shift

你可能毫無疑問的認為這是個非常高效的作法。它是很好，但是除法是個代價非常高的操作，並且我們的其中一個願望就是不要經常做除法，因為如果能以任何方式提升速度就是件非常好的事情。當我們檢視有迴圈的最佳化程式碼時，我們總是重點考慮一個問題，這個迴圈會執行多少次。在本案例中，在輸入為 1 的情況下，這個迴圈最多執行 31 次。在不考慮特殊情況的時候，這很容易改進。例如，當 1 除以 1 時，不需要移位，我們將把除數移到它上面的每個位置。這可以透過簡單地在被除數上使用新的 clz 命令並從中減去它來改進。在 1 ÷ 1 的案例中，這意味著移位將設定為 0，明確地表示它不需要移位。如果它設定移位為負數，表示除數大於被除數，因此我們就可以知道結果是 0，而餘數是被除數。我們可以做的另一個快速檢查就是，如果當前值為 0，那麼它是一個整除的除法，我們就可以停止迴圈了。

clz dest,src 將第一個暫存器 dest 中二進製表示的值的前導零的數量，儲存到第二個暫存器 src 中。

1. .globl DivideU32
2. DivideU32:
3. result .req r0
4. remainder .req r1
5. shift .req r2
6. current .req r3
8. clz shift,r1
9. clz r3,r0
10. subs shift,r3
11. lsl current,r1,shift
12. mov remainder,r0
13. mov result,#0
14. blt divideU32Return$
16. divideU32Loop$:
17. cmp remainder,current
18. blt divideU32LoopContinue$
20. add result,result,#1
21. subs remainder,current
22. lsleq result,shift
23. beq divideU32Return$
24. divideU32LoopContinue$:
25. subs shift,#1
26. lsrge current,#1
27. lslge result,#1
28. bge divideU32Loop$
30. divideU32Return$:
31. .unreq current
32. mov pc,lr
34. .unreq result
35. .unreq remainder
36. .unreq shift

複製上面的程式碼到一個名為 maths.s 的檔案中。

3、數字字串

現在，我們已經可以做除法了，我們來看一下另外的一個將數字轉換為字串的實現。下列的偽程式碼將暫存器中的一個數字轉換成以 36 為底的字串。根據慣例，a % b 表示 a 被 b 相除之後的餘數。

1. function SignedString(r0 is value, r1 is dest, r2 is base)
2. if value ≥ 0
3. then return UnsignedString(value, dest, base)
4. otherwise
5. if dest > 0 then
6. setByte(dest, '-')
7. set dest to dest + 1
8. end if
9. return UnsignedString(-value, dest, base) + 1
10. end if
11. end function
13. function UnsignedString(r0 is value, r1 is dest, r2 is base)
14. set length to 0
15. do
17. set (value, rem) to DivideU32(value, base)
18. if rem &gt 10
19. then set rem to rem + '0'
20. otherwise set rem to rem - 10 + 'a'
21. if dest > 0
22. then setByte(dest + length, rem)
23. set length to length + 1
25. while value > 0
26. if dest > 0
27. then ReverseString(dest, length)
28. return length
29. end function
31. function ReverseString(r0 is string, r1 is length)
32. set end to string + length - 1
33. while end > start
34. set temp1 to readByte(start)
35. set temp2 to readByte(end)
36. setByte(start, temp2)
37. setByte(end, temp1)
38. set start to start + 1
39. set end to end - 1
40. end while
41. end function

上述程式碼實現在一個名為 text.s 的彙編檔案中。記住，如果你遇到了困難，可以在下載頁面找到完整的解決方案。

4、格式化字串

我們繼續回到我們的字串格式化方法。因為我們正在編寫我們自己的作業系統，我們根據我們自己的意願來新增或修改格式化規則。我們可以發現，新增一個 a % b 操作去輸出一個二進位制的數字比較有用，而如果你不使用空終止符字串，那麼你應該去修改 %s 的行為，讓它從另一個引數中得到字串的長度，或者如果你願意，可以從長度字首中獲取。我在下麵的示例中使用了一個空終止符。

實現這個函式的一個主要的障礙是它的引數個數是可變的。根據 ABI 規定，額外的引數在呼叫方法之前以相反的順序先推送到棧上。比如，我們使用 8 個引數 1、2、3、4、5、6、7 和 8 來呼叫我們的方法，我們將按下麵的順序來處理：

現在，我們必須確定我們的函式確切需要的引數。在我的案例中，我將暫存器 r0 用來儲存格式化字串地址，格式化字串長度則放在暫存器 r1 中，標的字串地址放在暫存器 r2 中，緊接著是要求的引數串列，從暫存器 r3 開始和像上面描述的那樣在棧上繼續。如果你想去使用一個空終止符格式化字串，在暫存器 r1 中的引數將被移除。如果你想有一個最大緩衝區長度，你可以將它儲存在暫存器 r3 中。由於有額外的修改，我認為這樣修改函式是很有用的，如果標的字串地址為 0，意味著沒有字串被輸出，但如果仍然傳回一個精確的長度，意味著能夠精確的判斷格式化字串的長度。

如果你希望嘗試實現你自己的函式，現在就可以去做了。如果不去實現你自己的，下麵我將首先構建方法的偽程式碼，然後給出實現的彙編程式碼。

1. function StringFormat(r0 is format, r1 is formatLength, r2 is dest, ...)
2. set index to 0
3. set length to 0
4. while index < formatLength
5. if readByte(format + index) = '%' then
6. set index to index + 1
7. if readByte(format + index) = '%' then
8. if dest > 0
9. then setByte(dest + length, '%')
10. set length to length + 1
11. otherwise if readByte(format + index) = 'c' then
12. if dest > 0
13. then setByte(dest + length, nextArg)
14. set length to length + 1
15. otherwise if readByte(format + index) = 'd' or 'i' then
16. set length to length + SignedString(nextArg, dest, 10)
17. otherwise if readByte(format + index) = 'o' then
18. set length to length + UnsignedString(nextArg, dest, 8)
19. otherwise if readByte(format + index) = 'u' then
20. set length to length + UnsignedString(nextArg, dest, 10)
21. otherwise if readByte(format + index) = 'b' then
22. set length to length + UnsignedString(nextArg, dest, 2)
23. otherwise if readByte(format + index) = 'x' then
24. set length to length + UnsignedString(nextArg, dest, 16)
25. otherwise if readByte(format + index) = 's' then
26. set str to nextArg
27. while getByte(str) != '\0'
28. if dest > 0
29. then setByte(dest + length, getByte(str))
30. set length to length + 1
31. set str to str + 1
32. loop
33. otherwise if readByte(format + index) = 'n' then
34. setWord(nextArg, length)
35. end if
36. otherwise
37. if dest > 0
38. then setByte(dest + length, readByte(format + index))
39. set length to length + 1
40. end if
41. set index to index + 1
42. loop
43. return length
44. end function

雖然這個函式很大，但它還是很簡單的。大多數的程式碼都是在檢查所有各種條件，每個程式碼都是很簡單的。此外，所有的無符號整數的大小寫都是相同的（除了底以外）。因此在彙編中可以將它們彙總。下麵是它的彙編程式碼。

1. .globl FormatString
2. FormatString:
3. format .req r4
4. formatLength .req r5
5. dest .req r6
6. nextArg .req r7
7. argList .req r8
8. length .req r9
10. push {r4,r5,r6,r7,r8,r9,lr}
11. mov format,r0
12. mov formatLength,r1
13. mov dest,r2
14. mov nextArg,r3
15. add argList,sp,#7*4
16. mov length,#0
18. formatLoop$:
19. subs formatLength,#1
20. movlt r0,length
21. poplt {r4,r5,r6,r7,r8,r9,pc}
23. ldrb r0,[format]
24. add format,#1
25. teq r0,#'%'
26. beq formatArg$
28. formatChar$:
29. teq dest,#0
30. strneb r0,[dest]
31. addne dest,#1
32. add length,#1
33. b formatLoop$
35. formatArg$:
36. subs formatLength,#1
37. movlt r0,length
38. poplt {r4,r5,r6,r7,r8,r9,pc}
40. ldrb r0,[format]
41. add format,#1
42. teq r0,#'%'
43. beq formatChar$
45. teq r0,#'c'
46. moveq r0,nextArg
47. ldreq nextArg,[argList]
48. addeq argList,#4
49. beq formatChar$
51. teq r0,#'s'
52. beq formatString$
54. teq r0,#'d'
55. beq formatSigned$
57. teq r0,#'u'
58. teqne r0,#'x'
59. teqne r0,#'b'
60. teqne r0,#'o'
61. beq formatUnsigned$
63. b formatLoop$
65. formatString$:
66. ldrb r0,[nextArg]
67. teq r0,#0x0
68. ldreq nextArg,[argList]
69. addeq argList,#4
70. beq formatLoop$
71. add length,#1
72. teq dest,#0
73. strneb r0,[dest]
74. addne dest,#1
75. add nextArg,#1
76. b formatString$
78. formatSigned$:
79. mov r0,nextArg
80. ldr nextArg,[argList]
81. add argList,#4
82. mov r1,dest
83. mov r2,#10
84. bl SignedString
85. teq dest,#0
86. addne dest,r0
87. add length,r0
88. b formatLoop$
90. formatUnsigned$:
91. teq r0,#'u'
92. moveq r2,#10
93. teq r0,#'x'
94. moveq r2,#16
95. teq r0,#'b'
96. moveq r2,#2
97. teq r0,#'o'
98. moveq r2,#8
100. mov r0,nextArg
101. ldr nextArg,[argList]
102. add argList,#4
103. mov r1,dest
104. bl UnsignedString
105. teq dest,#0
106. addne dest,r0
107. add length,r0
108. b formatLoop$

5、一個轉換作業系統

你可以使用這個方法隨意轉換你希望的任何東西。比如，下麵的程式碼將生成一個換算表，可以做從十進位制到二進位制到十六進位制到八進位制以及到 ASCII 的換算操作。

刪除 main.s 檔案中 bl SetGraphicsAddress 之後的所有程式碼，然後貼上以下的程式碼進去。

1. mov r4,#0
2. loop$:
3. ldr r0,=format
4. mov r1,#formatEnd-format
5. ldr r2,=formatEnd
6. lsr r3,r4,#4
7. push {r3}
8. push {r3}
9. push {r3}
10. push {r3}
11. bl FormatString
12. add sp,#16
14. mov r1,r0
15. ldr r0,=formatEnd
16. mov r2,#0
17. mov r3,r4
19. cmp r3,#768-16
20. subhi r3,#768
21. addhi r2,#256
22. cmp r3,#768-16
23. subhi r3,#768
24. addhi r2,#256
25. cmp r3,#768-16
26. subhi r3,#768
27. addhi r2,#256
29. bl DrawString
31. add r4,#16
32. b loop$
34. .section .data
35. format:
36. .ascii "%d=0b%b=0x%x=0%o='%c'"
37. formatEnd:

你能在測試之前推算出將發生什麼嗎？特別是對於 r3 ≥ 128 會發生什麼？嘗試在樹莓派上執行它，看看你是否猜對了。如果不能正常執行，請檢視我們的排錯頁面。

如果一切順利，恭喜你！你已經完成了螢幕04 教程，螢幕系列的課程結束了！我們學習了畫素和幀緩衝的知識，以及如何將它們應用到樹莓派上。我們學習瞭如何繪製簡單的線條，也學習如何繪製字元，以及將數字格式化為文字的寶貴技能。我們現在已經擁有了在一個作業系統上進行圖形輸出的全部知識。你可以寫出更多的繪製方法嗎？三維繪圖是什麼？你能實現一個 24 位幀緩衝嗎？能夠從命令列上讀取幀緩衝的大小嗎？

接下來的課程是輸入[4]系列課程，它將教我們如何使用鍵盤和滑鼠去實現一個傳統的計算機控制檯。