The BBC and Master Computer Public Domain Library

A118 NUMASC (Numeric value to ASCII String conversion)

Submitted by Steve Fewell

Routine:numasc
Name: NUMASC (Numeric value to ASCII String conversion)
Starting Address: &A118
Entry criteria: Either the IWA or the FWA contains the numeric value to convert into ASCII (for printing to the screen, etc...).
&15 is negative if the value should be converted to ASCII with a Hexadecimal representation of the value.
Y is negative if the value is a Floating-Point value (stored in the FWA), or positive
if the value is an Integer value (stored in the IWA).
Exit: The SWA contains the ASCII result.

Description:

A118 - A137: validate the format & number of digits to print
The format that the number will be converted to and the number of digits to print
is specified by variable @%. This variable consists of 4 bytes with the following meanings:
Byte 4: Conains a non-zero value if STR$ function should use @% Number conversion format (default value 0).

Byte 3: Contains one of the following:

0 - for General format (e.g. nnn.nnn), Byte 2 contains max digits printed

1 - for Exponential format (e.g. n.nnnnnEnn), Byte 2 contains number of digits printed

2 - for Fixed format (e.g. nnn.nnnnn), Byte 2 contains numberof digits after decimal point to print

The default value for byte 3 is 0 (general format).

Byte 2: Has the following meanings depending on Format type:

If General format, contains number of digits to print before Exponential format needs to be used.

If Exponential format, contains maximum number of significant digits to be printed after the decimal point.

If Fixed format, contains exact number of digits required to follow the decimal point.

The default value for byte 2 is 9 (print 9 decimals).

Byte 1: Print field width (0-255) (when using the PRINT statement with commas).
Only bytes 3 and 2 are used by the NUMASC routine. The default value for byte 1 is 10.

This routine sets &37 to a copy of byte 3 and &4D to a copy of byte 2.
If the Format is not between 0 to 2, then &37 (format) is set to 0.
If the Number of decimals is not between 0 to 10, then &4D (decimals) is set to 10.
If the Format is not 2 (Fixed) and the number of decimals is 0 then set &4D (decimals)
to 10.
If this routine is called from location &A132, then the @% format settings will not be used.

