add curly braces to bank-switch macros

src/banks.h

 
 #include <gbdk/platform.h>
 
-#define START_ROM_BANK_2(x) __previous__bank = CURRENT_BANK; SWITCH_ROM(x)
+#define START_ROM_BANK_2(x) __xyz_previous__bank = CURRENT_BANK; SWITCH_ROM(x); do
 #define START_ROM_BANK(x) uint8_t START_ROM_BANK_2(x)
-#define END_ROM_BANK() SWITCH_ROM(__previous__bank)
+#define END_ROM_BANK while (0); SWITCH_ROM(__xyz_previous__bank);
 
 #endif // __BANKS_H__

src/input.c

     joyp = joypad();
 
     if (debug_cnt < DEBUG_SEQUENCE_COUNT) {
-        START_ROM_BANK(BANK(input));
+        START_ROM_BANK(BANK(input)) {
             if (key_pressed(key_debug_sequence[debug_cnt])) {
                 debug_cnt++;
             } else if (key_pressed(0xFF)) {
                 debug_cnt = 0;
             }
-        END_ROM_BANK();
+        } END_ROM_BANK
     } else {
         if (key_pressed(0xFF ^ J_START)) {
             debug_cnt = 0;

src/main.c

             }
             win_conf();
         } else if (key_pressed(J_LEFT)) {
-            START_ROM_BANK(BANK(main));
+            START_ROM_BANK(BANK(main)) {
                 if (*conf_entries[debug_menu_index].var > 0) {
                     (*conf_entries[debug_menu_index].var)--;
                 } else {
                     *conf_entries[debug_menu_index].var = conf_entries[debug_menu_index].max;
                 }
                 conf_write_crc();
-            END_ROM_BANK();
+            } END_ROM_BANK
             win_conf();
         } else if (key_pressed(J_RIGHT)) {
-            START_ROM_BANK(BANK(main));
+            START_ROM_BANK(BANK(main)) {
                 if (*conf_entries[debug_menu_index].var < conf_entries[debug_menu_index].max) {
                     (*conf_entries[debug_menu_index].var)++;
                 } else {
                     *conf_entries[debug_menu_index].var = 0;
                 }
                 conf_write_crc();
-            END_ROM_BANK();
+            } END_ROM_BANK
             win_conf();
         } else if (key_pressed(J_A) || key_pressed(J_B) || key_pressed(J_START)) {
             break;
                     snd_note_off();
                     splash_win();
                 } else if (key_pressed(J_LEFT)) {
-                    START_ROM_BANK(BANK(main));
+                    START_ROM_BANK(BANK(main)) {
                         if (debug_entries[debug_menu_index].flag != DBG_NONE) {
                             conf_get()->debug_flags ^= debug_entries[debug_menu_index].flag;
                             conf_write_crc();
                             }
                             switch_special = 1;
                         }
-                    END_ROM_BANK();
+                    } END_ROM_BANK
                     splash_win();
                 } else if (key_pressed(J_RIGHT)) {
-                    START_ROM_BANK(BANK(main));
+                    START_ROM_BANK(BANK(main)) {
                         if (debug_entries[debug_menu_index].flag != DBG_NONE) {
                             conf_get()->debug_flags ^= debug_entries[debug_menu_index].flag;
                             conf_write_crc();
                             }
                             switch_special = 1;
                         }
-                    END_ROM_BANK();
+                    } END_ROM_BANK
                     splash_win();
                 } else if (key_pressed(J_A)) {
-                    START_ROM_BANK(BANK(main));
+                    START_ROM_BANK(BANK(main)) {
                         if (debug_entries[debug_menu_index].flag != DBG_NONE) {
                             conf_get()->debug_flags ^= debug_entries[debug_menu_index].flag;
                             conf_write_crc();
                             }
                             switch_special = 1;
                         }
-                    END_ROM_BANK();
+                    } END_ROM_BANK
                     splash_win();
                 } else if (key_pressed(J_B)) {
                     conf_get()->debug_flags &= ~DBG_MENU;
 
     DISPLAY_ON;
 
-    START_ROM_BANK(BANK(border_sgb));
+    START_ROM_BANK(BANK(border_sgb)) {
         set_sgb_border((const uint8_t *)border_sgb_tiles, sizeof(border_sgb_tiles),
                        (const uint8_t *)border_sgb_map, sizeof(border_sgb_map),
                        (const uint8_t *)border_sgb_palettes, sizeof(border_sgb_palettes));
-    END_ROM_BANK();
+    } END_ROM_BANK
 
     DISPLAY_OFF;
 }

