incbin | Include binary files in C/C++ | Reverse Engineering library

The issue seems to relate to the feature of the PETSCII specification called shifting.

Assuming the graphics mode is unshifted, PETSCII has only uppercase letters in its powerup state.

In the shifted mode, the lowercase characters a-z occupy the same character space (0x41..0x5a) as the upper case characters A-Z in the unshifted mode. In this mode the upper case characters are located at (0x61..0x7a), which holds some graphical glyphs in the unshifted mode.

The evidence supports this, since the lower case letters are visualised as uppercase and the uppercase letters are shown as block graphics characters.

To solve this:

On C64 the sets are alternated by flipping bit 2 of the byte 53272

Alternatively I think it's possible to output the right character directly to the screen memory without using the KERNAL function. I'm not sure about this, since it's been quite a long time when I programmed C64. It might have been that instead the toggling of the character set needed to be disabled so that random key presses didn't alter the screen...

This is currently not supported, as you could see from the table of core options, only 3 options are settable per subproject as of now: werror and default_library (since 0.54.0) and warning_level (since 0.56.0). And below in Specifying options per subproject you can find more details e.g. about order of applying.

Also I found from discussion in issue Subproject default_options are ignored one of the main contributor says:

Right now only a couple of options are allowed on a per-project basis: default_library, werror (and one more I can't remember off the top of my head). We keep adding more over time, but other ones are ignored, yes.

As per @arrowd 's idea:

You have three alternatives.

1. You can include all three bitmaps to the different memory locations and transfer them one by one to the correct location. For example you currently load your first bitmap to $2000. It's fine. You can load next bitmaps to $4800 and $7000. Then transfer them accordingly to the right places when you need to show the next bitmap.
2. You can load bitmaps to the suitable VIC bitmap positions like $2000, $6000, $e000 etc. Then all you need to do is to change $dd00 and make bank switching. But be careful, $6000 is fine but to be able to use $e000, you need to disable Kernal ROM. Things get a little bit more trickier there, you need to fiddle with $01 values.
3. You can use an IRQ loader like Krill's IRQ loader. You can search it on the web. Using an IRQ loader, you can include first bitmap, and then load the other bitmaps from the disk to $2000 location again and do repeat the same thing. Of course you might want to show something else, a loading message maybe during loading. Better way is to use $2000 and $6000 for the bitmap, loading next picture to the other bank and make bank switching using $dd00 again. This way your initial PRG file would only include the first picture and you can load the rest from the disk.

About going back to the character mode, just setting $d011, $d016 and $d018 to their initial values would be enough (also $dd00 if you change it).

The final problem you run in to:

ERROR: new format image overwritten - must RESET the board to recover

is because you've loaded the image in to memory in the same location as the entry point but you need to load it in to memory somewhere else so that U-Boot can unpack the image and put the contents where their load address is set to. Since you have 128MB of memory you should be able to put it at +32 or +64MB from start and then things should work.

Based on the comments I've received, my understanding is that no, it wouldn't be considered a quine in the usual sense.

The strongest point, I think, is the one made by @12431234123412341234123: once the program is compiled, the compiled form cannot be said to output itself, as "itself" is a binary, and it outputs C source code. So the compiled binary wouldn't be a quine anyway. The source code wouldn't be either, because the .incbin line loads the source code from the file. (It doesn't matter that it happens at compile time, because the source code needs to be compiled in order to be run.)

Regardless, (as @Raymond Chen pointed out) it doesn't fit the spirit of a quine, and (as @n. 'pronouns' m. pointed out) there's no definite "letter of the law" for it to fit either. More than anything else it depends on the definition you're using.

When I load the image into adress 2000 it's works fine, but as soon as try a different address like 2400 it doesn't work anymore.

This is your answer. The bitmap needs to be located at the same address where the video chip is going to read it. Usually that address is $2000, but that can be changed.

Similarly, colour must always be at address $d800. This address is fixed in hardware.

The problem is solved by entering the protected mode and including the kernel.asm file instead of the binary file.

Here's how (stage2.asm):