FormToTextBufN - Délka formátovaného textu

Funkce FormToTextBufN zjistí délku textu v bufferu zformátovaného pomocí funkce FormToTextBuf.


; -----------------------------------------------------------------------------
;               Format text into text buffer - get text length
; -----------------------------------------------------------------------------
; INPUT:	EAX = callback value
;		EBX = size of source text to be formatted
;		EDX = source text to be formatted
;		EBP = callback function to read argument
;			INPUT:	EAX = callback value
;				EBX = formatting parameters with argument type
;				EDX = DWORD index in argument stack (0 to 255)
;			OUTPUT: CY=error, invalid argument index
;				EAX = width or precision parameter
;				EDX:EAX integer
;				EAX character UNICODE
;				ST0 floating point (only if NC)
;				EAX pointer to text UTF-8, EDX length of text
;			DESTROYS: EBX, ECX, EDX:EAX (if not returning a value)
; OUTPUT:	CY = error, invalid argument index
;		ESI = output text length
; NOTES:	64-bit integer or double float takes 2 DWORDs, extended double
;		takes 3 DWORDs and other numbers take 1 DWORD. Argument index
;		refers to index of DWORD argument, not to real argument number.
; -----------------------------------------------------------------------------

Na vstupu funkce obsahuje registr EAX zpětnou hodnotu, která je předávána funkci sloužící k načtení hodnoty argumentu. Zpětnou hodnotou bývá zpravidla ukazatel na strukturu popisující objekt, který si vyžádal zformátování textu. Registr EBX obsahuje délku zdrojového textu ke zformátování. Registr EDX obsahuje ukazatel na zdrojový text ke zformátování. Zdrojový text je v kódu UTF-8.

Registr EBP obsahuje ukazatel na zpětně volanou funkci sloužící k načtení hodnoty argumentu. Na vstupu funkce zpětného volání obsahuje registr EAX zpětnou hodnotu. Registr EBX obsahuje formátovací argumenty FORMPAR (ne ukazatel) spolu s typem požadovaného argumentu. Registr EDX obsahuje index požadovaného DWORD argumentu v rozsahu 0 až 255. Má-li argument větší velikost než DWORD, zabere v zásobníku místo pro více argumentů a registr EDX obsahuje index počátku argumentu zarovnaný na DWORD.

Na výstupu funkce zpětného volání je navracen příznak CY jako indikace chyby neplatného indexu argumentu. V případě této chyby se celá funkce FormToTextBufN ukončí s indikací chyby. Obsah ostatních registrů závisí na typu požadovaného argumentu. Parametr přesnosti nebo šířky je navracen v registru EAX, celé číslo v registrovém páru EDX:EAX, znak Unicode v registru EAX, desetinné číslo v registru ST0 a ukazatel na text v registru EAX, délka textu je obsažena v registru EDX. Obsahy nevyužitých registrů EAX, EBX, ECX a EDX mohou být funkcí zrušeny.

Na výstupu funkce FormToTextBufN je nastaven příznak chyby CY v případě, že funkce zpětného volání navrátila chybu neplatného indexu argumentu. Registr ESI obsahuje délku textu. Funkce předpokládá, že koprocesor je v implicitním nastavení - přesnost 64 bitů, zaokrouhlení k nejbližšímu.


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

FormToTextBufN:	push	eax		; push EAX (callback value)
		push	ebx		; push EBX
		push	ecx		; push ECX
		push	edx		; push EDX
		push	ebp		; push EBP (callback function)
		mov	ebp,esp		; EBP <- push ESP
		sub	esp,FORMStack	; ESP <- create local variables

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

		mov	byte [FORMInx],0 ; clear current argument index
		mov	ecx,ebx		; ECX <- source text counter
		xor	esi,esi		; ESI <- 0, text length

Na začátku funkce jsou uchovány obsahy registrů (některé registry jsou použity jako lokální proměnné s kladným offsetem) a vytvořeno místo v zásobníku pro lokální proměnné. Aktuální index argumentu je vynulován a do registru ECX je připraven čítač znaků zdrojového textu. Střadač délky textu ESI je vynulován.


; ------------- Read one character (-> AL)

FormToTextBufN2:dec	ecx		; check next source character
		js	FormToTextBufN7	; end of source text
		mov	al,[edx]	; AL <- character from source text
		inc	edx		; increase source pointer

; ------------- Check if it is switch character

		cmp	al,"%"		; is it switch character?
		je	FormToTextBufN4	; switch character

; ------------- Store one character into destination buffer

FormToTextBufN3:inc	esi		; increase text length
		jmp	short FormToTextBufN2 ; next character

Čítáním registru ECX se zkontroluje, zda je připraven další zdrojový znak. Pokud ne, funkce se ihned ukončí. Jinak se ze zdrojového textu (ukazatel EDX) načte další znak.

Není-li dalším znakem znak procenta "%", který je použit jako indikátor začátku formátovací sekvence, zvýší se délka výstupního textu o 1 znak a pokračuje se načtením dalšího znaku.


; ------------- Prepare variables to read formatting parameters

FormToTextBufN4:xor	ebx,ebx		; EBX <- 0, formatting parameters
		mov	[FORMFlagNum],bx ; clear read number and flags

; ------------- Read one character (-> AL)

FormToTextBufN5:dec	ecx		; check next source character
		js	FormToTextBufN7	; end of source text
		mov	al,[edx]	; AL <- character from source text
		inc	edx		; increase source pointer

; ------------- Jump to character service

		cmp	al,32		; minimal character (space character)
		jb	FormToTextBufN3	; invalid character
		cmp	al,127		; maximal character
		jae	FormToTextBufN3	; invalid character
		movzx	eax,al		; EAX <- character
		jmp	[FormTxtNJumpTab+eax*4-32*4] ; jump

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

FormToTextBufN7:clc			; clear error flag
FormToTextBufN8: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

Je-li dalším znakem znak procenta "%", pokračuje se dále obsluhou zpracování formátovací sekvence. Registr EBX se vynuluje, bude použit jako střadač formátovacích parametrů.

Na začátku smyčky obsluhy znaků formátovací sekvence se čítáním registru ECX zkontroluje, zda je připraven další zdrojový znak. Pokud ne, funkce se ihned ukončí. Jinak se ze zdrojového textu (ukazatel EDX) načte další znak.

Ověří se platnost formátovacího znaku (musí ležet v intervalu 32 až 126) a provede se skok na osbluhu znaku podle tabulky FormTxtNJumpTab. Pro neplatný znak se obsluha formátovacího řetězce přeruší a znaky se opět začnou započítávat jako běžné znaky.


; ------------- Left-justify "-"

FormToTxtNLeft:	bts	ebx,FORMFLAG_Left_b ; set flag "left-justify"
		jmp	short FormToTextBufN5 ; next character


; ------------- Always use sign "+"

FormToTxtNSign:	bts	ebx,FORMFLAG_Sign_b ; set flag "sign"
		jmp	short FormToTextBufN5 ; next character


; ------------- Prefix space if number is positive " "

FormToTxtNSpace:bts	ebx,FORMFLAG_Spc_b ; set flag "space"
		jmp	short FormToTextBufN5 ; next character

Obsluha znaku mezery nastaví v registru EBX příznak náhrady kladného znaménka mezerou.


; ------------- Thousand separator "~"

FormToTxtNThsnd:bts	ebx,FORMFLAG_Thsn_b ; set flag "thousand"
		jmp	short FormToTextBufN5 ; next character

Obsluha znaku "~" nastaví v registru EBX příznak zobrazení oddělovačů řádů.


; ------------- Center "@"

FormToTxtNCent:	bts	ebx,FORMFLAG_Cent_b ; set flag "center"
		jmp	short FormToTextBufN5 ; next character


; ------------- Alternate form "#" and "##"

