OctToTextBuf - Zformátování čísla OCT do bufferu

Funkce OctToTextBuf zkonvertuje 64-bitové celé číslo bez znaménka na text ve formátovaném oktalovém (osmičkovém) tvaru. Na rozdíl od předešlých funkcí pro hexadecimální a binární formát nepodporuje oktalový formát oddělovače řádů (jedna číslice zabírá 3 bity a není tedy přirozeným dělitelem velikosti binárních čísel).


; -----------------------------------------------------------------------------
;                    Convert OCT number into text buffer
; -----------------------------------------------------------------------------
; INPUT:	EDX:EAX = number
;		EBX = formatting parameters FORMPAR
;		ESI = remaining free space in buffer
;		EDI = destination buffer
; OUTPUT:	ESI = next remaining free space in buffer
;		EDI = next destination buffer
; NOTES:	On AMD 1.6 GHz it takes approx. "6*digits+45" nanoseconds.
; -----------------------------------------------------------------------------
; Local variables (ebp+N are read-only variables):
%define		OCTNumL    ebp+16	; (4) number LOW
%define		OCTNumH    ebp+4	; (4) number HIGH
%define		OCTForm    ebp-4	; (4) formatting parameters FORMPAR
%define		OCTLen     ebp-8	; (4) text length

%define		OCTStack  8		; stack size

Na vstupu funkce obsahuje registrový pár EDX:EAX číslo bez znaménka ke konverzi, registr EBX obsahuje formátovací parametry FORMPAR (ne ukazatel), registr ESI čítač zbylého místa v cílovém bufferu a registr EDI ukazatel do cílového bufferu. Na výstupu z funkce jsou registry ESI a EDI posunuty na novou ukládací pozici.

Funkce používá lokální proměnné s bázovým registrem EBP. Proměnné s kladným offsetem (OCTNumL a OCTNumH) jsou použity jen pro čtení, jejich obsah není modifikován. OCTNumL je nižší dvojslovo vstupního čísla (vstupní registr EAX), OCTNumH je vyšší dvojslovo vstupního čísla (vstupní registr EDX). OCTForm jsou formátovací parametry FORMPAR (vstupní registr EBX). OCTLen je délka ukládaného textu. OCTStack je velikost lokálních proměnných v zásobníku.


; ------------- Check remaining free space in buffer

OctToTextBuf:	or	esi,esi		; check remaining space
		jle	short OctToTextBufN9 ; not enough free space

; ------------- Push registers

		push	eax		; push EAX number LOW
		push	ebx		; push EBX
		push	ecx		; push ECX
		push	edx		; push EDX number HIGH
		push	ebp		; push EBP
		mov	ebp,esp		; EBP <- push ESP
		sub	esp,OCTStack	; ESP <- create local variables

; ------------- Prepare local variables

		mov	[OCTForm],ebx	; formatting parameters FORMPAR

Na začátku funkce OctToTextBuf je nejdříve proveden test volného místa v cílovém bufferu. Není-li v cílovém bufferu volné místo, funkce se ihned ukončí.

Po úschově registrů se vytvoří v zásobníku místo pro lokální proměnné. Do proměnné OCTForm se uschovají formátovací parametry z registru EBX.


; ------------- Get text length without spaces (-> EDX)

		call	Oct0ToTextBufN	; get text length without spaces
		mov	[OCTLen],eax	; store text length
		xchg	eax,edx		; EDX <- push text length

Ke zformátování čísla v bufferu je potřeba nejdříve znát délku čísla. Délka čísla se zjistí funkcí Oct0ToTextBufN, která na rozdíl od funkce OctToTextBufN ignoruje parametr minimální šířky pole s údajem. Délka čísla se uchová do proměnné OCTLen a do registru EDX.


; ------------- Store leading spaces

		bt	ebx,FORMFLAG_Left_b ; left-justify?
		jc	OctToTextBuf22	; left-justify, no leading spaces
		movzx	ecx,bh		; ECX <- minimal width of field
		sub	ecx,edx		; ECX <- remaining spaces
		jle	OctToTextBuf22	; no spaces left
		bt	ebx,FORMFLAG_Cent_b ; center?
		jnc	OctToTextBuf2	; no, right-justify
		shr	ecx,1		; ECX <- spaces / 2, round down
		jz	OctToTextBuf22	; no spaces left