A138 - A154: Initialise & Convert numeric value to Float & handle 0.00 valuet
Sets &36 to zero (SWA length), as we are starting with a blank string.
Set &48 to zero (this is the Exponential value (the value printed after the 'E')).
If &15 is negative then convert the numeric value to an ASCII string in Hexadecimal notation (&A0CA).
If the numeric value is an Integer (Y is positive, most likely #&40, which means Integer) then
convert the Integer value to a Float (storing the result in the FWA). This is so that the routine
only needs to handle Floating-Point values (i.e. one format of storage).
Call routine &A3F2 to obtain the sign of the Floating-Point value.
If the sign is 0 then the value is 0.00, so if the format is 1 (exponential) or 2 (Fixed) then
jump to &A1D0 to print the value 0.00 in that format; Otherwise, set A to "0" and jump to &A2D0
to add a single 0 to the SWA, and exit.
If the value is not 0.00 then jump to &A102 to check the value.

A0CA - A101: Convert Numeric value to ASCII String in Hexadecimal notation
If the Numeric value is a Floating-Point value (Y is negative) then call &96C3 to convert the
Floating-Point value to Integer and put the result in the IWA.
This is because only the Integer portion of Hexadecimal values is converted.
Additionally, the Hexadecimal conversion for negative values is in two's complement format,
I.e. -4 in BASIC's Hexadecimal format ('~') is &FFFFFFFC.

Set X and Y to zero. Y is the current byte offset and X is the next free location for the Hex values.

Loop for each byte of the IWA value. For each byte do the following:

* Get the next byte of the Integer value (LSB first) and push this value to the stack.

* Clear the top half (top 4 bits of the value). This leaves the lower Hex digit of the 2-digit byte
   (4 bits per digit).

* Store the Hex digit (lower half of byte) in the next location (&3F-&46) and increment X.

* Pop the byte from the Stack. Divide this value by 8 (to get rid of the lower 4-bits
   of the value) and move the top 4-bits to the lower half of the byte.

* Store the Hex digit (top half of byte) in the next location (&3F-&46) and increment X.

* Increment Y (byte offset) to point to the next byte in the IWA.

* If the byte offset (Y) is less than 4 then loop again.

Now, locations &3F to &46 contain the 8 Hex digit values for the Integer value in the IWA.

Now, loop for each of the Hex dgits (starting at the last one, &46, which is the most significant digit).
For each digit, check if it is zero. If it is zero (and it isn't the first digit) then skip it,
as we do not want leading zeros in the ASCII string value.

When we have found the first non-zero digit, or the last digit (if all other digits are zero),
then we can begin to add the digits to the SWA (ASCII string value).
To add a digit, add #&30 to the value (plus an extra #&07 if the digit is 10-15 ['A'-'F']).
Now, we have the ASCII value for the Hex digit, so call routine &A2D0 to add the ASCII character
to the end of the existing SWA string value.
Next, decrement X and repeat the adding digit to SWA process for the other digits.
When X is negative then we have finished as the last digit added to the SWA value was the least
significant digit of the hexadecimal value.

Finally exit as we have finished the ASCNUM conversion.

A102 - A10A: Handle '-' for negative Floating-Point values
If the Floating-Point value is negative (the FWA sign routine returned with the negative flag set)
so add a leading '-' to the SWA (ASCII String) output value [via routine &A2D0].

A10B - A117: Multiply Floating-Point value until it is >= 1
Test the FWA exponent, if the exponent is more than or equal to #&81 then jump to &A15C to
check that the Floating-Point value is less than 1.
If the FWA exponent is less than #&81 then the FWA value is less than 1 so multiply the
numeric value by 10 [via routine &A436] and decrement &48 (the Exponent value).
Keep repeating this until the FWA exponent is >=&81 (i.e. we have a value with an Integer part
between 1 and 9.99999999 - this representation will aid the conversion to ASCII procedure).
When the value is within the required range then jump to &A15C.

A15C - A16E: Divide Floating-Point value until it is <= 9.9999999999
Test the FWA exponent, if the exponent is less then #&84 then jump to &A16F as
the FWA value is within the required range (less than 10).
If the FWA exponent is equal to #&84 then check the FWA Mantissa byte 1 (MSB) value.
If the FWA Mantissa byte 1 value is less ten &A0 then the FWA contains a value less
than 10, so jump to &A16F to continue the conversion procedure.
Otherwise the FWA value is >&eq;10, so divide the numeric value by 10 [via routine &A478]
and increment &48 (the Exponent value).
Jump back to &A10B to check the FWA value again.
Keep repeating this until the FWA contains a value between 1 and 9.99999999, and then
jump to &A16F to continue the conversion to ASCII procedure.

A16F - A1CF: Check that the value can be printed in the requested format
At this stage the Floating-Point value is between 1.0 and 9.99999999999, and &48 contains the
base 10 exponent value (so that the original value can be determined).

Temporarily store the FWA rounding byte (&35) into location &27 and store the FWA value
as a packed Floating-Point variable at location &046C-&0470.
The rounding byte needs to be stored separately as it is not included in the packed variable.

If the requested format is Fixed-Point then check the following:

* Add the number of digits required to follow the decimal point (&4D) to the exponent (&48).

* If the result is negative then the Floating-Point value is too small to fix to the number of decimal

   places suggested, so set the FWA to 0.00 & zero the exponent (&48) [by jumping to &A1D4].

* If the result is less than 11 then the value will fit in the display field (without the need to

   display the 'E' value (as in the exponential format)).

* Otherwise, if the result is more than 11 then the value's exponent is too large to display in Fixed-point

   format without including the exponent value as part of the output, so set the number of digits

   (&38) to 10 and set the format to 0 (general), so that the 'E' part of the value will be output.

[A190] Set the FWA to 5.0 and divide this value by 10 * The number of digits to output.
I.e. if the number of digits to output is 9 then set FWA to 0.000000005.
Unpack the temporary Floating-Point variable stored at &046C-&0470 (i.e. the numeric
value that we are outputting) to the FWB, and restore the
Rounding byte (that we temporarily stored to &27).
Add the FWB number to the FWA value. This will round up the last significant digit (that we are outputting)
if the entire numeric value cannot be outputted (to the required number of decimals) and the next
(non-outputted) digit is >&eq;5.

If the FWA exponent is less than #&84 then keep dividing the FWA mantissa by 2 and incrementing the FWA exponent
until the FWA exponent >&eq;#&84. This will make sure that the FWA value is >&eq;1 if the calculations
above caused the FWA value to drop below 1.0.
If the FWA exponent is more than #&A0 then the calculations above caused the FWA value to be rounded
to more than 10.0, so jump to &A157 to set the FWA value to 1.0 and increment the decimal exponent (&48)
by 1 to result in an actual FWA value of 10.0. This solves the problems caused by the rounding.

If the number of digits is 0 then [&A1D4] set the FWA value to 0.0 and the decimal exponent (&48) to 0,
as there are no digits required to be output.
Otherwise, jump to &A1DE to output the value to the requested number of digits in the requested format.

A1D0 - A1DD: Set Floating-Point value to 0.00 if A is not 1
If the number format requested (A) is 0 (general) or 2 (Fixed) then the FWA value to print is 0.00,
so set the FWA to 0.00 and [&A1D4] zero &48 (the decimal Exponent); next, increment the number
of decimals to print (&38) [from 0 to 1], as 0 decimals were originally requested.

A1DE - A2CF: Convert Floating-Point value to ASCII in required format
If the requested number format is 1 (Exponential format) then [&A215] Set the position of the decimal
point to 1 (&4D) - as in exponential format, the decimal point always appears after the first digit; and
jump to &A217 to convert the Floating-Point value to ASCII.

Otherwise (format is General or Fixed-Point).
If the exponent value (&48) is positive and greater than or equal to the number of decimals to print (&38),
then the value will be converted in Exponential-format (as it is too large to be converted without the 'E'xponent),
so [&A215] Set the position of the decimal point to 1 (&4D) - as in exponential format, the decimal
point always appears after the first digit; & jump to &A217 to convert the
Floating-Point value to ASCII.

If the exponent value (&48) is positive and less than the number of decimals to print (&38),
then the value can be converted without the exponential value, so [&A215] Set the position of the
decimal point (&4D) to the exponential value (&48) plus 1, so that the decimal point will occur in the
correct potition (i.e. value 1E3 will print the decimal point after the 4th digit - as the decimal value is '1000.00'),
clear &48 - the exponential value & jump to &A217 to convert the Floating-Point value to ASCII.

[&A1F2] If the requested format is General and the exponential value is not &FF, then
the Floating-Point value contains a negative exponent that needs to be converted in exponential format.
(i.e. the Floating-Point value is not a single fractional digit, i.e. 0.3), so [&A215] Set the position
of the decimal point to 1 (&4D) and jump to &A217 to convert the Floating-Point
value to ASCII in exponential format. This is because BASIC always converts a general format number to
exponential format if it is smaller than or equal to 0.01.

Otherwise, [&A1FE] The Floating-Point value can be converted in Fixed-Point format
Firstly, add the characters "0." to the output string (SWA), as we are converting a fractional value.
Next, Keep incrementing &48 (the exponent value), until the exponent &48 is zero, for each loop
add a zero "0" to the output string (SWA). This adds the required number of leading zeros to the output value.
Set &4D to #&80. &4D is the number of digits to output before the decimal point (".") is output.
The value &80 means that routine section &A217-&A2CF will not output a decimal point (as it has
already been output). Now, continue with the next routine section - &A217.

A217 - A2CF: Convert the Floating-Point value to ASCII string (in SWA)
Call &A26C to add the top digit of the Floating-Point (FWA) Mantissa value to the output string and
then remove the top digit and multiply the rest of the FWA mantissa by 10 (so that the new top digit is the next digit).

&A26C does the following:

1) Load FWA Mantissa byte 1 and divide it by 8 (to place the top 4 bits in the lower 4 bits - also
clearing the top 4 bits.

2) Call &A2CE to ORA the 4 lower bits (from step 1) with #&30 (this adds &30 to the digit
value, and thus converts the digit from a numeric value to ASCII value (offset from 48)) and continue to
&A2D0 to add the digit to the output string.