FormToTxtNAlt:	btc	ebx,FORMFLAG_Alt_b ; alternate form
		jnc	short FormToTextBufN5 ; next character
		btc	ebx,FORMFLAG_Alt2_b ; flip alternate form 2
		jmp	short FormToTextBufN5 ; next character

Obsluha znaku "#" posune v registru EBX příznaky alternativního formátu. Příznaky FORMFLAG_Alt_b a FORMFLAG_Alt2_b se s příchodem znaků "#" postupně překlápí tak, že čítají znaky "#" v počtu 0, 1, 2 nebo 3.


; ------------- Precision "."

FormToTxtNPrec:	test	byte [FORMFlag],FORMFLAG_PREC ; precision?
		jnz	FormToTxtNPrec2	; precision has been started
		or	byte [FORMFlag],FORMFLAG_PREC ; start precision
		call	FormToTextStopW	; stop parsing width
		jmp	short FormToTextBufN5 ; next character

FormToTxtNPrec2:bts	ebx,FORMFLAG_Prec_b ; alternate precision
FormToTxtNBuf52:jmp	short FormToTextBufN5 ; next character

Znak tečky "." je oddělovač pole přesnosti a pole šířky. Pokud v proměnné FORMFlag nebyl dosud nastaven přepínač FORMFLAG_PREC, nebylo zahájeno načítání přesnosti. Příznak se nastaví a voláním funkce FormToTextStopW se ukončí načítání pole šířky.

Byl-li příznak FORMFLAG_PREC nastaven, obsluha načítání přesnosti byla již zahájena. V tom případě se pouze nastavi příznak FORMFLAG_Prec_b indikující, že se použije alternativní přesnost "..".


; ------------- Digit "0" to "9"

FormToTxtNDig0:	test	byte [FORMFlag],FORMFLAG_NUM+FORMFLAG_PREC ; first 0?
		jz	short FormToTxtNZero ; first zero digit
FormToTxtNDig:	or	byte [FORMFlag],FORMFLAG_NUM ; start number
		mov	ah,[FORMNum]	; AH <- number
		sub	al,"0"		; AL <- digit
		cmp	ah,25		; check overflow
		jae	FormToTextDig4	; it will overflow or maybe it will not
		aad			; AL <- AL + AH*10
FormToTxtNDig2:	mov	[FORMNum],al	; store new number
		jmp	short FormToTxtNBuf52 ; next character

FormToTxtNDig4:	ja	FormToTxtNDig6	; it will overflow
		aad			; AL <- AL + AH*10
		cmp	al,250		; check overflow
		jae	FormToTxtNDig2	; parameter is OK
FormToTxtNDig6:	mov	al,255		; AL <- limit on overflow
		jmp	short FormToTxtNDig2 ; next character

; ------------- Add zeros instead of spaces "0"

FormToTxtNZero:	bts	ebx,FORMFLAG_Zero_b ; set flag "zero"
		jmp	short FormToTxtNBuf52 ; next character

Číslice "0" se může vyskytnout jen uvnitř čísla. Pokud načítání čísla ještě nebylo zahájeno a ani nebylo zahájeno pole přesnosti, je číslice "0" považována za příznak, nastaví se příznak požadavku doplnění nul před číslo.

Jedná-li se o číslici "1" až "9" nebo o platnou číslici "0", bude provedena obsluha načítání čísla. Nastaví se příznak FORMFLAG_NUM indikující, že bylo zahájeno číslo. Do registru AH je připraven střadač čísla FORMNum. Má-li střadač hodnotu menší než 25, nedojde určitě k přetečení čísla rozměru BYTE a nová číslice je přidána ke střadači instrukcí AAD.

Je-li střadač větší než 25, k přetečení dojde a číslo je omezeno na maximální povolenou hodnotu 255. Je-li střadač roven 25, k přetečení může nebo nemusí dojít. Nová číslice se přidá ke střadači a pokud je nová hodnota střadače menší než 250, došlo k přetečení a číslo je opět omezeno na 255.


; ------------- Integer size "I16", "I32", "I64"

