Hoy me he puesto con las instrucciones de Entrada/Salida, son pocas (26 COs), así que he aprovechado para ponerme con las de propósito general y control de CPU (exceptuando la DAA que es un coñazo de implementar y la NEG que necesita la de resta que todavía no tengo implementada son otros 15 COs).

Estas instrucciones de control de la CPU las necesitaba para implementar el manejo de las interrupciones, así que he aprovechado para dejarlo también listo y probado.

Por otro lado, he corregido la plantilla de Blogger para mostrar el código fuente en condiciones, pues como vísteis se descuadraba todo (no programo tan chapuzas como salía sin identar).

Bueno, lo prometido es deuda, aquí van algunas macros de ejemplo de las que tengo implementadas:


/************************************************
* LD (dir), n - 8 bits
***********************************************/
#define LD_D_I(dir) \
{ \
WM(dir, RM(_PC++)); \
}
Como véis esta macro se encarga de las instrucciones de carga de un dato inmediato en una dirección de memoria. El PC al ejecutarse está apuntando a la dirección del dato inmediato, así que se lee de esa dirección de memoria, después se incrementa el PC (para que apunte a la siguiente instrucción) y finalmente se escribe lo leído en la dirección de memoria pasada como parámetro.


/************************************************
* DJNZ e
***********************************************/
#define DJNZ(e) \
{ \
_PC += (--_B) ? ((INT8) e)+1 : 1; \
}
Esta es una curiosa, se le pasa como parámetro un desplazamiento (codificado en complemento a 2), se decrementa en una unidad el registro B y se comprueba si es cero. Si resulta ser 0 se suma 1 al PC (para apuntar a la siguiente instrucción) y sino se le suma el desplazamiento para hacer un salto relativo.


/************************************************
* CALL nn
***********************************************/
#define CALL_NN \
{ \
UINT16 dir = RM(_PC++) | (RM(_PC++)<<8); \
WM(_SP-1,_PCh); \
WM(_SP-2,_PCl); \
_SP -= 2; \
_PC = dir; \
}

Esta instrucción se usa para hacer llamadas a subrutinas. Primero se obtiene la dirección de salto a partir del dato inmediato de 16 bits que acompaña a la instrucción, después se salvaguarda el PC en la Pila (decrementando ésta para no machacarla con una próxima escritura) y finalmente se carga el PC con la dirección de la subrutina para saltar a ella.

Bueno, por hoy es suficiente, mañana pongo algunos ejemplos comentados más.