3) Set the top 4 bits of the FWA mantissa to zero (this removes the digit that we have just output from
the FWA mantissa value).

4) Store result from step 3, and FWA Mantissa bytes &31 to &33 to the stack.
Set X to &34 and A to &35.

5) Multiply FWA Mantissa (A and Mantissa bytes &34 to &31) by 4

6) Add the FWA Mantissa values (now, multiplied by 4) to the previous FWA mantissa values (before
the multiplication, stored in &35, X and the other 3 bytes from the Stack).

7) Now the FWA mantissa has been multiplied by 5 (4 plus 1), so multiply the FWA mantissa again, this
time by 2, in order to achieve the desired result of multipling the FWA value by 10.

8) Exit with A = the lower 4 bits of &31 (before the multiplication by 10 occurred).

Next, decrement &4D (the number of digits to output before the decimal point value).
If &4D has reached zero then add a decimal point, ".", to the output string.

Decrement &38, the number of decinals to print, and if this value hasn't reached zero then there
are still further digits to print, so jump back to &A217 to output the next digit.

Now, all required digits have been added to the output string.

If the output format is 0 (general) then strip any trailing zeros and decimal points, as follows:

1) Set Y to &36; i.e. the next free character in the output string.

2) Decrement Y (to point to the next character from the end of the output value).

3) If the current last character (&0600, Y) is zero then go back to step 2 (to skip all trailing zeros)

4) If the current last character is a decimal point then skip this also.

5) Now Y points to the actual length of the value, excluding any training zeros and decimal points, so
store Y in &36 to set the new length of the output string (SWA).

If the output format is 2 (fixed-point) or 0 (general) and the Exponent (&48) is zero then exit.
Otherwise, there is an exponent value to output.

The exponent value is outputted as follows:

1) Add "E" to the output string value.

2) If &48 is negative then add "-" to the output string and subtract the exponent (&48) from zero to
obtain the positive exponent value (reverse the two's compliment).

3) [&A2BF] Keep subtracting 10 from the exponent value and incrementing X until the exponent value
is less than 10. Now X contains the ten's part (first digit) of the exponent value.

4) A now contains the number of units, the second digit of the exponent value. Store this value on the stack.

5) If the number of ten's (X) (the first digit) of the exponent value is not zero then set A = X and call &A2D0
to add the digit to the end of the output string.

6) Pop the number of units (second digit) in the exponent value from the stack, and call &A2D0 to add
the digit to the end of the output string.

7) If the output format (&37) is 0 (general) then exit.
Otherwise, we may need to add spaces to the end of the output value, to ensure that the exponent value
lines up with other printed numerical values.

8) If the exponent value (&48) is positive then add a space to the end of the output string (to make
up for the "-" that we didn't need to add!).

9) If X is zero (the exponent was 1 digit long, no ten's value) then add a space to the end of the output
string (to make up for the extra digit that we did not need to add!).

Exit from the routine as the SWA now contains the original numerical value (from the FWA) converted to ASCII format.
Note: this routine does not preserve the original value of the FWA.


A2D0 - A2D9: Add character to the end of the current ASCII value
Temporarily store X on the stack.
Store the ASCII character in A in location &0600 + &36 (the end of the current SWA value).
Retrieve X from the stack.
Increment &36, so that the SWA length is now correctly incrememted by 1 character and return.

Examples:

Example 1:
Value = 1000 (FWA Exponent is &8A, FWA Mantissa is &FA)
Output format = 0 (General format).
The NUMASC routine will process this value as follows:
[&A10B] The FWA exponent is > &83, so divide the FWA by 10 and increment the decimal exponent.
Now, FWA = 100 (Exponent &87, Mantissa &C8). &48 = 1.
The FWA exponent is > &83, so divide the FWA by 10 and increment the decimal exponent.
Now, FWA = 10 (Exponent &84, Mantissa &A0). &48 = 2.
The FWA exponent is > &83, so divide the FWA by 10 and increment the decimal exponent.
Now, FWA = 1 (Exponent &81, Mantissa &80). &48 = 3.

[&A16F] ?&38 = ?&4D (9).
Output format is not 2 so goto &A190.
Decimals (?&38) is 9, so the roundup value is 0.000000005.
Add roundup value to numeric value = 1.000000005 (Exponent = &81, Mantissa = &8000000ABC).
FWA Exponent is < &84, so divide FWA by 2 & increment exponent; FWA now = 1.000000005 (Exp: &82, Mantissa: &400000055E)
FWA Exponent is < &84, so divide FWA by 2 & increment exponent; FWA now = 1.000000005 (Exp: &83, Mantissa: &20000002AF)
FWA Exponent is < &84, so divide FWA by 2 & increment exponent; FWA now = 1.000000005 (Exp: &84, Mantissa: &1000000157)

[&A1C6] FWA Mantissa byte 1 is less than #&A0, so okay, continue to &A1DE.
[&A1DE] Format is not scientific and Exponent is not negative or greater than &48 (the number of digits
to print, so the value can be outputted without the exponent, so set &48 to zero.
The exponent is not #&FF so jump to &A215.
[&A215] Set ?&4D to decimal point position (A) = position 4 in the output string.
[&A217] Call &A26C (output top digit "1", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&0000000D66)
Decrement &4D to 3; &4D is not zero, so [&A223] Decrement &38 to 8; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&00000085FC)
Decrement &4D to 2; &4D is not zero, so [&A223] Decrement &38 to 7; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&0000053BD8)
Decrement &4D to 1; &4D is not zero, so [&A223] Decrement &38 to 6; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&0000345670)
Decrement &4D to 0; &4D is zero, so [&A21E] Add "." to the output string.
Decrement &38 to 5; (no decrement for the "." as it isn't a significant digit!). Jump to &A217 as &38 not zero.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&00020B6060)
Decrement &4D to &FF; &4D is not zero, so [&A223] Decrement &38 to 4; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&001471C3C0)
Decrement &4D to &FE; &4D is not zero, so [&A223] Decrement &38 to 3; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&00CC71A580)
Decrement &4D to &FD; &4D is not zero, so [&A223] Decrement &38 to 2; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&07FC707700)
Decrement &4D to &FC; &4D is not zero, so [&A223] Decrement &38 to 1; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&4FDC64A600)
Decrement &4D to &FB; &4D is not zero, so [&A223] Decrement &38 to 0; &38 is now zero so goto &A227.

