module cpu.ctfe_d6502;


import cpu.data_d6502;


// The following versions are mutually exclusive.

// OpDelegates: each opcode is a method of the Cpu class.
version(OpDelegates)
{
    enum versionCheck = 1;
    enum opArray = true;
}

// OpFunctions: each opcode is a free function with a Cpu argument.
version(OpFunctions)
{
    enum versionCheck = 2;
    enum opArray = true;

    // With free functions, strict and cumulative need to be set by
    // version.
    version(Strict)
        enum vStrict = true;
    else
        enum vStrict = false;
    version(Cumulative)
        enum vCumulative = true;
    else
        enum vCumulative = false;
}

// OpSwitch: each opcode is inlined in a 256-case switch.
version(OpSwitch)
{
    enum versionCheck = 3;
    enum opArray = false;
}

/*
 * OpNestedSwitch: each opcode is inlined in a nested switch.
 *
 * (The outer one switches on the high byte, with each case switching
 * on the low byte.)
 */
version(OpNestedSwitch)
{
    enum versionCheck = 4;
    enum opArray = false;
}


// At least one of the previous versions must be specified.
static if (!__traits(compiles, { bool b = opArray; })) enum opArray = 0;
static assert (versionCheck);


string OpArrayDef()
{
    version(OpDelegates)
        return q{void delegate()[256] opcodes;};
    else version(OpFunctions)
        return q{void function(typeof(this))[256] opcodes;};
    else
        return "";
}

string OpArrayInit()
{
    static if (!opArray) return "";
    else
    {
        string ret;
        foreach (op; 0..256)
        {
            version(OpDelegates)
                ret ~= Fmt("opcodes[0x#] = &opcode_#;\n",
                           Hex2(op), Hex2(op));
            version(OpFunctions)
                ret ~= Fmt("opcodes[0x#] = &opcode_#!(typeof(this));\n",
                           Hex2(op), Hex2(op));
        }
        return ret;
    }
}

string OpBodies(string chip, bool strict, bool cumulative)
{
    static if (!opArray) return "";
    else
    {
        string ret;
        foreach (op; 0..256)
        {
            version(OpDelegates)
                ret ~= "final void opcode_" ~ Hex2(op) ~ "()\n{\n" ~
                       If!(cumulative)("int cycles = 1;\n") ~
                       OpBody(op, chip, strict, cumulative) ~ "}\n";
            version(OpFunctions)
                ret ~= "void opcode_" ~ Hex2(op) ~
                       "(T)(T cpu) if (is" ~ chip ~ "!T)\n{\n" ~
                       If!(cumulative)("int cycles = 1;\n") ~
                       OpBody(op, chip, strict, cumulative) ~ "}\n";
        }
/+
        foreach (op; 13..256)
            version(OpDelegates)
                ret ~= "final void opcode_" ~ Hex2(op) ~ "()\n{\n" ~
                       If!(cumulative)("int cycles = 1;\n") ~
                       "" ~ "}\n";
            version(OpFunctions)
                ret ~= "void opcode_" ~ Hex2(op) ~
                       "(T)(T cpu) if (is" ~ chip ~ "!T)\n{\n" ~
                       If!(cumulative)("int cycles = 1;\n") ~
                       "" ~ "}\n";
+/
        return ret;
    }
}

string OpExecute(string chip, bool strict, bool cumulative)
{
    version(OpDelegates)
        return q{opcodes[opcode]();};
    version(OpFunctions)
        return q{opcodes[opcode](this);};
    version(OpSwitch)
        return Switch256(chip, strict, cumulative);
    version(OpNestedSwitch)
        return Switch16x16(chip, strict, cumulative);
}

string Switch256(string chip, bool strict, bool cumulative)
{
    string ret = "final switch (opcode)\n{\n";
    foreach (op; 0..256)
        ret ~= "case 0x" ~ Hex2(op) ~ ":\n" ~
               OpBody(op, chip, strict, cumulative) ~ "break;\n";
    return ret ~ "}\n";
}

string Switch16x16(string chip, bool strict, bool cumulative)
{
    string ret = "final switch (opcode & 0xF0)\n{\n";
    foreach (opHi; 0..16)
    {
        ret ~= "case 0x" ~ Hex1(opHi) ~ "0:\n" ~
               "final switch(opcode & 0x0F)\n{\n";
        foreach (opLo; 0..16)
        {
            int op = opLo | (opHi << 4);
            ret ~= "case 0x0" ~ Hex1(opLo) ~ ":\n" ~
                   OpBody(op, chip, strict, cumulative) ~
                   "break;\n";
        }
        ret ~= "}\nbreak;\n";
    }
    return ret ~ "}\n";
}