src/maps.c

  *
  * Copyright (C) 2025 Thomas Buck <thomas@xythobuz.de>
  *
+ * Based on examples from gbdk-2020:
+ * https://github.com/gbdk-2020/gbdk-2020/blob/develop/gbdk-lib/examples/cross-platform/large_map
+ *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * See <http://www.gnu.org/licenses/>.
  */
 
+#include <assert.h>
+
 #include "banks.h"
 #include "title_map.h"
 #include "bg_map.h"
 #include "util.h"
 #include "maps.h"
 
+// currently this assumption is hard-coded
+static_assert(bg_map_WIDTH == 256, "bg_map needs to be 256x256");
+static_assert(bg_map_HEIGHT == 256, "bg_map needs to be 256x256");
+
 #define POS_SCALE_BG 6
 
 // define this to disable mirrored map scaling support
 static uint8_t map_pos_x, map_pos_y, old_map_pos_x, old_map_pos_y;
 
 void map_title(void) NONBANKED {
-    START_ROM_BANK(BANK(title_map));
+    START_ROM_BANK(BANK(title_map)) {
 
         set_bkg_palette(OAMF_CGB_PAL0, title_map_PALETTE_COUNT, title_map_palettes);
         set_bkg_data(0, title_map_TILE_COUNT, title_map_tiles);
                       title_map_HEIGHT / title_map_TILE_H,
                       title_map_map);
 
-    END_ROM_BANK();
+    } END_ROM_BANK
 
     move_bkg(0, 0);
 }
 
 void map_game(void) NONBANKED {
-    START_ROM_BANK(BANK(bg_map));
+    START_ROM_BANK(BANK(bg_map)) {
 
         set_bkg_palette(OAMF_CGB_PAL0, bg_map_PALETTE_COUNT, bg_map_palettes);
         set_bkg_data(0, bg_map_TILE_COUNT, bg_map_tiles);
 
 #endif // WRAP_BG
 
-    END_ROM_BANK();
+    } END_ROM_BANK
 }
 
 void map_move(int16_t delta_x, int16_t delta_y) NONBANKED {
     map_pos_y = (uint8_t)(camera_y >> 3u);
     map_pos_x = (uint8_t)(camera_x >> 3u);
 
-    START_ROM_BANK(BANK(bg_map));
+    START_ROM_BANK(BANK(bg_map)) {
 
         // up or down
         if (map_pos_y != old_map_pos_y) {
             if (camera_y < old_camera_y) {
                 set_bkg_sub(map_pos_x, map_pos_y,
-                            MIN(DEVICE_SCREEN_WIDTH + 1, bg_map_mapWidth-map_pos_x), 1,
+                            MIN(DEVICE_SCREEN_WIDTH + 1, bg_map_mapWidth - map_pos_x), 1,
                             bg_map_map, bg_map_MAP_ATTRIBUTES, bg_map_mapWidth);
             } else if ((bg_map_mapHeight - DEVICE_SCREEN_HEIGHT) > map_pos_y) {
                 set_bkg_sub(map_pos_x, map_pos_y + DEVICE_SCREEN_HEIGHT,
-                            MIN(DEVICE_SCREEN_WIDTH + 1, bg_map_mapWidth-map_pos_x), 1,
+                            MIN(DEVICE_SCREEN_WIDTH + 1, bg_map_mapWidth - map_pos_x), 1,
                             bg_map_map, bg_map_MAP_ATTRIBUTES, bg_map_mapWidth);
             }
             old_map_pos_y = map_pos_y;
             old_map_pos_x = map_pos_x;
         }
 
-    END_ROM_BANK();
+    } END_ROM_BANK
 
     // set old camera position to current camera position
     old_camera_x = camera_x;

src/sample.c

     NR51_REG = 0xBB; // turn CH3 off in left and right pan
     NR30_REG = 0x00; // turn DAC off
 
-    START_ROM_BANK(play_bank);
+    START_ROM_BANK(play_bank) {
         // load waveforms
         for (uint8_t i = 0; i < 16; i++) {
             _AUD3WAVERAM[i] = *(play_sample++);
         }
-    END_ROM_BANK();
+    } END_ROM_BANK
 
     NR30_REG = 0x80; // turn DAC on
     NR31_REG = 0xFE; // length of wave, 2nd shortest

src/score.c

 }
 
 void score_reset(void) NONBANKED {
-    START_ROM_BANK(BANK(score));
+    START_ROM_BANK(BANK(score)) {
         memcpy(conf_scores(), initial_scores, sizeof(struct scores) * SCORE_NUM * 2);
-    END_ROM_BANK();
+    } END_ROM_BANK
     conf_write_crc();
 }
 