[&A227] Now the output string is contained in SWA locations &600-&609, which contain the value "1000.00000".
Strip any trailing "0" and "."-characters from the value, now the value is "1000".
The Exponent value (&48) is zero, meaning that there is no exponent to print, so exit.

Example 2:
Value = 28.96301767 (FWA Exponent is &85, FWA Mantissa is &E7B4429C00)
Output format = 1 (Exponential format).
The NUMASC routine will process this value as follows:
[&A10B] The FWA exponent is > &83, so divide the FWA by 10 and increment the decimal exponent.
Now, FWA = 2.896301767 (Exponent &82, Mantissa &B95D021666). &48 = 1.

[&A16F] ?&38 = ?&4D (9).
Output format is not 2 so goto &A190.
Decimals (?&38) is 9, so the roundup value is 0.000000005.
Add roundup value to numeric value = 2.896301772 (Exponent = &82, Mantissa = &B95D021BC4).
FWA Exponent is < &84, so divide FWA by 2 & increment exponent; FWA now = 2.896301772 (Exp: &83, Mantissa: &5CAE810DE2)
FWA Exponent is < &84, so divide FWA by 2 & increment exponent; FWA now = 2.896301772 (Exp: &84, Mantissa: &2E574086F1)

[&A1C6] FWA Mantissa byte 1 is less than #&A0, so okay, continue to &A1DE.
[&A1DE] Format is scientific so jump to &A215
[&A215] Set ?&4D to decimal point position (A) = position 1 in the output string (as we are outputting in
exponential format).
[&A217] Call &A26C (output top digit "2", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&8F6885456A)
Decrement &4D to 0; &4D is zero, so [&A21E] Add "." to the output string.
Decrement &38 to 8; (no decrement for the "." as it isn't a significant digit!). Jump to &A217 as &38 not zero.
[&A217] Call &A26C (output top digit "8", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&9A1534B624)
Decrement &4D to &FF; &4D is not zero, so [&A223] Decrement &38 to 7; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "9", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&64D40F1D68)
Decrement &4D to &FE; &4D is not zero, so [&A223] Decrement &38 to 6; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "6", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&3048972610)
Decrement &4D to &FD; &4D is not zero, so [&A223] Decrement &38 to 5; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "3", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&02D5E77CA0)
Decrement &4D to &FC; &4D is not zero, so [&A223] Decrement &38 to 4; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&1C5B0ADE40)
Decrement &4D to &FB; &4D is not zero, so [&A223] Decrement &38 to 3; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "1", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&7B8E6CAE80)
Decrement &4D to &FA; &4D is not zero, so [&A223] Decrement &38 to 2; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "7", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&73903ED100)
Decrement &4D to &F9; &4D is not zero, so [&A223] Decrement &38 to 1; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "7", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&23A2742A00)
Decrement &4D to &F8; &4D is not zero, so [&A223] Decrement &38 to 0; &38 is now zero so goto &A244.

[&A244] Now the output string is contained in SWA locations &600-&609, which contain the value "2.89630177".
The output format is exponential, so add "E" to the output string (for the exponent).
The Exponent value (&48) is positive (1), so no minus sign required.
Call &A2BC to add the exponent to the output string - "1" is added.
The exponent was not negative, so add a space to the end of the output string.
The exponent was only 1-digit long, so add a space to the end of the output string.
The SWA output string value is now: "2.89630177E1 " so exit as complete.

Example 3:
Value = 3.1417321E-5 (FWA Exponent is &72, FWA Mantissa is &8F55347000)
Output format = 2 (Fixed-Point format).
The NUMASC routine will process this value as follows:
[&A10B] The FWA exponent is < &81, so multiply the FWA by 10 and increment the decimal exponent.
Now, FWA = 0.0003417321 (Exponent &75, Mantissa &B32A818C). &48 = &FF.
The FWA exponent is < &81, so multiply the FWA by 10 and increment the decimal exponent.
Now, FWA = 0.003417321 (Exponent &78, Mantissa &EFF521EF). &48 = &FE.
The FWA exponent is < &81, so multiply the FWA by 10 and increment the decimal exponent.
Now, FWA = 0.03417321 (Exponent &7C, Mantissa &8BF93536). &48 = &FD.
The FWA exponent is < &81, so multiply the FWA by 10 and increment the decimal exponent.
Now, FWA = 0.3417321 (Exponent &7F, Mantissa &AEF78283). &48 = &FC.
The FWA exponent is < &81, so multiply the FWA by 10 and increment the decimal exponent.
Now, FWA = 3.417321 (Exponent &82, Mantissa &DAB5632366). &48 = &FB.