enum _PC = Attr("PC");
enum _A = Attr("A");
enum _X = Attr("X");
enum _Y = Attr("Y");
enum _N = Attr("N");
enum _V = Attr("V");
enum _D = Attr("D");
enum _I = Attr("I");
enum _Z = Attr("Z");
enum _C = Attr("C");
enum _S = Attr("S");
enum STACK = "0x0100 + " ~ _S;

struct Env
{
    int op;
    string chip;
    bool s, c;
    bool nmos, cmos;
    int mode;
    int exCyc;

    this(int op, string chip, bool s, bool c)
    {
        this.op = op;
        this.chip = chip;
        this.s = s;
        this.c = c;
        nmos = (chip == "6502");
        cmos = !nmos;
        mode = opMode(op, chip);
        exCyc = opExCyc(op, chip);
    }
}

string OpBody(int op, string chip, bool s, bool c)
{
    auto env = Env(op, chip, s, c);
    string ret = ((op == 0x20) ? "" : Address(env));

    final switch (opName(op, chip))
    {
        case "BRK":
            ret ~= Break(env);
            break;
        case "RTI":
            ret ~= RetInt(env);
            break;
        case "JSR":
            ret ~= JumpSub(env);
            break;
        case "RTS":
            ret ~= RetSub(env);
            break;
        case "JMP":
            ret ~= Jump(env);
            break;
        case "KIL":
            ret ~= _PC ~ "--;\n";
            break;
        case "BPL":
            ret ~= Branch("!(" ~ _N ~ " & 0x80)", env);
            break;
        case "BMI":
            ret ~= Branch("(" ~ _N ~ " & 0x80)", env);
            break;
        case "BVC":
            ret ~= Branch("!" ~ _V, env);
            break;
        case "BVS":
            ret ~= Branch(_V, env);
            break;
        case "BRA":
            ret ~= Branch("true", env);
            break;
        case "BCC":
            ret ~= Branch("!" ~ _C, env);
            break;
        case "BCS":
            ret ~= Branch(_C, env);
            break;
        case "BNE":
            ret ~= Branch(_Z, env);
            break;
        case "BEQ":
            ret ~= Branch("!" ~ _Z, env);
            break;
        case "CLC":
            ret ~= ClearFlag(_C);
            break;
        case "SEC":
            ret ~= SetFlag(_C);
            break;
        case "CLI":
            ret ~= ClearFlag(_I);
            break;
        case "SEI":
            ret ~= SetFlag(_I);
            break;
        case "CLV":
            ret ~= ClearFlag(_V);
            break;
        case "CLD":
            ret ~= ClearFlag(_D);
            break;
        case "SED":
            ret ~= SetFlag(_D);
            break;
        case "NOP":
            ret ~= Nop(env);
            break;
        case "TAX":
            ret ~= Transfer(_A, _X, env);
            break;
        case "TXA":
            ret ~= Transfer(_X, _A, env);
            break;
        case "TAY":
            ret ~= Transfer(_A, _Y, env);
            break;
        case "TYA":
            ret ~= Transfer(_Y, _A, env);
            break;
        case "TSX":
            ret ~= Transfer(_S, _X, env);
            break;
        case "TXS":
            ret ~= Transfer(_X, _S, env);
            break;
        case "DEX":
            ret ~= Dec(_X);
            break;
        case "DEY":
            ret ~= Dec(_Y);
            break;
        case "INX":
            ret ~= Inc(_X);
            break;
        case "INY":
            ret ~= Inc(_Y);
            break;
        case "PHP":
            ret ~= Push(Attr("statusToByte()"), env);
            break;
        case "PLP":
            ret ~= PullStatus(env);
            break;
        case "PLA":
            ret ~= PullReg(_A, env);
            break;
        case "PLX":
            ret ~= PullReg(_X, env);
            break;
        case "PLY":
            ret ~= PullReg(_Y, env);
            break;
        case "PHA":
            ret ~= PushReg(_A, env);
            break;
        case "PHX":
            ret ~= PushReg(_X, env);
            break;
        case "PHY":
            ret ~= PushReg(_Y, env);
            break;
        case "LDA":
            ret ~= Load(_A, env);
            break;
        case "LDX":
            ret ~= Load(_X, env);
            break;
        case "LDY":
            ret ~= Load(_Y, env);
            break;
        case "STA":
            ret ~=  Store(_A, env);
            break;
        case "STX":
            ret ~= Store(_X, env);
            break;
        case "STY":
            ret ~= Store(_Y, env);
            break;
        case "STZ":
            ret ~= Store("0", env);
            break;
        case "CMP":
            ret ~= Compare(_A, env);
            break;
        case "CPX":
            ret ~= Compare(_X, env);
            break;
        case "CPY":
            ret ~= Compare(_Y, env);
            break;
        case "BIT":
            ret ~= Bit(env);
            break;
        case "ORA":
            ret ~= Logic("|=", env);
            break;
        case "AND":
            ret ~= Logic("&=", env);
            break;
        case "EOR":
            ret ~= Logic("^=", env);
            break;
        case "ADC":
            ret ~= Add(env);
            break;
        case "SBC":
            ret ~= Sub(env);
            break;
        case "INC":
            if (op == 0x1a)
                ret ~= Inc(_A);
            else
                ret ~= RMW(Inc("data"), env);
            break;
        case "DEC":
            if (op == 0x3a)
                ret ~= Dec(_A);
            else
                ret ~= RMW(Dec("data"), env);
            break;
        case "ASL":
            if (op == 0x0a)
                ret ~= ShiftLeft(_A);
            else
                ret ~= RMW(ShiftLeft("data"), env);
            break;
        case "ROL":
            if (op == 0x2a)
                ret ~= RotateLeft(_A);
            else
                ret ~= RMW(RotateLeft("data"), env);
            break;
        case "LSR":
            if (op == 0x4a)
                ret ~= ShiftRight(_A);
            else
                ret ~= RMW(ShiftRight("data"), env);
            break;
        case "ROR":
            if (op == 0x6a)
                ret ~= ShiftRight(_A);
            else
                ret ~= RMW(RotateRight("data"), env);
            break;
        case "TRB":
                ret ~= RMW(TestReset(), env);
                break;
        case "TSB":
                ret ~= RMW(TestSet(), env);
                break;
        case "LAS":
            ret ~= LAS_Undoc(env);
            break;
        case "LAX":
            if (op != 0xAB)
                ret ~= Load(_A ~ " = " ~ _X, env);
            else
                return "";
            break;
        case "SAX":
            ret ~= Store(_A ~ " & " ~ _X, env);
            break;
        case "ANC":
            ret ~= ANC_Undoc(env);
            break;
        case "ALR":
            ret ~= ALR_Undoc(env);
            break;
        case "ARR":
            ret ~= ARR_Undoc(env);
            break;
        case "AXS":
            ret ~= AXS_Undoc(env);
            break;
        case "AHX":
            return "";
        case "SHY":
            return "";
        case "SHX":
            return "";
        case "TAS":
            return "";
        case "XAA":
            return "";
        case "SLO":
            ret ~= RMW_Undoc(ShiftLeft("data"),
                             SetNZ(_A ~ " |= data"), env);
            break;
        case "RLA":
            ret ~= RMW_Undoc(RotateLeft("data"),
                             SetNZ(_A ~ " &= data"), env);
            break;
        case "SRE":
            ret ~= RMW_Undoc(ShiftRight("data"),
                             SetNZ(_A ~ " ^= data"), env);
            break;
        case "RRA":
            ret ~= RMW_Undoc(RotateRight("data"), AddBase(env), env);
            break;
        case "DCP":
            ret ~= RMW_Undoc(Dec("data"), CompareBase(_A, env), env);
            break;
        case "ISC":
            ret ~= RMW_Undoc(Inc("data"), SubBase(env), env);
            break;
    }
    return ret ~ Done(env);
}


