#include <cpu_prog_model.h>
#include <cpu6502_addrm.h>



void AND_imm( code)
PM *code;
{
   code->Ac &= code->Me [imm_address( code)];
   set_neg_zero_stat( code, code->Ac);
}

void AND_zer( code)
PM *code;
{
   unsigned short int address;

   short temp_value;

   address = zero_address( code);

   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   temp_value = code->Me [address];

   code->Ac &= temp_value;
   set_neg_zero_stat( code, code->Ac);
}

void AND_zex( code)
PM *code;
{
   unsigned short int address;

   short temp_value;

   address = zero_x_address( code);

   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   temp_value = code->Me [address];

   code->Ac &= temp_value;
   set_neg_zero_stat( code, code->Ac);
}

void AND_abs( code)
PM *code;
{
   unsigned short int address;

   short temp_value;

   address = abs_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   temp_value = code->Me [address];

   code->Ac &= temp_value;
   set_neg_zero_stat( code, code->Ac);
}

void AND_abx( code)
PM *code;
{
   unsigned short int address;

   short temp_value;

   address = abs_x_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   temp_value = code->Me [address];

   code->Ac &= temp_value;
   set_neg_zero_stat( code, code->Ac);
}

void AND_aby( code)
PM *code;
{
   unsigned short int address;

   short temp_value;

   address = abs_y_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   temp_value = code->Me [address];

   code->Ac &= temp_value;
   set_neg_zero_stat( code, code->Ac);
}

void AND_inx( code)
PM *code;
{
   unsigned short int address;

   short temp_value;

   address = ind_x_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   temp_value = code->Me [address];

   code->Ac &= temp_value;
   set_neg_zero_stat( code, code->Ac);
}

void AND_iny( code)
PM *code;
{
   unsigned short int address;

   short temp_value;

   address = ind_y_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   temp_value = code->Me [address];

   code->Ac &= temp_value;
   set_neg_zero_stat( code, code->Ac);
}

void ASL_acc( code)
PM *code;
{
   (code->Ac) <<= 1;
   code->Ca = (code->Ac >= 0x100);
   code->Ac &= 0xFF;
   set_neg_zero_stat( code, code->Ac);
}

void ASL_zer( code)
PM *code;
{
   unsigned short int address;

   short temp_value;

   address = zero_address( code);

   (code->Me [address]) <<= 1;
   code->Ca = (code->Me [address] >= 0x100);
   code->Me [address] &= 0xFF;

   mem_check( address, &(code->Me [address]), code, Func_STORE);
   set_neg_zero_stat( code, code->Me [address]);
}

void ASL_zex( code)
PM *code;
{
   unsigned short int address;

   short temp_value;

   address = zero_x_address( code);

   (code->Me [address]) <<= 1;
   code->Ca = (code->Me [address] >= 0x100);
   code->Me [address] &= 0xFF;

   mem_check( address, &(code->Me [address]), code, Func_STORE);
   set_neg_zero_stat( code, code->Me [address]);
}

void ASL_abs( code)
PM *code;
{
   unsigned short int address;

   short temp_value;

   address = abs_address( code);

   (code->Me [address]) <<= 1;
   code->Ca = (code->Me [address] >= 0x100);
   code->Me [address] &= 0xFF;

   mem_check( address, &(code->Me [address]), code, Func_STORE);
   set_neg_zero_stat( code, code->Me [address]);
}


void ASL_abx( code)
PM *code;
{
   unsigned short int address;

   short temp_value;

   address = abs_x_address( code);

   (code->Me [address]) <<= 1;
   code->Ca = (code->Me [address] >= 0x100);
   code->Me [address] &= 0xFF;

   mem_check( address, &(code->Me [address]), code, Func_STORE);
   set_neg_zero_stat( code, code->Me [address]);
}


void BIT_zer( code)
PM *code;
{
   unsigned short int address;

   short temp_value;

   address = zero_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   temp_value = code->Me [address];

   code->Ov = ( (temp_value & 0x40) == 0x40);
   code->Ze = ( (temp_value & code->Ac) == 0);
   code->Ne = (temp_value >= 0x80);
}

void BIT_abs( code)
PM *code;
{
   unsigned short int  address;
   short               temp_value;

   address = abs_address( code);

   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   temp_value = code->Me [address];

   code->Ov = ( (temp_value & 0x40) == 0x40);
   code->Ze = ( (temp_value & code->Ac) == 0);
   code->Ne = (temp_value >= 0x80);
}

void EOR_imm( code)
PM *code;
{
   code->Ac ^= code->Me [imm_address( code)];
   set_neg_zero_stat( code, code->Ac);
}

