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_math.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-06-28  |  10.6 KB  |  489 lines
  1. #include <cpu_prog_model.h>
  2. #include <cpu6502_addrm.h>
  3.  
  4.  
  5.  
  6. void ADC_imm( code)
  7. PM *code;
  8. {
  9.    short Value,
  10.          Komp_Acc,
  11.          Komp_Value,
  12.          Old_Acc,
  13.          Old_Carry;
  14.  
  15.    Value = code->Me [imm_address( code)];
  16.  
  17.    Komp_Acc = code->Ac;
  18.    if (Komp_Acc >= 0x80)
  19.       Komp_Acc |= (-1 ^ 0xFF);
  20.  
  21.    Komp_Value = Value;
  22.    if (Komp_Value >= 0x80)
  23.       Komp_Value |= (-1 ^ 0xFF);
  24.  
  25.    Old_Acc   = code->Ac;
  26.    Old_Carry = code->Ca;
  27.  
  28.    (code->Ac) += (Value + code->Ca);
  29.    code->Ca = (code->Ac > 0xFF);
  30.    (code->Ac) &= 0xFF;
  31.    set_neg_zero_stat( code, code->Ac);
  32.  
  33.    code->Ov = ( (Komp_Acc + Komp_Value + Old_Carry) >= 0x80) ||
  34.               ( !(code->Ne) && (Old_Acc >= 0x80) && (Value >= 0x80) );
  35. }
  36.  
  37. void ADC_zer( code)
  38. PM *code;
  39. {
  40.    unsigned short int address;
  41.  
  42.    short Value,
  43.          Komp_Acc,
  44.          Komp_Value,
  45.          Old_Acc,
  46.          Old_Carry;
  47.  
  48.    address = zero_address( code);
  49.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  50.    Value = code->Me [address];
  51.  
  52.    Komp_Acc = code->Ac;
  53.    if (Komp_Acc >= 0x80)
  54.       Komp_Acc |= (-1 ^ 0xFF);
  55.  
  56.    Komp_Value = Value;
  57.    if (Komp_Value >= 0x80)
  58.       Komp_Value |= (-1 ^ 0xFF);
  59.  
  60.    Old_Acc   = code->Ac;
  61.    Old_Carry = code->Ca;
  62.  
  63.    (code->Ac) += (Value + code->Ca);
  64.    code->Ca = (code->Ac > 0xFF);
  65.    (code->Ac) &= 0xFF;
  66.    set_neg_zero_stat( code, code->Ac);
  67.  
  68.    code->Ov = ( (Komp_Acc + Komp_Value + Old_Carry) >= 0x80) ||
  69.               ( !(code->Ne) && (Old_Acc >= 0x80) && (Value >= 0x80) );
  70. }
  71.  
  72. void ADC_zex( code)
  73. PM *code;
  74. {
  75.    unsigned short int address;
  76.  
  77.    short Value,
  78.          Komp_Acc,
  79.          Komp_Value,
  80.          Old_Acc,
  81.          Old_Carry;
  82.  
  83.    address = zero_x_address( code);
  84.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  85.    Value = code->Me [address];
  86.  
  87.    Komp_Acc = code->Ac;
  88.    if (Komp_Acc >= 0x80)
  89.       Komp_Acc |= (-1 ^ 0xFF);
  90.  
  91.    Komp_Value = Value;
  92.    if (Komp_Value >= 0x80)
  93.       Komp_Value |= (-1 ^ 0xFF);
  94.  
  95.    Old_Acc   = code->Ac;
  96.    Old_Carry = code->Ca;
  97.  
  98.    (code->Ac) += (Value + code->Ca);
  99.    code->Ca = (code->Ac > 0xFF);
  100.    (code->Ac) &= 0xFF;
  101.    set_neg_zero_stat( code, code->Ac);
  102.  
  103.    code->Ov = ( (Komp_Acc + Komp_Value + Old_Carry) >= 0x80) ||
  104.               ( !(code->Ne) && (Old_Acc >= 0x80) && (Value >= 0x80) );
  105. }
  106.  
  107. void ADC_abs( code)
  108. PM *code;
  109. {
  110.    unsigned short int address;
  111.  
  112.    short Value,
  113.          Komp_Acc,
  114.          Komp_Value,
  115.          Old_Acc,
  116.          Komp_Old_Acc,
  117.          Old_Carry;
  118.  
  119.    address = abs_address( code);
  120.  
  121.    Value = code->Me [address];
  122.    mem_check( address, &Value, code, Func_LOAD);
  123.  
  124.    Komp_Old_Acc = code->Ac;
  125.    if (Komp_Acc >= 0x80)
  126.       Komp_Acc |= (-1 ^ 0xFF);
  127.  
  128.    Komp_Value = Value;
  129.    if (Komp_Value >= 0x80)
  130.       Komp_Value |= (-1 ^ 0xFF);
  131.  
  132.    Old_Acc   = code->Ac;
  133.    Old_Carry = code->Ca;
  134.  
  135.    (code->Ac) += (Value + code->Ca);
  136.    code->Ca = (code->Ac > 0xFF);
  137.    (code->Ac) &= 0xFF;
  138.  
  139.    Komp_Acc = code->Ac;
  140.    if (Komp_Acc >= 0x80)
  141.       Komp_Acc |= (-1 ^ 0xFF);
  142.  
  143.    set_neg_zero_stat( code, code->Ac);
  144.  
  145.    code->Ov = ( (Komp_Old_Acc + Komp_Value + Old_Carry) >= 0x80) ||
  146.               ( !(code->Ne) && (Old_Acc >= 0x80) && (Value >= 0x80) );
  147. }
  148.  
  149. void ADC_abx( code)
  150. PM *code;
  151. {
  152.    unsigned short int address;
  153.  
  154.    short Value,
  155.          Komp_Acc,
  156.          Komp_Value,
  157.          Old_Acc,
  158.          Old_Carry;
  159.  
  160.    address = abs_x_address( code);
  161.  
  162.    Value = code->Me [address];
  163.    mem_check( address, &Value, code, Func_LOAD);
  164.  
  165.    Komp_Acc = code->Ac;
  166.    if (Komp_Acc >= 0x80)
  167.       Komp_Acc |= (-1 ^ 0xFF);
  168.  
  169.    Komp_Value = Value;
  170.    if (Komp_Value >= 0x80)
  171.       Komp_Value |= (-1 ^ 0xFF);
  172.  
  173.    Old_Acc   = code->Ac;
  174.    Old_Carry = code->Ca;
  175.  
  176.    (code->Ac) += (Value + code->Ca);
  177.    code->Ca = (code->Ac > 0xFF);
  178.    (code->Ac) &= 0xFF;
  179.    set_neg_zero_stat( code, code->Ac);
  180.  
  181.    code->Ov = ( (Komp_Acc + Komp_Value + Old_Carry) >= 0x80) ||
  182.               ( !(code->Ne) && (Old_Acc >= 0x80) && (Value >= 0x80) );
  183. }
  184.  
  185. void ADC_aby( code)
  186. PM *code;
  187. {
  188.    unsigned short int address;
  189.  
  190.    short Value,
  191.          Komp_Acc,
  192.          Komp_Value,
  193.          Old_Acc,
  194.          Old_Carry;
  195.  
  196.    address = abs_y_address( code);
  197.  
  198.    Value = code->Me [address];
  199.    mem_check( address, &Value, code, Func_LOAD);
  200.  
  201.    Komp_Acc = code->Ac;
  202.    if (Komp_Acc >= 0x80)
  203.       Komp_Acc |= (-1 ^ 0xFF);
  204.  
  205.    Komp_Value = Value;
  206.    if (Komp_Value >= 0x80)
  207.       Komp_Value |= (-1 ^ 0xFF);
  208.  
  209.    Old_Acc   = code->Ac;
  210.    Old_Carry = code->Ca;
  211.  
  212.    (code->Ac) += (Value + code->Ca);
  213.    code->Ca = (code->Ac > 0xFF);
  214.    (code->Ac) &= 0xFF;
  215.    set_neg_zero_stat( code, code->Ac);
  216.  
  217.    code->Ov = ( (Komp_Acc + Komp_Value + Old_Carry) >= 0x80) ||
  218.               ( !(code->Ne) && (Old_Acc >= 0x80) && (Value >= 0x80) );
  219. }
  220.  
  221. void ADC_inx( code)
  222. PM *code;
  223. {
  224.    unsigned short int address;
  225.  
  226.    short Value,
  227.          Komp_Acc,
  228.          Komp_Value,
  229.          Old_Acc,
  230.          Old_Carry;
  231.  
  232.    address = ind_x_address( code);
  233.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  234.    Value = code->Me [address];
  235.  
  236.    Komp_Acc = code->Ac;
  237.    if (Komp_Acc >= 0x80)
  238.       Komp_Acc |= (-1 ^ 0xFF);
  239.  
  240.    Komp_Value = Value;
  241.    if (Komp_Value >= 0x80)
  242.       Komp_Value |= (-1 ^ 0xFF);
  243.  
  244.    Old_Acc   = code->Ac;
  245.    Old_Carry = code->Ca;
  246.  
  247.    (code->Ac) += (Value + code->Ca);
  248.    code->Ca = (code->Ac > 0xFF);
  249.    (code->Ac) &= 0xFF;
  250.    set_neg_zero_stat( code, code->Ac);
  251.  
  252.    code->Ov = ( (Komp_Acc + Komp_Value + Old_Carry) >= 0x80) ||
  253.               ( !(code->Ne) && (Old_Acc >= 0x80) && (Value >= 0x80) );
  254. }
  255.  
  256. void ADC_iny( code)
  257. PM *code;
  258. {
  259.    unsigned short int address;
  260.  
  261.    short Value,
  262.          Komp_Acc,
  263.          Komp_Value,
  264.          Old_Acc,
  265.          Old_Carry;
  266.  
  267.    address = ind_y_address( code);
  268.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  269.    Value = code->Me [address];
  270.  
  271.    Komp_Acc = code->Ac;
  272.    if (Komp_Acc >= 0x80)
  273.       Komp_Acc |= (-1 ^ 0xFF);
  274.  
  275.    Komp_Value = Value;
  276.    if (Komp_Value >= 0x80)
  277.       Komp_Value |= (-1 ^ 0xFF);
  278.  
  279.    Old_Acc   = code->Ac;
  280.    Old_Carry = code->Ca;
  281.  
  282.    (code->Ac) += (Value + code->Ca);
  283.    code->Ca = (code->Ac > 0xFF);
  284.    (code->Ac) &= 0xFF;
  285.    set_neg_zero_stat( code, code->Ac);
  286.  
  287.    code->Ov = ( (Komp_Acc + Komp_Value + Old_Carry) >= 0x80) ||
  288.               ( !(code->Ne) && (Old_Acc >= 0x80) && (Value >= 0x80) );
  289. }
  290.  
  291. void SBC_imm( code)
  292. PM *code;
  293. {
  294.    short  memory,
  295.           Acc_flag,
  296.           Mem_flag,
  297.           Ans_flag;
  298.  
  299.    memory = code->Me [imm_address( code)];
  300.    Mem_flag = (memory >= 0x80);
  301.    Acc_flag = (code->Ac >= 0x80);
  302.    code->Ac = code->Ac - memory - !code->Ca;
  303.    Ans_flag = (code->Ac >= 0x80);
  304.  
  305.    code->Ca = (code->Ac >= 0);
  306.    code->Ac &= 0xFF;
  307.    code->Ov = (Ans_flag ^ (Acc_flag && Mem_flag)) && !(Acc_flag ^ Mem_flag);
  308.    set_neg_zero_stat( code, code->Ac);
  309. }
  310.  
  311.  
  312. void SBC_zer( code)
  313. PM *code;
  314. {
  315.    unsigned short int address;
  316.  
  317.    short  memory,
  318.           Acc_flag,
  319.           Mem_flag,
  320.           Ans_flag;
  321.  
  322.    address = zero_address( code);
  323.  
  324.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  325.    memory = code->Me [address];
  326.  
  327.    Mem_flag = (memory >= 0x80);
  328.    Acc_flag = (code->Ac >= 0x80);
  329.    code->Ac = code->Ac - memory - !code->Ca;
  330.    Ans_flag = (code->Ac >= 0x80);
  331.  
  332.    code->Ca = (code->Ac >= 0);
  333.    code->Ac &= 0xFF;
  334.    code->Ov = (Ans_flag ^ (Acc_flag && Mem_flag)) && !(Acc_flag ^ Mem_flag);
  335.    set_neg_zero_stat( code, code->Ac);
  336. }
  337.  
  338. void SBC_zex( code)
  339. PM *code;
  340. {
  341.    unsigned short int address;
  342.  
  343.    short  memory,
  344.           Acc_flag,
  345.           Mem_flag,
  346.           Ans_flag;
  347.  
  348.    address = zero_x_address( code);
  349.  
  350.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  351.    memory = code->Me [address];
  352.  
  353.    Mem_flag = (memory >= 0x80);
  354.    Acc_flag = (code->Ac >= 0x80);
  355.    code->Ac = code->Ac - memory - !code->Ca;
  356.    Ans_flag = (code->Ac >= 0x80);
  357.  
  358.    code->Ca = (code->Ac >= 0);
  359.    code->Ac &= 0xFF;
  360.    code->Ov = (Ans_flag ^ (Acc_flag && Mem_flag)) && !(Acc_flag ^ Mem_flag);
  361.    set_neg_zero_stat( code, code->Ac);
  362. }
  363. void SBC_abs( code)
  364. PM *code;
  365. {
  366.    unsigned short int address;
  367.  
  368.    short  memory,
  369.           Acc_flag,
  370.           Mem_flag,
  371.           Ans_flag;
  372.  
  373.    address = abs_address( code);
  374.  
  375.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  376.    memory = code->Me [address];
  377.  
  378.    Mem_flag = (memory >= 0x80);
  379.    Acc_flag = (code->Ac >= 0x80);
  380.    code->Ac = code->Ac - memory - !code->Ca;
  381.    Ans_flag = (code->Ac >= 0x80);
  382.  
  383.    code->Ca = (code->Ac >= 0);
  384.    code->Ac &= 0xFF;
  385.    code->Ov = (Ans_flag ^ (Acc_flag && Mem_flag)) && !(Acc_flag ^ Mem_flag);
  386.    set_neg_zero_stat( code, code->Ac);
  387. }
  388.  
  389. void SBC_abx( code)
  390. PM *code;
  391. {
  392.    unsigned short int address;
  393.  
  394.    short  memory,
  395.           Acc_flag,
  396.           Mem_flag,
  397.           Ans_flag;
  398.  
  399.    address = abs_x_address( code);
  400.  
  401.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  402.    memory = code->Me [address];
  403.  
  404.    Mem_flag = (memory >= 0x80);
  405.    Acc_flag = (code->Ac >= 0x80);
  406.    code->Ac = code->Ac - memory - !code->Ca;
  407.    Ans_flag = (code->Ac >= 0x80);
  408.  
  409.    code->Ca = (code->Ac >= 0);
  410.    code->Ac &= 0xFF;
  411.    code->Ov = (Ans_flag ^ (Acc_flag && Mem_flag)) && !(Acc_flag ^ Mem_flag);
  412.    set_neg_zero_stat( code, code->Ac);
  413. }
  414.  
  415. void SBC_aby( code)
  416. PM *code;
  417. {
  418.    unsigned short int address;
  419.  
  420.    short  memory,
  421.           Acc_flag,
  422.           Mem_flag,
  423.           Ans_flag;
  424.  
  425.    address = abs_y_address( code);
  426.  
  427.    mem_check( address, &(code->Me [address]), code, Func_LOAD);
  428.    memory = code->Me [address];
  429.  
  430.    Mem_flag = (memory >= 0x80);
  431.    Acc_flag = (code->Ac >= 0x80);
  432.    code->Ac = code->Ac - memory - !code->Ca;
  433.    Ans_flag = (code->Ac >= 0x80);
  434.  
  435.    code->Ca = (code->Ac >= 0);
  436.    code->Ac &= 0xFF;
  437.    code->Ov = (Ans_flag ^ (Acc_flag && Mem_flag)) && !(Acc_flag ^ Mem_flag);
  438.    set_neg_zero_stat( code, code->Ac);
  439. }
  440.  
  441.  
  442. void SBC_inx( code)
  443. PM *code;
  444. {
  445.    unsigned short int   address;
  446.    short                memory,
  447.                         Acc_flag,
  448.                         Mem_flag,
  449.                         Ans_flag;
  450.  
  451.    address = ind_x_address( code);
  452.  
  453.    memory = code->Me [address];
  454.    Mem_flag = (memory >= 0x80);
  455.    Acc_flag = (code->Ac >= 0x80);
  456.    code->Ac = code->Ac - memory - !code->Ca;
  457.    Ans_flag = (code->Ac >= 0x80);
  458.  
  459.    code->Ca = (code->Ac >= 0);
  460.    code->Ac &= 0xFF;
  461.    code->Ov = (Ans_flag ^ (Acc_flag && Mem_flag)) && !(Acc_flag ^ Mem_flag);
  462.    set_neg_zero_stat( code, code->Ac);
  463. }
  464.  
  465. void SBC_iny( code)
  466. PM *code;
  467. {
  468.    unsigned short int   address;
  469.    short                memory,
  470.                         Acc_flag,
  471.                         Mem_flag,
  472.                         Ans_flag;
  473.  
  474.    address = ind_y_address( code);
  475.  
  476.    memory = code->Me [address];
  477.    Mem_flag = (memory >= 0x80);
  478.    Acc_flag = (code->Ac >= 0x80);
  479.    code->Ac = code->Ac - memory - !code->Ca;
  480.    Ans_flag = (code->Ac >= 0x80);
  481.  
  482.    code->Ca = (code->Ac >= 0);
  483.    code->Ac &= 0xFF;
  484.    code->Ov = (Ans_flag ^ (Acc_flag && Mem_flag)) && !(Acc_flag ^ Mem_flag);
  485.    set_neg_zero_stat( code, code->Ac);
  486. }
  487.  
  488.  
  489.