Unfinished Bitness

It’s been a while since my last post.  Over the last few months I was working on a converting a string to an integer and an integer to a string.  This was beyond my meager 6502 abilities.  I finally got it working, but had to enlist the help of Karl Wiegers.  I used routines published in the July 1988 issue of Analog magazine authored by him for the Boot Camp column.  I did not want to publish this post until I completely understood what his code did.  I made some slight modifications to his original published code.  My changes were mainly to make it easier for me to follow; allow them to be included in my libraries; and removing some pieces that I am not interested in.  The source is in two pieces; Macros, and Functions.  But first, the matter of the new assembly instructions that are used.

Instructions

In this post the following opcodes are introduced:

• CLC: CLear Carry flag.
• SEC: SEt Carry flag.
• SBC: SuBtract with Carry.  Subtracts value from value in the accumulator.
• ADC: ADd with Carry.  Adds value to the value in the accumulator.
• ORA: OR the Accumulator with value.  Does an inclusive OR with the value of the accumulator and the specified value.
• ROL: ROtate Left.  Moves each bit of the value in the accumulator one position to the left.
• ASL: Arithmetic Shift Left.  Moves each bit in specified location (or accumulator) one position to the left.
• PHA: PusH the value in the accumulator onto the stack.
• PLA: PuLl one byte from stack and put it in the accumulator.

Macros

There are two macros; one for converting string to integer, and one for converting integer to string.  As originally published this used 3 variables at fixed locations in memory.  I’ve modified them to use assemble time addresses, removed an unwanted error message, and renamed variables to they make more sense to me.  I put these in their own file in my library, named “A8STRMAC.LIB”.  The file is SAVEd not LISTed so it can be included in other source.

Source

1000 ; Storage & Pointers
1005 MSISTR *= *+6
1010 MSIINT *= *+2
1020 MSICTR *= *+1
5000 ; ------------------------------
5001 ; Mac.: STR2INT
5002 ; Desc: String to Integer
5003 ; Parm: 1=address of string to convert
5004 ;       2=storage address for integer
5005 ; ------------------------------
5010     .MACRO STR2INT 
5020       .IF %0<>2
5030       .ERROR "STR2INT missing parms"
5040       .ELSE 
5050       LDX #$FF
5060 @STILP
5070       INX 
5080       LDA %1,X
5090       STA MSISTR,X
5100       CMP #EOL
5110       BNE @STILP
5120       JSR STIVALID
5130       BCS @STIDONE
5140       JSR STR2INT
5150       BCS @STIERROR
5160       LDA MSIINT
5170       STA %2
5180       LDA MSIINT+1
5190       STA %2+1
5200       CLC 
5210       BCC @STIDONE
5220 @STIERROR
5230       SEC 
5240 @STIDONE
5250       .ENDIF 
5260     .ENDM 
5500 ; ------------------------------
5501 ; Mac.: INT2STR
5502 ; Desc: Integer to String
5003 ; Parm: 1=address of integer to convert
5004 ;       2=storage address for string
5505 ; ------------------------------
5510     .MACRO INT2STR
5520       .IF %0<>2
5530       .ERROR "INT2STR missing parms"
5540       .ELSE
5550       LDA %1
5560       STA MSIINT
5570       LDA %1+1
5580       STA MSIINT+1
5590       JSR INT2STR
5600       LDX #$FF
5610 @ITSLP
5620       INX
5630       LDA MSISTR,X
5640       STA %2,X
5650       CMP #EOL
5660       BNE @ITSLP
5670       .ENDIF
5680     .ENDM

Breakdown

STR2INT

• 1005-1020: Set memory space aside for the string (MSISTR), the integer (MSIINT), and a counter (MSICTR)
• 5010: Start of the STR2INT macro
• 5020: IF 2 parameters were not passed (check)
• 5030: Define the error string (though not using it here)
• 5040: Parameter check passes, continue
• 5050: Load the X register with $FF (255).
• 5060-5230: Label-Start of STILP loop (copies the string from the users string address to the functions working storage, converts its, and copies the functions integer working storage to the users integer address). It’s pretty easy to see what this is doing.  It does call STIVALID to ensure the characters are valid numeric digits, and then calls the STR2INT function to do the conversion.
• 5240: Label-Start of STIERROR
• 5250: End of IF
• 5260: End of the STR2INT macro

INT2STR

• 5510: Start of the INT2STR macro
• 5520: IF 2 parameters were not passed (check)
• 5530: Define the error string (though not using it here)
• 5540: Parameter check passes, continue
• 5550-5660: Copies the integer from the users integer address to the functions working storage, calls INT2STR to do the conversion, then copies the string from the functions string working storage to the users string address.
• 5680: End of the INT2STR macro

