2.1.1. Odwracanie łańcucha

Zwykłe odwracanie łańcucha jest oczywiście dość proste, ale ja proponuję inne podejście. Otóż można użyć stosu do niejawnego odwrócenia łańcucha, a właściwie do odwrócenia kolejności zapisów do łańcucha.

void display_uint(unsigned int x) {
 if (!x) return
 display_uint(x/10);
 // wyświetlenie cyfry
 putchar(x % 10 + '0');
}

Przy rekursji stos jest wykorzystywany zupełnie naturalnie, ale można również bezpośrednio użyć struktury stosowej.

void push(char);
char pop();
int  stack_empty();

void display_uint(unsigned int x)
{
 do {
     push(x%10 + '0');
     x /= 10;
 }
 while (x)

 while (!stack_empty())
   putchar(pop());
}

W asemblerze użycie powyższego sposobu jest nadzwyczaj proste, ponieważ procesor wspiera operacje na stosie poprzez instrukcje push i pop.

; edi - wskaźnik na łańcuch - minimum 11 bajtów
; eax - zamieniana wartość (bez znaku!)
dword2dec_ascii:

pushad

mov ecx, 10

mov ebp, esp                            ; zapisz wierzchołek stosu
.conv:
        xor     edx, edx                ; edx = eax % 10
        div     ecx                     ;

        lea     ebx, [edx + '0']        ; ebx = ASCII(edx)
        push    bx

        or      eax, eax                ; do ... while (eax)
        jnz     .conv                   ; /

cld
.create_string:
        cmp     ebp, esp                ; while(!stack_empty()) - dopóki
        je      .end                    ; oryginalna zawartość stosu
                                        ; nie zostanie odtworzona

        pop     ax                      ; stos jest opróżniany
        stosb                           ; a zapisane na nim uprzednio litery
                                        ; zapisywane do łańcucha [edi]
        jmp     .create_string
.end:

mov [edi], byte 0  ; zapisz kończący symbol
popad
ret

2.1.2. Liczby o znanej ilości cyfr

W tym przypadku łańcuch wypełnia się od końca, a funkcja zwraca wskaźnik do ostatnio zapisanego znaku.

#define size 20 /* ilość cyfr */

char string[size+1] = {0};

char* uint2ascii(unsigned int x)
{
 char *c = &string[size-1]; // przedostatni znak

 do
   {
   *c-- = x % 10 + '0';
    x  /= 10;
   }
 while (x)

 return c;
}

W asemblerze kod jest równie prosty, a nawet bardziej, bowiem rozkaz div zarówno dzieli jak i liczy resztę. W C zdefiniowano funkcję div, która działa analogicznie do rozkazu div.

; esi = c > string[size]
; eax = x
uint2ascii:
        mov ebx, 10
  .conv:
        div   eax, ebx ; eax = eax/10
                       ; edx = eax%10
        add   dl , '0' ;  dl = ASCII(dl)
        mov [esi], dl
        dec  esi

        test  eax, eax ; if (x != 0) goto .conv
        jnz   .conv
        ret

3.2.1. Kod x86 (bez rozgałęzień!)

;  2-02-02

; wejście: al - tetrada
; wyjście: bl - bl='0' + (al >= 9) ? al : al+('a'-10-'0');
; niszczy: cl

mov bl, '0'
mov cl, 9

cmp cl, al ; CF = al>cl
sbb cl, cl ; cl = -1 jeśli CF==1

and cl, 'a'-10-'0'

add bl, al
add bl, cl

3.2.2. Kod MMX

segment .text

_word2ascii_mmx:
; eax - liczba           ; eax: hgfedcba

; Pierwszym krokiem jest odwrócenie kolejność tetrad,
; ponieważ pierwszy jest wyświetlany bajt o młodszym adresie, a
; na pierwszej pozycji jest zawsze najstarsza cyfra.
; Stąd całe zamieszanie

bswap     eax            ; eax: badcfehg

; Kolejnym krokiem jest "rozpakowanie" tetrad do
; bajtów

movd      mm0, eax       ; mm0: 00000000badcfehg
movd      mm1, eax       ; mm1: 00000000badcfehg
psrlq     mm0, 4         ; mm0: 000000000badcfeh

punpcklbw mm0, mm1       ; mm0: ba 0b dc ad fe cf hg eh
pand      mm0, [mm_mask] ; mm0: 0a 0b 0c 0d 0e 0f 0g 0h

; Na końcu właściwa konwersja

                         ; np.
movq      mm1, mm0       ; mm1: 0a 01 07 0f 0d 00 08 0c
pcmpgtb   mm1, [mm_nine] ; mm1: ff 00 00 ff ff 00 00 ff ; mm1 > 9
pand      mm1, [mm_corr] ; mm2: 27 00 00 27 27 00 00 27

paddb     mm0, [mm_zero] ;
paddb     mm0, mm1       ;

movq [string], mm0

ret;urn

segment .data

mm_mask dd 0x0f0f0f0f, 0x0f0f0f0f  ; maska dla młodszych tetrad
mm_nine dd 0x09090909, 0x09090909  ; packed_byte(0x9)
mm_zero dd 0x30303030, 0x30303030  ; packed_byte('0')
mm_corr dd 0x27272727, 0x27272727  ; packed_byte('a' - 10)

string db '????????',0

3.2.3. Kod SSSE3

Zobacz wpis w osobnym artykule.