string Break(Env env)
{
    return IncPC() ~
           PushPC(env) ~
           Push(Attr("statusToByte()"), env) ~
           SetFlag(_I) ~
           ReadWord(_PC, "IRQ_VECTOR", env);
}


string JumpSub(Env env)
{
    return ReadOp(Local("ushort", "address"), env) ~
           Peek(STACK, env) ~
           PushPC(env) ~
           LoadHiByte("address", _PC ~ "++", env) ~
           _PC ~ " = address;\n";
}


string RetSub(Env env)
{
    return Peek(STACK, env) ~
           PullPC(env) ~
           Peek(_PC, env) ~
           IncPC();
}


string RetInt(Env env)
{
    return PullStatus(env) ~
           PullPC(env);
}


string Jump(Env env)
{
    bool cmos = env.cmos;
    bool nmos = env.nmos;

    if (env.op == 0x4c)
        return _PC ~ " = address;\n";
    else if (env.op == 0x6c)
        return ReadWordOp("ushort", "base", env) ~
               If!(cmos)(
                   Peek(_PC, env)) ~
               ReadWordBasic(_PC, "base",
                             If!(nmos)(
                                 "(base & 0xFF00) | cast(ubyte)(base + 1)",
                                 "cast(ushort)(base + 1)"), env);
    else if (env.op == 0x7c)
        return ReadWordOp("ushort", "base",  env) ~
               Peek(_PC, env) ~
               ReadWord(_PC, "cast(ushort)(base + " ~ _X ~ ")", env);
    return "";
}