[&A16F] ?&38 = ?&4D (9).
Output format is 2 (fixed) so do the following:
Add &48 (decimal exponent) to &38 (decimals to output) = &FB + 9 + 1 (carry) = &05.
The result (&05) is < #&0B, so Set &38 (digits to output) to 5 (the result), zero the exponent (&48),
and goto &A190.
[&A190] Decimals is 9, so the roundup value is 0.000000005.
Add roundup value to numeric value = 3.417321005 (Exponent = &82, Mantissa = &DAB56328C4).
FWA Exponent is < &84, so divide FWA by 2 & increment exponent; FWA now = 3.417321005 (Exp: &83, Mantissa: &6D5AB19462)
FWA Exponent is < &84, so divide FWA by 2 & increment exponent; FWA now = 3.417321005 (Exp: &84, Mantissa: &36AD58CA31)

[&A1C6] FWA Mantissa byte 1 is less than #&A0, so okay, continue to &A1E4.
[&A1DE] The exponent is negative and format is 2 (Fixed), so goto &A1FE.
[&A1FE] Add "0." to the output string (SWA).
Increment the Exponent value (&48), and keep adding "0" to the output string until &48 is 0.
Now the output string is "0.0000".
[&A213] Set ?&4D to &80 (as we do not need to print a decimal point now).
[&A217] Call &A26C (output top digit "3", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&42C577E5EA)
Decrement &4D to &7F; &4D is not zero, so [&A223] Decrement &38 to 4; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "4", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&1BB6AEFB24)
Decrement &4D to &7E; &4D is not zero, so [&A223] Decrement &38 to 3; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "1", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&7522D5CF68)
Decrement &4D to &7D; &4D is not zero, so [&A223] Decrement &38 to 2; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "7", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&335C5A1A10)
Decrement &4D to &7C; &4D is not zero, so [&A223] Decrement &38 to 1; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "3", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&219B8504A0)
Decrement &4D to &7B; &4D is not zero, so [&A223] Decrement &38 to 0; &38 is now zero so goto &A240.
[&A240] The exponent (&48) is zero so exit with SWA = "0.000034173".

Example 4:
value = 8.92381E-10 (FWA Exponent is &62, FWA Mantissa is &F54BBAF5)
Output format = 0 (General format).
The NUMASC routine will process this value as follows:
[&A10B] While the FWA exponent is < &81, so multiply the FWA by 10 and increment the decimal exponent.
Now, FWA = 8.92381 (Exponent &84, Mantissa &8EC7ECFEB7). &48 = &F6 (-10).

[&A16F] ?&38 = ?&4D (9).
Output format is not 2 so goto &A190.
Decimals (?&38) is 9, so the roundup value is 0.000000005.
Add roundup value to numeric value = 8.923810005 (Exponent = &84, Mantissa = &8EC7ED000E).

[&A1C6] FWA Mantissa byte 1 is less than #&A0, so okay, continue to &A1E4.
[&A1E4] The Exponent is negative, so [&A1F4] check whether the exponent is = #&FF
as a single zero before the first non-zero digit after the decimal point is the threshold for the
general output format. Our value does not meet this threshold, so store 1 in &4D (output in Exponential format).

[&A217] Call &A26C (output top digit "8", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&93CF42008C)
Decrement &4D to 0; &4D is zero, so [&A21E] Add "." to the output string.
Decrement &38 to 8; (no decrement for the "." as it isn't a significant digit!). Jump to &A217 as &38 not zero.
[&A217] Call &A26C (output top digit "9", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&2618940578)
Decrement &4D to &FF; &4D is not zero, so [&A223] Decrement &38 to 7; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "2", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&3CF5C836B0)
Decrement &4D to &FE; &4D is not zero, so [&A223] Decrement &38 to 6; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "3", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&8199D222E0)
Decrement &4D to &FD; &4D is not zero, so [&A223] Decrement &38 to 5; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "8", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&1002355CC0)
Decrement &4D to &FC; &4D is not zero, so [&A223] Decrement &38 to 4; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "1", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&0016159F80)
Decrement &4D to &FB; &4D is not zero, so [&A223] Decrement &38 to 3; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&00DCD83B00)
Decrement &4D to &FA; &4D is not zero, so [&A223] Decrement &38 to 2; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&08A0724E00)
Decrement &4D to &F9; &4D is not zero, so [&A223] Decrement &38 to 1; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&5644770C00)
Decrement &4D to &F8; &4D is not zero, so [&A223] Decrement &38 to 0; &38 is now zero so goto &A244.

[&A244] Now the output string is contained in SWA locations &600-&609, which contain the value "8.92381000".
The output format is exponential, so add "E" to the output string (for the exponent).
The Exponent value (&48) is negative (-10), so add a minus sign ("-") to the output string.
Call &A2BC to add the exponent to the output string - "10" is added.
The exponent is subtracted from 0 in order to obtain its positive value.
The SWA output string value is now: "8.92381000E-10" so exit as complete.

Example 5:
Value = 0.8 (FWA Exponent is &80, FWA Mantissa is &CCCCCCCD00)
Output format = 2 (Fixed-Point format).
The NUMASC routine will process this value as follows:
[&A10B] The FWA exponent is < &81, so multiply the FWA by 10 and increment the decimal exponent.
Now, FWA = 8.0 (Exponent &84, Mantissa &8000000020). &48 = &FF.

[&A16F] ?&38 = ?&4D (9).
Output format is 2 (fixed) so do the following:
Add &48 (decimal exponent) to &38 (decimals to output) = &FF + 9 + 1 (carry) = &09.
The result (&09) is < #&0B, so Set &38 (digits to output) to 9 (the result), zero the exponent (&48),
and goto &A190.
[&A190] Decimals is 9, so the roundup value is 0.000000005.
Add roundup value to numeric value = 8.000000005 (Exponent = &84, Mantissa = &8000000177).