OctToTextBuf2:	mov	al," "		; AL <- space
OctToTextBuf21:	dec	esi		; decrease space counter
		stosb			; store one space
		jz	short OctToTextBuf9 ; buffer is full
		loop	OctToTextBuf21	; next character

Není-li číslo zarovnáno doleva (příznakový bit FORMFLAG_Left_b), je nutno před číslo doplnit úvodní mezery. Do registru ECX se připraví z registru BH (což je parametr FORMPAR_Width z popisovače formátovacích parametrů) požadovaná šířka pole. Odečtením délky textu z registru EDX se obdrží zbývající šířka pro okraje. Je-li to kladné číslo, bude se pokračovat dále. Má-li být text centrován, použije se pouze polovina mezer se zaokrouhlením dolů.

V cyklu se ukládají znaky mezer do cílového bufferu. Počet mezer je v registru ECX. Dekrementací registru ESI se ověřuje, zda bude v bufferu místo pro další znak. Pokud čítač ESI dosáhne nuly, dosáhlo se konce cílového bufferu a funkce se ukončí.


; ------------- Store prefix

OctToTextBuf22:	mov	ecx,edx		; ECX <- length
		bt	ebx,FORMFLAG_Alt_b ; use prefix?
		jnc	OctToTextBuf3	; not using prefix
		mov	al,"0"		; AL <- character "0"
		dec	esi		; decrease counter of free space
		stosb			; store prefix character
		jz	short OctToTextBuf9 ; buffer is full
		dec	ecx		; ECX <- text length - 1

; ------------- Suffix correction

OctToTextBuf3:	bt	ebx,FORMFLAG_Alt2_b ; use suffix?
		sbb	ecx,byte 0	; ECX <- decrease if suffix

Volitelně se může před začátek čísla uložit prefix "0" (je-li nastaven příznakový bit FORMFLAG_Alt_b). Při uložení znaku prefixu se dekrementací čítače v registru ESI ověří volné místo k uložení dalšího znaku. Dosáhne-li čítač nuly, funkce se ukončí. Údaj zbývající délky čísla v registru ECX se dekrementuje o 1.

Po uložení prefixu se testem příznakového bitu FORMFLAG_Alt2_b zjistí, zda se bude ukládat sufix "o". Pokud ano, sníží se údaj zbývající délky textu o 1.


; ------------- Prepare registers to convert number

		mov	ebx,[OCTNumL]	; EBX <- number LOW
		add	edi,ecx		; EDI <- last character + 1
		mov	edx,[OCTNumH]	; EDX <- number HIGH
		sub	esi,ecx		; ESI <- subtract length
		or	ecx,ecx		; check text length
		jle	OctToTextBuf81	; no characters

; ------------- Push registers 2

		push	esi		; push ESI
		push	edi		; push EDI
		dec	edi		; EDI <- set pointer to last character

Při přípravě registrů ke konverzi se do dvojregistru EDX:EBX načte konvertované číslo. Přičtením zbývající délky textu čísla k EDI a odečtením od ESI se ukládací ukazatel posune za konec ukládaného textu. Není-li délka textu v registru ECX platné kladné číslo, přeskočí se část pro ukládání čísla.

Po úschově zápisových ukazatelů ESI a EDI se dekrementací EDI nastaví ukládací ukazatel na poslední znak čísla.


; ------------- Convert number
; EDX:EBX=number, ESI=free space-1, EDI=end of destination, ECX=num. of chars

OctToTextBuf42:	inc	esi		; shift free space counter
		mov	al,bl		; EAX <- number
		jle	OctToTextBuf44	; position is behind end of buffer
		and	al,7		; mask low bits
		add	al,"0"		; convert to ASCII character
		mov	[edi],al	; store character
OctToTextBuf44:	shrd	ebx,edx,3	; shift number LOW 3 bits right
		dec	edi		; shift destination pointer
		shr	edx,3		; shift number HIGH 3 bits right
		loop	OctToTextBuf42	; next digit

Během konverze obsahuje registrový pár EDX:EBX konvertované číslo, registr ESI čítač volného místa - 1, registr EDI ukazatel na konec ukládaného textu a registr ECX čítač znaků k uložení. Ukládání číslic je opakovaně prováděno ve smyčce s čítačem ECX.

Inkrementací čítače volného místa v registru ESI se provede test, zda je ukazatel do cílového bufferu platný. Není-li čítač kladný, ukazuje ukazatel za konec cílového bufferu, v tom případě se přeskočí část ukládající další znak.