string Branch(string check, Env env)
{
    return ReadOp(Local("ushort", "base"), env) ~
           "if (" ~ check ~ ")\n{\n" ~
               Peek(_PC, env) ~
               Local("ushort", "address") ~
               " = cast(ushort)(" ~ _PC ~ " + cast(byte)base);\n" ~
               CheckShortcut(_PC, "address", env) ~
               _PC ~ " = address;\n" ~
           "}\n";
}


string Nop(Env env)
{
    if (env.mode == IMP ||  env.mode == NP1 || env.mode == NP8)
        return ""; // XXX add np1/np8 stuff
    else
        return PreAccess(env) ~
               ReadRaw("address") ~ ";\n";
}


string Transfer(string source, string dest, Env env)
{
    return dest ~ " = " ~ source ~ ";\n" ~
           ((env.op != 0x9a) ? SetNZ(dest) : "");
}


string PullReg(string reg, Env env)
{
    return Peek(STACK, env) ~
           PullInto(reg, env) ~
           SetNZ(reg);
}


string PushReg(string reg, Env env)
{
    return Push(reg, env);
}


string Load(string reg, Env env)
{
    return ReadInto(reg, "address", env) ~
           SetNZ(reg);
}


string Store(string reg, Env env)
{
    return Write("address", reg, env);
}


string Compare(string reg, Env env)
{
    return ReadInto(Local("ubyte", "data"), "address", env) ~
           CompareBase(reg, env);
}

string CompareBase(string reg, Env env)
{
    return UpdateFlag(_C, reg ~ " >= data") ~
           SetNZ("cast(ubyte)(" ~ reg ~ " - data)");
}


string Bit(Env env)
{
    bool notImm = (env.mode != IMM);

    return ReadInto(Local("ubyte", "data"), "address", env) ~
           If!(notImm)(
               _N ~ " = data;\n" ~
               _V ~ " = ((data & 0x40) != 0);\n") ~
           _Z ~ " = (" ~ _A ~ " & data);\n";
}


string Logic(string action, Env env)
{
    return ReadInto(_A, action, "address", env) ~
           SetNZ(_A);
}


string Add(Env env)
{
    return ReadInto(Local("ubyte", "data"), "address", env) ~
           AddBase(env);
}

string AddBase(Env env)
{
    return "if (" ~ _D ~ ")\n{\n" ~
               DecAdd(env) ~
           "}\nelse\n{\n" ~
               HexAdd(env) ~
           "}\n";
}

string HexAdd(Env env)
{
    return "uint sum = " ~ _A ~ " + data + " ~ _C ~ ";\n" ~
           _V ~
           " = (!((" ~ _A ~ " ^ data) & 0x80)) && ((data ^ sum) & 0x80);\n" ~
           _C ~ " = (sum > 0xFF);\n" ~
           SetNZ(_A ~ " = cast(ubyte)sum");
}

string DecAdd(Env env)
{
    bool cmos = env.cmos;

    return "int a = " ~ _A ~ ";\n" ~
           "int al = (a & 0x0F) + (data & 0x0F) + " ~ _C ~ ";\n" ~
           "if (al >= 0x0A)\n" ~
               "al = ((al + 0x06) & 0x0F) + 0x10;\n" ~
           "a = (a & 0xF0) + (data & 0xF0) + al;\n" ~
           If!(cmos)("",
               _N ~ " = cast(ubyte)a;\n" ~
               _Z ~ " = cast(ubyte)(" ~ _A ~ " + data + " ~ _C ~ ");\n") ~
           _V ~
           " = (!((" ~ _A ~ " ^ data) & 0x80)) && ((data ^ a) & 0x80);\n" ~
           "if (a >= 0xA0)\n" ~
               "a = a + 0x60;\n" ~
           _C ~ " = (a >= 0x100);\n" ~
           If!(cmos)(
               SetNZ(_A ~ " = cast(ubyte)a") ~ Peek(_PC, env),
               _A ~ " = cast(ubyte)a;\n");
}