src/sound.c

 
 static void play_note(enum notes note) NONBANKED {
     if (note < SILENCE) {
-        START_ROM_BANK(BANK(sound));
-            uint16_t freq = frequencies[note];
-        END_ROM_BANK();
+        uint16_t freq;
+        START_ROM_BANK(BANK(sound)) {
+            freq = frequencies[note];
+        } END_ROM_BANK
 
         NR11_REG = 0x80 | duration; // 50% duty, higher value is shorter time (up to 0x3F)
         NR12_REG = (conf_get()->music_vol << 4) | 0x00; // given volume, no change
 
 static void play_note2(enum notes note) NONBANKED {
     if (note < SILENCE) {
-        START_ROM_BANK(BANK(sound));
-            uint16_t freq = frequencies[note];
-        END_ROM_BANK();
+        uint16_t freq;
+        START_ROM_BANK(BANK(sound)) {
+            freq = frequencies[note];
+        } END_ROM_BANK
 
         NR21_REG = 0x80 | duration; // 50% duty, higher value is shorter time (up to 0x3F)
         NR22_REG = (conf_get()->music_vol << 4) | 0x00; // given volume, no change
         return;
     }
 
-    START_ROM_BANK(bank);
+    START_ROM_BANK(bank) {
 
         uint16_t diff = timer_get() - last_t;
         if (diff >= music->duration) {
         }
 
 end:
-    END_ROM_BANK();
+    } END_ROM_BANK
 }

src/sprites.c

 void spr_init(void) NONBANKED {
     uint8_t off = TILE_NUM_START;
     for (uint8_t i = 0; i < SPRITE_COUNT; i++) {
-        START_ROM_BANK(metasprites[i].bank);
+        START_ROM_BANK(metasprites[i].bank) {
             if (metasprites[i].off == TILE_NUM_START) {
                 metasprites[i].off = off;
                 off += metasprites[i].cnt;
             } else {
                 metasprites[i].off = metasprites[metasprites[i].off].off;
             }
-        END_ROM_BANK();
+        } END_ROM_BANK
     }
 }
 
             bank = BANK(power_palettes);
         }
 
-        START_ROM_BANK(bank);
+        START_ROM_BANK(bank) {
             if ((metasprites[i].pa != NULL) && ((metasprites[i].pa_i & PALETTE_ALL_FLAGS) == PALETTE_PRELOAD)) {
                 set_sprite_palette(metasprites[i].pa_i, metasprites[i].pa_n, metasprites[i].pa);
             }
-        END_ROM_BANK();
+        } END_ROM_BANK
     }
 }
 
         return;
     }
 
