Hola,
a ver si alguien puede echarme un cable en esta duda:
;----------------- 0x10 "You are" -----------------------------------
; (#44# OK)
L_740C: LD A, (ActionActor) ; 740C 3A EA B6 ; carga ActionActor
EX AF, AF' ; 740F 08 ; Intercambia AF <-> AF', guarda AF en registro 'espejo'
XOR A ; 7410 AF ; A = A XOR A ; A = 0, borra A, flag Z = 1
i_7411: LD (L_B703), A ; 7411 32 03 B7 ; (L_B703) = 0
EX AF, AF' ; 7414 08 ; Intercambia AF <-> AF', recupera AF del registro 'espejo'
PUSH AF ; 7415 F5 ; Guarda AF
CALL FillActorIfNull ; 7416 CD 88 74 ; llama FillActorIfNull
POP AF ; 7419 F1 ; Recupera AF
AND A ; 741A A7 ; A = A AND A ; Adecua flags
LD DE, $039B ; 741B 11 9B 03 ; DE = $039B (palabra 'is')
RET NZ ; 741E C0 ; Retorna si flag Z = 0
LD DE, $0065 ; 741F 11 65 00 ; DE = $0065 (palabra 'are')
OR $01 ; 7422 F6 01 ; A = A OR 1, flag Z = 0
RET ; 7424 C9 ; Retorna
Vamos a ver, empecemos por el EX AF,AF en $740F parece que el valor de AF les importa poco ya que tras el EX AF,AF pasan A a cero con lo que se cargan también el F recuperado.
Debo pensar que solo tendrían interés en guardar los valores actuales (como un push cualquiera)
Pero lo que remata la jugada es que acto seguido hacen PUSH AF, llaman una rutina y recuperan con POP AF
Y luego, tristemente hacen un ANDA que se carga vilmente lo que hubiera en el F tan bien guardado ... en el stack
Digo yo, pensando en voz alta ... ¿Puedo eliminar tranquilamente los dos EX AF,AF ya que A se lo cargan inmediatamente y F también aunque después de marearlo por el stack?
Una vez asumido esto, bastaría con hacer un solo PSHS A y luego PULS A (en 6809) cosa que evitaría quebraderos de cabeza ...
Como segunda parte, vamos a suponer que en 6809 queremos imitar la sentencia EX AF,AF pero sin poder usar U (DE), Y (IX) ni X (HL), situación habitual
Consideremos que existe en memoria una zona llamada reg_AF
A mi se me ocurren esta forma, que no me encanta precisamente, tengo que encontrar algo mejor ... lo que queda por convertir usa los espejos de vez en cuando
pshs CC
puls B ; Ahora tenemos en AB el equivalente de AF
pshs U ; para liberarlo
ldu <reg_AF'
exg u,d ; aquí hacemos el intercambio
stu <reg_AF' ; recibe los valores de AF
puls U ; recuperamos U
pshs B
puls CC ; ahora tenemos F' en CC
Y como me resulta horroroso, me planteo otro método usando mas el stack
y redefiniendo reg_AF' como reg_FA' por facilidad de uso ... veamos pues
pshs CC,A ; guardamos lo actual
ldd <reg_FA' ; recuperamos el AF' de memoria espejo (F' en A y A en B)
pshs D ; guardamos AB, queda el stack así: A, CC, A', F' (siendo F' el byte de la cima del stack, o sea offset 0)
ldd 2,s ; recupera CC en A y A en B
std <reg_FA' ; guarda A(CC) en F' y luego B(A) en A'
puls CC,A ; recupera F' en CC y luego A' en A
leas 2,s ; limpiamos el stack
Pero, no consigo una reducción notable ...
Espero mejores ideas que éstas, posiblemente me he empeñado en complicarme la vida ...
saludos
pere