Z registru BL se obdrží nejnižší bajt dekódovaného čísla a zamaskováním číslem 7 se připraví nejnižší 3 bity čísla. Přičtením ASCII znaku "0" se číslo zkonvertuje na ASCII číslici, která se uloží do cílového bufferu.

Ukazatel cílového bufferu se sníží a rotací dvojregistru EDX:EBX o 3 bity doprava (instrukcemi SHRD a SHR) se číslo posune o jednu číslici k vyšším řádům.


; ------------- Pop registers 2

OctToTextBuf8:	pop	edi		; pop EDI
		pop	esi		; pop ESI

; ------------- Limit offset

OctToTextBuf81:	or	esi,esi		; buffer overflow?
		jg	OctToTextBuf82	; buffer is OK
		add	edi,esi		; EDI <- correct address
		xor	esi,esi		; limit free space to 0
		jmp	short OctToTextBuf9

Po dekódování textu čísla se navrátí ukládací registry ESI a EDI, které ukazovaly za konec ukládaného čísla. Ukazatele se upraví tak, aby nepřesahovaly konec bufferu - tj. přesahující ukládací ukazatel EDI se přičtením čítače ESI posune na konec a poté se čítač zbylého místa vynuluje.


; ------------- Store suffix

OctToTextBuf82:	test	byte [OCTForm+FORMPAR_Flags2],FORMFLAG2_Alt2 ; suffix?
		jz	OctToTextBuf83	; not using suffix
		mov	al,"o"		; AL <- suffix
		stosb			; store suffix
		dec	esi		; decrease space counter
		jz	OctToTextBuf9	; no free space

Je-li nastaven v registru formátovacích parametrů příznakový bit FORMFLAG2_Alt2, uloží se za konec čísla sufix "o". Po uložení sufixu se dekrementací čítače volného místa ESI zkontroluje zbývající volné místo, při dosažení konce bufferu se funkce ukončí.


; ------------- Store trailing spaces

OctToTextBuf83:	mov	eax,[OCTLen]	; EAX <- text length
		movzx	ecx,byte [OCTForm+FORMPAR_Width] ; ECX <- minimal width
		sub	ecx,eax		; ECX <- remaining spaces
		jle	OctToTextBuf9	; no spaces remain
		test	byte [OCTForm+FORMPAR_Flags1],FORMFLAG1_Left ; left?
		jnz	OctToTextBuf84	; left-justify
		test	byte [OCTForm+FORMPAR_Flags2],FORMFLAG2_Cent ; center?
		jz	OctToTextBuf9	; no center
		shr	ecx,1		; ECX <- spaces / 2
		adc	cl,ch		; ECX <- round up
		jz	OctToTextBuf9	; no spaces
OctToTextBuf84:	mov	al," "		; AL <- space
OctToTextBuf85:	stosb			; store one space
		dec	esi		; decrease space counter
		loopnz	OctToTextBuf85	; next character

; ------------- Pop registers

OctToTextBuf9:	mov	esp,ebp		; pop ESP
		pop	ebp		; pop EBP
		pop	edx		; pop EDX
		pop	ecx		; pop ECX
		pop	ebx		; pop EBX
		pop	eax		; pop EAX
		ret

Poslední operací je uložení mezer za koncem čísla. Do registru EAX je načtena délka textu (bez mezer), do registru ECX požadovaná šířka pole, odečtením zůstane v registru ECX počet zbývajících mezer. Pokud žádné mezery pro okraje nezbyly, funkce se ukončí.

Je-li nastaven příznakový bit FORMFLAG1_Left, je číslo zarovnáno doleva, ihned se přejde k ukládání mezer za číslo. Není-li tento příznak nastaven a není-li nastaven ani příznakový bit FORMFLAG2_Cent, bylo číslo zarovnáno doprava a mezery tedy již byly uloženy dříve, takže se funkce ukončí. Jinak platí, že číslo je centrováno. Do registru ECX se připraví poloviční počet mezer, ale tentokrát se zaokrouhlí nahoru (aby se zachytila případná lichá mezera).

Následuje ukládání mezer do bufferu. Počet mezer je dán čítačem v registru ECX. Současně se sleduje zbývající volné místo v cílovém bufferu čítáním registru ESI. Pokud dosáhne nuly, bylo dosaženo konce bufferu a smyčka se ukončí.

OctToTextBufN		Délka textu formátovaného čísla OCT
FormToTextBuf		Zformátování textu do bufferu