string Sub(Env env)
{
    return ReadInto(Local("ubyte", "data"), "address", env) ~
           SubBase(env);
}

string SubBase(Env env)
{
    bool nmos = env.nmos;

    return "if (" ~ _D ~ ")\n{\n" ~
               If!(nmos)(DecSubNMOS(), DecSubCMOS(env)) ~
           "}\nelse\n{\n" ~
               HexSub() ~
           "}\n";
}

string HexSub()
{
    return "uint diff = " ~ _A ~ " - data - !" ~ _C ~ ";\n" ~
           _V ~
           " = ((" ~ _A ~ " ^ diff) & 0x80) && ((" ~
           _A ~ " ^ data) & 0x80);\n" ~
           _C ~ " = (diff < 0x100);\n" ~
           SetNZ(_A ~ " = cast(ubyte)diff");
}

string DecSubNMOS()
{
    return "int a = " ~ _A ~ ";\n" ~
           "int al = (a & 0x0F) - (data & 0x0F) - !" ~ _C ~ ";\n" ~
           "if (al < 0)\n" ~
               "al = ((al - 0x06) & 0x0F) - 0x10;\n" ~
           "a = (a & 0xF0) - (data & 0xF0) + al;\n" ~
           "if (a < 0)\n" ~
               "a = a - 0x60;\n" ~
           "uint diff = " ~ _A ~ " - data - !" ~ _C ~ ";\n" ~
           _V ~
           " = ((" ~ _A ~ " ^ diff) & 0x80) && ((" ~
           _A ~ " ^ data) & 0x80);\n" ~
           _C ~ " = (diff < 0x100);\n" ~
           SetNZ("cast(ubyte)diff") ~
           _A ~ " = cast(ubyte)a;\n";
}

string DecSubCMOS(Env env)
{
    return "int a = " ~ _A ~ ";\n" ~
           "int al = (a & 0x0F) - (data & 0x0F) - !" ~ _C ~ ";\n" ~
           "a = a - data - !" ~ _C ~ ";\n" ~
           "if (a < 0) a = a - 0x60;\n" ~
           "if (al < 0) a = a - 0x06;\n" ~
           "uint diff = " ~ _A ~ " - data - !" ~ _C ~ ";\n" ~
           _V ~
           " = ((" ~ _A ~ " ^ diff) & 0x80) && ((" ~
           _A ~ " ^ data) & 0x80);\n" ~
           _C ~ " = (diff < 0x100);\n" ~
           Peek(_PC, env) ~
           SetNZ(_A ~ " = cast(ubyte)a");
}


string Inc(string val)
{
    return val ~ "++;\n" ~
           SetNZ(val);
}


string Dec(string val)
{
    return val ~ "--;\n" ~
           SetNZ(val);
}


string ShiftLeft(string val)
{
    return _C ~ " = (" ~ val ~ " > 0x7F);\n" ~
           SetNZ(val ~ " = cast(ubyte)(" ~ val ~ " << 1)");
}


string RotateLeft(string val)
{
    return "auto oldC = " ~ _C ~ ";\n" ~
            _C ~ " = (" ~ val ~ " > 0x7f);\n" ~
            SetNZ(val ~ " = cast(ubyte)(" ~ val ~ " << 1 | (oldC ? 1 : 0))");
}


string ShiftRight(string val)
{
    return _C ~ " = ((" ~ val ~ " & 0x01) != 0);\n" ~
           SetNZ(val ~ " = " ~ val ~ " >> 1");
}


string RotateRight(string val)
{
    return "auto oldC = " ~ _C ~ ";\n" ~
           _C ~ " = ((" ~ val ~ " & 0x01) != 0);\n" ~
           SetNZ(val ~ " = (" ~ val ~ " >> 1 | (oldC ? 0x80 : 0))");
}


string TestReset()
{
    return _Z ~ " = data & " ~ _A ~ ";\n" ~
           "data &= (~" ~ _A ~ ");\n";
}