FormToTxtNSize:	sub	ecx,byte 2	; check number of characters
		js	short FormToTextBufN7 ; end of source text
		mov	ax,[edx]	; AX <- get 2 characters
		inc	edx		; increase pointer
		inc	edx		; increase pointer
		cmp	ax,"64"		; long variant?
		je	short FormToTxtNLong ; long variant
		cmp	ax,"16"		; short variant?
		je	short FormToTxtNShrt ; short variant
		cmp	ax,"32"		; default variant?
		jne	FormToTxtNSize2	; no default variant
		btr	ebx,FORMFLAG_Long_b ; reset flag "long"
		btr	ebx,FORMFLAG_Shrt_b ; reset flag "short"
		jmp	short FormToTxtNBuf52 ; next character

FormToTxtNSize2:inc	ecx		; increase number of characters
		dec	edx		; decrease pointer
		inc	ecx		; increase number of characters
		dec	edx		; decrease pointer
		jmp	short FormToTxtNBuf52 ; next character

Znak velkého písmene "I" označuje přepínač nastavení velikosti argumentu. Platné přepínače mají tvar "I16", "I32" a "I64", proto je kontrolou registru ECX ověřeno, zda zbývají 2 znaky zdrojového textu a pokud zbývají, jsou další 2 znaky načteny do registru AX.

Jedná-li se o text "I64", je pokračováno obsluhou dlouhé varianty argumentu. Jedná-li se o text "I16", pokračuje se obsluhou krátké varianty argumentu. V případě textu "I32" se pokračuje obsluhou střední varianty argumentu. Obsluha spočívá ve vynulování příznaků krátké a dlouhé varianty argumentu.

V ostatních případech se ukazatel zdrojového textu navrátí za pozici znaku "I" a pokračuje se obsluhou dalších znaků.


; ------------- Get parameter "*"

FormToTxtNArg:	or	byte [FORMFlag],FORMFLAG_PAR ; set flag "parameter"
		jmp	short FormToTxtNBuf52 ; next character

Obsluha znaku "*" nastaví v registru EBX příznak, že číselný parametr (šířka nebo přesnost) bude načten z argumentu.


; ------------- Long variant "l", "L"

FormToTxtNLong:	bts	ebx,FORMFLAG_Long_b ; set flag "long"
		btr	ebx,FORMFLAG_Shrt_b ; reset flag "short"
		jmp	short FormToTxtNBuf52 ; next character

Obsluha znaku "l" nebo "L" zapne v registru EBX příznak dlouhého argumentu a vypne příznak krátkého argumentu.


; ------------- Short variant "h", "H"

FormToTxtNShrt:	btr	ebx,FORMFLAG_Long_b ; reset flag "long"
		bts	ebx,FORMFLAG_Shrt_b ; set flag "short"
FormToTxtNBuf54:jmp	short FormToTxtNBuf52 ; next character

Obsluha znaku "h" nebo "H" vypne v registru EBX příznak dlouhého argumentu a zapne příznak krátkého argumentu.


; ------------- Indexed argument "$"

FormToTxtNInx:	mov	al,0		; AL <- 0
		xchg	al,[FORMNum]	; AL <- number, clear number
		and	byte [FORMFlag],~FORMFLAG_NUM ; stop number
		or	al,al		; is index valid?
		jz	FormToTxtNBuf54	; index is not valid
		dec	eax		; AL <- correct index value
		test	byte [FORMFlag],FORMFLAG_PAR ; get "parameter"?
		jnz	FormToTxtNInx2	; yes, parameter is valid
		mov	[FORMExpInx],al	; store explicit argument index
		or	byte [FORMFlag],FORMFLAG_EXP ; explicit argument valid
		jmp	short FormToTxtNBuf54 ; next character

FormToTxtNInx2:	and	byte [FORMFlag],~FORMFLAG_PAR ; clear "parameter"
		test	byte [FORMFlag],FORMFLAG_PREC ; precision?
		jnz	FormToTxtNInx4	; precision has been started
		mov	bh,al		; store width index
		or	byte [FORMFlag],FORMFLAG_INXW ; width from arguments
		jmp	short FormToTxtNBuf54 ; next character