[&A1C6] FWA Mantissa byte 1 is less than #&A0, so okay, continue to &A1E4.
[&A1E4] The exponent is negative and format is 2 (Fixed), so goto &A1FE.
[&A1FE] Add "0." to the output string (SWA).
Increment the Exponent value (&48), the exponent value is now 0, so there are no further "0"'s to add after the
decimal point. Now the output string is "0.".
[&A213] Set ?&4D to &80 (as we do not need to print a decimal point now).
[&A217] Call &A26C (output top digit "8", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&0000000EA6)
Decrement &4D to &7F; &4D is not zero, so [&A223] Decrement &38 to 8; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&000000927C)
Decrement &4D to &7E; &4D is not zero, so [&A223] Decrement &38 to 7; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&000005B8D8)
Decrement &4D to &7D; &4D is not zero, so [&A223] Decrement &38 to 6; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&0000393870)
Decrement &4D to &7C; &4D is not zero, so [&A223] Decrement &38 to 5; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&00023C3460)
Decrement &4D to &7B; &4D is not zero, so [&A223] Decrement &38 to 4; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&00165A0BC0)
Decrement &4D to &7A; &4D is not zero, so [&A223] Decrement &38 to 3; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&00DF847580)
Decrement &4D to &79; &4D is not zero, so [&A223] Decrement &38 to 2; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&08BB2C9700)
Decrement &4D to &78; &4D is not zero, so [&A223] Decrement &38 to 1; &38 isn't zero so goto &A217.
[&A217] Call &A26C (output top digit "0", & multiply FWA mantissa by 10; now FWA=(Exp=&84, Mantissa=&574FBDE600)
Decrement &4D to &77; &4D is not zero, so [&A223] Decrement &38 to 0; &38 is now zero so goto &A240.
[&A240] The exponent (&48) is zero so exit with SWA = "0.800000000". Note: In Fixed-Point format the trailing
zeros are not stripped.

Disassembly for the NUMASC (Numeric value to ASCII String conversion) routine

Convert numeric value to ASCII (in Hexadecimal notation)

A0CA		152	98	TYA
A0CB		016 003	10 03	BPL 3 --> &A0D0
A0CD		032 195 150	20 C3 96	JSR &96C3 Convert Float to Integer
A0D0		162 000	A2 00	LDX#&00
A0D2		160 000	A0 00	LDY#&00
A0D4	*	185 042 000	B9 2A 00	LDA &002A,Y
A0D7	H	072	48	PHA
A0D8	)	041 015	29 0F	AND#&0F
A0DA	?	149 063	95 3F	STA &3F,X
A0DC	h	104	68	PLA
A0DD	J	074	4A	LSR A
A0DE	J	074	4A	LSR A
A0DF	J	074	4A	LSR A
A0E0	J	074	4A	LSR A
A0E1		232	E8	INX
A0E2	?	149 063	95 3F	STA &3F,X
A0E4		232	E8	INX
A0E5		200	C8	INY
A0E6		192 004	C0 04	CPY#&04
A0E8		208 234	D0 EA	BNE -22 --> &A0D4
A0EA		202	CA	DEX
A0EB		240 004	F0 04	BEQ 4 --> &A0F1
A0ED	?	181 063	B5 3F	LDA &3F,X
A0EF		240 249	F0 F9	BEQ -7 --> &A0EA
A0F1	?	181 063	B5 3F	LDA &3F,X
A0F3		201 010	C9 0A	CMP#&0A
A0F5		144 002	90 02	BCC 2 --> &A0F9
A0F7	i	105 006	69 06	ADC#&06
A0F9	i0	105 048	69 30	ADC#&30
A0FB		032 208 162	20 D0 A2	JSR &A2D0 Add ASCII character to existing output string (SWA)
A0FE		202	CA	DEX
A0FF		016 240	10 F0	BPL -16 --> &A0F1
A101	`	096	60	RTS

Multiply FWA value until number is greater than or equal to 1

A102		016 007	10 07	BPL 7 --> &A10B
A104	-	169 045	A9 2D	LDA#&2D
A106	d.	100 046	64 2E	STZ &2E
A108		032 208 162	20 D0 A2	JSR &A2D0 Add ASCII character to existing output string (SWA)
A10B	0	165 048	A5 30	LDA &30
A10D		201 129	C9 81	CMP#&81
A10F	K	176 075	B0 4B	BCS 75 --> &A15C
A111	6	032 054 164	20 36 A4	JSR &A436 Floating-point multiply by 10 [FWA=FWA*10]
A114	H	198 072	C6 48	DEC &48
A116		128 243	80 F3	BRA -13 --> &A10B

NUMASC : Check conversion formats & conv IWA to FWA & handle zero

A118		174 002 004	AE 02 04	LDX &0402
A11B		224 003	E0 03	CPX#&03
A11D		144 002	90 02	BCC 2 --> &A121
A11F		162 000	A2 00	LDX#&00
A121	7	134 055	86 37	STX &37
A123		173 001 004	AD 01 04	LDA &0401
A126		240 006	F0 06	BEQ 6 --> &A12E
A128		201 010	C9 0A	CMP#&0A
A12A		176 006	B0 06	BCS 6 --> &A132
A12C		128 006	80 06	BRA 6 --> &A134
A12E		224 002	E0 02	CPX#&02
A130		240 002	F0 02	BEQ 2 --> &A134
A132		169 010	A9 0A	LDA#&0A
A134	8	133 056	85 38	STA &38
A136	M	133 077	85 4D	STA &4D
A138	d6	100 054	64 36	STZ &36
A13A	dH	100 072	64 48	STZ &48
A13C	$	036 021	24 15	BIT &15
A13E	0	048 138	30 8A	BMI -118 --> &A0CA
A140		152	98	TYA
A141	0	048 003	30 03	BMI 3 --> &A146
A143		032 133 129	20 85 81	JSR &8185 Convert Integer to Float
A146		032 242 163	20 F2 A3	JSR &A3F2 Obtain Sign of the FWA Floating-Point value
A149		208 183	D0 B7	BNE -73 --> &A102
A14B	7	165 055	A5 37	LDA &37
A14D		208 005	D0 05	BNE 5 --> &A154
A14F	0	169 048	A9 30	LDA#&30
A151	L	076 208 162	4C D0 A2	JMP &A2D0 Add ASCII character to existing output string (SWA)
A154	L	076 208 161	4C D0 A1	JMP &A1D0

Divide FWA value until number is less than 1

A157		032 216 165	20 D8 A5	JSR &A5D8 Set FWA to 1.0
A15A		128 015	80 0F	BRA 15 --> &A16B
A15C		201 132	C9 84	CMP#&84
A15E		144 015	90 0F	BCC 15 --> &A16F
A160		208 006	D0 06	BNE 6 --> &A168
A162	1	165 049	A5 31	LDA &31
A164		201 160	C9 A0	CMP#&A0
A166		144 007	90 07	BCC 7 --> &A16F
A168	x	032 120 164	20 78 A4	JSR &A478 Divide Floating-Point value by 10 [FWA=FWA/10]
A16B	H	230 072	E6 48	INC &48
A16D		128 156	80 9C	BRA -100 --> &A10B

Check the number can be converted to required format

A16F	5	165 053	A5 35	LDA &35
A171	'	133 039	85 27	STA &27
A173		032 017 165	20 11 A5	JSR &A511 Store FWA to &046C & set argp=&046C
A176	M	165 077	A5 4D	LDA &4D
A178	8	133 056	85 38	STA &38
A17A	7	166 055	A6 37	LDX &37
A17C		224 002	E0 02	CPX#&02
A17E		208 016	D0 10	BNE 16 --> &A190
A180	eH	101 072	65 48	ADC &48
A182	0P	048 080	30 50	BMI 80 --> &A1D4
A184	8	133 056	85 38	STA &38
A186		201 011	C9 0B	CMP#&0B
A188		144 006	90 06	BCC 6 --> &A190
A18A		169 010	A9 0A	LDA#&0A
A18C	8	133 056	85 38	STA &38
A18E	d7	100 055	64 37	STZ &37
A190		032 184 166	20 B8 A6	JSR &A6B8 Clear FWA (except Exp/Mantissa1)
A193		169 160	A9 A0	LDA#&A0
A195	1	133 049	85 31	STA &31
A197		169 131	A9 83	LDA#&83
A199	0	133 048	85 30	STA &30
A19B	8	166 056	A6 38	LDX &38
A19D		240 006	F0 06	BEQ 6 --> &A1A5
A19F	x	032 120 164	20 78 A4	JSR &A478 Divide Floating-Point value by 10 [FWA=FWA/10]
A1A2		202	CA	DEX
A1A3		208 250	D0 FA	BNE -6 --> &A19F
A1A5		032 146 165	20 92 A5	JSR &A592 Set argp to &046C
A1A8		032 224 164	20 E0 A4	JSR &A4E0 Unpack (&4A, &4B) variable to FWB
A1AB	'	165 039	A5 27	LDA &27
A1AD	A	133 065	85 41	STA &41
A1AF	h	032 104 131	20 68 83	JSR &8368 Floating-Point Addition
A1B2	0	165 048	A5 30	LDA &30
A1B4		201 132	C9 84	CMP#&84
A1B6		176 014	B0 0E	BCS 14 --> &A1C6
A1B8	f1	102 049	66 31	ROR &31
A1BA	f2	102 050	66 32	ROR &32
A1BC	f3	102 051	66 33	ROR &33
A1BE	f4	102 052	66 34	ROR &34
A1C0	f5	102 053	66 35	ROR &35
A1C2	0	230 048	E6 30	INC &30
A1C4		208 236	D0 EC	BNE -20 --> &A1B2
A1C6	1	165 049	A5 31	LDA &31
A1C8		201 160	C9 A0	CMP#&A0
A1CA		176 139	B0 8B	BCS -117 --> &A157
A1CC	8	165 056	A5 38	LDA &38
A1CE		208 014	D0 0E	BNE 14 --> &A1DE

If A is not 1 then set the FWA value to 0.00

A1D0		201 001	C9 01	CMP#&01
A1D2	A	240 065	F0 41	BEQ 65 --> &A215
A1D4		032 180 166	20 B4 A6	JSR &A6B4	JSR &A6B4 Clear FWA
A1D7	dH	100 072	64 48	STZ &48
A1D9	M	165 077	A5 4D	LDA &4D
A1DB		026	1A	INC A
A1DC	8	133 056	85 38	STA &38

Covert the numeric to the required format

A1DE		169 001	A9 01	LDA#&01
A1E0	7	197 055	C5 37	CMP &37
A1E2	1	240 049	F0 31	BEQ 49 --> &A215
A1E4	H	164 072	A4 48	LDY &48
A1E6	0	048 010	30 0A	BMI 10 --> &A1F2
A1E8	8	196 056	C4 38	CPY &38
A1EA	)	176 041	B0 29	BCS 41 --> &A215
A1EC	dH	100 072	64 48	STZ &48
A1EE		200	C8	INY
A1EF		152	98	TYA
A1F0	#	208 035	D0 23	BNE 35 --> &A215
A1F2	7	165 055	A5 37	LDA &37
A1F4		201 002	C9 02	CMP#&02
A1F6		240 006	F0 06	BEQ 6 --> &A1FE
A1F8		169 001	A9 01	LDA#&01
A1FA		192 255	C0 FF	CPY#&FF
A1FC		208 023	D0 17	BNE 23 --> &A215
A1FE	0	169 048	A9 30	LDA#&30
A200		032 208 162	20 D0 A2	JSR &A2D0 Add ASCII character to existing output string (SWA)
A203	.	169 046	A9 2E	LDA#&2E
A205		032 208 162	20 D0 A2	JSR &A2D0 Add ASCII character to existing output string (SWA)
A208	0	169 048	A9 30	LDA#&30
A20A	H	230 072	E6 48	INC &48
A20C		240 005	F0 05	BEQ 5 --> &A213
A20E		032 208 162	20 D0 A2	JSR &A2D0 Add ASCII character to existing output string (SWA)
A211		128 247	80 F7	BRA -9 --> &A20A
A213		169 128	A9 80	LDA#&80
A215	M	133 077	85 4D	STA &4D
A217	l	032 108 162	20 6C A2	JSR &A26C
A21A	M	198 077	C6 4D	DEC &4D
A21C		208 005	D0 05	BNE 5 --> &A223
A21E	.	169 046	A9 2E	LDA#&2E
A220		032 208 162	20 D0 A2	JSR &A2D0 Add ASCII character to existing output string (SWA)
A223	8	198 056	C6 38	DEC &38
A225		208 240	D0 F0	BNE -16 --> &A217
A227	7	164 055	A4 37	LDY &37
A229		136	88	DEY
A22A		240 024	F0 18	BEQ 24 --> &A244
A22C		136	88	DEY
A22D		240 017	F0 11	BEQ 17 --> &A240
A22F	6	164 054	A4 36	LDY &36
A231		136	88	DEY
A232		185 000 006	B9 00 06	LDA &0600,Y
A235	0	201 048	C9 30	CMP#&30
A237		240 248	F0 F8	BEQ -8 --> &A231
A239	.	201 046	C9 2E	CMP#&2E
A23B		240 001	F0 01	BEQ 1 --> &A23E
A23D		200	C8	INY
A23E	6	132 054	84 36	STY &36
A240	H	165 072	A5 48	LDA &48
A242	'	240 039	F0 27	BEQ 39 --> &A26B
A244	E	169 069	A9 45	LDA#&45
A246		032 208 162	20 D0 A2	JSR &A2D0 Add ASCII character to existing output string (SWA)
A249	H	165 072	A5 48	LDA &48
A24B		016 010	10 0A	BPL 10 --> &A257
A24D	-	169 045	A9 2D	LDA#&2D
A24F		032 208 162	20 D0 A2	JSR &A2D0 Add ASCII character to existing output string (SWA)
A252	8	056	38	SEC
A253		169 000	A9 00	LDA#&00
A255	H	229 072	E5 48	SBC &48
A257		032 188 162	20 BC A2	JSR &A2BC Add exponent to the output string
A25A	7	165 055	A5 37	LDA &37
A25C		240 013	F0 0D	BEQ 13 --> &A26B
A25E		169 032	A9 20	LDA#&20
A260	H	164 072	A4 48	LDY &48
A262	0	048 003	30 03	BMI 3 --> &A267
A264		032 208 162	20 D0 A2	JSR &A2D0 Add ASCII character to existing output string (SWA)
A267		224 000	E0 00	CPX#&00
A269	e	240 101	F0 65	BEQ 101 --> &A2D0 Add ASCII character to existing output string (SWA)
A26B	`	096	60	RTS
A26C	1	165 049	A5 31	LDA &31
A26E	J	074	4A	LSR A
A26F	J	074	4A	LSR A
A270	J	074	4A	LSR A
A271	J	074	4A	LSR A
A272		032 206 162	20 CE A2	JSR &A2CE
A275		169 240	A9 F0	LDA#&F0
A277	1	020 049	14 31	TRB &31
A279	H	072	48	PHA
A27A	4	166 052	A6 34	LDX &34
A27C	1	165 049	A5 31	LDA &31
A27E	H	072	48	PHA
A27F	2	165 050	A5 32	LDA &32
A281	H	072	48	PHA
A282	3	165 051	A5 33	LDA &33
A284	H	072	48	PHA
A285	5	165 053	A5 35	LDA &35
A287		010	0A	ASL A
A288	&4	038 052	26 34	ROL &34
A28A	&3	038 051	26 33	ROL &33
A28C	&2	038 050	26 32	ROL &32
A28E	&1	038 049	26 31	ROL &31
A290		010	0A	ASL A
A291	&4	038 052	26 34	ROL &34
A293	&3	038 051	26 33	ROL &33
A295	&2	038 050	26 32	ROL &32
A297	&1	038 049	26 31	ROL &31
A299	e5	101 053	65 35	ADC &35
A29B	5	133 053	85 35	STA &35
A29D		138	8A	TXA
A29E	e4	101 052	65 34	ADC &34
A2A0	4	133 052	85 34	STA &34
A2A2	h	104	68	PLA
A2A3	e3	101 051	65 33	ADC &33
A2A5	3	133 051	85 33	STA &33
A2A7	h	104	68	PLA
A2A8	e2	101 050	65 32	ADC &32
A2AA	2	133 050	85 32	STA &32
A2AC	h	104	68	PLA
A2AD	e1	101 049	65 31	ADC &31
A2AF	5	006 053	06 35	ASL &35
A2B1	&4	038 052	26 34	ROL &34
A2B3	&3	038 051	26 33	ROL &33
A2B5	&2	038 050	26 32	ROL &32
A2B7	*	042	2A	ROL A
A2B8	1	133 049	85 31	STA &31
A2BA	h	104	68	PLA
A2BB	`	096	60	RTS
A2BC		162 255	A2 FF	LDX#&FF
A2BE	8	056	38	SEC
A2BF		232	E8	INX
A2C0		233 010	E9 0A	SBC#&0A
A2C2		176 251	B0 FB	BCS -5 --> &A2BF
A2C4	i	105 010	69 0A	ADC#&0A
A2C6	H	072	48	PHA
A2C7		138	8A	TXA
A2C8		240 003	F0 03	BEQ 3 --> &A2CD
A2CA		032 206 162	20 CE A2	JSR &A2CE
A2CD	h	104	68	PLA
A2CE	0	009 048	09 30	ORA#&30

Add ASCII character to existing output string (SWA)

A2D0		218	DA	PHX
A2D1	6	166 054	A6 36	LDX &36
A2D3		157 000 006	9D 00 06	STA &0600,X
A2D6		250	FA	PLX
A2D7	6	230 054	E6 36	INC &36
A2D9	`	096	60	RTS

 

---

  Or