string TestSet()
{
    return _Z ~ " = data & " ~ _A ~ ";\n" ~
           "data |= " ~ _A ~ ";\n";
}


string RMW(string action, Env env)
{
    bool nmos = env.nmos;

    return ReadInto(Local("ubyte", "data"), "address", env) ~
           If!(nmos)(Poke("address", "data", env),
                     Peek("address", env)) ~
           action ~
           Write("address", "data", env);
}


string RMW_Undoc(string action1, string action2, Env env)
{
    return ReadInto(Local("ubyte", "data"), "address", env) ~
           Poke("address", "data", env) ~
           action1 ~
           Write("address", "data", env) ~
           action2;
}


string LAS_Undoc(Env env)
{
    return ReadInto(Local("ubyte", "data"), "address", env) ~
           SetNZ(_X ~ " = " ~ _A ~ " = (" ~ _S ~ " & data)");
}


string ARR_Undoc(Env env)
{
    return ReadInto(Local("ubyte", "data"), "address", env) ~
           "ubyte tmp1 = data & " ~ _A ~ ";\n" ~
           "if (" ~ _D ~ ")\n{\n" ~
               "ubyte tmp2 = cast(ubyte)((tmp1 >> 1) + (" ~
               _C ~ " ? 0x80 : 0));\n" ~
               _N ~ " = " ~ _Z ~ " = tmp2;\n" ~
               _V ~ " = (((tmp2 ^ tmp1) & 0x40) != 0);\n" ~
               "if ((data & 0x0F) + (tmp1 & 0x01) > 5)\n" ~
                   "tmp2 = (tmp2 & 0xF0) + ((tmp2 + 0x6) & 0x0F);\n" ~
               "if (tmp1 + (tmp1 & 0x10) >= 0x60)\n{\n" ~
                   "tmp2 += 0x60;\n" ~
                   SetFlag(_C) ~
               "}\nelse\n" ~
                   ClearFlag(_C) ~
               _A ~ " = tmp2;\n" ~
           "}\nelse{\n" ~
               _A ~ " = cast(ubyte)((tmp1 >> 1) + (" ~
               _C ~ " ? 0x80 : 0));\n" ~
               _N ~ " = " ~ _Z ~ " = " ~_A ~ ";\n" ~
               "tmp1 >>= 7;\n" ~
               _C ~ " = (tmp1 != 0);\n" ~
               _V ~ " = ((tmp1 ^ ((" ~ _A ~ " >> 5) & 1)) != 0);\n}";
}


string ANC_Undoc(Env env)
{
    return ReadInto(_A, "address", env) ~
           SetNZ(_A) ~
           _C ~ " = (" ~ _A ~ " > 0x7f);\n";
}


string ALR_Undoc(Env env)
{
    return ReadInto(Local("ubyte", "data"), "address", env) ~
           _A ~ " &= data;\n" ~
           ShiftRight(_A);
}


string AXS_Undoc(Env env)
{
    return ReadInto(Local("ubyte", "data"), "address", env) ~
           _X ~ " &= " ~ _A ~ ";\n" ~
           CompareBase(_X, env);
}


string Local(string type)
{
    version(OpFunctions)
        return type ~ " ";
    else
        return "";
/+
    version(OpSwitch)
        return "";
    else version(OpNestedSwitch)
        return "";
    else
        return  type ~ " ";
+/
}

string Local(string type, string var)
{
    version(OpFunctions)
        return type ~ " " ~ var;
    else
        return var;
/+
    version(OpSwitch)
        return var;
    else version(OpNestedSwitch)
        return var;
    else
        return type ~ " " ~ var;
+/
}

string Attr(string var)
{
    version(OpFunctions)
        return "cpu." ~ var;
    else
        return var;
}


string Address(Env env)
{
    final switch (env.mode)
    {
        case IMP:
            return AddrIMP(env);
        case IMM:
            return AddrIMM(env);
        case ZP:
            return AddrZP(env);
        case ZPX:
            return AddrZPXY(_X, env);
        case ZPY:
            return AddrZPXY(_Y, env);
        case IZX:
            return AddrIZX(env);
        case IZY:
            return AddrIZY(env);
        case ABS:
            return AddrABS(env);
        case ABX:
            return AddrABXY(_X, env);
        case ABY:
            return AddrABXY(_Y, env);
        case IND:
            return "";
        case REL:
            return "";
        case ZPI:
            return AddrZPI(env);
        case ABI:
            return "";
        case NP1:
            return "";
        case NP8:
            return AddrNP8(env);
        case KIL:
            return "";
    }
    return "";
}


