// A/B INPUT

if ( NDB_ADD ) BI = ~DB;
if ( DB_ADD ) BI = DB;
if ( ADL_ADD ) BI = ADL;

if ( SB_ADD ) AI = SB;
if ( 0_ADD ) AI = 0;

// LOGIC (based on NAND/NOR)

NOR = ~(AI | BI);
NAND = ~(AI & BI);

if ( ORS ) ADD = NOR;
if ( ANDS ) ADD = NAND;
if ( SRS ) ADD = NAND >> 1;        // next bit feed previous result

if ( EORS ) {
    nEOR[0,2,4,6] = ~ (~NOR & NAND)
    EOR[1,3,5,7] = ~ (~NAND | NOR)
    ADD[0,2,4,6] = nEOR[0,2,4,6]
    ADD[1,3,5,7] = ~EOR[1,3,5,7]
}

// ARITHMETIC
// BCD correction run-flow : DAA -> ALU -> ADD -> DSA -> SB -> AC.

// DECIMAL ADDER ADJUST (detect decimal carry and halfcarry)
// ...

// input carry driver I_ADDC comes in inverted form

// carry chain
carry_out = I_ADDC;

// bits 0,2,4,6
carry_in = carry_out;
carry_out = ~(NAND[0,2,3,6] & carry_in) & ~NOR[0,2,4,6];
SUM[0,2,4,6] = ~(nEOR[0,2,4,6] & ~carry_in) & (nEOR[0,2,4,6] | ~carry_in);

// bits 1,3,5,7
carry_in = carry_out;
carry_out = ~(~NOR[1,3,5,7] & carry_in) & NAND[1,3,5,7];
SUM[1,3,5,7] = ~(EOR[1,3,5,7] & ~carry_in) & (EOR[1,3,5,7] | ~carry_in);

// trans-level implementation of summator see in ALU_sum.png

// overflow test
carry6_out = carry_in;
if ( PHI2 ) AVR_Latch = ~(NOR7 & carry6_out) & (NAND7 | carry6_out);
AVR = AVR_Latch;

if ( SUMS) ADD = SUM;

// High-level implementation :
// s = AI + BI + ~I_ADDC;
// SUM = ~ ( s & 0xFF );
// carry_out = s >> 8;

// ADDER HOLD (register holds data in inverted logic)

if ( ADD_ADL ) ADL = ~ADD;
if ( ADD_SB06 ) SB = (SB & 0x80) | (~ADD & 0x7F);
if ( ADD_SB7 ) SB = (SB & 0x7F) | (~ADD & 0x80);

// DECIMAL SBUS ADJUST (affects SBus lines)
// ...

// ACCUMULATOR

if ( SB_DB ) DB = SB;
if ( SB_AC ) AC = SB;
if ( AC_SB ) SB = AC;
if ( AC_DB ) DB = AC;

if ( 0_ADH0 ) ADH &= ~0x01;
if ( 0_ADH17 ) ADH &= 0x01;

if ( PHI2 )
{
    NDB_ADD = DB_ADD = ADL_ADD = 0_ADD = 0;
    SB_AC = AC_SB = AC_DB = 0;
    ADH = 0;
}

#include <stdio.h>

int nand (int a, int b, int bit )
{
    int bit_a = (a >> bit) & 1;
    int bit_b = (b >> bit) & 1;
    return (~ (bit_a & bit_b)) & 1;
}

int nor (int a, int b, int bit )
{
    int bit_a = (a >> bit) & 1;
    int bit_b = (b >> bit) & 1;
    return (~ (bit_a | bit_b)) & 1;
}

int noteor (int a, int b, int bit )
{
    return ~ (~nor(a,b,bit) & nand(a,b,bit));
}

int eor (int a, int b, int bit )
{
    return ~ (~nand(a,b,bit) | nor(a,b,bit));
}

