/*******************************************************************************************
NOTE: All registers are accessed directly, instead of using the SFR_R() function for speed
Direct register access is availabe from the R_(register name) macros.. ex: R_ACC for the ACC
with the exception of the PC
********************************************************************************************/
//ACALL code addr /* 1: aaa1 0001 */
INLINE void acall(void)
{
UINT8 op = ROP(PC-1); //Grab the opcode for ACALL
UINT8 addr = ROP_ARG(PC++); //Grab code address byte
PUSH_PC //Save PC to the stack
//Thanks Gerrit for help with this! :)
PC = (PC & 0xf800) | ((op & 0xe0) << 3) | addr;
}
//ADD A, #data /* 1: 0010 0100 */
INLINE void add_a_byte(void)
{
UINT8 data = ROP_ARG(PC++); //Grab data
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0) //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADD A, data addr /* 1: 0010 0101 */
INLINE void add_a_mem(void)
{
UINT8 addr = ROP_ARG(PC++); //Grab data address
UINT8 data = IRAM_R(addr); //Grab data from data address
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADD A, @R0/@R1 /* 1: 0010 011i */
INLINE void add_a_ir(int r)
{
UINT8 data = IRAM_IR(R_R(r)); //Grab data from memory pointed to by R0 or R1
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADD A, R0 to R7 /* 1: 0010 1rrr */
INLINE void add_a_r(int r)
{
UINT8 data = R_R(r); //Grab data from R0 - R7
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADDC A, #data /* 1: 0011 0100 */
INLINE void addc_a_byte(void)
{
UINT8 data = ROP_ARG(PC++); //Grab data
UINT8 result = R_ACC + data + GET_CY; //Add data + carry flag to accumulator
DO_ADD_FLAGS(R_ACC,data,GET_CY); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADDC A, data addr /* 1: 0011 0101 */
INLINE void addc_a_mem(void)
{
UINT8 addr = ROP_ARG(PC++); //Grab data address
UINT8 data = IRAM_R(addr); //Grab data from data address
UINT8 result = R_ACC + data + GET_CY; //Add data + carry flag to accumulator
DO_ADD_FLAGS(R_ACC,data,GET_CY); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADDC A, @R0/@R1 /* 1: 0011 011i */
INLINE void addc_a_ir(int r)
{
UINT8 data = IRAM_IR(R_R(r)); //Grab data from memory pointed to by R0 or R1
UINT8 result = R_ACC + data + GET_CY; //Add data + carry flag to accumulator
DO_ADD_FLAGS(R_ACC,data,GET_CY); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADDC A, R0 to R7 /* 1: 0011 1rrr */
INLINE void addc_a_r(int r)
{
UINT8 data = R_R(r); //Grab data from R0 - R7
UINT8 result = R_ACC + data + GET_CY; //Add data + carry flag to accumulator
DO_ADD_FLAGS(R_ACC,data,GET_CY); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
/*******************************************************************************************
NOTE: All registers are accessed directly, instead of using the SFR_R() function for speed
Direct register access is availabe from the R_(register name) macros.. ex: R_ACC for the ACC
with the exception of the PC
********************************************************************************************/
//ACALL code addr /* 1: aaa1 0001 */
INLINE void acall(void)
{
UINT8 op = ROP(PC-1); //Grab the opcode for ACALL
UINT8 addr = ROP_ARG(PC++); //Grab code address byte
PUSH_PC //Save PC to the stack
//Thanks Gerrit for help with this! :)
PC = (PC & 0xf800) | ((op & 0xe0) << 3) | addr;
}
//ADD A, #data /* 1: 0010 0100 */
INLINE void add_a_byte(void)
{
UINT8 data = ROP_ARG(PC++); //Grab data
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0) //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADD A, data addr /* 1: 0010 0101 */
INLINE void add_a_mem(void)
{
UINT8 addr = ROP_ARG(PC++); //Grab data address
UINT8 data = IRAM_R(addr); //Grab data from data address
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADD A, @R0/@R1 /* 1: 0010 011i */
INLINE void add_a_ir(int r)
{
UINT8 data = IRAM_IR(R_R(r)); //Grab data from memory pointed to by R0 or R1
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADD A, R0 to R7 /* 1: 0010 1rrr */
INLINE void add_a_r(int r)
{
UINT8 data = R_R(r); //Grab data from R0 - R7
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADDC A, #data /* 1: 0011 0100 */
INLINE void addc_a_byte(void)
{
UINT8 data = ROP_ARG(PC++); //Grab data
UINT8 result = R_ACC + data + GET_CY; //Add data + carry flag to accumulator
DO_ADD_FLAGS(R_ACC,data,GET_CY); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
/*******************************************************************************************
NOTE: All registers are accessed directly, instead of using the SFR_R() function for speed
Direct register access is availabe from the R_(register name) macros.. ex: R_ACC for the ACC
with the exception of the PC
********************************************************************************************/
//ACALL code addr /* 1: aaa1 0001 */
INLINE void acall(void)
{
UINT8 op = ROP(PC-1); //Grab the opcode for ACALL
UINT8 addr = ROP_ARG(PC++); //Grab code address byte
PUSH_PC //Save PC to the stack
//Thanks Gerrit for help with this! :)
PC = (PC & 0xf800) | ((op & 0xe0) << 3) | addr;
}
//ADD A, #data /* 1: 0010 0100 */
INLINE void add_a_byte(void)
{
UINT8 data = ROP_ARG(PC++); //Grab data
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0) //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADD A, data addr /* 1: 0010 0101 */
INLINE void add_a_mem(void)
{
UINT8 addr = ROP_ARG(PC++); //Grab data address
UINT8 data = IRAM_R(addr); //Grab data from data address
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADD A, @R0/@R1 /* 1: 0010 011i */
INLINE void add_a_ir(int r)
{
UINT8 data = IRAM_IR(R_R(r)); //Grab data from memory pointed to by R0 or R1
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADD A, R0 to R7 /* 1: 0010 1rrr */
INLINE void add_a_r(int r)
{
UINT8 data = R_R(r); //Grab data from R0 - R7
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADDC A, #data /* 1: 0011 0100 */
INLINE void addc_a_byte(void)
{
UINT8 data = ROP_ARG(PC++); //Grab data
UINT8 result = R_ACC + data + GET_CY; //Add data + carry flag to accumulator
DO_ADD_FLAGS(R_ACC,data,GET_CY); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADDC A, data addr /* 1: 0011 0101 */
INLINE void addc_a_mem(void)
{
UINT8 addr = ROP_ARG(PC++); //Grab data address
UINT8 data = IRAM_R(addr); //Grab data from data address
UINT8 result = R_ACC + data + GET_CY; //Add data + carry flag to accumulator
DO_ADD_FLAGS(R_ACC,data,GET_CY); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADDC A, @R0/@R1 /* 1: 0011 011i */
INLINE void addc_a_ir(int r)
{
UINT8 data = IRAM_IR(R_R(r)); //Grab data from memory pointed to by R0 or R1
UINT8 result = R_ACC + data + GET_CY; //Add data + carry flag to accumulator
DO_ADD_FLAGS(R_ACC,data,GET_CY); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
/*ADD A, R0 to R7 1: 0010 1rrr */
INLINE void add_a_r(int r)
{
UINT8 data = R_R(r); /*Grab data from R0 - R7 */
UINT8 result = R_ACC + data; /*Add data to accumulator */
DO_ADD_FLAGS(R_ACC,data,0); /*Set Flags */
SFR_W(ACC,result); /*Store 8 bit result of addtion in ACC */
}
/*ADD A, @R0/@R1 1: 0010 011i */
INLINE void add_a_ir(int r)
{
UINT8 data = IRAM_IR(R_R(r)); /*Grab data from memory pointed to by R0 or R1 */
UINT8 result = R_ACC + data; /*Add data to accumulator */
DO_ADD_FLAGS(R_ACC,data,0); /*Set Flags */
SFR_W(ACC,result); /*Store 8 bit result of addtion in ACC */
}
/*ADD A, #data 1: 0010 0100 */
INLINE void add_a_byte(void)
{
UINT8 data = ROP_ARG(PC++); /*Grab data */
UINT8 result = R_ACC + data; /*Add data to accumulator */
DO_ADD_FLAGS(R_ACC,data,0) /*Set Flags */
SFR_W(ACC,result); /*Store 8 bit result of addtion in ACC */
}
/*******************************************************************************************
NOTE: All registers are accessed directly, instead of using the SFR_R() function for speed
Direct register access is availabe from the R_(register name) macros.. ex: R_ACC for the ACC
with the exception of the PC
********************************************************************************************/
//ACALL code addr /* 1: aaa1 0001 */
INLINE void acall(void)
{
UINT8 op = ROP(PC-1); //Grab the opcode for ACALL
UINT8 addr = ROP_ARG(PC++); //Grab code address byte
PUSH_PC //Save PC to the stack
//Thanks Gerrit for help with this! :)
PC = (PC & 0xf800) | ((op & 0xe0) << 3) | addr;
}
//ADD A, #data /* 1: 0010 0100 */
INLINE void add_a_byte(void)
{
UINT8 data = ROP_ARG(PC++); //Grab data
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0) //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADD A, data addr /* 1: 0010 0101 */
INLINE void add_a_mem(void)
{
UINT8 addr = ROP_ARG(PC++); //Grab data address
UINT8 data = IRAM_R(addr); //Grab data from data address
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADD A, @R0/@R1 /* 1: 0010 011i */
INLINE void add_a_ir(int r)
{
UINT8 data = IRAM_IR(R_R(r)); //Grab data from memory pointed to by R0 or R1
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADD A, R0 to R7 /* 1: 0010 1rrr */
INLINE void add_a_r(int r)
{
UINT8 data = R_R(r); //Grab data from R0 - R7
UINT8 result = R_ACC + data; //Add data to accumulator
DO_ADD_FLAGS(R_ACC,data,0); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADDC A, #data /* 1: 0011 0100 */
INLINE void addc_a_byte(void)
{
UINT8 data = ROP_ARG(PC++); //Grab data
UINT8 result = R_ACC + data + GET_CY; //Add data + carry flag to accumulator
DO_ADD_FLAGS(R_ACC,data,GET_CY); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
//ADDC A, data addr /* 1: 0011 0101 */
INLINE void addc_a_mem(void)
{
UINT8 addr = ROP_ARG(PC++); //Grab data address
UINT8 data = IRAM_R(addr); //Grab data from data address
UINT8 result = R_ACC + data + GET_CY; //Add data + carry flag to accumulator
DO_ADD_FLAGS(R_ACC,data,GET_CY); //Set Flags
SFR_W(ACC,result); //Store 8 bit result of addtion in ACC
}
/*ADD A, data addr 1: 0010 0101 */
INLINE void add_a_mem(void)
{
UINT8 addr = ROP_ARG(PC++); /*Grab data address */
UINT8 data = IRAM_R(addr); /*Grab data from data address */
UINT8 result = R_ACC + data; /*Add data to accumulator */
DO_ADD_FLAGS(R_ACC,data,0); /*Set Flags */
SFR_W(ACC,result); /*Store 8 bit result of addtion in ACC */
}