Functions

There are four functions.  They are:

• STIVALID: Looks at each character of string and checks if the character is a valid numeric digit.  If it is not, the carry flag is set.
• MULT10: Multiplies integer at address (16 bit) by 10 and adds next digit in.
• STR2INT: Converts the string to a 2 byte integer.  In case of error, the carry flag is set.
• INT2STR: Converts the 2 byte integer to a string.

Source

5000 ; ------------------------------
5001 ; Func: STIVALID
5002 ; Desc: String to Integer string
5003 ; validation
5006 ; ------------------------------
5010 STIVALID
5020     LDX #0
5030 STIVLP
5040     LDA MSISTR,X
5050     CMP #EOL
5060     BNE STIVCHK
5070     CPX #0
5080     BEQ STIVINV
5090     CLC 
5100     RTS 
5110 STIVCHK
5120     CMP #$30
5130     BCC STIVINV
5140     CMP #$3A
5150     BCS STIVINV
5160     AND #$0F
5170     STA MSISTR,X
5180     INX 
5190     BCC STIVLP
5200 STIVINV
5210     SEC 
5220     RTS 
5300 ; ------------------------------
5301 ; Func: MULT10
5302 ; Desc: Multiply Integer by 10
5305 ; ------------------------------
5310 MULT10
5315     LDA MSIINT+1
5320     PHA 
5325     LDA MSIINT
5330     ASL MSIINT
5335     ROL MSIINT+1
5340     ASL MSIINT
5345     ROL MSIINT+1
5350     ADC MSIINT
5355     STA MSIINT
5360     PLA 
5370     ADC MSIINT+1
5375     STA MSIINT+1
5380     ASL MSIINT
5385     ROL MSIINT+1
5390     LDA MSISTR,X
5400     ADC MSIINT
5410     STA MSIINT
5420     LDA #0
5430     ADC MSIINT+1
5440     STA MSIINT+1
5450     RTS 
5500 ; ------------------------------
5501 ; Func: STR2INT
5502 ; Desc: String to Integer
5505 ; ------------------------------
5510 STR2INT
5520     LDA #0
5525     STA MSIINT+1
5530     LDA MSISTR
5535     STA MSIINT
5540     LDX #1
5545     LDA MSISTR,X
5550     CMP #EOL
5560     BNE STINEXT
5570     CLC 
5575     RTS 
5580 STINEXT
5590     JSR MULT10
5600     BCS STICAN
5610     INX 
5620     LDA MSISTR,X
5630     CMP #EOL
5640     BNE STINEXT
5650     CLC 
5660 STICAN
5670     RTS 
5700 ; ------------------------------
5701 ; Func: INT2STR
5702 ; Desc: Integer to String
5705 ; ------------------------------
5710 INT2STR
5720     LDY #0
5725     STY MSICTR
5730 ITSNEXT
5735     LDX #0
5740 ITSSLP
5750     LDA MSIINT
5755     SEC 
5760     SBC ITSTABLE,Y
5770     STA MSIINT
5775     LDA MSIINT+1
5780     INY 
5785     SBC ITSTABLE,Y
5790     BCC ITSADD
5795     STA MSIINT+1
5800     INX 
5805     DEY 
5810     CLC 
5815     BCC ITSSLP
5820 ITSADD
5825     DEY 
5830     LDA MSIINT
5840     ADC ITSTABLE,Y
5845     STA MSIINT
5850     TXA 
5855     ORA #$30
5860     LDX MSICTR
5865     STA MSISTR,X
5870     INC MSICTR
5875     INY 
5880     INY 
5885     CPY #8
5890     BCC ITSNEXT
5895     LDA MSIINT
5900     ORA #$30
5910     LDX MSICTR
5915     STA MSISTR,X
5920     INX 
5930     LDA #EOL
5940     STA MSISTR,X
5950     RTS 
5960 ITSTABLE
5965     .WORD 10000
5970     .WORD 1000
5975     .WORD 100
5980     .WORD 10

Breakdown

STIVALID

• 5010: Label-Start of STIVALID function
• 5020: Load the X register with 0
• 5030: Label-Start of string check loop
• 5040: Load the accumulator with the character at the X offset of the string address
• 5050: Compare the accumulator with EOL
• 5060: If it is not EOL, branch to STIVCHK (check if ascii)
• 5070: Compare X register with 0 (It is EOL, is this fist character?)
• 5080: If X is 0, branch to STIVINV (It is the first character and EOL, it is invalid)
• 5090: If X is not 0, clear carry
• 5100: Return from STIVALID (exit)
• 5110: Label-Start of valid ASCII numeric digit check
• 5120: Compare accumulator with $30 (is it less than ‘0’, ascii 48)
• 5130: If it’s less than 0 branch to STIVINV (it is an invalid character)
• 5140: Compare accumulator with $3A (it it greater than ‘9’, ascii 58)
• 5150: If it’s greater than 9 branch to STIVINV (it is an invalid character)
• 5160: Clear the 4 high bits
• 5170: Save the low 4 bits to the X offset of the string address
• 5180: Increment the X register by 1
• 5190: Branch to the start of the string check loop (STIVLP)
• 5200: Label-Start of invalid character encountered
• 5210: Set carry flag to indicate error
• 5220: Return from STIVALID (exit)

