I am porting the Rankin and Wozniak 32 bit floating point code from Doctor Dobbs (posted here: http://www.6502.org/source/floats/wozfp1.txt) to the Ophis assembler. Reading the code is a head trip because the code flow is a bit convoluted to save space. There are two weird things that I would normally think were bugs if a mere mortal wrote it But given the origin and age of the code, they might actually do something useful.

I was curious if anyone had experience with them.

• The exp function contains an ADC at address 1E29 that doesn’t seem to do anything useful because there’s an LDA M1 directly afterwards.

Is there some side effect that is being exploited?

• The swap function contains a STY at 1F1E without an LDY prior.

I suspect that the first pass through the loop moves a junk byte, but all the rest of the iterations do something useful, so the junk byte is overwritten on the final iteration.

Well, the LDA doesn't reset the carry flag, so that subsequent ADC would be affected by the result. I'll leave it to people who actually know from floating-point to analyze the implications.

IIRC there was an errata to the floating point routines that might be worth checking. The code and errata are also posted on this site somewhere I think. I ported the code to Verilog a while ago and it worked great.

_________________
http://www.finitron.ca

viewtopic.php?f=1&t=3633


It looks like he might be doing a 16-bit compare, and is only interested in the flags, not the actual numeric result.


I feel comfortable agreeing with you on that.

Mike B.

Thanks for the pointer to the errata. I wrote a Python program to read the old style assembly and spit out Ophis style, so I reported using the corrected version. Some of my tests which were failing now work, so I think that fixed some issues.

So does that mean you've found other issues?

I called float with 2 and it returned $89,$40,$00,$00. I think it should be $81,$40,$00,$00, so the exponent looks off.

Update: never mind. I was passing the value wrong and swapped the bytes which resulted in the bad exponent.

I've completed my port of the code https://github.com/Martin-H1/Lisp65/blob/master/fmath32.asm and created a unit test https://github.com/Martin-H1/Lisp65/blob/master/tests/fmathTest.asm

But those routines don't include a print function, and I am getting sick of translating the hex to make sure the answers are correct. Does anyone have a pointer to a print function for this format, or general pointers for printing floating point in decimal?

I also found the Calc65 packed decimal routines. That library seems more complete, but also has a steeper learning curve.

I think EhBASIC uses the same floating point format. Just look for LAB_296E (convert FAC1 to ASCII string).

_________________
6502 sources on GitHub: https://github.com/Klaus2m5

Thanks for the pointer. Reading the code it sure looks like the same format, so it should help. It will take some time to understand it as the code uses somewhat obscure naming conventions.

This is defintely a 16-bit compare. You have to use ADC or SBC because CMP ignores the Carry flag.

As I read it, the BPL branch will be taken if the 16 bit number at M1 is less than $0800.

... except that M1 is the high byte and M1+1 is the low byte in this setup, so to me it looks like Woz (and/or Roy) could be CONTINing if $FF88 (-120) <= number < $7F88 (+32648).

Mike B.