Printable View
Seems like an amazing coder to me but there are things like magic numbers and one letter variables that I notice him using. I have always read that it's bad to do stuff like that:
Creating a NES emulator in C++11 (PART 1/2) - YouTube
To me if that's for educational purposes, I think he should have at least slowed it down and had some discussion while he wrote it (Of course the video would be a lot longer)
Awful waste of bandwidth and crap music soundtrack.
Seriously, far more could be accomplished in 10K of text on a web page (source code and explanatory notes) than watching 100+MB of crazy typing and pointless music.
LOL! Not sure if he purposely obscures the code too... What the heck:
Code:#define t(s,code) { enum { \
i=o8m & (s[o8]>90 ? (130+" (),-089<>?BCFGHJLSVWZ[^hlmnxy|}"[s[o8]-94]) \
: (s[o8]-" (("[s[o8]/39])) }; if(i) { code; } }
that is probably the ugliest bit of code I've ever seen. what is the context of the code? what exactly is it supposed to do? is it deliberately obfuscated?Quote:
Originally Posted by Syscal
Can't say that it's deliberate since he posted the video and code for "educational purposes". The code is part of an NES emulator he has written. I for one can't follow the code when the most of it is written like that.
It's part of the "opcode decoding matrix." Can't say I approve of this obfuscation. Better to have many functions decoding these opcodes instead of this obfuscation.Quote:
Originally Posted by Elkvis
Overall impressions, though: Minus points for use of C I/O, some bad brace placement, use of unions, long complex expressions, C-style arrays and abusing enums as constants.
Use of namespace and templates are nice, though overall, save for a little use of some vector, this differs not much from C code. Now that I'd expect it to. This is very low-level code, and that in turn often makes it close to how C would do it.
It's amazingly confusing yet it works... Somehow he operates on string literals to execute opcodes... I have a function for every single opcode in my MOS 6502 emulator and I think anyone could follow through it. He has these strings that somehow perform the operations themselves... Blows my mind. Below is the snippet that follows the above define. Do people do stuff like this in production code and is it a big no no?
Code:
/* Decode address operand */
t(" !", addr = 0xFFFA) // NMI vector location
t(" *", addr = 0xFFFC) // Reset vector location
t("! ,", addr = 0xFFFE) // Interrupt vector location
t("zy}z{y}zzy}zzy}zzy}zzy}zzy}zzy}z ", addr = RB(PC++))
t("2 yy2 yy2 yy2 yy2 XX2 XX2 yy2 yy ", d = X) // register index
t(" 62 62 62 62 om om 62 62 ", d = Y)
t("2 y 2 y 2 y 2 y 2 y 2 y 2 y 2 y ", addr=u8(addr+d); d=0; tick()) // add zeropage-index
t(" y z!y z y z y z y z y z y z y z ", addr=u8(addr); addr+=256*RB(PC++)) // absolute address
t("3 6 2 6 2 6 286 2 6 2 6 2 6 2 6 /", addr=RB(c=addr); addr+=256*RB(wrap(c,c+1)))// indirect w/ page wrap
t(" *Z *Z *Z *Z 6z *Z *Z ", Misfire(addr, addr+d)) // abs. load: extra misread when cross-page
t(" 4k 4k 4k 4k 6z 4k 4k ", RB(wrap(addr, addr+d)))// abs. store: always issue a misread
/* Load source operand */
t("aa__ff__ab__,4 ____ - ____ ", t &= A) // Many operations take A or X as operand. Some try in
t(" knnn 4 99 ", t &= X) // error to take both; the outcome is an AND operation.
t(" 9989 99 ", t &= Y) // sty,dey,iny,tya,cpy
t(" 4 ", t &= S) // tsx, las
t("!!!! !! !! !! ! !! !! !!/", t &= P.raw|pbits; c = t)// php, flag test/set/clear, interrupts
t("_^__dc___^__ ed__98 ", c = t; t = 0xFF) // save as second operand
t("vuwvzywvvuwvvuwv zy|zzywvzywv ", t &= RB(addr+d)) // memory operand
t(",2 ,2 ,2 ,2 -2 -2 -2 -2 ", t &= RB(PC++)) // immediate operand
/* Operations that mogrify memory operands directly */
t(" 88 ", P.V = t & 0x40; P.N = t & 0x80) // bit
t(" nink nnnk ", sb = P.C) // rol,rla, ror,rra,arr
t("nnnknnnk 0 ", P.C = t & 0x80) // rol,rla, asl,slo,[arr,anc]
t(" nnnknink ", P.C = t & 0x01) // lsr,sre, ror,rra,asr
t("ninknink ", t = (t << 1) | (sb * 0x01))
t(" nnnknnnk ", t = (t >> 1) | (sb * 0x80))
t(" ! kink ", t = u8(t - 1)) // dec,dex,dey,dcp
t(" ! khnk ", t = u8(t + 1)) // inc,inx,iny,isb
/* Store modified value (memory) */
t("kgnkkgnkkgnkkgnkzy|J kgnkkgnk ", WB(addr+d, t))
t(" q ", WB(wrap(addr, addr+d), t &= ((addr+d) >> 8))) // [shx,shy,shs,sha?]
/* Some operations used up one clock cycle that we did not account for yet */
t("rpstljstqjstrjst - - - -kjstkjst/", tick()) // nop,flag ops,inc,dec,shifts,stack,transregister,interrupts
/* Stack operations and unconditional jumps */
t(" ! ! ! ", tick(); t = Pop()) // pla,plp,rti
t(" ! ! ", RB(PC++); PC = Pop(); PC |= (Pop() << 8)) // rti,rts
t(" ! ", RB(PC++)) // rts
t("! ! /", d=PC+(op?-1:1); Push(d>>8); Push(d)) // jsr, interrupts
t("! ! 8 8 /", PC = addr) // jmp, jsr, interrupts
t("!! ! /", Push(t)) // pha, php, interrupts
/* Bitmasks */
t("! !! !! !! !! ! !! !! !!/", t = 1)
t(" ! ! !! !! ", t <<= 1)
t("! ! ! !! !! ! ! !/", t <<= 2)
t(" ! ! ! ! ! ", t <<= 4)
t(" ! ! ! !____ ", t = u8(~t)) // sbc, isb, clear flag
t("`^__ ! ! !/", t = c | t) // ora, slo, set flag
t(" !!dc`_ !! ! ! !! !! ! ", t = c & t) // and, bit, rla, clear/test flag
t(" _^__ ", t = c ^ t) // eor, sre
/* Conditional branches */
t(" ! ! ! ! ", if(t) { tick(); Misfire(PC, addr = s8(addr) + PC); PC=addr; })
t(" ! ! ! ! ", if(!t) { tick(); Misfire(PC, addr = s8(addr) + PC); PC=addr; })
/* Addition and subtraction */
t(" _^__ ____ ", c = t; t += A + P.C; P.V = (c^t) & (A^t) & 0x80; P.C = t & 0x100)
t(" ed__98 ", t = c - t; P.C = ~t & 0x100) // cmp,cpx,cpy, dcp, sbx
/* Store modified value (register) */
t("aa__aa__aa__ab__ 4 !____ ____ ", A = t)
t(" nnnn 4 ! ", X = t) // ldx, dex, tax, inx, tsx,lax,las,sbx
t(" ! 9988 ! ", Y = t) // ldy, dey, tay, iny
t(" 4 0 ", S = t) // txs, las, shs
t("! ! ! !! ! ! ! ! !/", P.raw = t & ~0x30) // plp, rti, flag set/clear
/* Generic status flag updates */
t("wwwvwwwvwwwvwxwv 5 !}}||{}wv{{wv ", P.N = t & 0x80)
t("wwwv||wvwwwvwxwv 5 !}}||{}wv{{wv ", P.Z = u8(t) == 0)
t(" 0 ", P.V = (((t >> 5)+1)&2)) // [arr]
It's a way of compressing the source code. He gets the compiler (and preprocessor) to create 264 functions. He encodes the information for the construction of these functions in character-encoded bit-strings.
This function creates a static jump table for the opcodes (and interrupts).
Each o() defines 4 c()'s, which each define two Ins()'s. There are 33 o()'s, so Ins() is instantiated 264 times.Code:void Op()
{
#define c(n) Ins<0x##n>,Ins<0x##n+1>,
#define o(n) c(n)c(n+2)c(n+4)c(n+6)
static void(*const i[0x108])() =
{
o(00)o(08)o(10)o(18)o(20)o(28)o(30)o(38)
o(40)o(48)o(50)o(58)o(60)o(68)o(70)o(78)
o(80)o(88)o(90)o(98)o(A0)o(A8)o(B0)o(B8)
o(C0)o(C8)o(D0)o(D8)o(E0)o(E8)o(F0)o(F8) o(100)
};
unsigned op = RB(PC++);
i[op]();
}
The program simulates the 6502 using micro-instructions. The list of t()'s in Ins() associates micro-instructions with op-codes. Since the whole thing is done at compile time, a final Ins() might look something like
So each Ins() instantiation is a different list of micro-instructions designed to carry out that op-code's operation.Code:void Ins()
{
unsigned addr=0, d=0, t=0xFF, c=0, sb=0, pbits = op<0x100 ? 0x30 : 0x20;
{
enum { i = 0x80 };
////if (i) // removed by compiler since always true
{
addr=u8(addr+d); d=0; tick(); // THIS MICRO-INSTRUCTION EXECUTED
}
}
{
enum { i = 0x00 };
////if (i) // removed by compiler since always false
{
////RB(wrap(addr, addr+d));
}
}
{
enum { i = 0x02 };
////if (i) // removed by compiler since always true
{
t = (t << 1) | (sb * 0x01); // THIS MICRO-INSTRUCTION EXECUTED
}
}
// etc
}
The actual encoding of the bit strings is a little complicated. Note that o8 is set to the high 5 bits of op while o8m is set to a single bit in the location given by the low 3 bits of op. o8 indexes s (the string). o8m will select a bit from the final value given by the conditional operator.
The t() character strings encode indices into the two character arrays in t() itself. Then THAT character is offset and used to test against the single bit of o8m. If that bit is set, the micro-instruction is included.
O_oCode:" (),-089<>?BCFGHJLSVWZ[^hlmnxy|}"[s[o8]-94]
I didn't realize you could still do this in C++.
Soma
Yeah. It's a <cough> wonderful feature of the language, isn't it.Quote:
Originally Posted by phantomotap