FormToTxtNInx4:	mov	bl,al		; store precision index
		or	byte [FORMFlag],(FORMFLAG_INXP+FORMFLAG_PSET)
		jmp	short FormToTxtNBuf54 ; next character

Znak "$" označuje explicitní index argumentu. Do registru AL je připraven střadač číselného parametru a střadač je vynulován (spolu s příznakem zahájení číselného argumentu). Index s hodnotou 0 není platný a ignoruje se. Pro hodnotu 1 a více se index dekrementací převede na bázi 0.

Pokud nebyl nastaven příznak "*" načítání číselného parametru z argumentu FORMFLAG_PAR, má index význam explicitního indexu argumentu. Index se uloží do proměnné FORMExpInx a nastaví se příznak FORMFLAG_EXP.

Pokud byl příznak "*" nastaven, bude z argumentu načten parametr šířky nebo přesnosti. Příznak FORMFLAG_PAR se vynuluje a testem příznaku FORMFLAG_PREC se rozliší, zda je načítán parametr šířky nebo přesnosti a podle výsledku se index uloží do registrů BH nebo BL a nastaví se příznaky FORMFLAG_INXW nebo FORMFLAG_INXP+FORMFLAG_PSET.


; ------------- Signed decimal int "d", "D", "i"

FormToTxtNDC:	bts	ebx,FORMTYPE_Cap_b ; set flag "capital"
FormToTxtNDS:
FormToTxtNIS:	or	ebx,(FORMTYPE_Int<<FORMPAR_TypeF_b)
		push	edx		; push EDX
		call	FormToTextGet	; get parameters
		jc	short FormToTxtNErr2 ; invalid argument index
		jnz	FormToTxtNDS2	; no default precision
		mov	bl,1		; BL <- 1, default precision
FormToTxtNDS2:	call	IntToTextBufN	; convert signed INT - get length
		add	esi,eax		; increase text length
		pop	edx		; pop EDX
		jmp	short FormToTxtNOK2 ; read next character

Znaky "d", "D" a "i" jsou indikátory celého dekadického čísla se znaménkem. Pro znak "D" se nastaví příznak velkého písmene a dále se pokračuje společnou obsluhou.

Do registru EBX se uloží příznak celočíselného dekadického čísla se znaménkem FORMTYPE_Int. Voláním funkce FormToTextGet se do registrového páru EDX:EAX načte hodnota argumentu. V případě neplatného indexu argumentu se funkce ukončí s chybou. Pokud nebyla zadána přesnost, nastaví se do registru BL implicitní přesnost 1. Voláním funkce IntToTextBufN se zjistí délka textu a přičte se ke střadači ESI.


; ------------- Unsigned decimal int "u", "U"

FormToTxtNUC:	bts	ebx,FORMTYPE_Cap_b ; set flag "capital"
FormToTxtNUS:	or	ebx,(FORMTYPE_UInt<<FORMPAR_TypeF_b)
		push	edx		; push EDX
		call	FormToTextGet	; get parameters
		jc	short FormToTxtNErr2 ; invalid argument index
		jnz	FormToTxtNUS2	; no default precision
		mov	bl,1		; BL <- 1, default precision
FormToTxtNUS2:	call	UIntToTextBufN	; convert unsigned INT - get length
		add	esi,eax		; increase text length (and clear CF)
FormToTxtNErr2:	pop	edx		; pop EDX
		jc	FormToTextBufN8	; invalid argument index
FormToTxtNOK2:	jmp	FormToTextBufN2	; read next character

Znaky "u" a "U" jsou indikátory celého dekadického čísla bez znaménka. Pro znak "U" se nastaví příznak velkého písmene a dále se pokračuje společnou obsluhou.