MULT10

• 5315: Load the accumulator with the high byte of the integer address
• 5320: Push the accumulator onto the stack (saving the byte)
• 5325: Load the accumulator with the low byte of the integer address
• 5330-5335: Multiply the accumulator by 2
• 5340-5345: Multiply the accumulator by 2
• 5350-5375: Add to self  (effectively multiplying by 5 now)
• 5380-5385: Multiply the accumulator by 2 (effectively multiplied by 10 now)
• 5390: Load accumulator with next character from string
• 5400: Add the accumulator to the integer low byte address value
• 5410: Store the accumulator  at the integer low byte address
• 5420: Load the accumulator with 0
• 5430: Add accumulator to high byte address (pulls in the carry value) value
• 5440: Store the accumulator at the integer high byte address
• 5450: Return from MULT10 (exit)

STR2INT

• 5510: Label-Start of STR2INT function
• 5520: Load the accumulator with 0
• 5525: Store the accumulator at the integer high byte address (zero out high byte)
• 5530: Load the accumulator with the first character of the string
• 5535: Store the accumulator at the integer low byte address
• 5540: Load the X register with 1
• 5545: Load the accumulator with the X offset of the string address
• 5550: Compare accumulator with EOL
• 5560: Branch if Not equal to EOL to STINEXT
• 5570: If EOL, clear carry flag
• 5575: Return from STR2INT (exit)
• 5580: Label-Start of STINEXT
• 5590: Jump to SubRoutine MULT10 (to multiply by 10)
• 5600: Branch if carry set to STICAN (error, so cancel)
• 5610: Increment the X register by 1
• 5620: Load the accumulator with the X offset of the string address (next character)
• 5630: Compare the accumulator with EOL
• 5640: Branch if Not Equal to EOL to STINEXT
• 5650: Clear the carry flag
• 5660: Label-Start of STICAN
• 5670: Return from STR2INT (exit)

INT2STR

• 5710: Label-Start of INT2STR function
• 5720: Load the Y register with 0
• 5725: Store the Y register in a counter location
• 5730: Label-Start of ITSNEXT
• 5735: Load the X register with 0
• 5740: Label-Start of ITSSLP
• 5750: Load the accumulator with the value in the integer low byte
• 5755-5760: Subtract low byte of current power of 10
• 5770: Store the accumulator in the integer low byte address
• 5775: Load the accumulator with the value in the integer high byte
• 5780-Increment the Y register by 1
• 5785: Subtract the high byte of the current power of 10
• 5790: Branch on carry clear (negative) to ITSADD (restore value)
• 5795: Store the accumulator at the integer high byte address
• 5800: Increment the X register by 1 (digit counter)
• 5805: Decrement the Y register by 1
• 5810: Clear carry flag
• 5815: Branch on carry clear to ITSSLP (process next power of 10)
• 5820: Label-Start of ITSADD
• 5825: Decrement Y register by 1
• 5830: Load the accumulator with the value at the integer low byte address
• 5840: Add value of low byte current power of 10 back in
• 5845: Store the accumulator at the integer low byte address
• 5850: Transfer the X register to the accumulator
• 5855: OR the accumulator with $30 (to make it ascii)
• 5860: Load the X register with value in the counter address
• 5865: Store the accumulator at the X offset of the string address
• 5870: Increment the value in the counter address
• 5875-5780: Increment the Y register twice (point to next power of 10)
• 5885: Compare Y register with 8 (end of table?)
• 5890: Branch on carry clear to ITSNEXT  (not end of table, continue)
• 5895: Load the accumulator with the value in the integer low byte address
• 5900: OR the accumulator with $30 (to make it ascii)
• 5910: Load the X register with the value in the counter address
• 5915: Store the accumulator at the X offset of the string address
• 5920: Increment the X register by 1
• 5930: Load the accumulator with EOL
• 5940: Store the accumulator at the X offset of the string address (adding the EOL to end of the string)
• 5950: Return from INT2STR (exit)
• 5960: Label-Start of ITSTABLE (powers of 10)
• 5965-5980: Powers of 10 for digit positions

Done

Next time I will go over the library I have built so far.  Then I will put it to use on something fun!