void EOR_zer( code)
PM *code;
{
   unsigned short int address;
   short          value;

   address = zero_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   value = code->Me [address];

   code->Ac ^= value;
   mem_check( address, &(code->Ac), code, Func_STORE);
   set_neg_zero_stat( code, code->Ac);
}

void EOR_zex( code)
PM *code;
{
   unsigned short int address;
   short          value;

   address = zero_x_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   value = code->Me [address];

   code->Ac ^= value;
   mem_check( address, &(code->Ac), code, Func_STORE);
   set_neg_zero_stat( code, code->Ac);
}

void EOR_abs( code)
PM *code;
{
   unsigned short int address;
   short          value;

   address = abs_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   value = code->Me [address];

   code->Ac ^= value;
   mem_check( address, &(code->Ac), code, Func_STORE);
   set_neg_zero_stat( code, code->Ac);
}

void EOR_abx( code)
PM *code;
{
   unsigned short int address;
   short          value;

   address = abs_x_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   value = code->Me [address];

   code->Ac ^= value;
   mem_check( address, &(code->Ac), code, Func_STORE);
   set_neg_zero_stat( code, code->Ac);
}

void EOR_aby( code)
PM *code;
{
   unsigned short int address;
   short          value;

   address = abs_y_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   value = code->Me [address];

   code->Ac ^= value;
   mem_check( address, &(code->Ac), code, Func_STORE);
   set_neg_zero_stat( code, code->Ac);
}

void EOR_inx( code)
PM *code;
{
   unsigned short int address;
   short          value;

   address = ind_x_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   value = code->Me [address];

   code->Ac ^= value;
   mem_check( address, &(code->Ac), code, Func_STORE);
   set_neg_zero_stat( code, code->Ac);
}

void EOR_iny( code)
PM *code;
{
   unsigned short int address;
   short          value;

   address = ind_y_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   value = code->Me [address];

   code->Ac ^= value;
   mem_check( address, &(code->Ac), code, Func_STORE);
   set_neg_zero_stat( code, code->Ac);
}

void LSR_acc( code)
PM *code;
{
   code->Ca = (code->Ac & 0x01);
   (code->Ac) >>= 1;
   code->Ze = (code->Ac == 0);
   code->Ne = 0;
}

void LSR_zer( code)
PM *code;
{
   unsigned short int address;

   address = zero_address( code);

   code->Ca = (code->Me [address] & 0x01);
   (code->Me [address]) >>= 1;
   mem_check( address, &(code->Me [address]), code, Func_STORE);

   code->Ze = (code->Me [address] == 0);
   code->Ne = 0;
}

void LSR_zex( code)
PM *code;
{
   unsigned short int address;

   address = zero_x_address( code);

   code->Ca = (code->Me [address] & 0x01);
   (code->Me [address]) >>= 1;
   mem_check( address, &(code->Me [address]), code, Func_STORE);

   code->Ze = (code->Me [address] == 0);
   code->Ne = 0;
}

void LSR_abs( code)
PM *code;
{
   unsigned short int address;

   address = abs_address( code);

   code->Ca = (code->Me [address] & 0x01);
   (code->Me [address]) >>= 1;
   mem_check( address, &(code->Me [address]), code, Func_STORE);

   code->Ze = (code->Me [address] == 0);
   code->Ne = 0;
}

void LSR_abx( code)
PM *code;
{
   unsigned short int address;

   address = abs_x_address( code);

   code->Ca = (code->Me [address] & 0x01);
   (code->Me [address]) >>= 1;
   mem_check( address, &(code->Me [address]), code, Func_STORE);

   code->Ze = (code->Me [address] == 0);
   code->Ne = 0;
}

void ORA_imm( code)
PM *code;
{
   code->Ac |= code->Me [imm_address( code)];
   set_neg_zero_stat( code, code->Ac);
}


void ORA_zer( code)
PM *code;
{
   unsigned short int address;

   short memory;

   address = zero_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   memory = code->Me [address];

   code->Ac |= memory;
   set_neg_zero_stat( code, code->Ac);
}

void ORA_zex( code)
PM *code;
{
   unsigned short int address;

   short memory;

   address = zero_x_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   memory = code->Me [address];

   code->Ac |= memory;
   set_neg_zero_stat( code, code->Ac);
}

void ORA_abs( code)
PM *code;
{
   unsigned short int  address;
   short               memory;

   address = abs_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   memory = code->Me [address];

   code->Ac |= memory;
   set_neg_zero_stat( code, code->Ac);
}

void ORA_abx( code)
PM *code;
{
   unsigned short int  address;
   short               memory;

   address = abs_x_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   memory = code->Me [address];

   code->Ac |= memory;
   set_neg_zero_stat( code, code->Ac);
}