Do registru EBX se uloží příznak celočíselného dekadického čísla bez znaménka FORMTYPE_UInt. Voláním funkce FormToTextGet se do registrového páru EDX:EAX načte hodnota argumentu. V případě neplatného indexu argumentu se funkce ukončí s chybou. Pokud nebyla zadána přesnost, nastaví se do registru BL implicitní přesnost 1. Voláním funkce UIntToTextBufN se zjistí délka textu a přičte se ke střadači ESI.


; ------------- Unsigned binary int "b", "B"

FormToTxtNBC:	bts	ebx,FORMTYPE_Cap_b ; set flag "capital"
FormToTxtNBS:	or	ebx,(FORMTYPE_Bin<<FORMPAR_TypeF_b)
		push	edx		; push EDX
		call	FormToTextGet	; get parameters
		jc	short FormToTxtNErr2 ; invalid argument index
		jnz	FormToTxtNBS2	; no default precision
		mov	bl,1		; BL <- 1, default precision
FormToTxtNBS2:	call	BinToTextBufN	; convert BIN number - get length
		add	esi,eax		; increase text length
		pop	edx		; pop EDX
		jmp	short FormToTxtNOK2 ; read next character

Znaky "b" a "B" jsou indikátory celého binárního čísla bez znaménka. Pro znak "B" se nastaví příznak velkého písmene a dále se pokračuje společnou obsluhou.

Do registru EBX se uloží příznak celočíselného binárního čísla bez znaménka FORMTYPE_Bin. Voláním funkce FormToTextGet se do registrového páru EDX:EAX načte hodnota argumentu. V případě neplatného indexu argumentu se funkce ukončí s chybou. Pokud nebyla zadána přesnost, nastaví se do registru BL implicitní přesnost 1. Voláním funkce BinToTextBufN se zjistí délka textu a přičte se ke střadači ESI.


; ------------- Unsigned octal int "o", "O"

FormToTxtNOC:	bts	ebx,FORMTYPE_Cap_b ; set flag "capital"
FormToTxtNOS:	or	ebx,(FORMTYPE_Oct<<FORMPAR_TypeF_b)
		push	edx		; push EDX
		call	FormToTextGet	; get parameters
		jc	short FormToTxtNErr2 ; invalid argument index
		jnz	FormToTxtNOS2	; no default precision
		mov	bl,1		; BL <- 1, default precision
FormToTxtNOS2:	call	OctToTextBufN	; convert OCT number - get length
		add	esi,eax		; increase text length
		pop	edx		; op EDX
		jmp	short FormToTxtNOK2 ; read next character

Znaky "o" a "O" jsou indikátory celého oktalového čísla bez znaménka. Pro znak "O" se nastaví příznak velkého písmene a dále se pokračuje společnou obsluhou.

Do registru EBX se uloží příznak celočíselného oktalového čísla bez znaménka FORMTYPE_Oct. Voláním funkce FormToTextGet se do registrového páru EDX:EAX načte hodnota argumentu. V případě neplatného indexu argumentu se funkce ukončí s chybou. Pokud nebyla zadána přesnost, nastaví se do registru BL implicitní přesnost 1. Voláním funkce OctToTextBufN se zjistí délka textu a přičte se ke střadači ESI.


; ------------- Unsigned hex int "x", "X"

FormToTxtNXC:	bts	ebx,FORMTYPE_Cap_b ; set flag "capital"
FormToTxtNXS:	or	ebx,(FORMTYPE_Hex<<FORMPAR_TypeF_b)
		push	edx		; push EDX
		call	FormToTextGet	; get parameters
		jc	short FormToTxtNErr ; invalid argument index
		jnz	FormToTxtNXS2	; no default precision
		mov	bl,1		; BL <- 1, default precision
FormToTxtNXS2:	call	HexToTextBufN	; convert HEX - get length
		add	esi,eax		; increase text length
		pop	edx		; pop EDX
		jmp	short FormToTxtNOK ; read next character

Znaky "x" a "X" jsou indikátory celého hexadecimálního čísla bez znaménka. Pro znak "X" se nastaví příznak velkého písmene a dále se pokračuje společnou obsluhou.