string AddrIMM(Env env)
{
     return Local("ushort") ~ "address = " ~ _PC ~ "++;\n";
}

string AddrIMP(Env env)
{
    return Peek(_PC, env);
}

string AddrZP(Env env)
{
    return ReadOp(Local("ushort", "address"), env);
}

string AddrZPXY(string reg, Env env)
{
    bool nmos = env.nmos;

    return ReadOp(Local("ushort", "base"), env) ~
           If!(nmos)(
               Peek("base", env),
               Peek(_PC, env)) ~
           Local("ushort") ~
           "address = cast(ubyte)(base + " ~ reg ~ ");\n";
}

string AddrIZX(Env env)
{
    bool nmos = env.nmos;

    return ReadOp(Local("ushort", "base"), env) ~
           If!(nmos)(
               Peek("base", env),
               Peek(_PC, env)) ~
           ReadWordZP("ushort", "address", "base + " ~ _X, env);
}

string AddrIZY(Env env)
{
    return ReadOp("ubyte vector", env) ~
           ReadWordZP("ushort", "base", "vector", env) ~
           Local("ushort") ~
           "address = cast(ushort)(base + " ~ _Y ~ ");\n" ~
           CheckShortcut("base", "address", env);
}

string AddrABS(Env env)
{
    return ReadWordOp("ushort", "address", env);
}

string AddrABXY(string reg, Env env)
{
    return ReadWordOp("ushort", "base", env) ~
           Local("ushort") ~ "address = cast(ushort)(base + " ~ reg ~ ");\n" ~
           CheckShortcut("base", "address", env);
}

string AddrZPI(Env env)
{
    return ReadOp(Local("ushort", "base"), env) ~
           ReadWordZP("ushort", "address", "base", env);
}

string AddrNP8(Env env)
{
    return ReadOp(Local("ushort", "base"), env) ~
           Peek(_PC, env) ~
           IncPC() ~
           Peek("0xff00 | base", env) ~
           Peek("0xffff", env) ~
           Peek("0xffff", env) ~
           Peek("0xffff", env) ~
           Peek("0xffff", env);
}

string CheckShortcut(string base, string addr, Env env)
{
    bool nmos = env.nmos;
    int exCyc = env.exCyc;

    return "ushort guess = (" ~ base ~ " & 0xFF00) | cast(ubyte)" ~ addr ~ ";\n" ~
           "if (guess != " ~ addr ~ ")\n{\n" ~
               If!(nmos)(Peek("guess", env),
                         Peek(_PC, env)) ~
           "}\n" ~
           If!(exCyc)("else\n{\n" ~ Peek("address", env) ~ "}\n");
}


string ReadInto(string var, string action, string addr, Env env)
{
    return PreAccess(env) ~
           var ~ " " ~ action ~ " " ~ ReadRaw("(" ~ addr ~ ")") ~ ";\n";
}

string ReadInto(string var, string addr, Env env)
{
    return ReadInto(var, "=", addr, env);
}

string ReadOp(string var, Env env)
{
    return ReadInto(var, _PC ~ "++", env);
}

string ReadRaw(string addr)
{
    return Attr("memory") ~ ".read(" ~ addr ~")";
}

string ReadWordBasic(string type, string var, string addr1, string addr2,
                     Env env)
{
    return LoadLoByte(type, var, addr1, env) ~
           LoadHiByte(var, addr2, env);
}

string ReadWordBasic(string var, string addr1, string addr2, Env env)
{
    return ReadWordBasic("", var, addr1, addr2, env);
}

string ReadWord(string type, string var, string addr, Env env)
{
    return ReadWordBasic(type, var, addr, "cast(ushort)(" ~ addr ~ " + 1)",
                         env);
}

string ReadWord(string var, string addr, Env env)
{
    return ReadWord("", var, addr, env);
}

string ReadWordZP(string type, string var, string addr, Env env)
{
    return ReadWordBasic(type, var, "cast(ubyte)( " ~ addr ~ ")",
                                    "cast(ubyte)(" ~ addr ~ " + 1)", env);
}

string ReadWordZP(string var, string addr, Env env)
{
    return ReadWordZP("", var, addr, env);
}

