home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 405.lha / AppleII_Emulators_src / src-2 / cpu_bit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-06-28  |  13.4 KB  |  681 lines
  1. #include <cpu_prog_model.h>
  2. #include <cpu6502_addrm.h>
  3.  
  4.  
  5.  
  6. void AND_imm( code)
  7. PM *code;
  8. {
  9.    code->Ac &= code->Me [imm_address( code)];
  10.    set_neg_zero_stat( code, code->Ac);
  11. }
  12.  
  13. void AND_zer( code)
  14. PM *code;
  15. {
  16.    unsigned short int address;
  17.  
  18.    short temp_value;
  19.  
  20.    address = zero_address( code);
  21.  
  22.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  23.    temp_value = code->Me [address];
  24.  
  25.    code->Ac &= temp_value;
  26.    set_neg_zero_stat( code, code->Ac);
  27. }
  28.  
  29. void AND_zex( code)
  30. PM *code;
  31. {
  32.    unsigned short int address;
  33.  
  34.    short temp_value;
  35.  
  36.    address = zero_x_address( code);
  37.  
  38.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  39.    temp_value = code->Me [address];
  40.  
  41.    code->Ac &= temp_value;
  42.    set_neg_zero_stat( code, code->Ac);
  43. }
  44.  
  45. void AND_abs( code)
  46. PM *code;
  47. {
  48.    unsigned short int address;
  49.  
  50.    short temp_value;
  51.  
  52.    address = abs_address( code);
  53.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  54.    temp_value = code->Me [address];
  55.  
  56.    code->Ac &= temp_value;
  57.    set_neg_zero_stat( code, code->Ac);
  58. }
  59.  
  60. void AND_abx( code)
  61. PM *code;
  62. {
  63.    unsigned short int address;
  64.  
  65.    short temp_value;
  66.  
  67.    address = abs_x_address( code);
  68.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  69.    temp_value = code->Me [address];
  70.  
  71.    code->Ac &= temp_value;
  72.    set_neg_zero_stat( code, code->Ac);
  73. }
  74.  
  75. void AND_aby( code)
  76. PM *code;
  77. {
  78.    unsigned short int address;
  79.  
  80.    short temp_value;
  81.  
  82.    address = abs_y_address( code);
  83.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  84.    temp_value = code->Me [address];
  85.  
  86.    code->Ac &= temp_value;
  87.    set_neg_zero_stat( code, code->Ac);
  88. }
  89.  
  90. void AND_inx( code)
  91. PM *code;
  92. {
  93.    unsigned short int address;
  94.  
  95.    short temp_value;
  96.  
  97.    address = ind_x_address( code);
  98.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  99.    temp_value = code->Me [address];
  100.  
  101.    code->Ac &= temp_value;
  102.    set_neg_zero_stat( code, code->Ac);
  103. }
  104.  
  105. void AND_iny( code)
  106. PM *code;
  107. {
  108.    unsigned short int address;
  109.  
  110.    short temp_value;
  111.  
  112.    address = ind_y_address( code);
  113.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  114.    temp_value = code->Me [address];
  115.  
  116.    code->Ac &= temp_value;
  117.    set_neg_zero_stat( code, code->Ac);
  118. }
  119.  
  120. void ASL_acc( code)
  121. PM *code;
  122. {
  123.    (code->Ac) <<= 1;
  124.    code->Ca = (code->Ac >= 0x100);
  125.    code->Ac &= 0xFF;
  126.    set_neg_zero_stat( code, code->Ac);
  127. }
  128.  
  129. void ASL_zer( code)
  130. PM *code;
  131. {
  132.    unsigned short int address;
  133.  
  134.    short temp_value;
  135.  
  136.    address = zero_address( code);
  137.  
  138.    (code->Me [address]) <<= 1;
  139.    code->Ca = (code->Me [address] >= 0x100);
  140.    code->Me [address] &= 0xFF;
  141.  
  142.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  143.    set_neg_zero_stat( code, code->Me [address]);
  144. }
  145.  
  146. void ASL_zex( code)
  147. PM *code;
  148. {
  149.    unsigned short int address;
  150.  
  151.    short temp_value;
  152.  
  153.    address = zero_x_address( code);
  154.  
  155.    (code->Me [address]) <<= 1;
  156.    code->Ca = (code->Me [address] >= 0x100);
  157.    code->Me [address] &= 0xFF;
  158.  
  159.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  160.    set_neg_zero_stat( code, code->Me [address]);
  161. }
  162.  
  163. void ASL_abs( code)
  164. PM *code;
  165. {
  166.    unsigned short int address;
  167.  
  168.    short temp_value;
  169.  
  170.    address = abs_address( code);
  171.  
  172.    (code->Me [address]) <<= 1;
  173.    code->Ca = (code->Me [address] >= 0x100);
  174.    code->Me [address] &= 0xFF;
  175.  
  176.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  177.    set_neg_zero_stat( code, code->Me [address]);
  178. }
  179.  
  180.  
  181. void ASL_abx( code)
  182. PM *code;
  183. {
  184.    unsigned short int address;
  185.  
  186.    short temp_value;
  187.  
  188.    address = abs_x_address( code);
  189.  
  190.    (code->Me [address]) <<= 1;
  191.    code->Ca = (code->Me [address] >= 0x100);
  192.    code->Me [address] &= 0xFF;
  193.  
  194.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  195.    set_neg_zero_stat( code, code->Me [address]);
  196. }
  197.  
  198.  
  199. void BIT_zer( code)
  200. PM *code;
  201. {
  202.    unsigned short int address;
  203.  
  204.    short temp_value;
  205.  
  206.    address = zero_address( code);
  207.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  208.    temp_value = code->Me [address];
  209.  
  210.    code->Ov = ( (temp_value & 0x40) == 0x40);
  211.    code->Ze = ( (temp_value & code->Ac) == 0);
  212.    code->Ne = (temp_value >= 0x80);
  213. }
  214.  
  215. void BIT_abs( code)
  216. PM *code;
  217. {
  218.    unsigned short int  address;
  219.    short               temp_value;
  220.  
  221.    address = abs_address( code);
  222.  
  223.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  224.    temp_value = code->Me [address];
  225.  
  226.    code->Ov = ( (temp_value & 0x40) == 0x40);
  227.    code->Ze = ( (temp_value & code->Ac) == 0);
  228.    code->Ne = (temp_value >= 0x80);
  229. }
  230.  
  231. void EOR_imm( code)
  232. PM *code;
  233. {
  234.    code->Ac ^= code->Me [imm_address( code)];
  235.    set_neg_zero_stat( code, code->Ac);
  236. }
  237.  
  238. void EOR_zer( code)
  239. PM *code;
  240. {
  241.    unsigned short int address;
  242.    short          value;
  243.  
  244.    address = zero_address( code);
  245.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  246.    value = code->Me [address];
  247.  
  248.    code->Ac ^= value;
  249.    mem_check( address, &(code->Ac), code, Func_STORE);
  250.    set_neg_zero_stat( code, code->Ac);
  251. }
  252.  
  253. void EOR_zex( code)
  254. PM *code;
  255. {
  256.    unsigned short int address;
  257.    short          value;
  258.  
  259.    address = zero_x_address( code);
  260.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  261.    value = code->Me [address];
  262.  
  263.    code->Ac ^= value;
  264.    mem_check( address, &(code->Ac), code, Func_STORE);
  265.    set_neg_zero_stat( code, code->Ac);
  266. }
  267.  
  268. void EOR_abs( code)
  269. PM *code;
  270. {
  271.    unsigned short int address;
  272.    short          value;
  273.  
  274.    address = abs_address( code);
  275.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  276.    value = code->Me [address];
  277.  
  278.    code->Ac ^= value;
  279.    mem_check( address, &(code->Ac), code, Func_STORE);
  280.    set_neg_zero_stat( code, code->Ac);
  281. }
  282.  
  283. void EOR_abx( code)
  284. PM *code;
  285. {
  286.    unsigned short int address;
  287.    short          value;
  288.  
  289.    address = abs_x_address( code);
  290.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  291.    value = code->Me [address];
  292.  
  293.    code->Ac ^= value;
  294.    mem_check( address, &(code->Ac), code, Func_STORE);
  295.    set_neg_zero_stat( code, code->Ac);
  296. }
  297.  
  298. void EOR_aby( code)
  299. PM *code;
  300. {
  301.    unsigned short int address;
  302.    short          value;
  303.  
  304.    address = abs_y_address( code);
  305.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  306.    value = code->Me [address];
  307.  
  308.    code->Ac ^= value;
  309.    mem_check( address, &(code->Ac), code, Func_STORE);
  310.    set_neg_zero_stat( code, code->Ac);
  311. }
  312.  
  313. void EOR_inx( code)
  314. PM *code;
  315. {
  316.    unsigned short int address;
  317.    short          value;
  318.  
  319.    address = ind_x_address( code);
  320.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  321.    value = code->Me [address];
  322.  
  323.    code->Ac ^= value;
  324.    mem_check( address, &(code->Ac), code, Func_STORE);
  325.    set_neg_zero_stat( code, code->Ac);
  326. }
  327.  
  328. void EOR_iny( code)
  329. PM *code;
  330. {
  331.    unsigned short int address;
  332.    short          value;
  333.  
  334.    address = ind_y_address( code);
  335.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  336.    value = code->Me [address];
  337.  
  338.    code->Ac ^= value;
  339.    mem_check( address, &(code->Ac), code, Func_STORE);
  340.    set_neg_zero_stat( code, code->Ac);
  341. }
  342.  
  343. void LSR_acc( code)
  344. PM *code;
  345. {
  346.    code->Ca = (code->Ac & 0x01);
  347.    (code->Ac) >>= 1;
  348.    code->Ze = (code->Ac == 0);
  349.    code->Ne = 0;
  350. }
  351.  
  352. void LSR_zer( code)
  353. PM *code;
  354. {
  355.    unsigned short int address;
  356.  
  357.    address = zero_address( code);
  358.  
  359.    code->Ca = (code->Me [address] & 0x01);
  360.    (code->Me [address]) >>= 1;
  361.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  362.  
  363.    code->Ze = (code->Me [address] == 0);
  364.    code->Ne = 0;
  365. }
  366.  
  367. void LSR_zex( code)
  368. PM *code;
  369. {
  370.    unsigned short int address;
  371.  
  372.    address = zero_x_address( code);
  373.  
  374.    code->Ca = (code->Me [address] & 0x01);
  375.    (code->Me [address]) >>= 1;
  376.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  377.  
  378.    code->Ze = (code->Me [address] == 0);
  379.    code->Ne = 0;
  380. }
  381.  
  382. void LSR_abs( code)
  383. PM *code;
  384. {
  385.    unsigned short int address;
  386.  
  387.    address = abs_address( code);
  388.  
  389.    code->Ca = (code->Me [address] & 0x01);
  390.    (code->Me [address]) >>= 1;
  391.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  392.  
  393.    code->Ze = (code->Me [address] == 0);
  394.    code->Ne = 0;
  395. }
  396.  
  397. void LSR_abx( code)
  398. PM *code;
  399. {
  400.    unsigned short int address;
  401.  
  402.    address = abs_x_address( code);
  403.  
  404.    code->Ca = (code->Me [address] & 0x01);
  405.    (code->Me [address]) >>= 1;
  406.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  407.  
  408.    code->Ze = (code->Me [address] == 0);
  409.    code->Ne = 0;
  410. }
  411.  
  412. void ORA_imm( code)
  413. PM *code;
  414. {
  415.    code->Ac |= code->Me [imm_address( code)];
  416.    set_neg_zero_stat( code, code->Ac);
  417. }
  418.  
  419.  
  420. void ORA_zer( code)
  421. PM *code;
  422. {
  423.    unsigned short int address;
  424.  
  425.    short memory;
  426.  
  427.    address = zero_address( code);
  428.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  429.    memory = code->Me [address];
  430.  
  431.    code->Ac |= memory;
  432.    set_neg_zero_stat( code, code->Ac);
  433. }
  434.  
  435. void ORA_zex( code)
  436. PM *code;
  437. {
  438.    unsigned short int address;
  439.  
  440.    short memory;
  441.  
  442.    address = zero_x_address( code);
  443.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  444.    memory = code->Me [address];
  445.  
  446.    code->Ac |= memory;
  447.    set_neg_zero_stat( code, code->Ac);
  448. }
  449.  
  450. void ORA_abs( code)
  451. PM *code;
  452. {
  453.    unsigned short int  address;
  454.    short               memory;
  455.  
  456.    address = abs_address( code);
  457.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  458.    memory = code->Me [address];
  459.  
  460.    code->Ac |= memory;
  461.    set_neg_zero_stat( code, code->Ac);
  462. }
  463.  
  464. void ORA_abx( code)
  465. PM *code;
  466. {
  467.    unsigned short int  address;
  468.    short               memory;
  469.  
  470.    address = abs_x_address( code);
  471.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  472.    memory = code->Me [address];
  473.  
  474.    code->Ac |= memory;
  475.    set_neg_zero_stat( code, code->Ac);
  476. }
  477.  
  478. void ORA_aby( code)
  479. PM *code;
  480. {
  481.    unsigned short int  address;
  482.    short               memory;
  483.  
  484.    address = abs_y_address( code);
  485.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  486.    memory = code->Me [address];
  487.  
  488.    code->Ac |= memory;
  489.    set_neg_zero_stat( code, code->Ac);
  490. }
  491.  
  492.  
  493. void ORA_inx( code)
  494. PM *code;
  495. {
  496.    unsigned short int address;
  497.  
  498.    short memory;
  499.  
  500.    address = ind_x_address( code);
  501.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  502.    memory = code->Me [address];
  503.  
  504.    code->Ac |= memory;
  505.    set_neg_zero_stat( code, code->Ac);
  506. }
  507.  
  508. void ORA_iny( code)
  509. PM *code;
  510. {
  511.    unsigned short int address;
  512.  
  513.    short memory;
  514.  
  515.    address = ind_y_address( code);
  516.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  517.    memory = code->Me [address];
  518.  
  519.    code->Ac |= memory;
  520.    set_neg_zero_stat( code, code->Ac);
  521. }
  522.  
  523. ROL_acc( code)
  524. PM *code;
  525. {
  526.    code->Ac <<= 1;
  527.    code->Ac |= code->Ca;
  528.    code->Ca = (code->Ac >= 0x100);
  529.    code->Ac &= 0xFF;
  530.    set_neg_zero_stat( code, code->Ac);
  531. }
  532.  
  533. ROL_zer( code)
  534. PM *code;
  535. {
  536.    unsigned short int address;
  537.  
  538.    address = zero_address( code);
  539.  
  540.    code->Me [address] <<= 1;
  541.    code->Me [address] |= code->Ca;
  542.    code->Ca = (code->Me [address] >= 0x100);
  543.    code->Me [address] &= 0xFF;
  544.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  545.  
  546.    set_neg_zero_stat( code, code->Me [address]);
  547. }
  548.  
  549. ROL_zex( code)
  550. PM *code;
  551. {
  552.    unsigned short int address;
  553.  
  554.    address = zero_x_address( code);
  555.  
  556.    code->Me [address] <<= 1;
  557.    code->Me [address] |= code->Ca;
  558.    code->Ca = (code->Me [address] >= 0x100);
  559.    code->Me [address] &= 0xFF;
  560.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  561.  
  562.    set_neg_zero_stat( code, code->Me [address]);
  563. }
  564.  
  565. ROL_abs( code)
  566. PM *code;
  567. {
  568.    unsigned short int address;
  569.  
  570.    address = abs_address( code);
  571.  
  572.    code->Me [address] <<= 1;
  573.    code->Me [address] |= code->Ca;
  574.    code->Ca = (code->Me [address] >= 0x100);
  575.    code->Me [address] &= 0xFF;
  576.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  577.  
  578.    set_neg_zero_stat( code, code->Me [address]);
  579. }
  580.  
  581. ROL_abx( code)
  582. PM *code;
  583. {
  584.    unsigned short int address;
  585.  
  586.    address = abs_x_address( code);
  587.  
  588.    code->Me [address] <<= 1;
  589.    code->Me [address] |= code->Ca;
  590.    code->Ca = (code->Me [address] >= 0x100);
  591.    code->Me [address] &= 0xFF;
  592.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  593.  
  594.    set_neg_zero_stat( code, code->Me [address]);
  595. }
  596.  
  597. ROR_acc( code)
  598. PM *code;
  599. {
  600.    short temp_carry;
  601.  
  602.    temp_carry = code->Ac & 0x1;
  603.    code->Ac >>= 1;
  604.    code->Ac |= (code->Ca << 7);
  605.    code->Ca = temp_carry;
  606.  
  607.    set_neg_zero_stat( code, code->Ac);
  608. }
  609.  
  610. ROR_zer( code)
  611. PM *code;
  612. {
  613.    unsigned short int address;
  614.    short              temp_carry;
  615.  
  616.    address = zero_address( code);
  617.  
  618.    temp_carry = code->Me [address] & 0x1;
  619.    code->Me [address] >>= 1;
  620.    code->Me [address] |= (code->Ca << 7);
  621.    code->Ca = temp_carry;
  622.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  623.  
  624.    set_neg_zero_stat( code, code->Me [address]);
  625. }
  626.  
  627. ROR_zex( code)
  628. PM *code;
  629. {
  630.    unsigned short int address;
  631.    short              temp_carry;
  632.  
  633.    address = zero_x_address( code);
  634.  
  635.    temp_carry = code->Me [address] & 0x1;
  636.    code->Me [address] >>= 1;
  637.    code->Me [address] |= (code->Ca << 7);
  638.    code->Ca = temp_carry;
  639.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  640.  
  641.    set_neg_zero_stat( code, code->Me [address]);
  642. }
  643.  
  644. ROR_abs( code)
  645. PM *code;
  646. {
  647.    unsigned short int address;
  648.    short              temp_carry;
  649.  
  650.    address = abs_address( code);
  651.  
  652.    temp_carry = code->Me [address] & 0x1;
  653.    code->Me [address] >>= 1;
  654.    code->Me [address] |= (code->Ca << 7);
  655.    code->Ca = temp_carry;
  656.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  657.  
  658.    set_neg_zero_stat( code, code->Me [address]);
  659. }
  660.  
  661. ROR_abx( code)
  662. PM *code;
  663. {
  664.    unsigned short int address;
  665.    short              temp_carry;
  666.  
  667.    address = abs_x_address( code);
  668.  
  669.    temp_carry = code->Me [address] & 0x1;
  670.    code->Me [address] >>= 1;
  671.    code->Me [address] |= (code->Ca << 7);
  672.    code->Ca = temp_carry;
  673.    mem_check( address, &(code->Me [address]), code, Func_STORE);
  674.  
  675.    set_neg_zero_stat( code, code->Me [address]);
  676. }
  677.  
  678.  
  679.  
  680.  
  681.