void ORA_aby( code)
PM *code;
{
   unsigned short int  address;
   short               memory;

   address = abs_y_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   memory = code->Me [address];

   code->Ac |= memory;
   set_neg_zero_stat( code, code->Ac);
}


void ORA_inx( code)
PM *code;
{
   unsigned short int address;

   short memory;

   address = ind_x_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   memory = code->Me [address];

   code->Ac |= memory;
   set_neg_zero_stat( code, code->Ac);
}

void ORA_iny( code)
PM *code;
{
   unsigned short int address;

   short memory;

   address = ind_y_address( code);
   mem_check( address, &(code->Me [address]), code, Func_LOAD);
   memory = code->Me [address];

   code->Ac |= memory;
   set_neg_zero_stat( code, code->Ac);
}

ROL_acc( code)
PM *code;
{
   code->Ac <<= 1;
   code->Ac |= code->Ca;
   code->Ca = (code->Ac >= 0x100);
   code->Ac &= 0xFF;
   set_neg_zero_stat( code, code->Ac);
}

ROL_zer( code)
PM *code;
{
   unsigned short int address;

   address = zero_address( code);

   code->Me [address] <<= 1;
   code->Me [address] |= code->Ca;
   code->Ca = (code->Me [address] >= 0x100);
   code->Me [address] &= 0xFF;
   mem_check( address, &(code->Me [address]), code, Func_STORE);

   set_neg_zero_stat( code, code->Me [address]);
}

ROL_zex( code)
PM *code;
{
   unsigned short int address;

   address = zero_x_address( code);

   code->Me [address] <<= 1;
   code->Me [address] |= code->Ca;
   code->Ca = (code->Me [address] >= 0x100);
   code->Me [address] &= 0xFF;
   mem_check( address, &(code->Me [address]), code, Func_STORE);

   set_neg_zero_stat( code, code->Me [address]);
}

ROL_abs( code)
PM *code;
{
   unsigned short int address;

   address = abs_address( code);

   code->Me [address] <<= 1;
   code->Me [address] |= code->Ca;
   code->Ca = (code->Me [address] >= 0x100);
   code->Me [address] &= 0xFF;
   mem_check( address, &(code->Me [address]), code, Func_STORE);

   set_neg_zero_stat( code, code->Me [address]);
}

ROL_abx( code)
PM *code;
{
   unsigned short int address;

   address = abs_x_address( code);

   code->Me [address] <<= 1;
   code->Me [address] |= code->Ca;
   code->Ca = (code->Me [address] >= 0x100);
   code->Me [address] &= 0xFF;
   mem_check( address, &(code->Me [address]), code, Func_STORE);

   set_neg_zero_stat( code, code->Me [address]);
}

ROR_acc( code)
PM *code;
{
   short temp_carry;

   temp_carry = code->Ac & 0x1;
   code->Ac >>= 1;
   code->Ac |= (code->Ca << 7);
   code->Ca = temp_carry;

   set_neg_zero_stat( code, code->Ac);
}

ROR_zer( code)
PM *code;
{
   unsigned short int address;
   short              temp_carry;

   address = zero_address( code);

   temp_carry = code->Me [address] & 0x1;
   code->Me [address] >>= 1;
   code->Me [address] |= (code->Ca << 7);
   code->Ca = temp_carry;
   mem_check( address, &(code->Me [address]), code, Func_STORE);

   set_neg_zero_stat( code, code->Me [address]);
}

ROR_zex( code)
PM *code;
{
   unsigned short int address;
   short              temp_carry;

   address = zero_x_address( code);

   temp_carry = code->Me [address] & 0x1;
   code->Me [address] >>= 1;
   code->Me [address] |= (code->Ca << 7);
   code->Ca = temp_carry;
   mem_check( address, &(code->Me [address]), code, Func_STORE);

   set_neg_zero_stat( code, code->Me [address]);
}

ROR_abs( code)
PM *code;
{
   unsigned short int address;
   short              temp_carry;

   address = abs_address( code);

   temp_carry = code->Me [address] & 0x1;
   code->Me [address] >>= 1;
   code->Me [address] |= (code->Ca << 7);
   code->Ca = temp_carry;
   mem_check( address, &(code->Me [address]), code, Func_STORE);

   set_neg_zero_stat( code, code->Me [address]);
}

ROR_abx( code)
PM *code;
{
   unsigned short int address;
   short              temp_carry;

   address = abs_x_address( code);

   temp_carry = code->Me [address] & 0x1;
   code->Me [address] >>= 1;
   code->Me [address] |= (code->Ca << 7);
   code->Ca = temp_carry;
   mem_check( address, &(code->Me [address]), code, Func_STORE);

   set_neg_zero_stat( code, code->Me [address]);
}