int alusum ( int a, int b, int carry_in, int *carry, int numbits )
{
    int bit;
    int carry_out = ~carry_in;
    int sum = 0, s;

    for (bit=0; bit<numbits; bit++)
    {
        if ( bit & 1 ) {
            carry_in = carry_out & 1;
            carry_out = ~(~nor(a,b,bit) & carry_in) & nand(a,b,bit);
            s = ~(eor(a,b,bit) & ~carry_in) & (eor(a,b,bit) | ~carry_in);
        }
        else {
            carry_in = carry_out & 1;
            carry_out = ~(nand(a,b,bit) & carry_in) & ~nor(a,b,bit);
            s = ~(noteor(a,b,bit) & ~carry_in) & (noteor(a,b,bit) | ~carry_in);
        }
        //printf ( "%i: %i %i %i %i %i\n", bit, (a >> bit) & 1, (b >> bit) & 1, s & 1, carry_in & 1, carry_out & 1);
        sum |= (s & 1) << bit;
    }

    *carry = ~carry_out & 1;
    return ~sum & ((1 << numbits) - 1);
}

void logic_test ( int a, int b )
{
    int bit;
    for (bit=0; bit<8; bit++)
    {
        printf ( "NAND=%i ", nand(a, b, bit) );
        printf ( "NOR=%i ", nor(a, b, bit) );
        printf ( "EOR=%i \n", eor(a, b, bit) );
        printf ( "!EOR=%i \n", noteor(a, b, bit) );
    }
}

main ()
{
    int a, b, sum, carry;

    //logic_test ( 0x35, 0x53 );

    printf ( "6502 ALU test.\n" );
    printf ( " A  B  S C\n" );

    for ( a=0; a<256; a++ )
    {
        for (b=0; b<256; b++)
        {
            sum = alusum ( a, b, 0, &carry, 8 );
            printf ( "%02X %02X %02X %01X\n", a, b, sum, carry );
        }
    }

}

6502 ALU test.
 A  B  S C
03 F9 FC 0
03 FA FD 0
03 FB FE 0
03 FC FF 0
03 FD 00 1
03 FE 01 1
03 FF 02 1
04 00 04 0
04 01 05 0

carry0_out = ~(NAND0 & I_ADDC) & ~NOR0;
A = ~( ~(~NAND1 & carry0_out) | NOR2 );
B = ~(EOR3 | ~NAND2);
C = ~(EOR1 | ~NAND1) & ~carry0_out & (~NAND2 | NOR2);
DecimalHalfCarry = A & (B | C) & ~DAA;
(Decimal Half Carry is low when DAA driver is high)

A = ~ (~(~NAND5 & carry4_out) | EOR6);
B = ~(~NAND6 | EOR7);
C = ~(~NAND5 | XOR5) & ~(carry4_out | ~EOR6);
DecimalCarry = A & (B | C) & ~DAA;
(DecimalCarry is low when DAA driver is high)

Human-readable explanation:

Decimal HalfCarry is set, when AI and BI are in following combinations:
| AI | BI |
|----|----|
| X3 | X7 |
| X7 | X3 |
| XF | XB |
| XB | XF |

Decimal Carry is set, when AI and BI are in following combinations:
| AI | BI |
|----|----|
| 2X | 3X |
| 3X | 2X |
| 3X | 3X |
| AX | BX |
| BX | AX |
| BX | BX |

X - mean any number 0-F.

// Carry out.
if (PHI2 ) DAA_Latch = ~DAA
CarryOut = ~(DecimalCarry | ~carry7_out)
DSA_CarryOut = ~(CarryOut | ~DAA_Latch)
ACR = ~CarryOut;    // to random logic

// bits 1,3,5,7
carry_in = carry_out;
carry_out = ~(~NOR[1,3,5,7] & carry_in) & NAND[1,3,5,7];
if (bit == 3 && DecimalHalfCarry) carry_out = 0;
SUM[1,3,5,7] = ~(EOR[1,3,5,7] & ~carry_in) & (EOR[1,3,5,7] | ~carry_in);