Do registru EBX se uloží příznak celočíselného hexadecimálního čísla bez znaménka FORMTYPE_Hex. Voláním funkce FormToTextGet se do registrového páru EDX:EAX načte hodnota argumentu. V případě neplatného indexu argumentu se funkce ukončí s chybou. Pokud nebyla zadána přesnost, nastaví se do registru BL implicitní přesnost 1. Voláním funkce HexToTextBufN se zjistí délka textu a přičte se ke střadači ESI.


; ------------- Character "C", "c"

FormToTxtNCC:	bts	ebx,FORMTYPE_Cap_b ; set flag "capital"
FormToTxtNCS:	or	ebx,(FORMTYPE_Char<<FORMPAR_TypeF_b)
		push	edx		; push EDX
		call	FormToTextGet	; get parameters
		jc	short FormToTxtNErr ; invalid argument index
		pop	edx		; pop EDX
		xchg	esi,edi		; EDI <- data counter
		call	CharUTF8Size	; get size of UTF-8 character
		xchg	esi,edi		; ESI <- data counter
		jmp	short FormToTxtNOK ; read next character

Znaky "c" a "C" jsou indikátory jednoho znaku v Unicode kódu. Pro znak "C" se nastaví příznak velkého písmene a dále se pokračuje společnou obsluhou.

Do registru EBX se uloží příznak znaku Unicode FORMTYPE_Char. Voláním funkce FormToTextGet se do registru EAX načte hodnota argumentu. V případě neplatného indexu argumentu se funkce ukončí s chybou. Voláním funkce CharUTF8Size se zjistí délka textu a přičte se ke střadači ESI.


; ------------- String "S", "s"

FormToTxtNSC:	bts	ebx,FORMTYPE_Cap_b ; set flag "capital"
FormToTxtNSS:	or	ebx,(FORMTYPE_String<<FORMPAR_TypeF_b)
		push	edx		; push EDX
		call	FormToTextGet	; get parameters
		jc	short FormToTxtNErr ; invalid argument index
		call	FormToTextLim	; limit text length by precision
		add	esi,edx		; ESI <- add text length
FormToTxtNErr:	pop	edx		; pop EDX
		jc	FormToTextBufN8	; invalid argument index
FormToTxtNOK:	jmp	FormToTextBufN2	; read next character

Znaky "s" a "S" jsou indikátory textu v kódu UTF-8. Pro znak "S" se nastaví příznak velkého písmene a dále se pokračuje společnou obsluhou.

Do registru EBX se uloží příznak textu FORMTYPE_String. Voláním funkce FormToTextGet se do registru EAX načte ukazatel na text v kódu UTF-8 a do registru EDX délka textu v bajtech. V případě neplatného indexu argumentu se funkce ukončí s chybou.

Voláním funkce FormToTextLim se délka omezí podle zadaného argumentu přesnosti a přičte se ke střadači ESI.


; ------------- Floating point "f", "F"

FormToTxtNFC:	bts	ebx,FORMTYPE_Cap_b ; set flag "capital"
FormToTxtNFS:	or	ebx,(FORMTYPE_Float<<FORMPAR_TypeF_b)
		push	edx		; push EDX
		call	FormToTextGet	; get parameters
		jc	short FormToTxtNErr ; invalid argument index
		jnz	FormToTxtNFS2	; no default precision
		mov	bl,6		; BL <- 6, default precision
FormToTxtNFS2:	pop	edx		; pop EDX
		call	FltToTextBufN	; convert float number - get length
		add	esi,eax		; increase text length
		ffreep	st0		; free number from FPU stack
		jmp	short FormToTxtNOK ; read next character

Znaky "f" a "F" jsou indikátory desetinného čísla bez exponentu. Pro znak "F" se nastaví příznak velkého písmene a dále se pokračuje společnou obsluhou.