-    START_ROM_BANK(metasprites[sprite].bank);
+    START_ROM_BANK(metasprites[sprite].bank) {
 
     if (frame >= metasprites[sprite].ms_n) {
         frame = 0;
             break;
     }
 
-    END_ROM_BANK();
+    } END_ROM_BANK
 }
 
 void spr_ship(enum SPRITE_ROT rot, uint8_t moving, uint8_t *hiwater) NONBANKED {

src/window.c

 void win_init(uint8_t is_splash) NONBANKED {
     fnt_off = is_splash ? title_map_TILE_COUNT : bg_map_TILE_COUNT;
 
-    START_ROM_BANK(BANK(numbers_fnt));
+    START_ROM_BANK(BANK(numbers_fnt)) {
         set_bkg_palette(OAMF_CGB_PAL0 + bg_map_PALETTE_COUNT, numbers_fnt_PALETTE_COUNT, numbers_fnt_palettes);
         set_win_data(fnt_off, numbers_fnt_TILE_COUNT, numbers_fnt_tiles);
-    END_ROM_BANK();
+    } END_ROM_BANK
 
-    START_ROM_BANK_2(BANK(window));
+    START_ROM_BANK_2(BANK(window)) {
         set_bkg_palette(OAMF_CGB_PAL0 + bg_map_PALETTE_COUNT + numbers_fnt_PALETTE_COUNT, numbers_fnt_PALETTE_COUNT, num_pal_inv);
-    END_ROM_BANK();
+    } END_ROM_BANK
 
     if (is_splash) {
-        START_ROM_BANK_2(BANK(text_fnt));
+        START_ROM_BANK_2(BANK(text_fnt)) {
             set_win_data(fnt_off + numbers_fnt_TILE_COUNT, text_fnt_TILE_COUNT, text_fnt_tiles);
-        END_ROM_BANK();
+        } END_ROM_BANK
     }
 }
 
                           const uint8_t *tiles, uint8_t base_tile, uint8_t tile_bank,
                           const uint8_t *attributes, uint8_t attr_bank) NONBANKED {
     if (attributes != NULL) {
-        START_ROM_BANK(attr_bank);
+        START_ROM_BANK(attr_bank) {
             VBK_REG = VBK_ATTRIBUTES;
             set_win_tiles(x, y, w, h, attributes);
-        END_ROM_BANK();
+        } END_ROM_BANK
     } else {
         VBK_REG = VBK_ATTRIBUTES;
         fill_win_rect(x, y, w, h, 0x00);
     }
 
-    START_ROM_BANK(tile_bank);
+    START_ROM_BANK(tile_bank) {
         VBK_REG = VBK_TILES;
         set_win_based_tiles(x, y, w, h, tiles, base_tile);
-    END_ROM_BANK();
+    } END_ROM_BANK
 }
 
 static void set_win_based_attr(uint8_t x, uint8_t y, uint8_t w, uint8_t h,
     VBK_REG = VBK_ATTRIBUTES;
     fill_win_rect(x, y, w, h, attr);
 
-    START_ROM_BANK(tile_bank);
+    START_ROM_BANK(tile_bank) {
         VBK_REG = VBK_TILES;
         set_win_based_tiles(x, y, w, h, tiles, base_tile);
-    END_ROM_BANK();
+    } END_ROM_BANK
 }
 
 static void character(uint8_t c, uint8_t pos, uint8_t x_off, uint8_t y_off, uint8_t is_black) {
 }
 
 static void get_git(char *line_buff) NONBANKED {
-    START_ROM_BANK(BANK(git));
+    START_ROM_BANK(BANK(git)) {
         strncpy(line_buff, git_version, 2 * LINE_WIDTH);
-    END_ROM_BANK();
+    } END_ROM_BANK
 }
 
 void win_about(void) BANKED {
 }
 
 static uint8_t get_debug(char *name_buff, uint8_t i) NONBANKED {
-    START_ROM_BANK(BANK(main));
+    uint8_t n_len;
+    START_ROM_BANK(BANK(main)) {
         strncpy(name_buff, debug_entries[i].name, ENTRY_NAME_LEN + 1);
 
-        uint8_t n_len = strlen(name_buff);
+        n_len = strlen(name_buff);
         name_buff[n_len] = ' ';
         if (debug_entries[i].flag == DBG_NONE) {
             if (debug_menu_index == i) {
         }
         name_buff[n_len + 2] = '\0';
         n_len += 2;
-    END_ROM_BANK();
+    } END_ROM_BANK
     return n_len;
 }
 
 }
 
 static uint8_t get_conf(char *name_buff, uint8_t i) NONBANKED {
-    START_ROM_BANK(BANK(main));
+    uint8_t n_len;
+    START_ROM_BANK(BANK(main)) {
         strncpy(name_buff, conf_entries[i].name, ENTRY_NAME_LEN + 1);
 
-        uint8_t n_len = strlen(name_buff);
+        n_len = strlen(name_buff);
         name_buff[n_len] = ' ';
         if (*conf_entries[i].var < 10) {
             name_buff[n_len + 1] = *conf_entries[i].var + '0';
         }
         name_buff[n_len + 2] = '\0';
         n_len += 2;
-    END_ROM_BANK();
+    } END_ROM_BANK
     return n_len;
 }