Si tu regardes il a plein de templates, par exemple add16.cs et il peut l'appliquer à n'importe quel registre (j'imagine), donc ça doit être une sorte d'include avec paramètre, j'ai pas regardé en détail.
Tu es un peu obligé si tu vises la vitesse max. Perso j'ai un truc comme ça:

u8 opcode = op_readb();
u8 upper_digit = opcode >> 6, mid_digit = opcode >> 3 & 7, low_digit = opcode & 7;
switch (upper_digit) {
case 0:
    switch (low_digit) {
    case 1:
        if ((opcode & 010) == 0) {    // 00 dd0 001 [nn nn] -> ld dd, nnnn
            op_dd_write(mid_digit >> 1, pc_readw());
            return 3;
        }
        else {    // 00 dd1 001 -> add hl, dd
            add16(R_HL, op_dd_read(mid_digit >> 1));
            return 2;
        }
    }
}

Mais c'est plus lent parce qu'il faut décoder avec 2 ou 3 switches + l'opérande (op_dd_read dans mon cas), au lieu d'en avoir un seul et pas de décodage:

switch (opcode = op_readb()) {
// ld dd, nnnn - 3 cycles
case 0001:
    regs.BC.w = pc_readw();
    return 3;
case 0021:
    regs.DE.w = pc_readw();
    return 3;
case 0041:
    regs.HL.w = pc_readw();
    return 3;
case 0061:
    regs.SP = pc_readw();
    return 3;
// add hl, dd - 2 cycles
case 0011:
    add16(&regs.HL.w, regs.BC.w);
    return 2;
case 0031:
    add16(&regs.HL.w, regs.DE.w);
    return 2;
case 0051:
    add16(&regs.HL.w, regs.HL.w);
    return 2;
case 0071:
    add16(&regs.HL.w, regs.SP);
    return 2;
}

Et avec son truc tu remplaces les appels à add16 (lent) par le code correspondant, inline.
Cette dernière approche est aussi plus prône aux erreurs (j'ai dû éditer 2 fois ces pauvres lignes quand même et je suis toujours pas sûr que c'est juste ).