Do registru EBX se uloží příznak desetinného čísla bez exponentu FORMTYPE_Float. Voláním funkce FormToTextGet se do registru ST0 načte hodnota argumentu. V případě neplatného indexu argumentu se funkce ukončí s chybou. Pokud nebyla zadána přesnost, nastaví se do registru BL implicitní přesnost 6. Voláním funkce FltToTextBufN se zjistí délka textu a přičte se ke střadači ESI. Po návratu z funkce se číslo uvolní ze zásobníku koprocesoru instrukcí ffreep.


; ------------- Exponential "e", "E"

FormToTxtNEC:	bts	ebx,FORMTYPE_Cap_b ; set flag "capital"
FormToTxtNES:	or	ebx,(FORMTYPE_Exp<<FORMPAR_TypeF_b)
		push	edx		; push EDX
		call	FormToTextGet	; get parameters
		jc	short FormToTxtNErr ; invalid argument index
		jnz	FormToTxtNES2	; no default precision
		mov	bl,6		; BL <- 6, default precision
FormToTxtNES2:	pop	edx		; pop EDX
		call	ExpToTextBufN	; convert exponent - get length
		add	esi,eax		; increase text length
		ffreep	st0		; free number from FPU stack
		jmp	short FormToTxtNOK ; read next character

Znaky "e" a "E" jsou indikátory desetinného čísla s exponentem. Pro znak "E" se nastaví příznak velkého písmene a dále se pokračuje společnou obsluhou.

Do registru EBX se uloží příznak desetinného čísla s exponentem FORMTYPE_Exp. Voláním funkce FormToTextGet se do registru ST0 načte hodnota argumentu. V případě neplatného indexu argumentu se funkce ukončí s chybou. Pokud nebyla zadána přesnost, nastaví se do registru BL implicitní přesnost 6. Voláním funkce ExpToTextBufN se zjistí délka textu a přičte se ke střadači ESI. Po návratu z funkce se číslo uvolní ze zásobníku koprocesoru instrukcí ffreep.


; ------------- Mixed "g", "G"

FormToTxtNGC:	bts	ebx,FORMTYPE_Cap_b ; set flag "capital"
FormToTxtNGS:	or	ebx,(FORMTYPE_Mix<<FORMPAR_TypeF_b)
		push	edx		; push EDX
		call	FormToTextGet	; get parameters
		jc	short FormToTxtNErr ; invalid argument index
		jnz	FormToTxtNGS2	; no default precision
		mov	bl,6		; BL <- 6, default precision
FormToTxtNGS2:	pop	edx		; pop EDX
		call	MixToTextBufN	; convert mixed - get length
		add	esi,eax		; increase text length
		ffreep	st0		; free number from FPU stack
		jmp	short FormToTxtNOK ; read next character

Znaky "g" a "G" jsou indikátory desetinného čísla ve smíšeném tvaru. Pro znak "G" se nastaví příznak velkého písmene a dále se pokračuje společnou obsluhou.

Do registru EBX se uloží příznak desetinného čísla ve smíšeném tvaru FORMTYPE_Mix. Voláním funkce FormToTextGet se do registru ST0 načte hodnota argumentu. V případě neplatného indexu argumentu se funkce ukončí s chybou. Pokud nebyla zadána přesnost, nastaví se do registru BL implicitní přesnost 6. Voláním funkce MixToTextBufN se zjistí délka textu a přičte se ke střadači ESI. Po návratu z funkce se číslo uvolní ze zásobníku koprocesoru instrukcí ffreep.

Formátovací řetězec funkce FormToTextBuf
HexToTextBufN		Délka textu formátovaného čísla HEX
BinToTextBufN		Délka textu formátovaného čísla BIN
OctToTextBufN		Délka textu formátovaného čísla OCT
IntToTextBufN		Délka textu formátovaného čísla INT se znaménkem
UIntToTextBufN		Délka textu formátovaného čísla INT bez znaménka
FltToTextBufN		Délka textu formátovaného desetinného čísla
ExpToTextBufN		Délka textu formátovaného čísla s exponentem
MixToTextBufN		Délka textu formátovaného smíšeného desetinného čísla
FormToTextBuf		Zformátování textu do bufferu