CHIP-8 | Assembler and Emulator in Go | Emulator library

If code is always known at compile time, make it a template parameter:

It appears that your issue is that you are incrementing the PC again after assigning it in the JMP instruction (0x1nnn) (You can see the discrepancy in your debug output). So after the current executeOpcode cycle, the execution returns to this.step and hits this line:

You have two or more cpp files. Each forms a compilation unit. (A .h you include becomes part of each compilation unit separately; the notion of compilation unit applies after preprocessing is done.)

Static global variables are not linked between compilation units, they're private to the unit they're defined in.
static uint16_t programCounter is thus local to each cpp file.

As a general rule:

1. Stop using global variables, especially mutable ones. Pass shared state explicitly. Use a class or struct.
2. Especially stop using mutable static variables in header files. That is insane.
3. Check the address of data when things don't make sense.

Be aware that static has a different meaning within classes and functions that it does at global scope. Regular globals already have static storage class (same as static variables), but with global cross-file visibility.

Let me start with a recommendation - if you're at all interested in an answer, please don't make it harder to answer your question than it needs to be. Think how it looks for others - some bulk of code, with problem seemingly in not drawing anything; why this example have to have 6 files? Why does it depend on external file which we don't have and hence have literally no way to verify? Surely it is possible to shrink it down to 30 lines of single file with just init and render - literally any "hello world" for SDL2 will do. And when it works and your code doesn't - you start checking what's different.

Now to your question. You can't draw anything from your main loop because your window and renderer here are NULL - it was initialised to NULL and never set to anything else. It appears you have misconception of how function arguments works - in C, funciton arguments are passed by value, and any modification of that value is made to local funciton copy. When you pass an int, function gets copy of that int, and don't push any changes back. If you pass SDL_Window*, then you pass value of that pointer (in your case, NULL); when you do SDL_CreateWindow, you assign it to local variable and once angain can't return it back to caller, where it stays NULL. So all your render calls are passing NULL as renderer, which naturally isn't a valid renderer.

The same thing appears in your close - you're trying to reset passed copies to NULL, but it makes no sense, as you can't modify external value, only function-local copy.

Programming classes often teach that there is "pass by value" and "pass by reference", which I suppose is a source of that confusion. I'd rather say there is no pass-by-reference in C, you always pass value, but pointer is a value too. To be able to modify data we pass pointer to that data; to mutate int you may pass int*, but to mutate SDL_Window* you'll need to get pointer to that pointer - SDL_Window**. Take a look at how SDL itself does it: https://wiki.libsdl.org/SDL_CreateWindowAndRenderer .

So, in short - make your init to be int init(SDL_Window **window, SDL_Renderer** renderer, int width, int height); (you don't need const int here either, as these are copies of width and height) instead, and modify its code accordingly. And check values of window and renderer after that call (debugger, debug printf, if(window==NULL) anything goes). init could be something like

There doesn't seem to be a definitive answer, as there doesn't seem to be a definitive reference.

This reference seems to have the same problem with the same ambiguity

This (contemporary) reference (page 113), however, says "I = I + X + 1". Authorship is by the inventor, Joseph Weisbecker - I guess he will have known.

Why doesn't the linker work with this? Are any other compiler flags required?

Yes, you need to tell the linker which libraries to link against, e.g.:

When you call glutMainLoop(), your program will enter a loop that looks a bit like:

I'm not sure of the exact problem, but...

When the compiler sees something like this:

You specify an initial size of width=62, height=32, these are sizes in pixels. Which means you want your window to be "tiny". Windows usually have a minimum size (often dictated by window controls), and seemingly this minimum size is bigger than your intended size. So the blue rectangle you draw will not will the whole window (which will not be less than the minimum size).

If you increase the size, e.g. Rows = 300, Cols = 600, then it will fill your window.

Also, drop the go keyword when calling driver.Main(), some OS-specific libraries require it to be called from the main goroutine. And so remove the empty for from main(), driver.Main() blocks until your app should exit.

Also, this still won't guarantee you see the blue rectangle, as if the window (screen) is refreshed / cleared, a redraw might be necessary.

So instead move your drawing logic to the event loop, and execute it for the paint.Event events: