Question

我正在编写一个程序来打印0到100之间的所有数字，我需要找到变量（在本例中为变量counter）的数字位数。

这是我的代码：

SECTION .data
len EQU 32

SECTION .bss
counter resd len 
digit1 resd len
digit2 resd len
digit3 resd len

SECTION .text
GLOBAL _start
_start:
nop

Print:
mov eax, 4
mov ebx, 1
mov ecx, counter
mov edx, len
int 80h 

Set:
mov BYTE [counter], 1

Divide:
; HERE IS WHERE I NEED TO FIND THE LENGTH OF THE VARIABLE COUNTER
; initial division
mov ax, [counter]   ; number we want to print
mov ch, 10    ; we divide by ten to siphon digits
div ch        ; divide our number by 10

; al now has 11, ah has 1
mov dh, ah             ; save the remainder in dh
xor ah,ah
mov ch, 10             ; refill ch with the divisor
div ch                 ; al now has 1, ah now has 1

Move:                     ; now to move our digits to a printable state
mov [digit1], dh      ; first digit is in edx
mov [digit2], ah
mov [digit3], al

Adjust:
add BYTE [digit1], '0'
add BYTE [digit2], '0'
add BYTE [digit3], '0'

Print:
mov eax, 4
mov ebx, 1
mov ecx, digit1
mov edx, len
int 80h

mov eax, 4
mov ebx, 1
mov ecx, digit2
mov edx, len
int 80h

mov eax, 4
mov ebx, 1
mov ecx, digit3
mov edx, len
int 80h

Exit:
mov eax, 1
mov ebx, 0
int 80h

我需要找到长度，以便知道要分割多少次以及打印变量计数器的位数。

我怎样才能找到它有多长？

提前致谢

Answer 1

对于0..100范围内的数字，我只是在边界处进行比较，使用伪汇编程序：

    mov ax, [counter]

    mov cx, 3             ; default length
    cmp ax, 100           ; >= 100, use 3
    bge done

    dec cx                ; set length to 2
    cmp val, 10           ; >= 10, use 2
    bge done

    dec cx                ; set length to 1

done:
                          ; cx now holds the digit count.

实际上最多可以处理999，但如果你想扩大范围，你也可以在100之前添加更多的条件检查。

Answer 2

Aki给出了一个例子！使用“-S”开关编译它以查看编译器使用它做什么 - 尽管这可能没有多大帮助。：）

你问如何计算出位数。我已经看过代码（来自一本着名书籍的作者！），它执行整个div循环，直到商为零才算数字。然后他做另一个div循环找到他们！做＆gt; 10，＆gt; 100，＆gt; 1000等将起作用。但为什么你需要知道？您可以保持div直到商为零，并计算数字。事实上，您可以通过将商与9进行比较来保存div（div非常慢！） - 如果be，您的最后一位数字在al中。更容易做额外的div，IMO。：）

我们以“错误”的顺序获得剩余/数字。我知道有三种方法可以解决这个问题。我认为“最简单”的是将它们推入堆栈，计算它们，然后按照我们想要存储/打印它们的顺序弹出它们，在之前或之后添加“0”。

另一种方法是从缓冲区的“后退”开始并“向前”工作。这就是Aki的颂歌所做的。对于C兼容代码，返回一个以零结尾的字符串很好，但sys_write不知道零终止字符串，它想知道长度。（没问题，我们可以找到“zstring”的长度）注意，这不会到达缓冲区的开头。如果你不关心“C兼容”代码，你可以返回“我们在缓冲区中的位置”和长度 - 可能在ecx和edx中，sys_write需要它们。或者您可以将空格键填充到缓冲区的开头。右对齐的数字在列中打印得很好。：）

另一种方法是继续将'em'放在缓冲区中“向后”并在结尾处做一个“反向字符串”。

这些方法都不是很快。 div很慢，期间！我“有”来自Terje Mathieson（“光速”解决方案专家）的一些代码，它不使用div，但我不理解它并且不使用它。如果您赶时间，可以在各种优化手册中找到它。：）

通过将自己限制为100，你并没有获得太多收益。使用完整的32位寄存器编写例程同样容易（也许更容易），并且CPU很熟悉它。如果你需要处理负数，那只会有点复杂。如果你在这里找不到例子，你可以在Nasm论坛找到一些例子，但这是一个有趣的练习，你可以自己尝试一下。

呃......看......保留“太多”记忆可能会让你的程序“臃肿”，但不会造成任何伤害。保留“不够”的内存是一个错误！所以你最好在“太多”方面犯错。仍然...

SECTION .data
len EQU 32

SECTION .bss
counter resd len 
digit1 resd len
digit2 resd len
digit3 resd len

...使用一个128字节的缓冲区，并为一个数字/字符打印32个字节，似乎很多。：）

最佳，弗兰克

Answer 3

通常这是通过内部缓冲区完成的（实际上堆栈将执行：）

你除Y = X mod 10（或Y = X mod base），X = X div base，直到X = 0（并推动每个mod Y）计算分区数，然后从堆栈C中弹出每个结果C次并写入输出流。

void print_number(int eax, int ebx) {  // ebx = base, eax = number
   int ecx = 0;
   do {
      edx = eax % ebx;
      eax = eax / ebx;
      push(edx);
      ecx++;
   } while (eax);

   while (ecx) {
      pop (eax);
      putch(eax+'0');
      ecx--;
   }
}

关键是你最终需要完全分开。

稍微优化一点的是[再次在C中鼓励你自己的想法] ......

void print_number(int a, int base) {
     char string[10];
     static *ptr = string+9;  // points to the last char of string
     *ptr--=0;                // write ending ASCII Zero.
     *ptr='0';
     while (a) {
          *--ptr= '0'+(a % base);  // works for base = 2-10
          a/=base;
     }
     printf("%s",ptr);
}

你能找出这个有效（或没有）的原因吗？

linux nasm assembly查找变量中保存的位数

3 个答案: