ACT available

[Oulan]

Hi,

I did not need a logic analyzer, just a de-assembler, a nice emulator (mine for windows at first in 2012), then some time (!!) to look at trace of execution for 'A' key press and understanding why it doesn't work (see windows HP97 emulator).
see my own re assembled HP97 rom code for GTO command :

Code:


                    #
                    # Command GSB S8 is set
                    # 
Comnd_GSB_n:                1 -> S8
                            1 -> p
                            a + 1 -> a[p]
                            a + 1 -> a[p]
                    #
                    # Command GTO S8 is not set
                    # 
Comnd_GTO_n:                1 -> p
                            a + 1 -> a[p]
                            a + 1 -> a[p]
                            0 -> p
                            b -> c[w]
                            m1 <-> c
                            a + 1 -> a[p]
                            if n/c go to .normal
                            1 -> S10                    is GTO (i)
                            go to Get_(i)                
                            
.normal:                    a - 1 -> a[p]
                            a <-> c[w]
gto_in_c:                    1 -> p                        from Get_(i)
                            c -> a[w]
                            shift left a[w]
                            shift left a[w]
                            a <-> c[xs]
.loop:                        shift left a[w]
                            shift left a[w]
                            c -> a[x]
                            p - 1 -> p
                            if p # 5
                              then go to .loop
                            jsb R3D_to_c                get prgm address
                            if c[x] # 0
                              then go to .skip            
                            jsb Inc_Prg_Step            inc if 0
.skip:                        1 -> p
.loop1:                        p - 1 -> p                    correct step
                            p - 1 -> p                  wrap at first
                            c - 1 -> c[xs]
                            if n/c go to .loop1
                            
gto_0C51:                    c -> addr                    
                            b <-> c[w]                    save start search pos
                            data -> c                    get prgm reg
                            b <-> c[w]
                            a <-> b[w]
ifg_0C56:                    if a >= b[p]
                              then go to ifg_0C85
gto_0C58:                    p + 1 -> p
                            p + 1 -> p
                            if p # 0
                              then go to ifg_0C56
                            go to gto_0C79
ifg_0C5D:                    
gto_0C5D:                    c -> addr
                            a <-> c[w]
                            data -> c                    get prgm reg
                            a <-> c[w]
                            if a[w] # 0
                              then go to ifg_0C64
                            go to gto_0C79
ifg_0C64:                    1 -> p
                            if a >= b[p]
                              then go to ifg_0C85
                            3 -> p
                            if a >= b[p]
                              then go to ifg_0C85
                            5 -> p
                            if a >= b[p]
                              then go to ifg_0C85
                            7 -> p
                            if a >= b[p]
                              then go to ifg_0C85
                            9 -> p
                            if a >= b[p]
                              then go to ifg_0C85
                            11 -> p
                            if a >= b[p]
                              then go to ifg_0C85
                            13 -> p
                            if a >= b[p]
                              then go to ifg_0C85
gto_0C79:                    1 -> p
                            c - 1 -> c[wp]
                            if c[p] # 0
                              then go to ifg_0C5D
                            if S6 = 1                    full research done ?
                              then go to (i)_Error_0
#ifdef HP97+                              
                            load constant 8
#else
                            load constant 2                start again
#endif
                            1 -> S6
                            go to gto_0C5D
                            9 -> p
                            a <-> b[w]
                            go to gto_0C51
ifg_0C85:                    a <-> b[p]
                            if a >= b[p]
                              then go to ifg_0C8A
                            a <-> b[p]
                            go to gto_0C58
ifg_0C8A:                    a <-> b[p]
                            p - 1 -> p
                            if a >= b[p]
                              then go to ifg_0C90
gto_0C8E:                    p + 1 -> p
                            go to gto_0C58
ifg_0C90:                    a <-> b[p]
                            if a >= b[p]
                              then go to ifg_0C95
                            a <-> b[p]
                            go to gto_0C8E
ifg_0C95:                    c + 1 -> c[xs]
                            p - 1 -> p
                            p - 1 -> p                  be careful when wrap
                            if p # 12
                              then go to ifg_0C95
                            c + 1 -> c[xs]
                            c + 1 -> c[xs]
                            c + 1 -> c[xs]
                            decimal
                            0 - c - 1 -> c[xs]
                            c -> a[w]
gto_do_it:                    m1 -> c
                            b <-> c[w]
                            jsb R3D_to_c                get R3D
                            if S8 = 0
                              then go to .gto_end            it's a GTO
                            a <-> c[w]                    is a GSB
                            11 -> p
                            shift left a[wp]            push a step/reg
                            shift left a[wp]
                            shift left a[wp]
                            a <-> c[w]
                            if S2 = 1
                              then go to .gto_end
                            1 -> S2
                            if S1 = 1
                              then go to .gto_end
                            0 -> c[w]                    
.gto_end:                    a <-> c[x]                    found ...
                            c -> data rD                save R3D
                            go to gto_0033                continue

the rest of the rom code is at mentioned website ... see for yourself.

As behavior of p - 1 -> p opcode I just avoid to do it if previous opcode was also p - 1 -> p opcode with a wrap

(04-09-2015 03:58 PM)PANAMATIK Wrote:  

(04-09-2015 07:06 AM)brouhaha Wrote:  That someone might reverse-engineer the ACT instruction set and simulate it, and have the 67/97 simulation work correctly without having run into this problem and analyzing it to determine how to fix it to make the label search work correctly, seems *extremely* implausible, because the "obvious" behavior of that instruction in all other instances is contrary to what is needed for label search.

Hello Olivier

I would agree to the above statement. I could track down and fix the label search problem only by comparing the original program flow with the emulated program flow with a dedicated ACT recorder/scanner. You could probably have used a sophisticated logic analyzer as well.

The more I utter my great respect to you, if you found a working emulation completely by yourself. Could you talk some more about how you developed your programs?

Bernhard