string ReadWordOp(string type, string var, Env env)
{
    return ReadWordBasic(type, var, _PC ~ "++", _PC ~ "++", env);
}

string ReadWordOp(string var, Env env)
{
    return ReadWordOp("", var, env);
}

string PreAccess(Env env)
{
    bool c = env.c;
    return If!(c)("++cycles;\n", Attr("clock") ~ ".tick();\n");
}

string Peek(string addr, Env env)
{
    bool s = env.s;
    return PreAccess(env) ~
           If!(s)(Attr("memory") ~ ".read(" ~ addr ~");\n");
}

string Poke(string addr, string val, Env env)
{
    bool s = env.s;
    return PreAccess(env) ~
           If!(s)(
               Attr("memory") ~ ".write(" ~ addr ~ ", " ~ val ~ ");\n");
}

string Write(string addr, string val, Env env)
{
    return PreAccess(env) ~
           Attr("memory") ~ ".write(" ~ addr ~ ", " ~ val ~ ");\n";
}

string IncPC()
{
    return "++" ~ _PC ~ ";\n";
}


string IncSP()
{
    return "++" ~ _S ~ ";\n";
}

string DecSP()
{
    return "--" ~ _S ~ ";\n";
}

string PullStatus(Env env)
{
    return Peek(STACK, env) ~
           IncSP() ~
           PreAccess(env) ~
           Attr("statusFromByte") ~ "(" ~
           ReadRaw(STACK) ~ ");\n";
}

string PullInto(string var, Env env)
{
    return IncSP() ~
           ReadInto(var, STACK, env);
}

string Push(string val, Env env)
{
    return Write(STACK, val, env) ~
           DecSP();
}

string PushPC(Env env)
{
    return Push(HiByte(_PC), env) ~
           Push(LoByte(_PC), env);
}


string PullPC(Env env)
{
    return PullInto(_PC, env) ~
           IncSP() ~
           LoadHiByte(_PC, STACK, env);
}

string LoadLoByte(string type, string var, string addr, Env env)
{
    return PreAccess(env) ~
           Local(type, var) ~ " = " ~ ReadRaw(addr) ~ ";\n";
}

string LoadHiByte(string var, string addr, Env env)
{
    return PreAccess(env) ~
           var ~ " |= (" ~ ReadRaw(addr) ~ " << 8);\n";
}

string SetFlag(string flag)
{
    return flag ~ " = true;\n";
}

string ClearFlag(string flag)
{
    return flag ~ " = false;\n";
}

string UpdateFlag(string flag, string val)
{
    return flag ~ " = (" ~ val ~ ");\n";
}

string SetNZ(string var)
{
    return _N ~ " = " ~ _Z ~ " = (" ~ var ~ ");\n";
}

string Done(Env env)
{
    bool c = env.c;
    return If!(c)(Attr("clock") ~ ".tick(cycles);\n");
}


string HiByte(string var)
{
    return var ~ " >> 8";
}

string LoByte(string var)
{
    return var ~ " & 0xff";
}


string If(alias cond)(string yes, string no = "")
{
    if (cond)
        return yes;
    else
        return no;
}


string opName(int op, string chip)
{
    if (chip == "6502")
        return OP_NAMES_6502[op];
    else
        return OP_NAMES_65C02[op];
}

int opMode(int op, string chip)
{
    if (chip == "6502")
        return ADDR_MODES_6502[op];
    else
        return ADDR_MODES_65C02[op];
}

int opExCyc(int op, string chip)
{
    if (chip == "6502")
        return EXTRA_CYCLES_6502[op];
    else
        return EXTRA_CYCLES_65C02[op];
}


// Custom string formatting.

enum HEX_DIGITS = "0123456789abcdef";

string Hex1(int dec)
{
    return HEX_DIGITS[dec..dec+1];
}

string Hex2(int dec)
{
    int highNybble = (dec & 0xF0) >> 4;
    int lowNybble = dec & 0x0F;

    return HEX_DIGITS[highNybble..highNybble+1] ~
           HEX_DIGITS[lowNybble..lowNybble+1];
}

string Fmt(string f, string[] p ...)
{
    if (!p.length) return "ERROR";
    string ret;
    size_t last;
    size_t other;
    for (size_t i = 0; i < f.length; i++)
    {
        if (f[i] == '#')
        {
            if (other == p.length) return "ERROR";
            ret ~= f[last..i] ~ p[other++];
            last = i + 1;
        }
    }
    return ret ~ f[last..$];
}