Merge branch '86Box:master' into machine_23

src/86box.c

@@ -408,18 +408,18 @@ pc_log(const char *fmt, ...)
 int
 pc_init(int argc, char *argv[])
 {
-    char      *ppath = NULL;
-    char      *rpath = NULL;
-    char      *cfg = NULL;
-    char      *p;
-    char       temp[2048];
-    char      *fn[FDD_NUM] = { NULL };
-    char       drive = 0;
-    char      *temp2 = NULL;
-    struct tm *info;
-    time_t     now;
-    int        c;
-    int        lvmp = 0;
+    char            *ppath = NULL;
+    char            *rpath = NULL;
+    char            *cfg = NULL;
+    char            *p;
+    char             temp[2048];
+    char            *fn[FDD_NUM] = { NULL };
+    char             drive = 0;
+    char            *temp2 = NULL;
+    const struct tm *info;
+    time_t           now;
+    int              c;
+    int              lvmp = 0;
 #ifdef ENABLE_NG
     int ng = 0;
 #endif
@@ -1144,9 +1144,9 @@ pc_reset_hard_init(void)
 void
 update_mouse_msg(void)
 {
-    wchar_t wcpufamily[2048];
-    wchar_t wcpu[2048];
-    wchar_t wmachine[2048];
+    wchar_t  wcpufamily[2048];
+    wchar_t  wcpu[2048];
+    wchar_t  wmachine[2048];
     wchar_t *wcp;
 
     mbstowcs(wmachine, machine_getname(), strlen(machine_getname()) + 1);
@@ -1185,7 +1185,7 @@ pc_reset_hard(void)
 }
 
 void
-pc_close(thread_t *ptr)
+pc_close(UNUSED(thread_t *ptr))
 {
     /* Wait a while so things can shut down. */
     plat_delay_ms(200);

src/acpi.c

@@ -226,10 +226,10 @@ acpi_reg_read_common_regs(UNUSED(int size), uint16_t addr, void *priv)
 static uint32_t
 acpi_reg_read_ali(int size, uint16_t addr, void *priv)
 {
-    acpi_t  *dev = (acpi_t *) priv;
-    uint32_t ret = 0x00000000;
-    int      shift16;
-    int      shift32;
+    const acpi_t  *dev = (acpi_t *) priv;
+    uint32_t       ret = 0x00000000;
+    int            shift16;
+    int            shift32;
 
     addr &= 0x3f;
     shift16 = (addr & 1) << 3;
@@ -294,10 +294,10 @@ acpi_reg_read_ali(int size, uint16_t addr, void *priv)
 static uint32_t
 acpi_reg_read_intel(int size, uint16_t addr, void *priv)
 {
-    acpi_t  *dev = (acpi_t *) priv;
-    uint32_t ret = 0x00000000;
-    int      shift16;
-    int      shift32;
+    const acpi_t  *dev = (acpi_t *) priv;
+    uint32_t       ret = 0x00000000;
+    int            shift16;
+    int            shift32;
 
     addr &= 0x3f;
     shift16 = (addr & 1) << 3;
@@ -391,10 +391,10 @@ acpi_reg_read_intel(int size, uint16_t addr, void *priv)
 static uint32_t
 acpi_reg_read_via_common(int size, uint16_t addr, void *priv)
 {
-    acpi_t  *dev = (acpi_t *) priv;
-    uint32_t ret = 0x00000000;
-    int      shift16;
-    int      shift32;
+    const acpi_t  *dev = (acpi_t *) priv;
+    uint32_t       ret = 0x00000000;
+    int            shift16;
+    int            shift32;
 
     addr &= 0xff;
     shift16 = (addr & 1) << 3;
@@ -544,10 +544,10 @@ acpi_reg_read_via(int size, uint16_t addr, void *priv)
 static uint32_t
 acpi_reg_read_via_596b(int size, uint16_t addr, void *priv)
 {
-    acpi_t  *dev = (acpi_t *) priv;
-    uint32_t ret = 0x00000000;
-    int      shift16;
-    int      shift32;
+    const acpi_t  *dev = (acpi_t *) priv;
+    uint32_t       ret = 0x00000000;
+    int            shift16;
+    int            shift32;
 
     addr &= 0x7f;
     shift16 = (addr & 1) << 3;
@@ -610,9 +610,9 @@ acpi_reg_read_smc(int size, uint16_t addr, void *priv)
 static uint32_t
 acpi_aux_reg_read_smc(UNUSED(int size), uint16_t addr, void *priv)
 {
-    acpi_t  *dev = (acpi_t *) priv;
-    uint32_t ret = 0x00000000;
-    int      shift16;
+    const acpi_t  *dev = (acpi_t *) priv;
+    uint32_t       ret = 0x00000000;
+    int            shift16;
 
     addr &= 0x07;
     shift16 = (addr & 1) << 3;
@@ -1189,7 +1189,7 @@ acpi_aux_reg_write_smc(UNUSED(int size), uint16_t addr, uint8_t val, void *priv)
 static uint32_t
 acpi_reg_read_common(int size, uint16_t addr, void *priv)
 {
-    acpi_t *dev = (acpi_t *) priv;
+    const acpi_t *dev = (acpi_t *) priv;
     uint8_t ret = 0xff;
 
     if (dev->vendor == VEN_ALI)
@@ -1209,7 +1209,7 @@ acpi_reg_read_common(int size, uint16_t addr, void *priv)
 static void
 acpi_reg_write_common(int size, uint16_t addr, uint8_t val, void *priv)
 {
-    acpi_t *dev = (acpi_t *) priv;
+    const acpi_t *dev = (acpi_t *) priv;
 
     if (dev->vendor == VEN_ALI)
         acpi_reg_write_ali(size, addr, val, priv);
@@ -1226,7 +1226,7 @@ acpi_reg_write_common(int size, uint16_t addr, uint8_t val, void *priv)
 static uint32_t
 acpi_aux_reg_read_common(int size, uint16_t addr, void *priv)
 {
-    acpi_t *dev = (acpi_t *) priv;
+    const acpi_t *dev = (acpi_t *) priv;
     uint8_t ret = 0xff;
 
     if (dev->vendor == VEN_SMC)
@@ -1238,7 +1238,7 @@ acpi_aux_reg_read_common(int size, uint16_t addr, void *priv)
 static void
 acpi_aux_reg_write_common(int size, uint16_t addr, uint8_t val, void *priv)
 {
-    acpi_t *dev = (acpi_t *) priv;
+    const acpi_t *dev = (acpi_t *) priv;
 
     if (dev->vendor == VEN_SMC)
         acpi_aux_reg_write_smc(size, addr, val, priv);
@@ -1591,8 +1591,8 @@ acpi_apm_out(uint16_t port, uint8_t val, void *priv)
 static uint8_t
 acpi_apm_in(uint16_t port, void *priv)
 {
-    acpi_t *dev = (acpi_t *) priv;
-    uint8_t ret = 0xff;
+    const acpi_t *dev = (acpi_t *) priv;
+    uint8_t       ret = 0xff;
 
     port &= 0x0001;
 
@@ -1694,7 +1694,7 @@ acpi_init(const device_t *info)
 
     dev = (acpi_t *) malloc(sizeof(acpi_t));
     if (dev == NULL)
-        return (NULL);
+        return NULL;
     memset(dev, 0x00, sizeof(acpi_t));
 
     cpu_to_acpi = ACPI_TIMER_FREQ / cpuclock;

src/apm.c

@@ -71,8 +71,8 @@ apm_out(uint16_t port, uint8_t val, void *priv)
 static uint8_t
 apm_in(uint16_t port, void *priv)
 {
-    apm_t  *dev = (apm_t *) priv;
-    uint8_t ret = 0xff;
+    const apm_t  *dev = (apm_t *) priv;
+    uint8_t       ret = 0xff;
 
     port &= 0x0001;
 
@@ -102,9 +102,8 @@ apm_close(void *priv)
     free(dev);
 }
 
-static void
-    *
-    apm_init(const device_t *info)
+static void *
+apm_init(const device_t *info)
 {
     apm_t *dev = (apm_t *) malloc(sizeof(apm_t));
     memset(dev, 0, sizeof(apm_t));

src/cdrom/cdrom.c

@@ -163,7 +163,7 @@ cdrom_interface_get_from_internal_name(char *s)
     int c = 0;
 
     while (controllers[c].device != NULL) {
-        if (!strcmp((char *) controllers[c].device->internal_name, s))
+        if (!strcmp(controllers[c].device->internal_name, s))
             return c;
         c++;
     }

src/cdrom/cdrom_image_backend.c

@@ -202,7 +202,7 @@ track_file_close(track_t *trk)
 static void
 cdi_clear_tracks(cd_img_t *cdi)
 {
-    track_file_t *last = NULL;
+    const track_file_t *last = NULL;
     track_t      *cur  = NULL;
 
     if ((cdi->tracks == NULL) || (cdi->tracks_num == 0))
@@ -273,7 +273,7 @@ cdi_get_audio_tracks_lba(cd_img_t *cdi, int *st_track, int *end, uint32_t *lead_
 int
 cdi_get_audio_track_pre(cd_img_t *cdi, int track)
 {
-    track_t *trk = &cdi->tracks[track - 1];
+    const track_t *trk = &cdi->tracks[track - 1];
 
     if ((track < 1) || (track > cdi->tracks_num))
         return 0;
@@ -285,7 +285,7 @@ cdi_get_audio_track_pre(cd_img_t *cdi, int track)
 int
 cdi_get_audio_track_info(cd_img_t *cdi, UNUSED(int end), int track, int *track_num, TMSF *start, uint8_t *attr)
 {
-    track_t *trk = &cdi->tracks[track - 1];
+    const track_t *trk = &cdi->tracks[track - 1];
     int      pos = trk->start + 150;
 
     if ((track < 1) || (track > cdi->tracks_num))
@@ -304,7 +304,7 @@ cdi_get_audio_track_info(cd_img_t *cdi, UNUSED(int end), int track, int *track_n
 int
 cdi_get_audio_track_info_lba(cd_img_t *cdi, UNUSED(int end), int track, int *track_num, uint32_t *start, uint8_t *attr)
 {
-    track_t *trk = &cdi->tracks[track - 1];
+    const track_t *trk = &cdi->tracks[track - 1];
 
     if ((track < 1) || (track > cdi->tracks_num))
         return 0;
@@ -320,8 +320,8 @@ cdi_get_audio_track_info_lba(cd_img_t *cdi, UNUSED(int end), int track, int *tra
 int
 cdi_get_track(cd_img_t *cdi, uint32_t sector)
 {
-    track_t *cur;
-    track_t *next;
+    const track_t *cur;
+    const track_t *next;
 
     /* There must be at least two tracks - data and lead out. */
     if (cdi->tracks_num < 2)
@@ -343,8 +343,8 @@ cdi_get_track(cd_img_t *cdi, uint32_t sector)
 int
 cdi_get_audio_sub(cd_img_t *cdi, uint32_t sector, uint8_t *attr, uint8_t *track, uint8_t *index, TMSF *rel_pos, TMSF *abs_pos)
 {
-    int      cur_track = cdi_get_track(cdi, sector);
-    track_t *trk;
+    int            cur_track = cdi_get_track(cdi, sector);
+    const track_t *trk;
 
     if (cur_track < 1)
         return 0;
@@ -483,8 +483,8 @@ cdi_read_sector_sub(cd_img_t *cdi, uint8_t *buffer, uint32_t sector)
 int
 cdi_get_sector_size(cd_img_t *cdi, uint32_t sector)
 {
-    int      track = cdi_get_track(cdi, sector) - 1;
-    track_t *trk;
+    int            track = cdi_get_track(cdi, sector) - 1;
+    const track_t *trk;
 
     if (track < 0)
         return 0;
@@ -496,8 +496,8 @@ cdi_get_sector_size(cd_img_t *cdi, uint32_t sector)
 int
 cdi_is_mode2(cd_img_t *cdi, uint32_t sector)
 {
-    int      track = cdi_get_track(cdi, sector) - 1;
-    track_t *trk;
+    int            track = cdi_get_track(cdi, sector) - 1;
+    const track_t *trk;
 
     if (track < 0)
         return 0;
@@ -510,8 +510,8 @@ cdi_is_mode2(cd_img_t *cdi, uint32_t sector)
 int
 cdi_get_mode2_form(cd_img_t *cdi, uint32_t sector)
 {
-    int      track = cdi_get_track(cdi, sector) - 1;
-    track_t *trk;
+    int            track = cdi_get_track(cdi, sector) - 1;
+    const track_t *trk;
 
     if (track < 0)
         return 0;
@@ -652,7 +652,9 @@ cdi_cue_get_buffer(char *str, char **line, int up)
                     done = 1;
                     break;
                 }
-                /*FALLTHROUGH*/
+#ifndef __APPLE__
+                [[fallthrough]];
+#endif
 
             default:
                 if (up && islower((int) *s))
@@ -787,7 +789,7 @@ cdi_add_track(cd_img_t *cdi, track_t *cur, uint64_t *shift, uint64_t prestart, u
         *total_pregap += cur_pregap;
         cur->start += *total_pregap;
     } else {
-        temp         = prev->file->get_length(prev->file) - ((uint64_t) prev->skip);
+        temp         = prev->file->get_length(prev->file) - (prev->skip);
         prev->length = temp / ((uint64_t) prev->sector_size);
         if ((temp % prev->sector_size) != 0)
             prev->length++;

src/cdrom/cdrom_image_viso.c

@@ -370,7 +370,7 @@ viso_fill_fn_rr(uint8_t *data, const viso_entry_t *entry, size_t max_len)
 
         /* Relocate extension if the original name exceeds the maximum length. */
         if (!S_ISDIR(entry->stats.st_mode)) { /* do this on files only */
-            char *ext = strrchr(entry->basename, '.');
+            const char *ext = strrchr(entry->basename, '.');
             if (ext > entry->basename) {
                 len = strlen(ext);
                 if (len >= max_len)
@@ -401,7 +401,7 @@ viso_fill_fn_joliet(uint8_t *data, const viso_entry_t *entry, size_t max_len) /*
 
         /* Relocate extension if the original name exceeds the maximum length. */
         if (!S_ISDIR(entry->stats.st_mode)) { /* do this on files only */
-            wchar_t *ext = wcsrchr(utf8dec, L'.');
+            const wchar_t *ext = wcsrchr(utf8dec, L'.');
             if (ext > utf8dec) {
                 len = wcslen(ext);
                 if (len > max_len)
@@ -725,8 +725,9 @@ viso_read(void *p, uint8_t *buffer, uint64_t seek, size_t count)
 uint64_t
 viso_get_length(void *p)
 {
-    track_file_t *tf   = (track_file_t *) p;
-    viso_t       *viso = (viso_t *) tf->priv;
+    track_file_t       *tf   = (track_file_t *) p;
+    const viso_t       *viso = (viso_t *) tf->priv;
+
     return ((uint64_t) viso->all_sectors) * viso->sector_size;
 }
 
@@ -799,18 +800,18 @@ viso_init(const char *dirname, int *error)
 
     /* Set up directory traversal. */
     cdrom_image_viso_log("VISO: Traversing directories:\n");
-    viso_entry_t  *entry;
-    viso_entry_t  *last_entry;
-    viso_entry_t  *dir;
-    viso_entry_t  *last_dir;
-    viso_entry_t  *eltorito_dir = NULL;
-    viso_entry_t  *eltorito_entry = NULL;
-    struct dirent *readdir_entry;
-    int            len;
-    int            eltorito_others_present = 0;
-    size_t         dir_path_len;
-    uint64_t       eltorito_offset = 0;
-    uint8_t        eltorito_type   = 0;
+    viso_entry_t        *entry;
+    viso_entry_t        *last_entry;
+    viso_entry_t        *dir;
+    viso_entry_t        *last_dir;
+    const viso_entry_t  *eltorito_dir = NULL;
+    const viso_entry_t  *eltorito_entry = NULL;
+    struct dirent       *readdir_entry;
+    int                  len;
+    int                  eltorito_others_present = 0;
+    size_t               dir_path_len;
+    uint64_t             eltorito_offset = 0;
+    uint8_t              eltorito_type   = 0;
 
     /* Fill root directory entry. */
     dir_path_len = strlen(dirname);

src/cdrom/cdrom_mitsumi.c

@@ -324,6 +324,9 @@ mitsumi_cdrom_out(uint16_t port, uint8_t val, void *priv)
                                 break;
                             case 5:
                                 dev->readmsf = 0;
+#ifndef __APPLE__
+                                [[fallthrough]];
+#endif
                             case 4:
                             case 3:
                                 dev->readmsf |= CD_DCB(val) << ((dev->cmdrd_count - 3) << 3);

src/chipset/82c100.c

@@ -109,7 +109,7 @@ ct_82c100_ems_out(uint16_t port, uint8_t val, void *priv)
 static uint8_t
 ct_82c100_ems_in(uint16_t port, void *priv)
 {
-    ct_82c100_t *dev = (ct_82c100_t *) priv;
+    const ct_82c100_t *dev = (ct_82c100_t *) priv;
     uint8_t      ret = 0xff;
 
     ret = dev->ems_page_regs[port >> 14];
@@ -278,15 +278,15 @@ ct_82c100_in(uint16_t port, void *priv)
 static uint8_t
 mem_read_emsb(uint32_t addr, void *priv)
 {
-    ems_page_t *page = (ems_page_t *) priv;
-    uint8_t     ret  = 0xff;
+    const ems_page_t *page = (ems_page_t *) priv;
+    uint8_t           ret  = 0xff;
 #ifdef ENABLE_CT_82C100_LOG
     uint32_t old_addr = addr;
 #endif
 
     addr = addr - page->virt + page->phys;
 
-    if (addr < ((uint32_t) mem_size << 10))
+    if (addr < (mem_size << 10))
         ret = ram[addr];
 
     ct_82c100_log("mem_read_emsb(%08X = %08X): %02X\n", old_addr, addr, ret);
@@ -297,7 +297,7 @@ mem_read_emsb(uint32_t addr, void *priv)
 static uint16_t
 mem_read_emsw(uint32_t addr, void *priv)
 {
-    ems_page_t *page = (ems_page_t *) priv;
+    const ems_page_t *page = (ems_page_t *) priv;
     uint16_t    ret  = 0xffff;
 #ifdef ENABLE_CT_82C100_LOG
     uint32_t old_addr = addr;
@@ -305,7 +305,7 @@ mem_read_emsw(uint32_t addr, void *priv)
 
     addr = addr - page->virt + page->phys;
 
-    if (addr < ((uint32_t) mem_size << 10))
+    if (addr < (mem_size << 10))
         ret = *(uint16_t *) &ram[addr];
 
     ct_82c100_log("mem_read_emsw(%08X = %08X): %04X\n", old_addr, addr, ret);
@@ -316,14 +316,14 @@ mem_read_emsw(uint32_t addr, void *priv)
 static void
 mem_write_emsb(uint32_t addr, uint8_t val, void *priv)
 {
-    ems_page_t *page = (ems_page_t *) priv;
+    const ems_page_t *page = (ems_page_t *) priv;
 #ifdef ENABLE_CT_82C100_LOG
     uint32_t old_addr = addr;
 #endif
 
     addr = addr - page->virt + page->phys;
 
-    if (addr < ((uint32_t) mem_size << 10))
+    if (addr < (mem_size << 10))
         ram[addr] = val;
 
     ct_82c100_log("mem_write_emsb(%08X = %08X, %02X)\n", old_addr, addr, val);
@@ -332,14 +332,14 @@ mem_write_emsb(uint32_t addr, uint8_t val, void *priv)
 static void
 mem_write_emsw(uint32_t addr, uint16_t val, void *priv)
 {
-    ems_page_t *page = (ems_page_t *) priv;
+    const ems_page_t *page = (ems_page_t *) priv;
 #ifdef ENABLE_CT_82C100_LOG
     uint32_t old_addr = addr;
 #endif
 
     addr = addr - page->virt + page->phys;
 
-    if (addr < ((uint32_t) mem_size << 10))
+    if (addr < (mem_size << 10))
         *(uint16_t *) &ram[addr] = val;
 
     ct_82c100_log("mem_write_emsw(%08X = %08X, %04X)\n", old_addr, addr, val);

src/chipset/acc2168.c

@@ -168,7 +168,7 @@ acc2168_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 acc2168_read(uint16_t addr, void *priv)
 {
-    acc2168_t *dev = (acc2168_t *) priv;
+    const acc2168_t *dev = (acc2168_t *) priv;
 
     return (addr == 0xf3) ? dev->regs[dev->reg_idx] : dev->reg_idx;
 }

src/chipset/ali1429.c

@@ -280,8 +280,8 @@ ali1429_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 ali1429_read(uint16_t addr, void *priv)
 {
-    ali1429_t *dev = (ali1429_t *) priv;
-    uint8_t    ret = 0xff;
+    const ali1429_t *dev = (ali1429_t *) priv;
+    uint8_t          ret = 0xff;
 
     if ((addr == 0x23) && (dev->index >= 0x10) && (dev->index <= 0x4a))
         ret = dev->regs[dev->index];

src/chipset/ali1435.c

@@ -166,8 +166,8 @@ ali1435_pci_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 ali1435_pci_read(int func, int addr, void *priv)
 {
-    ali1435_t *dev = (ali1435_t *) priv;
-    uint8_t    ret;
+    const ali1435_t *dev = (ali1435_t *) priv;
+    uint8_t          ret;
 
     ret = 0xff;
 
@@ -233,8 +233,8 @@ ali1435_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 ali1435_read(uint16_t addr, void *priv)
 {
-    ali1435_t *dev = (ali1435_t *) priv;
-    uint8_t    ret = 0xff;
+    const ali1435_t *dev = (ali1435_t *) priv;
+    uint8_t          ret = 0xff;
 
     if ((addr == 0x23) && (dev->index < 0x10))
         ret = dev->regs[dev->index];

src/chipset/ali1489.c

@@ -408,8 +408,8 @@ ali1489_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 ali1489_read(uint16_t addr, void *priv)
 {
-    uint8_t    ret = 0xff;
-    ali1489_t *dev = (ali1489_t *) priv;
+    uint8_t          ret = 0xff;
+    const ali1489_t *dev = (ali1489_t *) priv;
 
     switch (addr) {
         case 0x23:
@@ -456,8 +456,8 @@ ali1489_pci_write(UNUSED(int func), int addr, uint8_t val, void *priv)
 static uint8_t
 ali1489_pci_read(UNUSED(int func), int addr, void *priv)
 {
-    ali1489_t *dev = (ali1489_t *) priv;
-    uint8_t    ret = 0xff;
+    const ali1489_t *dev = (ali1489_t *) priv;
+    uint8_t          ret = 0xff;
 
     ret = dev->pci_conf[addr];
     ali1489_log("M1489-PCI: dev->pci_conf[%02x] (%02x)\n", addr, ret);
@@ -560,8 +560,8 @@ ali1489_ide_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 ali1489_ide_read(uint16_t addr, void *priv)
 {
-    ali1489_t *dev = (ali1489_t *) priv;
-    uint8_t    ret = 0xff;
+    const ali1489_t *dev = (ali1489_t *) priv;
+    uint8_t          ret = 0xff;
 
     switch (addr) {
         case 0xf4:

src/chipset/ali1531.c

@@ -303,8 +303,8 @@ ali1531_write(UNUSED(int func), int addr, uint8_t val, void *priv)
 static uint8_t
 ali1531_read(UNUSED(int func), int addr, void *priv)
 {
-    ali1531_t *dev = (ali1531_t *) priv;
-    uint8_t    ret = 0xff;
+    const ali1531_t *dev = (ali1531_t *) priv;
+    uint8_t          ret = 0xff;
 
     ret = dev->pci_conf[addr];
 

src/chipset/ali1541.c

@@ -560,8 +560,8 @@ ali1541_write(UNUSED(int func), int addr, uint8_t val, void *priv)
 static uint8_t
 ali1541_read(UNUSED(int func), int addr, void *priv)
 {
-    ali1541_t *dev = (ali1541_t *) priv;
-    uint8_t    ret = 0xff;
+    const ali1541_t *dev = (ali1541_t *) priv;
+    uint8_t          ret = 0xff;
 
     ret = dev->pci_conf[addr];
 

src/chipset/ali1543.c

@@ -895,7 +895,7 @@ ali5229_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 ali5229_read(int func, int addr, void *priv)
 {
-    ali1543_t *dev = (ali1543_t *) priv;
+    const ali1543_t *dev = (ali1543_t *) priv;
     uint8_t    ret = 0xff;
 
     if (dev->ide_dev_enable && (func == 0)) {
@@ -983,7 +983,7 @@ ali5237_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 ali5237_read(int func, int addr, void *priv)
 {
-    ali1543_t *dev = (ali1543_t *) priv;
+    const ali1543_t *dev = (ali1543_t *) priv;
     uint8_t    ret = 0xff;
 
     if (dev->usb_dev_enable && (func == 0))
@@ -1474,7 +1474,7 @@ ali7101_read(int func, int addr, void *priv)
 static void
 ali5237_usb_update_interrupt(usb_t* usb, void *priv)
 {
-    ali1543_t *dev = (ali1543_t *) priv;
+    const ali1543_t *dev = (ali1543_t *) priv;
 
     if (usb->irq_level)
         pci_set_mirq(4, !!(dev->pci_conf[0x74] & 0x10));

src/chipset/ali1621.c

@@ -108,7 +108,9 @@ ali1621_smram_recalc(uint8_t val, ali1621_t *dev)
             switch (val & 0x30) {
                 case 0x10: /* Open. */
                     access_normal = ACCESS_SMRAM_RX;
-                    /* FALLTHROUGH */
+#ifndef __APPLE__
+                    [[fallthrough]];
+#endif
                 case 0x30: /* Protect. */
                     access_smm |= ACCESS_SMRAM_R;
                     break;
@@ -121,7 +123,9 @@ ali1621_smram_recalc(uint8_t val, ali1621_t *dev)
             switch (val & 0x30) {
                 case 0x10: /* Open. */
                     access_normal |= ACCESS_SMRAM_W;
-                    /* FALLTHROUGH */
+#ifndef __APPLE__
+                    [[fallthrough]];
+#endif
                 case 0x30: /* Protect. */
                     access_smm |= ACCESS_SMRAM_W;
                     break;
@@ -579,8 +583,8 @@ ali1621_write(UNUSED(int func), int addr, uint8_t val, void *priv)
 static uint8_t
 ali1621_read(UNUSED(int func), int addr, void *priv)
 {
-    ali1621_t *dev = (ali1621_t *) priv;
-    uint8_t    ret = 0xff;
+    const ali1621_t *dev = (ali1621_t *) priv;
+    uint8_t          ret = 0xff;
 
     ret = dev->pci_conf[addr];
 

src/chipset/ali6117.c

@@ -233,7 +233,9 @@ ali6117_reg_write(uint16_t addr, uint8_t val, void *priv)
 
                 case 0x12:
                     val &= 0xf7;
-                    /* FALL-THROUGH */
+#ifndef __APPLE__
+                    [[fallthrough]];
+#endif
 
                 case 0x14:
                 case 0x15:
@@ -388,7 +390,7 @@ ali6117_reg_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 ali6117_reg_read(uint16_t addr, void *priv)
 {
-    ali6117_t *dev = (ali6117_t *) priv;
+    const ali6117_t *dev = (ali6117_t *) priv;
     uint8_t    ret;
 
     if (addr == 0x22)

src/chipset/cs4031.c

@@ -148,7 +148,7 @@ cs4031_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 cs4031_read(uint16_t addr, void *priv)
 {
-    cs4031_t *dev = (cs4031_t *) priv;
+    const cs4031_t *dev = (cs4031_t *) priv;
 
     return (addr == 0x23) ? dev->regs[dev->index] : 0xff;
 }

src/chipset/cs8230.c

@@ -81,8 +81,8 @@ rethink_shadow_mappings(cs8230_t *cs8230)
 static uint8_t
 cs8230_read(uint16_t port, void *priv)
 {
-    cs8230_t *cs8230 = (cs8230_t *) priv;
-    uint8_t   ret    = 0xff;
+    const cs8230_t *cs8230 = (cs8230_t *) priv;
+    uint8_t         ret    = 0xff;
 
     if (port & 1) {
         switch (cs8230->idx) {

src/chipset/et6000.c

@@ -121,7 +121,7 @@ et6000_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 et6000_read(uint16_t addr, void *priv)
 {
-    et6000_t *dev = (et6000_t *) priv;
+    const et6000_t *dev = (et6000_t *) priv;
 
     return ((addr == 0x23) && (INDEX >= 0) && (INDEX <= 5)) ? dev->regs[INDEX] : 0xff;
 }

src/chipset/gc100.c

@@ -145,9 +145,9 @@ gc100_write(uint16_t port, uint8_t val, void *priv)
 static uint8_t
 gc100_read(uint16_t port, void *priv)
 {
-    gc100_t *dev  = (gc100_t *) priv;
-    uint8_t  ret  = 0xff;
-    uint16_t addr = port & 0xf;
+    const gc100_t *dev  = (gc100_t *) priv;
+    uint8_t        ret  = 0xff;
+    uint16_t       addr = port & 0xf;
 
     ret = dev->reg[addr];
 

src/chipset/headland.c

@@ -165,7 +165,7 @@ get_addr(headland_t *dev, uint32_t addr, headland_mr_t *mr)
 static void
 hl_ems_disable(headland_t *dev, uint8_t mar, uint32_t base_addr, uint8_t indx)
 {
-    if (base_addr < ((uint32_t) mem_size << 10))
+    if (base_addr < (mem_size << 10))
         mem_mapping_set_exec(&dev->ems_mapping[mar & 0x3f], ram + base_addr);
     else
         mem_mapping_set_exec(&dev->ems_mapping[mar & 0x3f], NULL);
@@ -197,7 +197,7 @@ hl_ems_update(headland_t *dev, uint8_t mar)
         dev->ems_mr[mar & 0x3f].virt_base = virt_addr;
         if (indx < 24)
             mem_mapping_disable(&dev->upper_mapping[indx]);
-        if (virt_addr < ((uint32_t) mem_size << 10))
+        if (virt_addr < (mem_size << 10))
             mem_mapping_set_exec(&dev->ems_mapping[mar & 0x3f], ram + virt_addr);
         else
             mem_mapping_set_exec(&dev->ems_mapping[mar & 0x3f], NULL);
@@ -244,7 +244,7 @@ memmap_state_update(headland_t *dev)
 
     for (uint8_t i = 0; i < 24; i++) {
         addr = get_addr(dev, 0x40000 + (i << 14), NULL);
-        mem_mapping_set_exec(&dev->upper_mapping[i], addr < ((uint32_t) mem_size << 10) ? ram + addr : NULL);
+        mem_mapping_set_exec(&dev->upper_mapping[i], addr < (mem_size << 10) ? ram + addr : NULL);
     }
 
     memmap_state_default(dev, ht_romcs);
@@ -513,7 +513,7 @@ mem_read_b(uint32_t addr, void *priv)
     uint8_t        ret = 0xff;
 
     addr = get_addr(dev, addr, mr);
-    if (addr < ((uint32_t) mem_size << 10))
+    if (addr < (mem_size << 10))
         ret = ram[addr];
 
     return ret;
@@ -527,7 +527,7 @@ mem_read_w(uint32_t addr, void *priv)
     uint16_t       ret = 0xffff;
 
     addr = get_addr(dev, addr, mr);
-    if (addr < ((uint32_t) mem_size << 10))
+    if (addr < (mem_size << 10))
         ret = *(uint16_t *) &ram[addr];
 
     return ret;
@@ -541,7 +541,7 @@ mem_read_l(uint32_t addr, void *priv)
     uint32_t       ret = 0xffffffff;
 
     addr = get_addr(dev, addr, mr);
-    if (addr < ((uint32_t) mem_size << 10))
+    if (addr < (mem_size << 10))
         ret = *(uint32_t *) &ram[addr];
 
     return ret;
@@ -554,7 +554,7 @@ mem_write_b(uint32_t addr, uint8_t val, void *priv)
     headland_t    *dev = mr->headland;
 
     addr = get_addr(dev, addr, mr);
-    if (addr < ((uint32_t) mem_size << 10))
+    if (addr < (mem_size << 10))
         ram[addr] = val;
 }
 
@@ -565,7 +565,7 @@ mem_write_w(uint32_t addr, uint16_t val, void *priv)
     headland_t    *dev = mr->headland;
 
     addr = get_addr(dev, addr, mr);
-    if (addr < ((uint32_t) mem_size << 10))
+    if (addr < (mem_size << 10))
         *(uint16_t *) &ram[addr] = val;
 }
 
@@ -576,7 +576,7 @@ mem_write_l(uint32_t addr, uint32_t val, void *priv)
     headland_t    *dev = mr->headland;
 
     addr = get_addr(dev, addr, mr);
-    if (addr < ((uint32_t) mem_size << 10))
+    if (addr < (mem_size << 10))
         *(uint32_t *) &ram[addr] = val;
 }
 

src/chipset/ims8848.c

@@ -327,8 +327,8 @@ ims8849_pci_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 ims8849_pci_read(int func, int addr, void *priv)
 {
-    ims8848_t *dev = (ims8848_t *) priv;
-    uint8_t    ret = 0xff;
+    const ims8848_t *dev = (ims8848_t *) priv;
+    uint8_t          ret = 0xff;
 
     if (func == 0)
         ret = dev->pci_conf[addr];

src/chipset/intel_420ex.c

@@ -118,7 +118,7 @@ i420ex_smram_handler_phase0(void)
 static void
 i420ex_smram_handler_phase1(i420ex_t *dev)
 {
-    uint8_t *regs = (uint8_t *) dev->regs;
+    const uint8_t *regs = (uint8_t *) dev->regs;
 
     uint32_t host_base = 0x000a0000;
     uint32_t ram_base  = 0x000a0000;
@@ -165,15 +165,14 @@ i420ex_smram_handler_phase1(i420ex_t *dev)
 static void
 i420ex_drb_recalc(i420ex_t *dev)
 {
-    int i;
     uint32_t boundary;
 
-    for (i = 4; i >= 0; i--)
+    for (uint8_t i = 4; i >= 0; i--)
         row_disable(i);
 
-    for (i = 0; i <= 4; i++) {
-	boundary = ((uint32_t) dev->regs[0x60 + i]) & 0xff;
-	row_set_boundary(i, boundary);
+    for (uint8_t i = 0; i <= 4; i++) {
+        boundary = ((uint32_t) dev->regs[0x60 + i]) & 0xff;
+        row_set_boundary(i, boundary);
     }
 
     flushmmucache();
@@ -398,8 +397,8 @@ i420ex_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 i420ex_read(int func, int addr, void *priv)
 {
-    i420ex_t *dev = (i420ex_t *) priv;
-    uint8_t   ret;
+    const i420ex_t *dev = (i420ex_t *) priv;
+    uint8_t         ret;
 
     ret = 0xff;
 

src/chipset/intel_4x0.c

@@ -118,10 +118,10 @@ static void
 i4x0_smram_handler_phase1(i4x0_t *dev)
 {
 
-    uint8_t *regs    = (uint8_t *) dev->regs;
-    uint32_t tom     = (mem_size << 10);
-    uint8_t *reg     = (dev->type >= INTEL_430LX) ? &(regs[0x72]) : &(regs[0x57]);
-    uint8_t *ext_reg = (dev->type >= INTEL_440BX) ? &(regs[0x73]) : &(regs[0x71]);
+    const uint8_t *regs    = (uint8_t *) dev->regs;
+    uint32_t       tom     = (mem_size << 10);
+    const uint8_t *reg     = (dev->type >= INTEL_430LX) ? &(regs[0x72]) : &(regs[0x57]);
+    const uint8_t *ext_reg = (dev->type >= INTEL_440BX) ? &(regs[0x73]) : &(regs[0x71]);
 
     uint32_t s;
     uint32_t base[2] = { 0x000a0000, 0x00000000 };
@@ -228,7 +228,7 @@ i4x0_mask_bar(uint8_t *regs, void *agpgart)
 static uint8_t
 pm2_cntrl_read(UNUSED(uint16_t addr), void *priv)
 {
-    i4x0_t *dev = (i4x0_t *) priv;
+    const i4x0_t *dev = (i4x0_t *) priv;
 
     return dev->pm2_cntrl & 0x01;
 }
@@ -1068,6 +1068,8 @@ i4x0_write(int func, int addr, uint8_t val, void *priv)
                     case INTEL_440ZX:
                     case INTEL_440GX:
                         regs[addr] = val;
+                        break;
+
                     default:
                         break;
                 }
@@ -1077,6 +1079,8 @@ i4x0_write(int func, int addr, uint8_t val, void *priv)
                     case INTEL_440BX:
                     case INTEL_440ZX:
                         regs[0x77] = val & 0x03;
+                        break;
+
                     default:
                         break;
                 }
@@ -1505,9 +1509,9 @@ i4x0_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 i4x0_read(int func, int addr, void *priv)
 {
-    i4x0_t  *dev  = (i4x0_t *) priv;
-    uint8_t  ret  = 0xff;
-    uint8_t *regs = (uint8_t *) dev->regs;
+    i4x0_t        *dev  = (i4x0_t *) priv;
+    uint8_t        ret  = 0xff;
+    const uint8_t *regs = (uint8_t *) dev->regs;
 
     if (func == 0) {
         ret = regs[addr];

src/chipset/intel_82335.c

@@ -153,7 +153,7 @@ intel_82335_write(uint16_t addr, uint16_t val, void *priv)
 static uint16_t
 intel_82335_read(uint16_t addr, void *priv)
 {
-    intel_82335_t *dev = (intel_82335_t *) priv;
+    const intel_82335_t *dev = (intel_82335_t *) priv;
 
     intel_82335_log("Register %02x: Read %04x\n", addr, dev->regs[addr]);
 

src/chipset/intel_i450kx.c

@@ -90,9 +90,9 @@ i450kx_map(i450kx_t *dev, int bus, uint32_t addr, uint32_t size, int state)
 static void
 i450kx_smram_recalc(i450kx_t *dev, int bus)
 {
-    uint8_t *regs = bus ? dev->pb_pci_conf : dev->mc_pci_conf;
-    uint32_t addr;
-    uint32_t size;
+    const uint8_t *regs = bus ? dev->pb_pci_conf : dev->mc_pci_conf;
+    uint32_t       addr;
+    uint32_t       size;
 
     smram_disable(dev->smram[bus]);
 
@@ -112,7 +112,7 @@ i450kx_smram_recalc(i450kx_t *dev, int bus)
 static void
 i450kx_vid_buf_recalc(i450kx_t *dev, int bus)
 {
-    uint8_t *regs = bus ? dev->pb_pci_conf : dev->mc_pci_conf;
+    const uint8_t *regs = bus ? dev->pb_pci_conf : dev->mc_pci_conf;
 
 #if 0
     // int state = (regs[0x58] & 0x02) ? (MEM_READ_EXTANY | MEM_WRITE_EXTANY) : (MEM_READ_DISABLED | MEM_WRITE_DISABLED);
@@ -374,7 +374,7 @@ pb_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 pb_read(int func, int addr, void *priv)
 {
-    i450kx_t *dev = (i450kx_t *) priv;
+    const i450kx_t *dev = (i450kx_t *) priv;
     uint8_t   ret = 0xff;
 
     if (func == 0)
@@ -601,7 +601,7 @@ mc_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 mc_read(int func, int addr, void *priv)
 {
-    i450kx_t *dev = (i450kx_t *) priv;
+    const i450kx_t *dev = (i450kx_t *) priv;
     uint8_t   ret = 0xff;
 
     if (func == 0)

src/chipset/intel_piix.c

@@ -289,7 +289,7 @@ piix_trap_io(UNUSED(int size), UNUSED(uint16_t addr), UNUSED(uint8_t write), UNU
 static void
 piix_trap_io_ide(int size, uint16_t addr, uint8_t write, uint8_t val, void *priv)
 {
-    piix_io_trap_t *trap = (piix_io_trap_t *) priv;
+    const piix_io_trap_t *trap = (piix_io_trap_t *) priv;
 
     /* IDE traps are per drive, not per channel. */
     if (ide_drives[trap->dev_id]->selected)
@@ -327,10 +327,10 @@ piix_trap_update_devctl(piix_t *dev, uint8_t trap_id, uint8_t dev_id,
 static void
 piix_trap_update(void *priv)
 {
-    piix_t  *dev     = (piix_t *) priv;
-    uint8_t  trap_id = 0;
-    uint8_t *fregs   = dev->regs[3];
-    uint16_t temp;
+    piix_t        *dev     = (piix_t *) priv;
+    uint8_t        trap_id = 0;
+    const uint8_t *fregs   = dev->regs[3];
+    uint16_t       temp;
 
     piix_trap_update_devctl(dev, trap_id++, 0, 0x00000002, 1, 0x1f0, 8);
     piix_trap_update_devctl(dev, trap_id++, 0, 0x00000002, 1, 0x3f6, 1);
@@ -1166,9 +1166,9 @@ piix_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 piix_read(int func, int addr, void *priv)
 {
-    piix_t  *dev = (piix_t *) priv;
-    uint8_t  ret = 0xff;
-    uint8_t *fregs;
+    piix_t        *dev = (piix_t *) priv;
+    uint8_t        ret = 0xff;
+    const uint8_t *fregs;
 
     if ((dev->type == 3) && (func == 2) && (dev->max_func == 1) && (addr >= 0x40))
         ret = 0x00;
@@ -1202,8 +1202,8 @@ board_write(uint16_t port, uint8_t val, void *priv)
 static uint8_t
 board_read(uint16_t port, void *priv)
 {
-    piix_t *dev = (piix_t *) priv;
-    uint8_t ret = 0x64;
+    const piix_t *dev = (piix_t *) priv;
+    uint8_t       ret = 0x64;
 
     if (port == 0x0078)
         ret = dev->board_config[0];
@@ -1446,7 +1446,7 @@ piix_fast_off_count(void *priv)
 static void
 piix_usb_update_interrupt(usb_t* usb, void *priv)
 {
-    piix_t *dev = (piix_t *) priv;
+    const piix_t *dev = (piix_t *) priv;
 
     if (usb->irq_level)
         pci_set_irq(dev->pci_slot, PCI_INTD);
@@ -1457,7 +1457,7 @@ piix_usb_update_interrupt(usb_t* usb, void *priv)
 static void
 piix_reset(void *priv)
 {
-    piix_t *dev = (piix_t *) priv;
+    const piix_t *dev = (piix_t *) priv;
 
     if (dev->type > 3) {
         piix_write(3, 0x04, 0x00, priv);

src/chipset/intel_sio.c

@@ -324,8 +324,8 @@ sio_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 sio_read(int func, int addr, void *priv)
 {
-    sio_t  *dev = (sio_t *) priv;
-    uint8_t ret;
+    const sio_t  *dev = (sio_t *) priv;
+    uint8_t       ret;
 
     ret = 0xff;
 
@@ -452,7 +452,7 @@ sio_fast_off_count(void *priv)
 static void
 sio_reset(void *priv)
 {
-    sio_t *dev = (sio_t *) priv;
+    const sio_t *dev = (sio_t *) priv;
 
     /* Disable the PIC mouse latch. */
     sio_write(0, 0x4d, 0x40, priv);

src/chipset/neat.c

@@ -349,9 +349,9 @@ ems_write(uint16_t port, uint8_t val, void *priv)
 static uint8_t
 ems_read(uint16_t port, void *priv)
 {
-    neat_t *dev = (neat_t *) priv;
-    uint8_t ret = 0xff;
-    int     vpage;
+    const neat_t *dev = (neat_t *) priv;
+    uint8_t       ret = 0xff;
+    int           vpage;
 
     /* Get the viewport page number. */
     vpage = (port / EMS_PGSIZE);
@@ -637,8 +637,8 @@ neat_write(uint16_t port, uint8_t val, void *priv)
 static uint8_t
 neat_read(uint16_t port, void *priv)
 {
-    neat_t *dev = (neat_t *) priv;
-    uint8_t ret = 0xff;
+    const neat_t *dev = (neat_t *) priv;
+    uint8_t       ret = 0xff;
 
     switch (port) {
         case 0x22:

src/chipset/opti283.c

@@ -66,7 +66,7 @@ typedef struct opti283_t {
 static uint8_t
 opti283_read_remapped_ram(uint32_t addr, void *priv)
 {
-    mem_remapping_t *dev = (mem_remapping_t *) priv;
+    const mem_remapping_t *dev = (mem_remapping_t *) priv;
 
     return mem_read_ram((addr - dev->virt) + dev->phys, priv);
 }
@@ -74,7 +74,7 @@ opti283_read_remapped_ram(uint32_t addr, void *priv)
 static uint16_t
 opti283_read_remapped_ramw(uint32_t addr, void *priv)
 {
-    mem_remapping_t *dev = (mem_remapping_t *) priv;
+    const mem_remapping_t *dev = (mem_remapping_t *) priv;
 
     return mem_read_ramw((addr - dev->virt) + dev->phys, priv);
 }
@@ -82,7 +82,7 @@ opti283_read_remapped_ramw(uint32_t addr, void *priv)
 static uint32_t
 opti283_read_remapped_raml(uint32_t addr, void *priv)
 {
-    mem_remapping_t *dev = (mem_remapping_t *) priv;
+    const mem_remapping_t *dev = (mem_remapping_t *) priv;
 
     return mem_read_raml((addr - dev->virt) + dev->phys, priv);
 }
@@ -90,7 +90,7 @@ opti283_read_remapped_raml(uint32_t addr, void *priv)
 static void
 opti283_write_remapped_ram(uint32_t addr, uint8_t val, void *priv)
 {
-    mem_remapping_t *dev = (mem_remapping_t *) priv;
+    const mem_remapping_t *dev = (mem_remapping_t *) priv;
 
     mem_write_ram((addr - dev->virt) + dev->phys, val, priv);
 }
@@ -98,7 +98,7 @@ opti283_write_remapped_ram(uint32_t addr, uint8_t val, void *priv)
 static void
 opti283_write_remapped_ramw(uint32_t addr, uint16_t val, void *priv)
 {
-    mem_remapping_t *dev = (mem_remapping_t *) priv;
+    const mem_remapping_t *dev = (mem_remapping_t *) priv;
 
     mem_write_ramw((addr - dev->virt) + dev->phys, val, priv);
 }
@@ -106,7 +106,7 @@ opti283_write_remapped_ramw(uint32_t addr, uint16_t val, void *priv)
 static void
 opti283_write_remapped_raml(uint32_t addr, uint32_t val, void *priv)
 {
-    mem_remapping_t *dev = (mem_remapping_t *) priv;
+    const mem_remapping_t *dev = (mem_remapping_t *) priv;
 
     mem_write_raml((addr - dev->virt) + dev->phys, val, priv);
 }
@@ -228,7 +228,9 @@ opti283_write(uint16_t addr, uint8_t val, void *priv)
 
                 case 0x14:
                     reset_on_hlt = !!(val & 0x40);
-                    /* FALLTHROUGH */
+#ifndef __APPLE__
+                    [[fallthrough]];
+#endif
                 case 0x11:
                 case 0x12:
                 case 0x13:
@@ -249,8 +251,8 @@ opti283_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 opti283_read(uint16_t addr, void *priv)
 {
-    opti283_t *dev = (opti283_t *) priv;
-    uint8_t    ret = 0xff;
+    const opti283_t *dev = (opti283_t *) priv;
+    uint8_t          ret = 0xff;
 
     if (addr == 0x24)
         ret = dev->regs[dev->index];

src/chipset/opti291.c

@@ -122,7 +122,7 @@ opti291_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 opti291_read(uint16_t addr, void *priv)
 {
-    opti291_t *dev = (opti291_t *) priv;
+    const opti291_t *dev = (opti291_t *) priv;
 
     return (addr == 0x24) ? dev->regs[dev->index] : 0xff;
 }

src/chipset/opti391.c

@@ -178,8 +178,8 @@ opti391_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 opti391_read(uint16_t addr, void *priv)
 {
-    opti391_t *dev = (opti391_t *) priv;
-    uint8_t    ret = 0xff;
+    const opti391_t *dev = (opti391_t *) priv;
+    uint8_t          ret = 0xff;
 
     if (addr == 0x24)
         ret = dev->regs[dev->index];

src/chipset/opti495.c

@@ -157,8 +157,8 @@ opti495_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 opti495_read(uint16_t addr, void *priv)
 {
-    uint8_t    ret = 0xff;
-    opti495_t *dev = (opti495_t *) priv;
+    uint8_t          ret = 0xff;
+    const opti495_t *dev = (opti495_t *) priv;
 
     switch (addr) {
         case 0x22:

src/chipset/opti5x7.c

@@ -156,7 +156,7 @@ opti5x7_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 opti5x7_read(uint16_t addr, void *priv)
 {
-    opti5x7_t *dev = (opti5x7_t *) priv;
+    const opti5x7_t *dev = (opti5x7_t *) priv;
 
     return (addr == 0x24) ? dev->regs[dev->idx] : 0xff;
 }

src/chipset/opti822.c

@@ -336,8 +336,8 @@ opti822_pci_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 opti822_pci_read(int func, int addr, void *priv)
 {
-    opti822_t *dev = (opti822_t *) priv;
-    uint8_t    ret;
+    const opti822_t *dev = (opti822_t *) priv;
+    uint8_t          ret;
 
     ret = 0xff;
 

src/chipset/opti895.c

@@ -204,8 +204,8 @@ opti895_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 opti895_read(uint16_t addr, void *priv)
 {
-    uint8_t    ret = 0xff;
-    opti895_t *dev = (opti895_t *) priv;
+    uint8_t          ret = 0xff;
+    const opti895_t *dev = (opti895_t *) priv;
 
     switch (addr) {
         case 0x23:

src/chipset/scamp.c

@@ -152,12 +152,12 @@ static const struct {
 static uint8_t
 ram_mirrored_256k_in_4mi_read(uint32_t addr, void *priv)
 {
-    ram_struct_t *rs   = (ram_struct_t *) priv;
-    scamp_t      *dev  = rs->parent;
-    int           bank = rs->bank;
-    int           byte;
-    int           row;
-    int           column;
+    const ram_struct_t *rs   = (ram_struct_t *) priv;
+    const scamp_t      *dev  = rs->parent;
+    int                 bank = rs->bank;
+    int                 byte;
+    int                 row;
+    int                 column;
 
     addr -= dev->ram_virt_base[bank];
     byte = addr & 1;
@@ -183,12 +183,12 @@ ram_mirrored_256k_in_4mi_read(uint32_t addr, void *priv)
 static void
 ram_mirrored_256k_in_4mi_write(uint32_t addr, uint8_t val, void *priv)
 {
-    ram_struct_t *rs   = (ram_struct_t *) priv;
-    scamp_t      *dev  = rs->parent;
-    int           bank = rs->bank;
-    int           byte;
-    int           row;
-    int           column;
+    const ram_struct_t *rs   = (ram_struct_t *) priv;
+    const scamp_t      *dev  = rs->parent;
+    int                 bank = rs->bank;
+    int                 byte;
+    int                 row;
+    int                 column;
 
     addr -= dev->ram_virt_base[bank];
     byte = addr & 1;
@@ -216,12 +216,12 @@ ram_mirrored_256k_in_4mi_write(uint32_t addr, uint8_t val, void *priv)
 static uint8_t
 ram_mirrored_interleaved_read(uint32_t addr, void *priv)
 {
-    ram_struct_t *rs   = (ram_struct_t *) priv;
-    scamp_t      *dev  = rs->parent;
-    int           bank = rs->bank;
-    int           byte;
-    int           row;
-    int           column;
+    const ram_struct_t *rs   = (ram_struct_t *) priv;
+    const scamp_t      *dev  = rs->parent;
+    int                 bank = rs->bank;
+    int                 byte;
+    int                 row;
+    int                 column;
 
     addr -= dev->ram_virt_base[bank];
     byte = addr & 1;
@@ -247,12 +247,12 @@ ram_mirrored_interleaved_read(uint32_t addr, void *priv)
 static void
 ram_mirrored_interleaved_write(uint32_t addr, uint8_t val, void *priv)
 {
-    ram_struct_t *rs   = (ram_struct_t *) priv;
-    scamp_t      *dev  = rs->parent;
-    int           bank = rs->bank;
-    int           byte;
-    int           row;
-    int           column;
+    const ram_struct_t *rs   = (ram_struct_t *) priv;
+    const scamp_t      *dev  = rs->parent;
+    int                 bank = rs->bank;
+    int                 byte;
+    int                 row;
+    int                 column;
 
     addr -= dev->ram_virt_base[bank];
     byte = addr & 1;
@@ -278,12 +278,12 @@ ram_mirrored_interleaved_write(uint32_t addr, uint8_t val, void *priv)
 static uint8_t
 ram_mirrored_read(uint32_t addr, void *priv)
 {
-    ram_struct_t *rs   = (ram_struct_t *) priv;
-    scamp_t      *dev  = rs->parent;
-    int           bank = rs->bank;
-    int           byte;
-    int           row;
-    int           column;
+    const ram_struct_t *rs   = (ram_struct_t *) priv;
+    const scamp_t      *dev  = rs->parent;
+    int                 bank = rs->bank;
+    int                 byte;
+    int                 row;
+    int                 column;
 
     addr -= dev->ram_virt_base[bank];
     byte   = addr & 1;
@@ -297,12 +297,12 @@ ram_mirrored_read(uint32_t addr, void *priv)
 static void
 ram_mirrored_write(uint32_t addr, uint8_t val, void *priv)
 {
-    ram_struct_t *rs   = (ram_struct_t *) priv;
-    scamp_t      *dev  = rs->parent;
-    int           bank = rs->bank;
-    int           byte;
-    int           row;
-    int           column;
+    const ram_struct_t *rs   = (ram_struct_t *) priv;
+    const scamp_t      *dev  = rs->parent;
+    int                 bank = rs->bank;
+    int                 byte;
+    int                 row;
+    int                 column;
 
     addr -= dev->ram_virt_base[bank];
     byte   = addr & 1;
@@ -574,9 +574,9 @@ recalc_sltptr(scamp_t *dev)
 static uint8_t
 scamp_ems_read(uint32_t addr, void *priv)
 {
-    ems_struct_t *ems     = (ems_struct_t *) priv;
-    scamp_t      *dev     = ems->parent;
-    int           segment = ems->segment;
+    const ems_struct_t *ems     = (ems_struct_t *) priv;
+    const scamp_t      *dev     = ems->parent;
+    int                 segment = ems->segment;
 
     addr = (addr & 0x3fff) | dev->mappings[segment];
     return ram[addr];
@@ -585,9 +585,9 @@ scamp_ems_read(uint32_t addr, void *priv)
 static void
 scamp_ems_write(uint32_t addr, uint8_t val, void *priv)
 {
-    ems_struct_t *ems     = (ems_struct_t *) priv;
-    scamp_t      *dev     = ems->parent;
-    int           segment = ems->segment;
+    const ems_struct_t *ems     = (ems_struct_t *) priv;
+    const scamp_t      *dev     = ems->parent;
+    int                 segment = ems->segment;
 
     addr      = (addr & 0x3fff) | dev->mappings[segment];
     ram[addr] = val;

src/chipset/scat.c

@@ -1204,9 +1204,9 @@ scat_out(uint16_t port, uint8_t val, void *priv)
 static uint8_t
 scat_in(uint16_t port, void *priv)
 {
-    scat_t *dev = (scat_t *) priv;
-    uint8_t ret = 0xff;
-    uint8_t indx;
+    const scat_t *dev = (scat_t *) priv;
+    uint8_t       ret = 0xff;
+    uint8_t       indx;
 
     switch (port) {
         case 0x23:

src/chipset/sis_5511.c

@@ -348,7 +348,8 @@ sis_5511_write(UNUSED(int func), int addr, uint8_t val, void *priv)
 static uint8_t
 sis_5511_read(UNUSED(int func), int addr, void *priv)
 {
-    sis_5511_t *dev = (sis_5511_t *) priv;
+    const sis_5511_t *dev = (sis_5511_t *) priv;
+
     sis_5511_log("SiS 5511: dev->pci_conf[%02x] (%02x) POST %02x\n", addr, dev->pci_conf[addr], inb(0x80));
     return dev->pci_conf[addr];
 }
@@ -554,7 +555,7 @@ sis_5513_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 sis_5513_read(int func, int addr, void *priv)
 {
-    sis_5511_t *dev = (sis_5511_t *) priv;
+    const sis_5511_t *dev = (sis_5511_t *) priv;
 
     sis_5511_log("SiS 5513: dev->pci_conf[%02x][%02x] = %02x POST %02x\n", func, addr, dev->pci_conf_sb[func][addr], inb(0x80));
     if ((func >= 0) && (func <= 1))
@@ -624,7 +625,7 @@ sis_5513_isa_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 sis_5513_isa_read(uint16_t addr, void *priv)
 {
-    sis_5511_t *dev = (sis_5511_t *) priv;
+    const sis_5511_t *dev = (sis_5511_t *) priv;
 
     if (addr == 0x23) {
         sis_5511_log("SiS 5513-ISA: dev->regs[%02x] (%02x) POST: %02x\n", dev->index + 0x50, dev->regs[dev->index], inb(0x80));

src/chipset/sis_5571.c

@@ -340,7 +340,8 @@ memory_pci_bridge_write(UNUSED(int func), int addr, uint8_t val, void *priv)
 static uint8_t
 memory_pci_bridge_read(UNUSED(int func), int addr, void *priv)
 {
-    sis_5571_t *dev = (sis_5571_t *) priv;
+    const sis_5571_t *dev = (sis_5571_t *) priv;
+
     sis_5571_log("SiS5571: dev->pci_conf[%02x] (%02x)\n", addr, dev->pci_conf[addr]);
     return dev->pci_conf[addr];
 }
@@ -638,6 +639,7 @@ pci_isa_bridge_write(int func, int addr, uint8_t val, void *priv)
                     break;
             }
             sis_5571_log("SiS5571-USB: dev->pci_conf[%02x] = %02x\n", addr, val);
+            break;
 
         default:
             break;
@@ -647,7 +649,7 @@ pci_isa_bridge_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 pci_isa_bridge_read(int func, int addr, void *priv)
 {
-    sis_5571_t *dev = (sis_5571_t *) priv;
+    const sis_5571_t *dev = (sis_5571_t *) priv;
 
     switch (func) {
         case 0:
@@ -668,7 +670,7 @@ pci_isa_bridge_read(int func, int addr, void *priv)
 static void
 sis_5571_usb_update_interrupt(usb_t* usb, void* priv)
 {
-    sis_5571_t *dev = (sis_5571_t *) priv;
+    const sis_5571_t *dev = (sis_5571_t *) priv;
 
     if (dev->pci_conf_sb[0][0x68] & 0x80) {
         /* TODO: Is the normal PCI interrupt inhibited when USB IRQ remapping is enabled? */

src/chipset/sis_85c496.c

@@ -115,8 +115,8 @@ sis_85c497_isa_write(uint16_t port, uint8_t val, void *priv)
 static uint8_t
 sis_85c497_isa_read(uint16_t port, void *priv)
 {
-    sis_85c496_t *dev = (sis_85c496_t *) priv;
-    uint8_t       ret = 0xff;
+    const sis_85c496_t *dev = (sis_85c496_t *) priv;
+    uint8_t             ret = 0xff;
 
     if (port == 0x23)
         ret = dev->regs[dev->cur_reg];
@@ -505,8 +505,8 @@ sis_85c49x_pci_write(UNUSED(int func), int addr, uint8_t val, void *priv)
 static uint8_t
 sis_85c49x_pci_read(UNUSED(int func), int addr, void *priv)
 {
-    sis_85c496_t *dev = (sis_85c496_t *) priv;
-    uint8_t       ret = dev->pci_conf[addr];
+    const sis_85c496_t *dev = (sis_85c496_t *) priv;
+    uint8_t             ret = dev->pci_conf[addr];
 
     switch (addr) {
         case 0xa0:

src/chipset/sis_85c50x.c

@@ -228,8 +228,8 @@ sis_85c50x_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 sis_85c50x_read(int func, int addr, void *priv)
 {
-    sis_85c50x_t *dev = (sis_85c50x_t *) priv;
-    uint8_t       ret = 0xff;
+    const sis_85c50x_t *dev = (sis_85c50x_t *) priv;
+    uint8_t             ret = 0xff;
 
     if (func == 0x00)
         ret = dev->pci_conf[addr];
@@ -283,8 +283,8 @@ sis_85c50x_sb_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 sis_85c50x_sb_read(int func, int addr, void *priv)
 {
-    sis_85c50x_t *dev = (sis_85c50x_t *) priv;
-    uint8_t       ret = 0xff;
+    const sis_85c50x_t *dev = (sis_85c50x_t *) priv;
+    uint8_t             ret = 0xff;
 
     if (func == 0x00)
         ret = dev->pci_conf_sb[addr];
@@ -338,8 +338,8 @@ sis_85c50x_isa_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 sis_85c50x_isa_read(uint16_t addr, void *priv)
 {
-    sis_85c50x_t *dev = (sis_85c50x_t *) priv;
-    uint8_t       ret = 0xff;
+    const sis_85c50x_t *dev = (sis_85c50x_t *) priv;
+    uint8_t             ret = 0xff;
 
     switch (addr) {
         case 0x22:

src/chipset/stpc.c

@@ -166,8 +166,8 @@ stpc_host_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 stpc_host_read(uint16_t addr, void *priv)
 {
-    stpc_t *dev = (stpc_t *) priv;
-    uint8_t ret;
+    const stpc_t *dev = (stpc_t *) priv;
+    uint8_t       ret;
 
     if (addr == dev->host_base)
         ret = dev->host_offset;
@@ -196,8 +196,8 @@ stpc_localbus_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 stpc_localbus_read(uint16_t addr, void *priv)
 {
-    stpc_t *dev = (stpc_t *) priv;
-    uint8_t ret;
+    const stpc_t *dev = (stpc_t *) priv;
+    uint8_t       ret;
 
     if (addr == dev->localbus_base)
         ret = dev->localbus_offset;
@@ -260,8 +260,8 @@ stpc_nb_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 stpc_nb_read(int func, int addr, void *priv)
 {
-    stpc_t *dev = (stpc_t *) priv;
-    uint8_t ret;
+    const stpc_t *dev = (stpc_t *) priv;
+    uint8_t       ret;
 
     if (func > 0)
         ret = 0xff;
@@ -445,8 +445,8 @@ stpc_ide_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 stpc_ide_read(int func, int addr, void *priv)
 {
-    stpc_t *dev = (stpc_t *) priv;
-    uint8_t ret;
+    const stpc_t *dev = (stpc_t *) priv;
+    uint8_t       ret;
 
     if (func > 0)
         ret = 0xff;
@@ -507,8 +507,8 @@ stpc_isab_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 stpc_isab_read(int func, int addr, void *priv)
 {
-    stpc_t *dev = (stpc_t *) priv;
-    uint8_t ret;
+    const stpc_t *dev = (stpc_t *) priv;
+    uint8_t       ret;
 
     if ((func == 1) && (dev->local != STPC_ATLAS))
         ret = stpc_ide_read(0, addr, priv);
@@ -571,8 +571,8 @@ stpc_usb_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 stpc_usb_read(int func, int addr, void *priv)
 {
-    stpc_t *dev = (stpc_t *) priv;
-    uint8_t ret;
+    const stpc_t *dev = (stpc_t *) priv;
+    uint8_t       ret;
 
     if (func > 0)
         ret = 0xff;
@@ -614,7 +614,8 @@ stpc_remap_localbus(stpc_t *dev, uint16_t localbus_base)
 static uint8_t
 stpc_serial_handlers(uint8_t val)
 {
-    stpc_serial_t *dev = device_get_priv(&stpc_serial_device);
+    const stpc_serial_t *dev = device_get_priv(&stpc_serial_device);
+
     if (!dev) {
         stpc_log("STPC: Not remapping UARTs, disabled by strap (raw %02X)\n", val);
         return 0;
@@ -744,8 +745,8 @@ stpc_reg_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 stpc_reg_read(uint16_t addr, void *priv)
 {
-    stpc_t *dev = (stpc_t *) priv;
-    uint8_t ret;
+    const stpc_t *dev = (stpc_t *) priv;
+    uint8_t       ret;
 
     if (addr == 0x22)
         ret = dev->reg_offset;
@@ -895,7 +896,7 @@ stpc_setup(stpc_t *dev)
 static void
 stpc_usb_update_interrupt(usb_t* usb, void* priv)
 {
-    stpc_t *dev = (stpc_t *) priv;
+    const stpc_t *dev = (stpc_t *) priv;
 
     if (usb->irq_level)
         pci_set_irq(dev->usb_slot, PCI_INTA);

src/chipset/umc_8886.c

@@ -289,8 +289,8 @@ umc_8886_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 umc_8886_read(int func, int addr, void *priv)
 {
-    umc_8886_t *dev = (umc_8886_t *) priv;
-    uint8_t     ret = 0xff;
+    const umc_8886_t *dev = (umc_8886_t *) priv;
+    uint8_t           ret = 0xff;
 
     if (func <= dev->max_func)
         ret = dev->pci_conf_sb[func][addr];

src/chipset/umc_hb4.c

@@ -333,8 +333,8 @@ hb4_write(UNUSED(int func), int addr, uint8_t val, void *priv)
 static uint8_t
 hb4_read(int func, int addr, void *priv)
 {
-    hb4_t  *dev = (hb4_t *) priv;
-    uint8_t ret = 0xff;
+    const hb4_t  *dev = (hb4_t *) priv;
+    uint8_t       ret = 0xff;
 
     if (func == 0)
         ret = dev->pci_conf[addr];

src/chipset/via_apollo.c

@@ -671,8 +671,8 @@ via_apollo_host_bridge_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 via_apollo_read(int func, int addr, void *priv)
 {
-    via_apollo_t *dev = (via_apollo_t *) priv;
-    uint8_t       ret = 0xff;
+    const via_apollo_t *dev = (via_apollo_t *) priv;
+    uint8_t             ret = 0xff;
 
     switch (func) {
         case 0:

src/chipset/via_pipc.c

@@ -750,8 +750,8 @@ pipc_codec_handlers(pipc_t *dev, uint8_t modem)
 static uint8_t
 pipc_fmnmi_read(uint16_t addr, void *priv)
 {
-    pipc_t *dev = (pipc_t *) priv;
-    uint8_t ret = dev->fmnmi_regs[addr & 0x03];
+    const pipc_t *dev = (pipc_t *) priv;
+    uint8_t       ret = dev->fmnmi_regs[addr & 0x03];
 
     pipc_log("PIPC: fmnmi_read(%02X) = %02X\n", addr & 0x03, ret);
 
@@ -786,7 +786,7 @@ pipc_fmnmi_handlers(pipc_t *dev, uint8_t modem)
 static uint8_t
 pipc_fm_read(uint16_t addr, void *priv)
 {
-    pipc_t *dev = (pipc_t *) priv;
+    const pipc_t *dev = (pipc_t *) priv;
 #ifdef VIA_PIPC_FM_EMULATION
     uint8_t ret = ((addr & 0x03) == 0x00) ? dev->fmnmi_status : 0x00;
 #else
@@ -1474,7 +1474,9 @@ pipc_write(int func, int addr, uint8_t val, void *priv)
             case 0xd2:
                 if (dev->local == VIA_PIPC_686B)
                     smbus_piix4_setclock(dev->smbus, (val & 0x04) ? 65536 : 16384);
-                /* fall-through */
+#ifndef __APPLE__
+                [[fallthrough]];
+#endif
 
             case 0x90:
             case 0x91:

src/chipset/via_vt82c49x.c

@@ -296,8 +296,8 @@ vt82c49x_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 vt82c49x_read(uint16_t addr, void *priv)
 {
-    uint8_t     ret = 0xff;
-    vt82c49x_t *dev = (vt82c49x_t *) priv;
+    uint8_t           ret = 0xff;
+    const vt82c49x_t *dev = (vt82c49x_t *) priv;
 
     switch (addr) {
         case 0xa9:

src/chipset/via_vt82c505.c

@@ -126,8 +126,8 @@ vt82c505_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 vt82c505_read(int func, int addr, void *priv)
 {
-    vt82c505_t *dev = (vt82c505_t *) priv;
-    uint8_t     ret = 0xff;
+    const vt82c505_t *dev = (vt82c505_t *) priv;
+    uint8_t           ret = 0xff;
 
     if (func != 0)
         return ret;
@@ -151,8 +151,8 @@ vt82c505_out(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 vt82c505_in(uint16_t addr, void *priv)
 {
-    vt82c505_t *dev = (vt82c505_t *) priv;
-    uint8_t     ret = 0xff;
+    const vt82c505_t *dev = (vt82c505_t *) priv;
+    uint8_t           ret = 0xff;
 
     if ((addr == 0xa9) && (dev->index >= 0x80) && (dev->index <= 0x9f))
         ret = vt82c505_read(0, dev->index, priv);

src/chipset/vl82c480.c

@@ -137,8 +137,8 @@ vl82c480_write(uint16_t addr, uint8_t val, void *priv)
 static uint8_t
 vl82c480_read(uint16_t addr, void *priv)
 {
-    vl82c480_t *dev = (vl82c480_t *) priv;
-    uint8_t     ret = 0xff;
+    const vl82c480_t *dev = (vl82c480_t *) priv;
+    uint8_t           ret = 0xff;
 
     switch (addr) {
         case 0xec:

src/chipset/wd76c10.c

@@ -368,7 +368,8 @@ wd76c10_write(uint16_t addr, uint16_t val, void *priv)
 static uint16_t
 wd76c10_read(uint16_t addr, void *priv)
 {
-    wd76c10_t *dev = (wd76c10_t *) priv;
+    const wd76c10_t *dev = (wd76c10_t *) priv;
+
     wd76c10_log("WD76C10: R dev->regs[%04x]\n", addr);
     switch (addr) {
         case 0x1072:

src/config.c

@@ -228,7 +228,7 @@ load_monitor(int monitor_index)
     ini_section_t cat;
     char          name[512];
     char          temp[512];
-    char         *p = NULL;
+    const char   *p = NULL;
 
     sprintf(name, "Monitor #%i", monitor_index + 1);
     sprintf(temp, "%i, %i, %i, %i", cx, cy, cw, ch);
@@ -256,7 +256,7 @@ load_machine(void)
 {
     ini_section_t cat = ini_find_section(config, "Machine");
     char         *p;
-    char         *migrate_from = NULL;
+    const char   *migrate_from = NULL;
     int           c;
     int           i;
     int           j;
@@ -448,7 +448,7 @@ load_machine(void)
                 cpu_f = cpu_get_family(legacy_table_entry->family);
                 if (cpu_f) {
                     /* Save the new values. */
-                    ini_section_set_string(cat, "cpu_family", (char *) legacy_table_entry->family);
+                    ini_section_set_string(cat, "cpu_family", legacy_table_entry->family);
                     ini_section_set_int(cat, "cpu_speed", legacy_table_entry->rspeed);
                     ini_section_set_double(cat, "cpu_multi", legacy_table_entry->multi);
                 }
@@ -500,7 +500,7 @@ load_machine(void)
 
     cpu_waitstates = ini_section_get_int(cat, "cpu_waitstates", 0);
 
-    p        = (char *) ini_section_get_string(cat, "fpu_type", "none");
+    p        = ini_section_get_string(cat, "fpu_type", "none");
     fpu_type = fpu_get_type(cpu_f, cpu, p);
 
     mem_size = ini_section_get_int(cat, "mem_size", 64);
@@ -911,7 +911,7 @@ load_ports(void)
         lpt_ports[c].enabled = !!ini_section_get_int(cat, temp, (c == 0) ? 1 : 0);
 
         sprintf(temp, "lpt%d_device", c + 1);
-        p                   = (char *) ini_section_get_string(cat, temp, "none");
+        p                   = ini_section_get_string(cat, temp, "none");
         lpt_ports[c].device = lpt_device_get_from_internal_name(p);
     }
 
@@ -1557,7 +1557,7 @@ load_other_removable_devices(void)
     ini_section_t cat = ini_find_section(config, "Other removable devices");
     char          temp[512];
     char          tmp2[512];
-    char         *p;
+    const char   *p;
     char          s[512];
     unsigned int  board = 0;
     unsigned int  dev = 0;
@@ -2017,7 +2017,7 @@ save_general(void)
     char          temp[512];
     char          buffer[512] = { 0 };
 
-    char *va_name;
+    const char *va_name = NULL;
 
     ini_section_set_int(cat, "vid_resize", vid_resize);
     if (vid_resize == 0)
@@ -2216,7 +2216,7 @@ static void
 save_machine(void)
 {
     ini_section_t cat = ini_find_or_create_section(config, "Machine");
-    char         *p;
+    const char   *p;
     int           c;
     int           i = 0;
     int           legacy_mfg;
@@ -2226,7 +2226,7 @@ save_machine(void)
     p = machine_get_internal_name();
     ini_section_set_string(cat, "machine", p);
 
-    ini_section_set_string(cat, "cpu_family", (char *) cpu_f->internal_name);
+    ini_section_set_string(cat, "cpu_family", cpu_f->internal_name);
     ini_section_set_int(cat, "cpu_speed", cpu_f->cpus[cpu].rspeed);
     ini_section_set_double(cat, "cpu_multi", cpu_f->cpus[cpu].multi);
     if (cpu_override)
@@ -2247,14 +2247,14 @@ save_machine(void)
     }
     if (cpu_legacy_table[c].machine) {
         /* Look for a corresponding CPU entry. */
-        cpu_legacy_table_t *legacy_table_entry;
+        const cpu_legacy_table_t *legacy_table_entry;
         for (legacy_mfg = 0; legacy_mfg < 4; legacy_mfg++) {
             if (!cpu_legacy_table[c].tables[legacy_mfg])
                 continue;
 
             i = 0;
             while (cpu_legacy_table[c].tables[legacy_mfg][i].family) {
-                legacy_table_entry = (cpu_legacy_table_t *) &cpu_legacy_table[c].tables[legacy_mfg][i];
+                legacy_table_entry = &cpu_legacy_table[c].tables[legacy_mfg][i];
 
                 /* Match the family name, speed and multiplier. */
                 if (!strcmp(cpu_f->internal_name, legacy_table_entry->family)) {
@@ -2294,7 +2294,7 @@ save_machine(void)
     if (fpu_type == 0)
         ini_section_delete_var(cat, "fpu_type");
     else
-        ini_section_set_string(cat, "fpu_type", (char *) fpu_get_internal_name(cpu_f, cpu, fpu_type));
+        ini_section_set_string(cat, "fpu_type", fpu_get_internal_name(cpu_f, cpu, fpu_type));
 
     // Write the mem_size explicitly to the setttings in order to help managers to display it without having the actual machine table
     ini_section_delete_var(cat, "mem_size");
@@ -2613,7 +2613,7 @@ save_ports(void)
             ini_section_delete_var(cat, temp);
         else
             ini_section_set_string(cat, temp,
-                                   (char *) lpt_device_get_internal_name(lpt_ports[c].device));
+                                   lpt_device_get_internal_name(lpt_ports[c].device));
     }
 
     ini_delete_section_if_empty(config, cat);
@@ -2738,7 +2738,7 @@ save_other_peripherals(void)
             ini_section_delete_var(cat, temp);
         else
             ini_section_set_string(cat, temp,
-                                   (char *) isamem_get_internal_name(isamem_type[c]));
+                                   isamem_get_internal_name(isamem_type[c]));
     }
 
     if (isartc_type == 0)
@@ -2836,7 +2836,7 @@ save_hard_disks(void)
         if (!hdd_is_valid(c) || (hdd[c].bus != HDD_BUS_IDE && hdd[c].bus != HDD_BUS_ESDI))
             ini_section_delete_var(cat, temp);
         else
-            ini_section_set_string(cat, temp, (char *) hdd_preset_get_internal_name(hdd[c].speed_preset));
+            ini_section_set_string(cat, temp, hdd_preset_get_internal_name(hdd[c].speed_preset));
     }
 
     ini_delete_section_if_empty(config, cat);

src/cpu/cpu.h

@@ -133,13 +133,13 @@ enum {
 #    define LOOKUP_INV -1
 #endif
 
-typedef struct {
+typedef struct fpu_t {
     const char *name;
     const char *internal_name;
     const int   type;
 } FPU;
 
-typedef struct {
+typedef struct cpu_t {
     const char *name;
     uint64_t    cpu_type;
     const FPU  *fpus;

src/ddma.c

@@ -57,10 +57,10 @@ ddma_log(const char *fmt, ...)
 static uint8_t
 ddma_reg_read(uint16_t addr, void *priv)
 {
-    ddma_channel_t *dev  = (ddma_channel_t *) priv;
-    uint8_t         ret  = 0xff;
-    int             ch   = dev->channel;
-    int             dmab = (ch >= 4) ? 0xc0 : 0x00;
+    const ddma_channel_t *dev  = (ddma_channel_t *) priv;
+    uint8_t               ret  = 0xff;
+    int                   ch   = dev->channel;
+    uint8_t               dmab = (ch >= 4) ? 0xc0 : 0x00;
 
     switch (addr & 0x0f) {
         case 0x00:
@@ -92,10 +92,10 @@ ddma_reg_read(uint16_t addr, void *priv)
 static void
 ddma_reg_write(uint16_t addr, uint8_t val, void *priv)
 {
-    ddma_channel_t *dev          = (ddma_channel_t *) priv;
-    int             ch           = dev->channel;
-    int             page_regs[4] = { 7, 3, 1, 2 };
-    int             dmab = (ch >= 4) ? 0xc0 : 0x00;
+    const ddma_channel_t *dev          = (ddma_channel_t *) priv;
+    int                   ch           = dev->channel;
+    uint8_t               page_regs[4] = { 7, 3, 1, 2 };
+    uint8_t               dmab = (ch >= 4) ? 0xc0 : 0x00;
 
     switch (addr & 0x0f) {
         case 0x00:

src/device.c

@@ -90,8 +90,8 @@ device_init(void)
 void
 device_set_context(device_context_t *c, const device_t *dev, int inst)
 {
-    void *sec;
-    void *single_sec;
+    const void *sec;
+    void       *single_sec;
 
     memset(c, 0, sizeof(device_context_t));
     c->dev      = dev;
@@ -143,7 +143,7 @@ device_add_common(const device_t *dev, const device_t *cd, void *p, void *params
     int   c;
 
     for (c = 0; c < 256; c++) {
-        if (!inst && (devices[c] == (device_t *) dev)) {
+        if (!inst && (devices[c] == dev)) {
             device_log("DEVICE: device already exists!\n");
             return (NULL);
         }
@@ -343,23 +343,23 @@ device_get_priv(const device_t *dev)
 int
 device_available(const device_t *dev)
 {
-    device_config_t      *config = NULL;
-    device_config_bios_t *bios   = NULL;
-    int                   roms_present = 0;
-    int                   i = 0;
+    const device_config_t      *config = NULL;
+    const device_config_bios_t *bios   = NULL;
+    int                         roms_present = 0;
+    int                         i = 0;
 
     if (dev != NULL) {
-        config = (device_config_t *) dev->config;
+        config = dev->config;
         if (config != NULL) {
             while (config->type != -1) {
                 if (config->type == CONFIG_BIOS) {
-                    bios = (device_config_bios_t *) config->bios;
+                    bios = (const device_config_bios_t *) config->bios;
 
                     /* Go through the ROM's in the device configuration. */
                     while (bios->files_no != 0) {
                         i = 0;
                         for (int bf = 0; bf < bios->files_no; bf++)
-                            i += !!rom_present((char *) bios->files[bf]);
+                            i += !!rom_present(bios->files[bf]);
                         if (i == bios->files_no)
                             roms_present++;
                         bios++;
@@ -385,15 +385,15 @@ device_available(const device_t *dev)
 const char *
 device_get_bios_file(const device_t *dev, const char *internal_name, int file_no)
 {
-    device_config_t      *config = NULL;
-    device_config_bios_t *bios   = NULL;
+    const device_config_t      *config = NULL;
+    const device_config_bios_t *bios   = NULL;
 
     if (dev != NULL) {
-        config = (device_config_t *) dev->config;
+        config = dev->config;
         if (config != NULL) {
             while (config->type != -1) {
                 if (config->type == CONFIG_BIOS) {
-                    bios = (device_config_bios_t *) config->bios;
+                    bios = config->bios;
 
                     /* Go through the ROM's in the device configuration. */
                     while (bios->files_no != 0) {
@@ -418,8 +418,8 @@ device_get_bios_file(const device_t *dev, const char *internal_name, int file_no
 int
 device_has_config(const device_t *dev)
 {
-    int              c = 0;
-    device_config_t *config;
+    int                    c = 0;
+    const device_config_t *config;
 
     if (dev == NULL)
         return 0;
@@ -427,7 +427,7 @@ device_has_config(const device_t *dev)
     if (dev->config == NULL)
         return 0;
 
-    config = (device_config_t *) dev->config;
+    config = dev->config;
 
     while (config->type != -1) {
         if (config->type != CONFIG_MAC)
@@ -472,10 +472,10 @@ device_register_pci_slot(const device_t *dev, int device, int type, int inta, in
 void
 device_get_name(const device_t *dev, int bus, char *name)
 {
-    char *sbus = NULL;
-    char *fbus;
-    char *tname;
-    char  pbus[8] = { 0 };
+    const char *sbus = NULL;
+    const char *fbus;
+    char       *tname;
+    char        pbus[8] = { 0 };
 
     if (dev == NULL)
         return;

src/device/cartridge.c

@@ -61,7 +61,7 @@ cartridge_log(const char *fmt, ...)
 static uint8_t
 cart_read(uint32_t addr, void *priv)
 {
-    cart_t *dev = (cart_t *) priv;
+    const cart_t *dev = (cart_t *) priv;
 
     return dev->buf[addr - dev->base];
 }

src/device/hwm_lm78.c

@@ -421,8 +421,8 @@ lm78_i2c_read(UNUSED(void *bus), UNUSED(uint8_t addr), void *priv)
 uint8_t
 lm78_as99127f_read(void *priv, uint8_t reg)
 {
-    lm78_t *dev = (lm78_t *) priv;
-    uint8_t ret = dev->as99127f.regs[1][reg & 0x7f];
+    const lm78_t *dev = (lm78_t *) priv;
+    uint8_t       ret = dev->as99127f.regs[1][reg & 0x7f];
 
     lm78_log("LM78: read(%02X, AS99127F) = %02X\n", reg, ret);
 

src/device/hwm_vt82c686.c

@@ -48,8 +48,8 @@ static void vt82c686_reset(vt82c686_t *dev, uint8_t initialization);
 static uint8_t
 vt82c686_read(uint16_t addr, void *priv)
 {
-    vt82c686_t *dev = (vt82c686_t *) priv;
-    uint8_t     ret;
+    const vt82c686_t *dev = (vt82c686_t *) priv;
+    uint8_t           ret;
 
     addr -= dev->io_base;
 

src/device/i2c.c

@@ -205,9 +205,9 @@ i2c_handler(int set, void *bus_handle, uint8_t base, int size,
 uint8_t
 i2c_start(void *bus_handle, uint8_t addr, uint8_t read)
 {
-    uint8_t    ret = 0;
-    i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
-    i2c_t     *p;
+    uint8_t          ret = 0;
+    const i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
+    i2c_t           *p;
 
     if (!bus)
         return ret;
@@ -230,9 +230,9 @@ i2c_start(void *bus_handle, uint8_t addr, uint8_t read)
 uint8_t
 i2c_read(void *bus_handle, uint8_t addr)
 {
-    uint8_t    ret = 0;
-    i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
-    i2c_t     *p;
+    uint8_t          ret = 0;
+    const i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
+    i2c_t           *p;
 
     if (!bus)
         return ret;
@@ -256,9 +256,9 @@ i2c_read(void *bus_handle, uint8_t addr)
 uint8_t
 i2c_write(void *bus_handle, uint8_t addr, uint8_t data)
 {
-    uint8_t    ret = 0;
-    i2c_t     *p;
-    i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
+    uint8_t          ret = 0;
+    i2c_t           *p;
+    const i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
 
     if (!bus)
         return ret;
@@ -281,8 +281,8 @@ i2c_write(void *bus_handle, uint8_t addr, uint8_t data)
 void
 i2c_stop(void *bus_handle, uint8_t addr)
 {
-    i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
-    i2c_t     *p;
+    const i2c_bus_t *bus = (i2c_bus_t *) bus_handle;
+    i2c_t           *p;
 
     if (!bus)
         return;

src/device/i2c_gpio.c

@@ -171,14 +171,16 @@ i2c_gpio_set(void *dev_handle, uint8_t scl, uint8_t sda)
 uint8_t
 i2c_gpio_get_scl(void *dev_handle)
 {
-    i2c_gpio_t *dev = (i2c_gpio_t *) dev_handle;
+    const i2c_gpio_t *dev = (i2c_gpio_t *) dev_handle;
+
     return dev->prev_scl;
 }
 
 uint8_t
 i2c_gpio_get_sda(void *dev_handle)
 {
-    i2c_gpio_t *dev = (i2c_gpio_t *) dev_handle;
+    const i2c_gpio_t *dev = (i2c_gpio_t *) dev_handle;
+
     i2c_gpio_log(3, "I2C GPIO %s: read myscl=%d mysda=%d slavesda=%d\n", dev->bus_name, dev->prev_scl, dev->prev_sda, dev->slave_sda);
     return dev->prev_sda && dev->slave_sda;
 }

src/device/ibm_5161.c

@@ -45,8 +45,8 @@ ibm_5161_out(uint16_t port, uint8_t val, void *priv)
 static uint8_t
 ibm_5161_in(uint16_t port, void *priv)
 {
-    ibm_5161_t *dev = (ibm_5161_t *) priv;
-    uint8_t     ret = 0xff;
+    const ibm_5161_t *dev = (ibm_5161_t *) priv;
+    uint8_t           ret = 0xff;
 
     ret = dev->regs[port & 0x0007];
 

src/device/isamem.c

@@ -288,9 +288,9 @@ ems_writew(uint32_t addr, uint16_t val, void *priv)
 static uint8_t
 ems_read(uint16_t port, void *priv)
 {
-    memdev_t *dev = (memdev_t *) priv;
-    uint8_t   ret = 0xff;
-    int       vpage;
+    const memdev_t *dev = (memdev_t *) priv;
+    uint8_t         ret = 0xff;
+    int             vpage;
 
     /* Get the viewport page number. */
     vpage = (port / EMS_PGSIZE);

src/device/isapnp.c

@@ -259,7 +259,8 @@ isapnp_reset_ld_regs(isapnp_device_t *ld)
 static uint8_t
 isapnp_read_rangecheck(UNUSED(uint16_t addr), void *priv)
 {
-    isapnp_device_t *dev = (isapnp_device_t *) priv;
+    const isapnp_device_t *dev = (isapnp_device_t *) priv;
+
     return (dev->regs[0x31] & 0x01) ? 0x55 : 0xaa;
 }
 

src/device/isartc.c

@@ -191,11 +191,11 @@ mm67_chkalrm(nvr_t *nvr, int8_t addr)
 static void
 mm67_tick(nvr_t *nvr)
 {
-    rtcdev_t *dev  = (rtcdev_t *) nvr->data;
-    uint8_t  *regs = nvr->regs;
-    int       mon;
-    int       year;
-    int       f = 0;
+    const rtcdev_t *dev  = (rtcdev_t *) nvr->data;
+    uint8_t        *regs = nvr->regs;
+    int             mon;
+    int             year;
+    int             f = 0;
 
     /* Update and set interrupt if needed. */
     regs[MM67_SEC] = RTC_BCDINC(nvr->regs[MM67_SEC], 1);
@@ -295,8 +295,8 @@ mm67_tick(nvr_t *nvr)
 static void
 mm67_time_get(nvr_t *nvr, struct tm *tm)
 {
-    rtcdev_t *dev  = (rtcdev_t *) nvr->data;
-    uint8_t  *regs = nvr->regs;
+    const rtcdev_t *dev  = (rtcdev_t *) nvr->data;
+    const uint8_t  *regs = nvr->regs;
 
     /* NVR is in BCD data mode. */
     tm->tm_sec  = RTC_DCB(regs[MM67_SEC]);
@@ -325,9 +325,9 @@ mm67_time_get(nvr_t *nvr, struct tm *tm)
 static void
 mm67_time_set(nvr_t *nvr, struct tm *tm)
 {
-    rtcdev_t *dev  = (rtcdev_t *) nvr->data;
-    uint8_t  *regs = nvr->regs;
-    int       year;
+    const rtcdev_t *dev  = (rtcdev_t *) nvr->data;
+    uint8_t        *regs = nvr->regs;
+    int             year;
 
     /* NVR is in BCD data mode. */
     regs[MM67_SEC]  = RTC_BCD(tm->tm_sec);
@@ -608,9 +608,6 @@ isartc_close(void *priv)
     io_removehandler(dev->base_addr, dev->base_addrsz,
                      dev->f_rd, NULL, NULL, dev->f_wr, NULL, NULL, dev);
 
-    if (dev->nvr.fn != NULL)
-        free(dev->nvr.fn);
-
     free(dev);
 }
 

src/device/kbc_at.c

@@ -463,7 +463,9 @@ kbc_at_poll_at(atkbc_t *dev)
         case STATE_KBC_AMI_OUT:
             if (dev->status & STAT_OFULL)
                 break;
-            /* FALLTHROUGH */
+#ifndef __APPLE__
+            [[fallthrough]];
+#endif
         case STATE_MAIN_IBF:
         default:
 at_main_ibf:
@@ -586,7 +588,9 @@ kbc_at_poll_ps2(atkbc_t *dev)
         case STATE_KBC_AMI_OUT:
             if (dev->status & STAT_OFULL)
                 break;
-            /* FALLTHROUGH */
+#ifndef __APPLE__
+            [[fallthrough]];
+#endif
         case STATE_MAIN_IBF:
         default:
 ps2_main_ibf:
@@ -1027,6 +1031,9 @@ write64_generic(void *priv, uint8_t val)
             kbc_at_log("ATkbc: pulse %01X\n", val & 0x0f);
             pulse_output(dev, val & 0x0f);
             return 0;
+
+        default:
+            break;
     }
 
     kbc_at_log("ATkbc: bad command %02X\n", val);
@@ -1328,12 +1335,13 @@ write64_siemens(void *priv, uint8_t val)
 static uint8_t
 write60_quadtel(void *priv, UNUSED(uint8_t val))
 {
-    atkbc_t *dev = (atkbc_t *) priv;
+    const atkbc_t *dev = (atkbc_t *) priv;
 
     switch (dev->command) {
         case 0xcf: /*??? - sent by MegaPC BIOS*/
             kbc_at_log("ATkbc: ??? - sent by MegaPC BIOS\n");
             return 0;
+
         default:
             break;
     }
@@ -1392,7 +1400,7 @@ write64_quadtel(void *priv, uint8_t val)
 static uint8_t
 write60_toshiba(void *priv, uint8_t val)
 {
-    atkbc_t *dev = (atkbc_t *) priv;
+    const atkbc_t *dev = (atkbc_t *) priv;
 
     switch (dev->command) {
         case 0xb6: /* T3100e - set color/mono switch */

src/device/kbc_at_dev.c

@@ -135,7 +135,9 @@ kbc_at_dev_poll(void *priv)
                 dev->port->wantcmd    = 0;
                 break;
             }
-            /* FALLTHROUGH */
+#ifndef __APPLE__
+            [[fallthrough]];
+#endif
         case DEV_STATE_MAIN_WANT_IN:
             /* Output command response and then return to main loop #2. */
             if ((dev->port->out_new == -1) && (dev->cmd_queue_start != dev->cmd_queue_end)) {

src/device/keyboard.c

@@ -87,8 +87,8 @@ fake_shift_needed(uint16_t scan)
 void
 key_process(uint16_t scan, int down)
 {
-    scancode *codes = scan_table;
-    int       c;
+    const scancode *codes = scan_table;
+    int             c;
 
     if (!codes)
         return;
@@ -222,7 +222,7 @@ keyboard_input(int down, uint16_t scan)
 static uint8_t
 keyboard_do_break(uint16_t scan)
 {
-    scancode *codes = scan_table;
+    const scancode *codes = scan_table;
 
     /* TODO: The keyboard controller needs to report the AT flag to us here. */
     if (is286 && ((keyboard_mode & 3) == 3)) {
@@ -266,7 +266,7 @@ keyboard_get_states(uint8_t *cl, uint8_t *nl, uint8_t *sl)
 void
 keyboard_set_states(uint8_t cl, uint8_t nl, uint8_t sl)
 {
-    scancode *codes = scan_table;
+    const scancode *codes = scan_table;
 
     int i;
 
@@ -320,7 +320,7 @@ keyboard_isfsenter(void)
 }
 
 int
-keyboard_isfsenter_down(void)
+keyboard_isfsenter_up(void)
 {
     return (!recv_key[0x01d] && !recv_key[0x11d] && !recv_key[0x038] && !recv_key[0x138] && !recv_key[0x049] && !recv_key[0x149]);
 }
@@ -333,7 +333,7 @@ keyboard_isfsexit(void)
 }
 
 int
-keyboard_isfsexit_down(void)
+keyboard_isfsexit_up(void)
 {
     return (!recv_key[0x01d] && !recv_key[0x11d] && !recv_key[0x038] && !recv_key[0x138] && !recv_key[0x051] && !recv_key[0x151]);
 }

src/device/keyboard_xt.c

@@ -594,8 +594,8 @@ kbd_write(uint16_t port, uint8_t val, void *priv)
 static uint8_t
 kbd_read(uint16_t port, void *priv)
 {
-    xtkbd_t *kbd = (xtkbd_t *) priv;
-    uint8_t  ret = 0xff;
+    const xtkbd_t *kbd = (xtkbd_t *) priv;
+    uint8_t        ret = 0xff;
 
     switch (port) {
         case 0x60: /* Keyboard Data Register  (aka Port A) */

src/device/mouse_bus.c

@@ -226,7 +226,6 @@ lt_read(uint16_t port, void *priv)
                 return (dev->control_val | 0x0F) & ~IRQ_MASK;
             else
                 return 0xff;
-            break;
 
         default:
             break;

src/device/mouse_serial.c

@@ -507,7 +507,9 @@ sermouse_command_timer(void *priv)
             break;
         case PHASE_ACK:
             serial_write_fifo(dev->serial, 0x06);
-            /* FALLTHROUGH */
+#ifndef __APPLE__
+            [[fallthrough]];
+#endif
         case PHASE_BAUD_RATE:
             sermouse_command_phase_idle(dev);
             sermouse_timer_on(dev, dev->report_period, 1);
@@ -645,7 +647,9 @@ ltsermouse_write(UNUSED(struct serial_s *serial), void *priv, uint8_t data)
                 switch (data) {
                     default:
                         mouse_serial_log("Serial mouse: Invalid period %02X, using 1200 bps\n", data);
-                        /*FALLTHROUGH*/
+#ifndef __APPLE__
+                        [[fallthrough]];
+#endif
                     case 0x6E:
                         dev->transmit_period = sermouse_transmit_period(dev, 1200, -1);
                         break;

src/device/pci_bridge.c

@@ -363,8 +363,8 @@ pci_bridge_write(int func, int addr, uint8_t val, void *priv)
 static uint8_t
 pci_bridge_read(int func, int addr, void *priv)
 {
-    pci_bridge_t *dev = (pci_bridge_t *) priv;
-    uint8_t       ret;
+    const pci_bridge_t *dev = (pci_bridge_t *) priv;
+    uint8_t             ret;
 
     if (func > 0)
         ret = 0xff;

src/device/phoenix_486_jumper.c

@@ -78,7 +78,8 @@ phoenix_486_jumper_write(UNUSED(uint16_t addr), uint8_t val, void *priv)
 static uint8_t
 phoenix_486_jumper_read(UNUSED(uint16_t addr), void *priv)
 {
-    phoenix_486_jumper_t *dev = (phoenix_486_jumper_t *) priv;
+    const phoenix_486_jumper_t *dev = (phoenix_486_jumper_t *) priv;
+
     phoenix_486_jumper_log("Phoenix 486 Jumper: Read %02x\n", dev->jumper);
     return dev->jumper;
 }

src/device/smbus_ali7101.c

@@ -193,7 +193,9 @@ smbus_ali7101_write(uint16_t addr, uint8_t val, void *priv)
                 case 0x4:          /* block R/W */
                     timer_bytes++; /* count the SMBus length byte now */
 
-                    /* fall-through */
+#ifndef __APPLE__
+                    [[fallthrough]];
+#endif
 
                 default:                   /* unknown */
                     dev->next_stat = 0x20; /* raise DEV_ERR */

src/device/smbus_piix4.c

@@ -195,7 +195,9 @@ smbus_piix4_write(uint16_t addr, uint8_t val, void *priv)
                             timer_bytes++;
                         }
 
-                        /* fall-through */
+#ifndef __APPLE__
+                        [[fallthrough]];
+#endif
 
                     case 0xc:        /* I2C process call */
                         if (!read) { /* word write (only when writing) */
@@ -214,7 +216,9 @@ smbus_piix4_write(uint16_t addr, uint8_t val, void *priv)
                     case 0x5:          /* block R/W */
                         timer_bytes++; /* count the SMBus length byte now */
 
-                        /* fall-through */
+#ifndef __APPLE__
+                        [[fallthrough]];
+#endif
 
                     case 0xd: /* I2C block R/W */
                         i2c_write(i2c_smbus, smbus_addr, dev->cmd);
@@ -247,7 +251,9 @@ smbus_piix4_write(uint16_t addr, uint8_t val, void *priv)
                         i2c_write(i2c_smbus, smbus_addr, dev->cmd);
                         timer_bytes++;
 
-                        /* fall-through */
+#ifndef __APPLE__
+                        [[fallthrough]];
+#endif
 
                     case 0xe:        /* I2C with 7-bit address */
                         if (!read) { /* word write (only when writing) */

src/disk/hdc_esdi_at.c

@@ -173,13 +173,13 @@ esdi_get_xfer_time(UNUSED(esdi_t *esdi), int size)
 static int
 get_sector(esdi_t *esdi, off64_t *addr)
 {
-    drive_t *drive   = &esdi->drives[esdi->drive_sel];
-    int      heads   = drive->cfg_hpc;
-    int      sectors = drive->cfg_spt;
-    int      c;
-    int      h;
-    int      s;
-    int      sector;
+    const drive_t *drive   = &esdi->drives[esdi->drive_sel];
+    int            heads   = drive->cfg_hpc;
+    int            sectors = drive->cfg_spt;
+    int            c;
+    int            h;
+    int            s;
+    int            sector;
 
     if (esdi->head > heads) {
         esdi_at_log("esdi_get_sector: past end of configured heads\n");
@@ -338,7 +338,9 @@ esdi_write(uint16_t port, uint8_t val, void *priv)
                             esdi->command &= ~0x03;
                             if (val & 0x02)
                                 fatal("Read with ECC\n");
-                            /*FALLTHROUGH*/
+#ifndef __APPLE__
+                            [[fallthrough]];
+#endif
 
                         case 0xa0:
                             esdi->status = STAT_BUSY;
@@ -397,7 +399,9 @@ esdi_write(uint16_t port, uint8_t val, void *priv)
 
                         default:
                             esdi_at_log("WD1007: bad command %02X\n", val);
-                            /*FALLTHROUGH*/
+#ifndef __APPLE__
+                            [[fallthrough]];
+#endif
                         case 0xe8: /*???*/
                             esdi->status = STAT_BUSY;
                             esdi_set_callback(esdi, 200 * HDC_TIME);
@@ -878,8 +882,8 @@ wd1007vse1_init(UNUSED(const device_t *info))
 static void
 wd1007vse1_close(void *priv)
 {
-    esdi_t  *esdi = (esdi_t *) priv;
-    drive_t *drive;
+    esdi_t        *esdi = (esdi_t *) priv;
+    const drive_t *drive;
 
     for (uint8_t d = 0; d < 2; d++) {
         drive = &esdi->drives[d];

src/disk/hdc_esdi_mca.c

@@ -352,10 +352,10 @@ complete_command_status(esdi_t *dev)
 static void
 esdi_callback(void *priv)
 {
-    esdi_t  *dev = (esdi_t *) priv;
-    drive_t *drive;
-    int      val;
-    double   cmd_time = 0.0;
+    esdi_t        *dev = (esdi_t *) priv;
+    const drive_t *drive;
+    int            val;
+    double         cmd_time = 0.0;
 
     esdi_mca_set_callback(dev, 0);
 
@@ -1059,7 +1059,7 @@ esdi_writew(uint16_t port, uint16_t val, void *priv)
 static uint8_t
 esdi_mca_read(int port, void *priv)
 {
-    esdi_t *dev = (esdi_t *) priv;
+    const esdi_t *dev = (esdi_t *) priv;
 
     esdi_mca_log("ESDI: mcard(%04x)\n", port);
 
@@ -1132,7 +1132,7 @@ esdi_mca_write(int port, uint8_t val, void *priv)
 static uint8_t
 esdi_mca_feedb(void *priv)
 {
-    esdi_t *dev = (esdi_t *) priv;
+    const esdi_t *dev = (esdi_t *) priv;
 
     return (dev->pos_regs[2] & 1);
 }
@@ -1210,8 +1210,8 @@ esdi_init(UNUSED(const device_t *info))
 static void
 esdi_close(void *priv)
 {
-    esdi_t  *dev = (esdi_t *) priv;
-    drive_t *drive;
+    esdi_t        *dev = (esdi_t *) priv;
+    const drive_t *drive;
 
     dev->drives[0].present = dev->drives[1].present = 0;
 

src/disk/hdc_ide.c

@@ -597,13 +597,13 @@ ide_hd_identify(ide_t *ide)
 static void
 ide_identify(ide_t *ide)
 {
-    int    d;
-    int    i;
-    int    max_pio;
-    int    max_sdma;
-    int    max_mdma;
-    int    max_udma;
-    ide_t *ide_other = ide_drives[ide->channel ^ 1];
+    int          d;
+    int          i;
+    int          max_pio;
+    int          max_sdma;
+    int          max_mdma;
+    int          max_udma;
+    const ide_t *ide_other = ide_drives[ide->channel ^ 1];
 
     ide_log("IDE IDENTIFY or IDENTIFY PACKET DEVICE on board %i (channel %i)\n", ide->board, ide->channel);
 
@@ -1114,8 +1114,8 @@ ide_atapi_packet_read(ide_t *ide, int length)
 {
     scsi_common_t *dev = ide->sc;
 
-    uint16_t *bufferw;
-    uint32_t *bufferl;
+    const uint16_t *bufferw;
+    const uint32_t *bufferl;
 
     uint32_t temp = 0;
 
@@ -1311,7 +1311,7 @@ ide_writew(uint16_t addr, uint16_t val, void *priv)
 static void
 ide_writel(uint16_t addr, uint32_t val, void *priv)
 {
-    ide_board_t *dev = (ide_board_t *) priv;
+    const ide_board_t *dev = (ide_board_t *) priv;
 
     ide_t *ide;
     int    ch;
@@ -1655,7 +1655,9 @@ ide_writeb(uint16_t addr, uint8_t val, void *priv)
                        disabled, the Read Multiple operation is rejected with an Aborted Com-
                        mand error. */
                     ide->blockcount = 0;
-                    /*FALLTHROUGH*/
+#ifndef __APPLE__
+                    [[fallthrough]];
+#endif
 
                 case WIN_READ:
                 case WIN_READ_NORETRY:
@@ -1704,7 +1706,9 @@ ide_writeb(uint16_t addr, uint8_t val, void *priv)
                     /* Turn on the activity indicator *here* so that it gets turned on
                        less times. */
                     ui_sb_update_icon(SB_HDD | hdd[ide->hdd_num].bus, 1);
-                    /*FALLTHROUGH*/
+#ifndef __APPLE__
+                    [[fallthrough]];
+#endif
 
                 case WIN_WRITE:
                 case WIN_WRITE_NORETRY:
@@ -1843,6 +1847,9 @@ ide_bad_command:
                     return;
             }
             return;
+
+        default:
+            break;
     }
 }
 
@@ -1864,9 +1871,9 @@ ide_read_data(ide_t *ide, int length)
         }
     }
 
-    uint8_t  *idebufferb = (uint8_t *) ide->buffer;
-    uint16_t *idebufferw = ide->buffer;
-    uint32_t *idebufferl = (uint32_t *) ide->buffer;
+    const uint8_t  *idebufferb = (uint8_t *) ide->buffer;
+    const uint16_t *idebufferw = ide->buffer;
+    const uint32_t *idebufferl = (uint32_t *) ide->buffer;
 
     if (ide->command == WIN_PACKETCMD) {
         ide->pos = 0;
@@ -1946,7 +1953,7 @@ ide_status(ide_t *ide, ide_t *ide_other, int ch)
 uint8_t
 ide_readb(uint16_t addr, void *priv)
 {
-    ide_board_t *dev = (ide_board_t *) priv;
+    const ide_board_t *dev = (ide_board_t *) priv;
 
     int    ch;
     int    absent = 0;
@@ -2062,6 +2069,9 @@ ide_readb(uint16_t addr, void *priv)
             ide_irq_lower(ide);
             temp = ide_status(ide, ide_drives[ch ^ 1], ch);
             break;
+
+        default:
+            break;
     }
 
     ide_log("ide_readb(%04X, %08X) = %02X\n", addr, priv, temp);
@@ -2073,7 +2083,7 @@ ide_read_alt_status(UNUSED(uint16_t addr), void *priv)
 {
     uint8_t temp = 0xff;
 
-    ide_board_t *dev = (ide_board_t *) priv;
+    const ide_board_t *dev = (ide_board_t *) priv;
 
     ide_t *ide;
     int    ch;
@@ -2094,7 +2104,7 @@ ide_readw(uint16_t addr, void *priv)
 {
     uint16_t temp = 0xffff;
 
-    ide_board_t *dev = (ide_board_t *) priv;
+    const ide_board_t *dev = (ide_board_t *) priv;
 
     ide_t *ide;
     int    ch;
@@ -2124,7 +2134,7 @@ ide_readl(uint16_t addr, void *priv)
     uint16_t temp2;
     uint32_t temp = 0xffffffff;
 
-    ide_board_t *dev = (ide_board_t *) priv;
+    const ide_board_t *dev = (ide_board_t *) priv;
 
     ide_t *ide;
     int    ch;
@@ -2620,11 +2630,11 @@ id_not_found:
 uint8_t
 ide_read_ali_75(void)
 {
-    ide_t  *ide0;
-    ide_t *ide1;
-    int     ch0;
-    int     ch1;
-    uint8_t ret = 0x00;
+    const ide_t *ide0;
+    const ide_t *ide1;
+    int          ch0;
+    int          ch1;
+    uint8_t      ret = 0x00;
 
     ch0  = ide_boards[0]->cur_dev;
     ch1  = ide_boards[1]->cur_dev;
@@ -2646,11 +2656,11 @@ ide_read_ali_75(void)
 uint8_t
 ide_read_ali_76(void)
 {
-    ide_t  *ide0;
-    ide_t  *ide1;
-    int     ch0;
-    int     ch1;
-    uint8_t ret = 0x00;
+    const ide_t  *ide0;
+    const ide_t  *ide1;
+    int           ch0;
+    int           ch1;
+    uint8_t       ret = 0x00;
 
     ch0  = ide_boards[0]->cur_dev;
     ch1  = ide_boards[1]->cur_dev;

src/disk/hdc_ide_cmd646.c

@@ -90,7 +90,7 @@ cmd646_set_irq(int channel, void *priv)
 static int
 cmd646_bus_master_dma(int channel, uint8_t *data, int transfer_length, int out, void *priv)
 {
-    cmd646_t *dev = (cmd646_t *) priv;
+    const cmd646_t *dev = (cmd646_t *) priv;
 
     return sff_bus_master_dma(channel, data, transfer_length, out, dev->bm[channel & 0x01]);
 }

src/disk/hdc_ide_opti611.c

@@ -93,8 +93,8 @@ opti611_cfg_writel(uint16_t addr, uint32_t val, void *priv)
 static uint8_t
 opti611_cfg_read(uint16_t addr, void *priv)
 {
-    uint8_t    ret = 0xff;
-    opti611_t *dev = (opti611_t *) priv;
+    uint8_t          ret = 0xff;
+    const opti611_t *dev = (opti611_t *) priv;
 
     addr &= 0x0007;
 

src/disk/hdc_ide_sff8038i.c

@@ -222,7 +222,7 @@ sff_bus_master_writel(uint16_t port, uint32_t val, void *priv)
 uint8_t
 sff_bus_master_read(uint16_t port, void *priv)
 {
-    sff8038i_t *dev = (sff8038i_t *) priv;
+    const sff8038i_t *dev = (sff8038i_t *) priv;
 
     uint8_t ret = 0xff;
 
@@ -261,7 +261,7 @@ sff_bus_master_read(uint16_t port, void *priv)
 static uint16_t
 sff_bus_master_readw(uint16_t port, void *priv)
 {
-    sff8038i_t *dev = (sff8038i_t *) priv;
+    const sff8038i_t *dev = (sff8038i_t *) priv;
 
     uint16_t ret = 0xffff;
 
@@ -290,7 +290,7 @@ sff_bus_master_readw(uint16_t port, void *priv)
 static uint32_t
 sff_bus_master_readl(uint16_t port, void *priv)
 {
-    sff8038i_t *dev = (sff8038i_t *) priv;
+    const sff8038i_t *dev = (sff8038i_t *) priv;
 
     uint32_t ret = 0xffffffff;
 

src/disk/hdc_st506_at.c

@@ -171,7 +171,7 @@ irq_update(mfm_t *mfm)
 static int
 get_sector(mfm_t *mfm, off64_t *addr)
 {
-    drive_t *drive = &mfm->drives[mfm->drvsel];
+    const drive_t *drive = &mfm->drives[mfm->drvsel];
 
     /* FIXME: See if this is even needed - if the code is present, IBM AT
               diagnostics v2.07 will error with: ERROR 152 - SYSTEM BOARD. */
@@ -734,7 +734,7 @@ mfm_close(void *priv)
     mfm_t *mfm = (mfm_t *) priv;
 
     for (uint8_t d = 0; d < 2; d++) {
-        drive_t *drive = &mfm->drives[d];
+        const drive_t *drive = &mfm->drives[d];
 
         hdd_image_close(drive->hdd_num);
     }

src/disk/hdc_st506_xt.c

@@ -623,6 +623,10 @@ st506_callback(void *priv)
                 st506_complete(dev);
                 break;
             }
+#ifndef __APPLE__
+            [[fallthrough]];
+#endif
+
         case CMD_FORMAT_TRACK:
         case CMD_FORMAT_BAD_TRACK:
             switch (dev->state) {
@@ -1377,10 +1381,10 @@ mem_write(uint32_t addr, uint8_t val, void *priv)
 static uint8_t
 mem_read(uint32_t addr, void *priv)
 {
-    hdc_t   *dev = (hdc_t *) priv;
-    uint32_t ptr;
-    uint32_t mask = 0;
-    uint8_t  ret = 0xff;
+    const hdc_t *dev = (hdc_t *) priv;
+    uint32_t     ptr;
+    uint32_t     mask = 0;
+    uint8_t      ret = 0xff;
 
     /* Ignore accesses to anything below the configured address,
        needed because of the emulator's 4k mapping granularity. */
@@ -1529,8 +1533,8 @@ loadhd(hdc_t *dev, int c, int d, UNUSED(const char *fn))
 static void
 set_switches(hdc_t *dev, hd_type_t *hdt, int num)
 {
-    drive_t *drive;
-    int      e;
+    const drive_t *drive;
+    int            e;
 
     dev->switches = 0x00;
 
@@ -1604,7 +1608,9 @@ st506_init(const device_t *info)
 
         case ST506_XT_TYPE_ST11R: /* Seagate ST-11R (RLL) */
             dev->spt = RLL_SECTORS;
-            /*FALLTHROUGH*/
+#ifndef __APPLE__
+            [[fallthrough]];
+#endif
 
         case ST506_XT_TYPE_ST11M: /* Seagate ST-11M (MFM) */
             dev->nr_err   = ERR_NOT_AVAILABLE;
@@ -1778,8 +1784,8 @@ st506_init(const device_t *info)
 static void
 st506_close(void *priv)
 {
-    hdc_t   *dev = (hdc_t *) priv;
-    drive_t *drive;
+    hdc_t         *dev = (hdc_t *) priv;
+    const drive_t *drive;
 
     for (uint8_t d = 0; d < MFM_NUM; d++) {
         drive = &dev->drives[d];

src/disk/hdc_xta.c

@@ -509,7 +509,9 @@ hdc_callback(void *priv)
 
         case CMD_READ_VERIFY:
             no_data = 1;
-            /*FALLTHROUGH*/
+#ifndef __APPLE__
+            [[fallthrough]];
+#endif
 
         case CMD_READ_SECTORS:
             if (!drive->present) {
@@ -534,7 +536,9 @@ hdc_callback(void *priv)
                     dev->buf_len = 512;
 
                     dev->state = STATE_SEND;
-                    /*FALLTHROUGH*/
+#ifndef __APPLE__
+                    [[fallthrough]];
+#endif
 
                 case STATE_SEND:
                     /* Activate the status icon. */
@@ -642,7 +646,9 @@ do_send:
                     dev->buf_len = 512;
 
                     dev->state = STATE_RECV;
-                    /*FALLTHROUGH*/
+#ifndef __APPLE__
+                    [[fallthrough]];
+#endif
 
                 case STATE_RECV:
                     /* Activate the status icon. */
@@ -1098,8 +1104,8 @@ xta_init(const device_t *info)
 static void
 xta_close(void *priv)
 {
-    hdc_t   *dev = (hdc_t *) priv;
-    drive_t *drive;
+    hdc_t         *dev = (hdc_t *) priv;
+    const drive_t *drive;
 
     /* Remove the I/O handler. */
     io_removehandler(dev->base, 4,

src/disk/hdd.c

@@ -160,7 +160,7 @@ hdd_seek_get_time(hard_disk_t *hdd, uint32_t dst_addr, uint8_t operation, uint8_
     if (!hdd->speed_preset)
         return HDD_OVERHEAD_TIME;
 
-    hdd_zone_t *zone = NULL;
+    const hdd_zone_t *zone = NULL;
     if (hdd->num_zones <= 0) {
         fatal("hdd_seek_get_time(): hdd->num_zones < 0)\n");
         return 0.0;
@@ -486,7 +486,7 @@ hdd_preset_apply(int hdd_id)
     if (hd->speed_preset >= hdd_preset_get_num())
         hd->speed_preset = 0;
 
-    hdd_preset_t *preset = &hdd_speed_presets[hd->speed_preset];
+    const hdd_preset_t *preset = &hdd_speed_presets[hd->speed_preset];
 
     hd->cache.num_segments = preset->rcache_num_seg;
     hd->cache.segment_size = preset->rcache_seg_size;

src/disk/mo.c

@@ -655,7 +655,9 @@ mo_update_request_length(mo_t *dev, int len, int block_len)
                     break;
                 }
             }
-            /*FALLTHROUGH*/
+#ifndef __APPLE__
+            [[fallthrough]];
+#endif
         default:
             dev->packet_len = len;
             break;
@@ -1342,7 +1344,9 @@ mo_command(scsi_common_t *sc, uint8_t *cdb)
                 mo_invalid_field(dev);
                 return;
             }
-            /*FALLTHROUGH*/
+#ifndef __APPLE__
+            [[fallthrough]];
+#endif
         case GPCMD_SCSI_RESERVE:
         case GPCMD_SCSI_RELEASE:
         case GPCMD_TEST_UNIT_READY:
@@ -2051,7 +2055,7 @@ mo_do_identify(ide_t *ide, int ide_has_dma)
 {
     char model[40];
 
-    mo_t *mo = (mo_t *) ide->sc;
+    const mo_t *mo = (mo_t *) ide->sc;
 
     memset(model, 0, 40);
 

src/disk/zip.c

@@ -821,7 +821,10 @@ zip_update_request_length(zip_t *dev, int len, int block_len)
                     break;
                 }
             }
-            /*FALLTHROUGH*/
+#ifndef __APPLE__
+            [[fallthrough]];
+#endif
+
         default:
             dev->packet_len = len;
             break;
@@ -1408,7 +1411,9 @@ zip_command(scsi_common_t *sc, uint8_t *cdb)
                 zip_invalid_field(dev);
                 return;
             }
-            /*FALLTHROUGH*/
+#ifndef __APPLE__
+            [[fallthrough]];
+#endif
         case GPCMD_SCSI_RESERVE:
         case GPCMD_SCSI_RELEASE:
         case GPCMD_TEST_UNIT_READY:
@@ -1571,6 +1576,9 @@ zip_command(scsi_common_t *sc, uint8_t *cdb)
                 zip_command_complete(dev);
                 break;
             }
+#ifndef __APPLE__
+            [[fallthrough]];
+#endif
         case GPCMD_WRITE_6:
         case GPCMD_WRITE_10:
         case GPCMD_WRITE_AND_VERIFY_10:
@@ -2280,7 +2288,7 @@ zip_250_identify(ide_t *ide, int ide_has_dma)
 static void
 zip_identify(ide_t *ide, int ide_has_dma)
 {
-    zip_t *zip;
+    const zip_t *zip;
 
     zip = (zip_t *) ide->sc;
 

src/dma.c

@@ -118,7 +118,7 @@ dma_sg_next_addr(dma_t *dev)
     dev->eot = dev->count >> 31;
     dev->count &= 0xfffe;
     dev->cb = (uint16_t) dev->count;
-    dev->cc = (int) dev->count;
+    dev->cc = dev->count;
     if (!dev->count)
         dev->count = 65536;
     if (ts == 2)
@@ -133,9 +133,7 @@ dma_sg_next_addr(dma_t *dev)
 static void
 dma_block_transfer(int channel)
 {
-    int bit16;
-
-    bit16 = (channel >= 4);
+    int bit16 = (channel >= 4);
 
     if (dma_advanced)
         bit16 = !!(dma_transfer_size(&(dma[channel])) == 2);
@@ -300,7 +298,7 @@ dma_sg_writel(uint16_t port, uint32_t val, void *priv)
 static uint8_t
 dma_sg_read(uint16_t port, void *priv)
 {
-    dma_t *dev = (dma_t *) priv;
+    const dma_t *dev = (dma_t *) priv;
 
     uint8_t ret = 0xff;
 
@@ -348,7 +346,7 @@ dma_sg_read(uint16_t port, void *priv)
 static uint16_t
 dma_sg_readw(uint16_t port, void *priv)
 {
-    dma_t *dev = (dma_t *) priv;
+    const dma_t *dev = (dma_t *) priv;
 
     uint16_t ret = 0xffff;
 
@@ -382,7 +380,7 @@ dma_sg_readw(uint16_t port, void *priv)
 static uint32_t
 dma_sg_readl(uint16_t port, void *priv)
 {
-    dma_t *dev = (dma_t *) priv;
+    const dma_t *dev = (dma_t *) priv;
 
     uint32_t ret = 0xffffffff;
 
@@ -596,7 +594,7 @@ dma_write(uint16_t addr, uint8_t val, UNUSED(void *priv))
 static uint8_t
 dma_ps2_read(uint16_t addr, UNUSED(void *priv))
 {
-    dma_t  *dma_c = &dma[dma_ps2.xfr_channel];
+    const dma_t  *dma_c = &dma[dma_ps2.xfr_channel];
     uint8_t temp  = 0xff;
 
     switch (addr) {
@@ -1280,7 +1278,7 @@ dma_sg(uint8_t *data, int transfer_length, int out, void *priv)
 uint8_t
 _dma_read(uint32_t addr, dma_t *dma_c)
 {
-    uint8_t temp;
+    uint8_t temp = 0;
 
     if (dma_advanced) {
         if (dma_c->sg_status & 1)
@@ -1296,7 +1294,7 @@ _dma_read(uint32_t addr, dma_t *dma_c)
 static uint16_t
 _dma_readw(uint32_t addr, dma_t *dma_c)
 {
-    uint16_t temp;
+    uint16_t temp = 0;
 
     if (dma_advanced) {
         if (dma_c->sg_status & 1)

src/fifo8.c

@@ -84,7 +84,7 @@ fifo8_pop(Fifo8 *fifo)
 const uint8_t *
 fifo8_pop_buf(Fifo8 *fifo, uint32_t max, uint32_t *num)
 {
-    uint8_t *ret;
+    const uint8_t *ret;
 
     assert(max > 0 && max <= fifo->num);
     *num = MIN(fifo->capacity - fifo->head, max);

src/floppy/fdc.c

@@ -916,7 +916,9 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
                             fdc_bad_command(fdc);
                             break;
                         }
-                        /*FALLTHROUGH*/
+#ifndef __APPLE__
+                        [[fallthrough]];
+#endif
                     case 0x07: /*Recalibrate*/
                         fdc->pnum = 0;
                         fdc->ptot = 1;
@@ -959,7 +961,9 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
                             fdc_bad_command(fdc);
                             break;
                         }
-                        /*FALLTHROUGH*/
+#ifndef __APPLE__
+                        [[fallthrough]];
+#endif
                     case 0x10: /*Get version*/
                     case 0x14: /*Unlock*/
                     case 0x94: /*Lock*/
@@ -1081,7 +1085,9 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
                         case 0x16: /* Verify */
                             if (fdc->params[0] & 0x80)
                                 fdc->sc = fdc->params[7];
-                            /*FALLTHROUGH*/
+#ifndef __APPLE__
+                            [[fallthrough]];
+#endif
                         case 0x06: /* Read data */
                         case 0x0c: /* Read deleted data */
                             fdc_io_command_phase1(fdc, 0);

src/floppy/fdd.c

@@ -64,7 +64,7 @@
 #define FLAG_IGNORE_DENSEL 512
 #define FLAG_PS2           1024
 
-typedef struct {
+typedef struct fdd_t {
     int type;
     int track;
     int densel;
@@ -451,10 +451,10 @@ fdd_get_densel(int drive)
 void
 fdd_load(int drive, char *fn)
 {
-    int   c = 0;
-    int   size;
-    char *p;
-    FILE *f;
+    int         c = 0;
+    int         size;
+    const char *p;
+    FILE *      f;
 
     fdd_log("FDD: loading drive %d with '%s'\n", drive, fn);
 
@@ -548,8 +548,8 @@ fdd_set_motor_enable(int drive, int motor_enable)
 static void
 fdd_poll(void *priv)
 {
-    int    drive;
-    DRIVE *drv = (DRIVE *) priv;
+    int          drive;
+    const DRIVE *drv = (DRIVE *) priv;
 
     drive = drv->id;
 
@@ -586,6 +586,9 @@ fdd_get_bitcell_period(int rate)
         case 3: /*Extended density*/
             bit_rate = 1000;
             break;
+
+        default:
+            break;
     }
 
     return 1000000 / bit_rate * 2; /*Bitcell period in ns*/

src/floppy/fdd_86f.c

@@ -180,7 +180,7 @@ typedef struct sector_t {
  *      specifies the entire bitcell count
  */
 typedef struct d86f_t {
-    FILE   *f;
+    FILE     *fp;
     uint8_t   state;
     uint8_t   fill;
     uint8_t   sector_count;
@@ -355,7 +355,7 @@ d86f_reverse_bytes(int drive)
 uint16_t
 d86f_disk_flags(int drive)
 {
-    d86f_t *dev = d86f[drive];
+    const d86f_t *dev = d86f[drive];
 
     return dev->disk_flags;
 }
@@ -363,7 +363,7 @@ d86f_disk_flags(int drive)
 uint32_t
 d86f_index_hole_pos(int drive, int side)
 {
-    d86f_t *dev = d86f[drive];
+    const d86f_t *dev = d86f[drive];
 
     return dev->index_hole_pos[side];
 }
@@ -413,7 +413,7 @@ null_format_conditions(UNUSED(int drive))
 int32_t
 d86f_extra_bit_cells(int drive, int side)
 {
-    d86f_t *dev = d86f[drive];
+    const d86f_t *dev = d86f[drive];
 
     return dev->extra_bit_cells[side];
 }
@@ -441,8 +441,8 @@ common_read_revolution(UNUSED(int drive))
 uint16_t
 d86f_side_flags(int drive)
 {
-    d86f_t *dev = d86f[drive];
-    int     side;
+    const d86f_t *dev = d86f[drive];
+    int           side;
 
     side = fdd_get_head(drive);
 
@@ -811,9 +811,9 @@ d86f_is_mfm(int drive)
 uint32_t
 d86f_get_data_len(int drive)
 {
-    d86f_t  *dev = d86f[drive];
-    uint32_t i;
-    uint32_t ret = 128;
+    const d86f_t  *dev = d86f[drive];
+    uint32_t       i;
+    uint32_t       ret = 128;
 
     if (dev->req_sector.id.n)
         ret = (uint32_t) 128 << dev->req_sector.id.n;
@@ -1243,8 +1243,8 @@ d86f_calccrc(d86f_t *dev, uint8_t byte)
 int
 d86f_word_is_aligned(int drive, int side, uint32_t base_pos)
 {
-    d86f_t  *dev                = d86f[drive];
-    uint32_t adjusted_track_pos = dev->track_pos;
+    const d86f_t  *dev                = d86f[drive];
+    uint32_t       adjusted_track_pos = dev->track_pos;
 
     if (base_pos == 0xFFFFFFFF)
         return 0;
@@ -1659,7 +1659,7 @@ d86f_write_sector_data(int drive, int side, int mfm, uint16_t am)
                     d86f_handler[drive].write_data(drive, side, dev->data_find.bytes_obtained - 1, dev->current_byte[side]);
             } else {
                 /* We're in the data field of the sector, use a CRC byte. */
-                dev->current_byte[side] = dev->calc_crc.bytes[(dev->data_find.bytes_obtained & 1)];
+                dev->current_byte[side] = dev->calc_crc.bytes[dev->data_find.bytes_obtained & 1];
             }
 
             dev->current_bit[side] = (15 - (dev->data_find.bits_obtained & 15)) >> 1;
@@ -1841,7 +1841,7 @@ d86f_write_direct_common(int drive, int side, uint16_t byte, uint8_t type, uint3
 void
 d86f_write_direct(int drive, int side, uint16_t byte, uint8_t type)
 {
-    d86f_t *dev = d86f[drive];
+    const d86f_t *dev = d86f[drive];
 
     d86f_write_direct_common(drive, side, byte, type, dev->track_pos >> 4);
 }
@@ -1951,7 +1951,9 @@ d86f_format_track(int drive, int side, int do_write)
                 if (dev->datac == 3)
                     fdc_stop_id_request(d86f_fdc);
             }
-            /*FALLTHROUGH*/
+#ifndef __APPLE__
+            [[fallthrough]];
+#endif
 
         case FMT_PRETRK_SYNC:
         case FMT_SECTOR_DATA_SYNC:
@@ -2106,9 +2108,9 @@ d86f_initialize_last_sector_id(int drive, int c, int h, int r, int n)
 static uint8_t
 d86f_sector_flags(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
 {
-    d86f_t   *dev = d86f[drive];
-    sector_t *s;
-    sector_t *t;
+    const d86f_t   *dev = d86f[drive];
+    sector_t       *s;
+    sector_t       *t;
 
     if (dev->last_side_sector[side]) {
         s = dev->last_side_sector[side];
@@ -2257,9 +2259,9 @@ d86f_turbo_format(int drive, int side, int nop)
 int
 d86f_sector_is_present(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
 {
-    d86f_t   *dev = d86f[drive];
-    sector_t *s;
-    sector_t *t;
+    const d86f_t   *dev = d86f[drive];
+    sector_t       *s;
+    sector_t       *t;
 
     if (dev->last_side_sector[side]) {
         s = dev->last_side_sector[side];
@@ -2294,7 +2296,9 @@ d86f_turbo_poll(int drive, int side)
         case STATE_0D_SPIN_TO_INDEX:
             dev->sector_count = 0;
             dev->datac        = 5;
-            /*FALLTHROUGH*/
+#ifndef __APPLE__
+            [[fallthrough]];
+#endif
 
         case STATE_02_SPIN_TO_INDEX:
             dev->state++;
@@ -2339,7 +2343,9 @@ d86f_turbo_poll(int drive, int side)
             dev->last_sector.id.r = dev->req_sector.id.r;
             dev->last_sector.id.n = dev->req_sector.id.n;
             d86f_handler[drive].set_sector(drive, side, dev->last_sector.id.c, dev->last_sector.id.h, dev->last_sector.id.r, dev->last_sector.id.n);
-            /*FALLTHROUGH*/
+#ifndef __APPLE__
+            [[fallthrough]];
+#endif
 
         case STATE_0A_FIND_ID:
             dev->turbo_pos = 0;
@@ -2800,22 +2806,22 @@ d86f_construct_encoded_buffer(int drive, int side)
 
     /* *_fuzm are fuzzy bit masks, *_holm are hole masks, dst_neim are masks is mask for bits that are neither fuzzy nor holes in both,
        and src1_d and src2_d are filtered source data. */
-    uint16_t  src1_fuzm;
-    uint16_t src2_fuzm;
-    uint16_t dst_fuzm;
-    uint16_t src1_holm;
-    uint16_t src2_holm;
-    uint16_t dst_holm;
-    uint16_t dst_neim;
-    uint16_t src1_d;
-    uint16_t src2_d;
-    uint32_t  len;
-    uint16_t *dst    = dev->track_encoded_data[side];
-    uint16_t *dst_s  = dev->track_surface_data[side];
-    uint16_t *src1   = dev->thin_track_encoded_data[0][side];
-    uint16_t *src1_s = dev->thin_track_surface_data[0][side];
-    uint16_t *src2   = dev->thin_track_encoded_data[1][side];
-    uint16_t *src2_s = dev->thin_track_surface_data[1][side];
+    uint16_t        src1_fuzm;
+    uint16_t        src2_fuzm;
+    uint16_t        dst_fuzm;
+    uint16_t        src1_holm;
+    uint16_t        src2_holm;
+    uint16_t        dst_holm;
+    uint16_t        dst_neim;
+    uint16_t        src1_d;
+    uint16_t        src2_d;
+    uint32_t        len;
+    uint16_t       *dst    = dev->track_encoded_data[side];
+    uint16_t       *dst_s  = dev->track_surface_data[side];
+    const uint16_t *src1   = dev->thin_track_encoded_data[0][side];
+    const uint16_t *src1_s = dev->thin_track_surface_data[0][side];
+    const uint16_t *src2   = dev->thin_track_encoded_data[1][side];
+    const uint16_t *src2_s = dev->thin_track_surface_data[1][side];
     len              = d86f_get_array_size(drive, side, 1);
 
     for (uint32_t i = 0; i < len; i++) {
@@ -2852,17 +2858,17 @@ d86f_construct_encoded_buffer(int drive, int side)
 void
 d86f_decompose_encoded_buffer(int drive, int side)
 {
-    d86f_t   *dev = d86f[drive];
-    uint16_t  temp;
-    uint16_t  temp2;
-    uint32_t  len;
-    uint16_t *dst    = dev->track_encoded_data[side];
-    uint16_t *src1   = dev->thin_track_encoded_data[0][side];
-    uint16_t *src1_s = dev->thin_track_surface_data[0][side];
-    uint16_t *src2   = dev->thin_track_encoded_data[1][side];
-    uint16_t *src2_s = dev->thin_track_surface_data[1][side];
-    dst              = d86f_handler[drive].encoded_data(drive, side);
-    len              = d86f_get_array_size(drive, side, 1);
+    d86f_t         *dev = d86f[drive];
+    uint16_t        temp;
+    uint16_t        temp2;
+    uint32_t        len;
+    const uint16_t *dst    = dev->track_encoded_data[side];
+    uint16_t       *src1   = dev->thin_track_encoded_data[0][side];
+    uint16_t       *src1_s = dev->thin_track_surface_data[0][side];
+    uint16_t       *src2   = dev->thin_track_encoded_data[1][side];
+    uint16_t       *src2_s = dev->thin_track_surface_data[1][side];
+    dst                    = d86f_handler[drive].encoded_data(drive, side);
+    len                    = d86f_get_array_size(drive, side, 1);
 
     for (uint32_t i = 0; i < len; i++) {
         if (d86f_has_surface_desc(drive)) {
@@ -2905,12 +2911,12 @@ d86f_read_track(int drive, int track, int thin_track, int side, uint16_t *da, ui
 
     if (dev->track_offset[logical_track]) {
         if (!thin_track) {
-            if (fseek(dev->f, dev->track_offset[logical_track], SEEK_SET) == -1)
+            if (fseek(dev->fp, dev->track_offset[logical_track], SEEK_SET) == -1)
                 fatal("d86f_read_track(): Error seeking to offset dev->track_offset[logical_track]\n");
-            if (fread(&(dev->side_flags[side]), 1, 2, dev->f) != 2)
+            if (fread(&(dev->side_flags[side]), 1, 2, dev->fp) != 2)
                 fatal("d86f_read_track(): Error reading side flags\n");
             if (d86f_has_extra_bit_cells(drive)) {
-                if (fread(&(dev->extra_bit_cells[side]), 1, 4, dev->f) != 4)
+                if (fread(&(dev->extra_bit_cells[side]), 1, 4, dev->fp) != 4)
                     fatal("d86f_read_track(): Error reading number of extra bit cells\n");
                 /* If RPM shift is 0% and direction is 1, do not adjust extra bit cells,
                    as that is the whole track length. */
@@ -2922,13 +2928,13 @@ d86f_read_track(int drive, int track, int thin_track, int side, uint16_t *da, ui
                 }
             } else
                 dev->extra_bit_cells[side] = 0;
-            (void) !fread(&(dev->index_hole_pos[side]), 4, 1, dev->f);
+            (void) !fread(&(dev->index_hole_pos[side]), 4, 1, dev->fp);
         } else
-            fseek(dev->f, dev->track_offset[logical_track] + d86f_track_header_size(drive), SEEK_SET);
+            fseek(dev->fp, dev->track_offset[logical_track] + d86f_track_header_size(drive), SEEK_SET);
         array_size = d86f_get_array_size(drive, side, 0);
-        (void) !fread(da, 1, array_size, dev->f);
+        (void) !fread(da, 1, array_size, dev->fp);
         if (d86f_has_surface_desc(drive))
-            (void) !fread(sa, 1, array_size, dev->f);
+            (void) !fread(sa, 1, array_size, dev->fp);
     } else {
         if (!thin_track) {
             switch ((dev->disk_flags >> 1) & 3) {
@@ -3125,22 +3131,22 @@ d86f_writeback(int drive)
 #endif
     header_size = d86f_header_size(drive);
 
-    if (!dev->f)
+    if (!dev->fp)
         return;
 
     /* First write the track offsets table. */
-    if (fseek(dev->f, 0, SEEK_SET) == -1)
+    if (fseek(dev->fp, 0, SEEK_SET) == -1)
         fatal("86F write_back(): Error seeking to the beginning of the file\n");
-    if (fread(header, 1, header_size, dev->f) != header_size)
+    if (fread(header, 1, header_size, dev->fp) != header_size)
         fatal("86F write_back(): Error reading header size\n");
 
-    if (fseek(dev->f, 8, SEEK_SET) == -1)
+    if (fseek(dev->fp, 8, SEEK_SET) == -1)
         fatal("86F write_back(): Error seeking\n");
     size = d86f_get_track_table_size(drive);
-    if (fwrite(dev->track_offset, 1, size, dev->f) != size)
+    if (fwrite(dev->track_offset, 1, size, dev->fp) != size)
         fatal("86F write_back(): Error writing data\n");
 
-    d86f_write_tracks(drive, &dev->f, NULL);
+    d86f_write_tracks(drive, &dev->fp, NULL);
 
 #ifdef D86F_COMPRESS
     if (dev->is_compressed) {
@@ -3152,16 +3158,16 @@ d86f_writeback(int drive)
         /* Write the header to the original file. */
         fwrite(header, 1, header_size, cf);
 
-        fseek(dev->f, 0, SEEK_END);
-        len = ftell(dev->f);
+        fseek(dev->fp, 0, SEEK_END);
+        len = ftell(dev->fp);
         len -= header_size;
 
-        fseek(dev->f, header_size, SEEK_SET);
+        fseek(dev->fp, header_size, SEEK_SET);
 
         /* Compress data from the temporary uncompressed file to the original, compressed file. */
         dev->filebuf = (uint8_t *) malloc(len);
         dev->outbuf  = (uint8_t *) malloc(len - 1);
-        fread(dev->filebuf, 1, len, dev->f);
+        fread(dev->filebuf, 1, len, dev->fp);
         ret = lzf_compress(dev->filebuf, len, dev->outbuf, len - 1);
 
         if (!ret)
@@ -3421,7 +3427,7 @@ d86f_export(int drive, char *fn)
     uint32_t tt[512];
     d86f_t  *dev = d86f[drive];
     d86f_t  *temp86;
-    FILE    *f;
+    FILE    *fp;
     int      tracks = 86;
     int      inc        = 1;
     uint32_t magic      = 0x46423638;
@@ -3430,19 +3436,19 @@ d86f_export(int drive, char *fn)
 
     memset(tt, 0, 512 * sizeof(uint32_t));
 
-    f = plat_fopen(fn, "wb");
-    if (!f)
+    fp = plat_fopen(fn, "wb");
+    if (!fp)
         return 0;
 
     /* Allocate a temporary drive for conversion. */
     temp86 = (d86f_t *) malloc(sizeof(d86f_t));
     memcpy(temp86, dev, sizeof(d86f_t));
 
-    fwrite(&magic, 4, 1, f);
-    fwrite(&version, 2, 1, f);
-    fwrite(&disk_flags, 2, 1, f);
+    fwrite(&magic, 4, 1, fp);
+    fwrite(&version, 2, 1, fp);
+    fwrite(&disk_flags, 2, 1, fp);
 
-    fwrite(tt, 1, ((d86f_get_sides(drive) == 2) ? 2048 : 1024), f);
+    fwrite(tt, 1, ((d86f_get_sides(drive) == 2) ? 2048 : 1024), fp);
 
     /* In the case of a thick track drive, always increment track
        by two, since two tracks are going to get output at once. */
@@ -3455,17 +3461,17 @@ d86f_export(int drive, char *fn)
         else
             fdd_do_seek(drive, i);
         dev->cur_track = i;
-        d86f_write_tracks(drive, &f, tt);
+        d86f_write_tracks(drive, &fp, tt);
     }
 
-    fclose(f);
+    fclose(fp);
 
-    f = plat_fopen(fn, "rb+");
+    fp = plat_fopen(fn, "rb+");
 
-    fseek(f, 8, SEEK_SET);
-    fwrite(tt, 1, ((d86f_get_sides(drive) == 2) ? 2048 : 1024), f);
+    fseek(fp, 8, SEEK_SET);
+    fwrite(tt, 1, ((d86f_get_sides(drive) == 2) ? 2048 : 1024), fp);
 
-    fclose(f);
+    fclose(fp);
 
     fdd_do_seek(drive, fdd_current_track(drive));
 
@@ -3492,10 +3498,10 @@ d86f_load(int drive, char *fn)
 
     writeprot[drive] = 0;
 
-    dev->f = plat_fopen(fn, "rb+");
-    if (!dev->f) {
-        dev->f = plat_fopen(fn, "rb");
-        if (!dev->f) {
+    dev->fp = plat_fopen(fn, "rb+");
+    if (!dev->fp) {
+        dev->fp = plat_fopen(fn, "rb");
+        if (!dev->fp) {
             memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
             free(dev);
             return;
@@ -3508,16 +3514,16 @@ d86f_load(int drive, char *fn)
     }
     fwriteprot[drive] = writeprot[drive];
 
-    fseek(dev->f, 0, SEEK_END);
-    len = ftell(dev->f);
-    fseek(dev->f, 0, SEEK_SET);
+    fseek(dev->fp, 0, SEEK_END);
+    len = ftell(dev->fp);
+    fseek(dev->fp, 0, SEEK_SET);
 
-    (void) !fread(&magic, 4, 1, dev->f);
+    (void) !fread(&magic, 4, 1, dev->fp);
 
     if (len < 16) {
         /* File is WAY too small, abort. */
-        fclose(dev->f);
-        dev->f = NULL;
+        fclose(dev->fp);
+        dev->fp = NULL;
         memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
         free(dev);
         return;
@@ -3526,13 +3532,13 @@ d86f_load(int drive, char *fn)
     if ((magic != 0x46423638) && (magic != 0x66623638)) {
         /* File is not of the valid format, abort. */
         d86f_log("86F: Unrecognized magic bytes: %08X\n", magic);
-        fclose(dev->f);
+        fclose(dev->fp);
         memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
         free(dev);
         return;
     }
 
-    if (fread(&(dev->version), 1, 2, dev->f) != 2)
+    if (fread(&(dev->version), 1, 2, dev->fp) != 2)
         fatal("d86f_load(): Error reading format version\n");
 
     if (dev->version != D86FVER) {
@@ -3544,8 +3550,8 @@ d86f_load(int drive, char *fn)
         } else {
             d86f_log("86F: Unrecognized file version: %i.%02i\n", dev->version >> 8, dev->version & 0xff);
         }
-        fclose(dev->f);
-        dev->f = NULL;
+        fclose(dev->fp);
+        dev->fp = NULL;
         memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
         free(dev);
         return;
@@ -3553,7 +3559,7 @@ d86f_load(int drive, char *fn)
         d86f_log("86F: Recognized file version: %i.%02i\n", dev->version >> 8, dev->version & 0xff);
     }
 
-    (void) !fread(&(dev->disk_flags), 2, 1, dev->f);
+    (void) !fread(&(dev->disk_flags), 2, 1, dev->fp);
 
     if (d86f_has_surface_desc(drive)) {
         for (uint8_t i = 0; i < 2; i++)
@@ -3572,31 +3578,31 @@ d86f_load(int drive, char *fn)
     if (len < 51052) {
 #endif
         /* File too small, abort. */
-        fclose(dev->f);
-        dev->f = NULL;
+        fclose(dev->fp);
+        dev->fp = NULL;
         memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
         free(dev);
         return;
     }
 
 #ifdef DO_CRC64
-    fseek(dev->f, 8, SEEK_SET);
-    fread(&read_crc64, 1, 8, dev->f);
+    fseek(dev->fp, 8, SEEK_SET);
+    fread(&read_crc64, 1, 8, dev->fp);
 
-    fseek(dev->f, 0, SEEK_SET);
+    fseek(dev->fp, 0, SEEK_SET);
 
     crc64 = 0xffffffffffffffff;
 
     dev->filebuf = malloc(len);
-    fread(dev->filebuf, 1, len, dev->f);
+    fread(dev->filebuf, 1, len, dev->fp);
     *(uint64_t *) &(dev->filebuf[8]) = 0xffffffffffffffff;
     crc64                            = (uint64_t) crc64speed(0, dev->filebuf, len);
     free(dev->filebuf);
 
     if (crc64 != read_crc64) {
         d86f_log("86F: CRC64 error\n");
-        fclose(dev->f);
-        dev->f = NULL;
+        fclose(dev->fp);
+        dev->fp = NULL;
         memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
         free(dev);
         return;
@@ -3608,11 +3614,11 @@ d86f_load(int drive, char *fn)
         memcpy(temp_file_name, drive ? nvr_path("TEMP$$$1.$$$") : nvr_path("TEMP$$$0.$$$"), 256);
         memcpy(dev->original_file_name, fn, strlen(fn) + 1);
 
-        fclose(dev->f);
-        dev->f = NULL;
+        fclose(dev->fp);
+        dev->fp = NULL;
 
-        dev->f = plat_fopen(temp_file_name, "wb");
-        if (!dev->f) {
+        dev->fp = plat_fopen(temp_file_name, "wb");
+        if (!dev->fp) {
             d86f_log("86F: Unable to create temporary decompressed file\n");
             memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
             free(dev);
@@ -3621,9 +3627,9 @@ d86f_load(int drive, char *fn)
 
         tf = plat_fopen(fn, "rb");
 
-        for (i = 0; i < 8; i++) {
+        for (uint8_t i = 0; i < 8; i++) {
             fread(&temp, 1, 2, tf);
-            fwrite(&temp, 1, 2, dev->f);
+            fwrite(&temp, 1, 2, dev->fp);
         }
 
         dev->filebuf = (uint8_t *) malloc(len);
@@ -3631,14 +3637,14 @@ d86f_load(int drive, char *fn)
         fread(dev->filebuf, 1, len, tf);
         temp = lzf_decompress(dev->filebuf, len, dev->outbuf, 67108864);
         if (temp) {
-            fwrite(dev->outbuf, 1, temp, dev->f);
+            fwrite(dev->outbuf, 1, temp, dev->fp);
         }
         free(dev->outbuf);
         free(dev->filebuf);
 
         fclose(tf);
-        fclose(dev->f);
-        dev->f = NULL;
+        fclose(dev->fp);
+        dev->fp = NULL;
 
         if (!temp) {
             d86f_log("86F: Error decompressing file\n");
@@ -3648,15 +3654,15 @@ d86f_load(int drive, char *fn)
             return;
         }
 
-        dev->f = plat_fopen(temp_file_name, "rb+");
+        dev->fp = plat_fopen(temp_file_name, "rb+");
     }
 #endif
 
     if (dev->disk_flags & 0x100) {
         /* Zoned disk. */
         d86f_log("86F: Disk is zoned (Apple or Sony)\n");
-        fclose(dev->f);
-        dev->f = NULL;
+        fclose(dev->fp);
+        dev->fp = NULL;
 #ifdef D86F_COMPRESS
         if (dev->is_compressed)
             plat_remove(temp_file_name);
@@ -3669,8 +3675,8 @@ d86f_load(int drive, char *fn)
     if (dev->disk_flags & 0x600) {
         /* Zone type is not 0 but the disk is fixed-RPM. */
         d86f_log("86F: Disk is fixed-RPM but zone type is not 0\n");
-        fclose(dev->f);
-        dev->f = NULL;
+        fclose(dev->fp);
+        dev->fp = NULL;
 #ifdef D86F_COMPRESS
         if (dev->is_compressed)
             plat_remove(temp_file_name);
@@ -3686,29 +3692,29 @@ d86f_load(int drive, char *fn)
     }
 
     if (writeprot[drive]) {
-        fclose(dev->f);
-        dev->f = NULL;
+        fclose(dev->fp);
+        dev->fp = NULL;
 
 #ifdef D86F_COMPRESS
         if (dev->is_compressed)
-            dev->f = plat_fopen(temp_file_name, "rb");
+            dev->fp = plat_fopen(temp_file_name, "rb");
         else
 #endif
-            dev->f = plat_fopen(fn, "rb");
+            dev->fp = plat_fopen(fn, "rb");
     }
 
     /* OK, set the drive data, other code needs it. */
     d86f[drive] = dev;
 
-    fseek(dev->f, 8, SEEK_SET);
+    fseek(dev->fp, 8, SEEK_SET);
 
-    (void) !fread(dev->track_offset, 1, d86f_get_track_table_size(drive), dev->f);
+    (void) !fread(dev->track_offset, 1, d86f_get_track_table_size(drive), dev->fp);
 
     if (!(dev->track_offset[0])) {
         /* File has no track 0 side 0, abort. */
         d86f_log("86F: No Track 0 side 0\n");
-        fclose(dev->f);
-        dev->f = NULL;
+        fclose(dev->fp);
+        dev->fp = NULL;
         memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
         free(dev);
         d86f[drive] = NULL;
@@ -3718,8 +3724,8 @@ d86f_load(int drive, char *fn)
     if ((d86f_get_sides(drive) == 2) && !(dev->track_offset[1])) {
         /* File is 2-sided but has no track 0 side 1, abort. */
         d86f_log("86F: No Track 0 side 1\n");
-        fclose(dev->f);
-        dev->f = NULL;
+        fclose(dev->fp);
+        dev->fp = NULL;
         memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
         free(dev);
         d86f[drive] = NULL;
@@ -3727,12 +3733,12 @@ d86f_load(int drive, char *fn)
     }
 
     /* Load track 0 flags as default. */
-    if (fseek(dev->f, dev->track_offset[0], SEEK_SET) == -1)
+    if (fseek(dev->fp, dev->track_offset[0], SEEK_SET) == -1)
         fatal("d86f_load(): Track 0: Error seeking to the beginning of the file\n");
-    if (fread(&(dev->side_flags[0]), 1, 2, dev->f) != 2)
+    if (fread(&(dev->side_flags[0]), 1, 2, dev->fp) != 2)
         fatal("d86f_load(): Track 0: Error reading side flags\n");
     if (dev->disk_flags & 0x80) {
-        if (fread(&(dev->extra_bit_cells[0]), 1, 4, dev->f) != 4)
+        if (fread(&(dev->extra_bit_cells[0]), 1, 4, dev->fp) != 4)
             fatal("d86f_load(): Track 0: Error reading the amount of extra bit cells\n");
         if ((dev->disk_flags & 0x1060) != 0x1000) {
             if (dev->extra_bit_cells[0] < -32768)
@@ -3745,12 +3751,12 @@ d86f_load(int drive, char *fn)
     }
 
     if (d86f_get_sides(drive) == 2) {
-        if (fseek(dev->f, dev->track_offset[1], SEEK_SET) == -1)
+        if (fseek(dev->fp, dev->track_offset[1], SEEK_SET) == -1)
             fatal("d86f_load(): Track 1: Error seeking to the beginning of the file\n");
-        if (fread(&(dev->side_flags[1]), 1, 2, dev->f) != 2)
+        if (fread(&(dev->side_flags[1]), 1, 2, dev->fp) != 2)
             fatal("d86f_load(): Track 1: Error reading side flags\n");
         if (dev->disk_flags & 0x80) {
-            if (fread(&(dev->extra_bit_cells[1]), 1, 4, dev->f) != 4)
+            if (fread(&(dev->extra_bit_cells[1]), 1, 4, dev->fp) != 4)
                 fatal("d86f_load(): Track 4: Error reading the amount of extra bit cells\n");
             if ((dev->disk_flags & 0x1060) != 0x1000) {
                 if (dev->extra_bit_cells[1] < -32768)
@@ -3781,10 +3787,10 @@ d86f_load(int drive, char *fn)
         dev->extra_bit_cells[1] = 0;
     }
 
-    fseek(dev->f, 0, SEEK_END);
-    dev->file_size = ftell(dev->f);
+    fseek(dev->fp, 0, SEEK_END);
+    dev->file_size = ftell(dev->fp);
 
-    fseek(dev->f, 0, SEEK_SET);
+    fseek(dev->fp, 0, SEEK_SET);
 
     d86f_register_86f(drive);
 
@@ -3847,9 +3853,9 @@ d86f_close(int drive)
         }
     }
 
-    if (dev->f) {
-        fclose(dev->f);
-        dev->f = NULL;
+    if (dev->fp) {
+        fclose(dev->fp);
+        dev->fp = NULL;
     }
 #ifdef D86F_COMPRESS
     if (dev->is_compressed)

src/floppy/fdd_fdi.c

@@ -36,8 +36,8 @@
 #include <86box/fdc.h>
 #include <fdi2raw.h>
 
-typedef struct {
-    FILE *f;
+typedef struct fdi_t {
+    FILE *fp;
     FDI  *h;
 
     int lasttrack;
@@ -176,10 +176,10 @@ fdi_density(void)
 static int32_t
 extra_bit_cells(int drive, int side)
 {
-    fdi_t *dev        = fdi[drive];
-    int    density    = 0;
-    int    raw_size   = 0;
-    int    is_300_rpm = 0;
+    const fdi_t *dev        = fdi[drive];
+    int          density    = 0;
+    int          raw_size   = 0;
+    int          is_300_rpm = 0;
 
     density = fdi_density();
 
@@ -249,8 +249,8 @@ read_revolution(int drive)
 static uint32_t
 index_hole_pos(int drive, int side)
 {
-    fdi_t *dev = fdi[drive];
-    int    density;
+    const fdi_t *dev = fdi[drive];
+    int          density;
 
     density = fdi_density();
 
@@ -260,8 +260,8 @@ index_hole_pos(int drive, int side)
 static uint32_t
 get_raw_size(int drive, int side)
 {
-    fdi_t *dev = fdi[drive];
-    int    density;
+    const fdi_t *dev = fdi[drive];
+    int          density;
 
     density = fdi_density();
 
@@ -291,7 +291,7 @@ fdi_seek(int drive, int track)
 
     d86f_set_cur_track(drive, track);
 
-    if (dev->f == NULL)
+    if (dev->fp == NULL)
         return;
 
     if (track < 0)
@@ -327,16 +327,16 @@ fdi_load(int drive, char *fn)
 
     d86f_unregister(drive);
 
-    dev->f = plat_fopen(fn, "rb");
-    if (fread(header, 1, 25, dev->f) != 25)
+    dev->fp = plat_fopen(fn, "rb");
+    if (fread(header, 1, 25, dev->fp) != 25)
         fatal("fdi_load(): Error reading header\n");
-    if (fseek(dev->f, 0, SEEK_SET) == -1)
+    if (fseek(dev->fp, 0, SEEK_SET) == -1)
         fatal("fdi_load(): Error seeking to the beginning of the file\n");
     header[25] = 0;
     if (strcmp(header, "Formatted Disk Image file") != 0) {
         /* This is a Japanese FDI file. */
         fdi_log("fdi_load(): Japanese FDI file detected, redirecting to IMG loader\n");
-        fclose(dev->f);
+        fclose(dev->fp);
         free(dev);
         img_load(drive, fn);
         return;
@@ -345,7 +345,7 @@ fdi_load(int drive, char *fn)
     /* Set up the drive unit. */
     fdi[drive] = dev;
 
-    dev->h         = fdi2raw_header(dev->f);
+    dev->h         = fdi2raw_header(dev->fp);
     dev->lasttrack = fdi2raw_get_last_track(dev->h);
     dev->sides     = fdi2raw_get_last_head(dev->h) + 1;
 
@@ -386,8 +386,8 @@ fdi_close(int drive)
     if (dev->h)
         fdi2raw_header_free(dev->h);
 
-    if (dev->f)
-        fclose(dev->f);
+    if (dev->fp)
+        fclose(dev->fp);
 
     /* Release the memory. */
     free(dev);

src/floppy/fdd_imd.c

@@ -31,7 +31,7 @@
 #include <86box/fdd_imd.h>
 #include <86box/fdc.h>
 
-typedef struct {
+typedef struct imd_track_t {
     uint8_t  is_present;
     uint32_t file_offs;
     uint8_t  params[5];
@@ -47,8 +47,8 @@ typedef struct {
     uint8_t  max_sector_size;
 } imd_track_t;
 
-typedef struct {
-    FILE       *f;
+typedef struct imd_t {
+    FILE       *fp;
     char       *buffer;
     uint32_t    start_offs;
     int         track_count;
@@ -136,21 +136,20 @@ get_raw_tsize(int side_flags, int slower_rpm)
 static int
 track_is_xdf(int drive, int side, int track)
 {
-    imd_t   *dev = imd[drive];
-    int      i;
-    int      effective_sectors;
-    int      xdf_sectors;
-    int      high_sectors;
-    int      low_sectors;
-    int      max_high_id;
-    int      expected_high_count;
-    int      expected_low_count;
-    uint8_t *r_map;
-    uint8_t *n_map;
+    imd_t         *dev = imd[drive];
+    int            effective_sectors;
+    int            xdf_sectors;
+    int            high_sectors;
+    int            low_sectors;
+    int            max_high_id;
+    int            expected_high_count;
+    int            expected_low_count;
+    const uint8_t *r_map;
+    const uint8_t *n_map;
 
     effective_sectors = xdf_sectors = high_sectors = low_sectors = 0;
 
-    for (i = 0; i < 256; i++)
+    for (uint16_t i = 0; i < 256; i++)
         dev->xdf_ordered_pos[i][side] = 0;
 
     if (dev->tracks[track][side].params[2] & 0xC0)
@@ -175,7 +174,7 @@ track_is_xdf(int drive, int side, int track)
             expected_low_count  = 0;
         }
 
-        for (i = 0; i < dev->tracks[track][side].params[3]; i++) {
+        for (uint8_t i = 0; i < dev->tracks[track][side].params[3]; i++) {
             if ((r_map[i] >= 0x81) && (r_map[i] <= max_high_id)) {
                 high_sectors++;
                 dev->xdf_ordered_pos[(int) r_map[i]][side] = i;
@@ -196,7 +195,7 @@ track_is_xdf(int drive, int side, int track)
 
         n_map = (uint8_t *) (dev->buffer + dev->tracks[track][side].n_map_offs);
 
-        for (i = 0; i < dev->tracks[track][side].params[3]; i++) {
+        for (uint8_t i = 0; i < dev->tracks[track][side].params[3]; i++) {
             effective_sectors++;
             if (!(r_map[i]) && !(n_map[i]))
                 effective_sectors--;
@@ -224,10 +223,10 @@ track_is_xdf(int drive, int side, int track)
 static int
 track_is_interleave(int drive, int side, int track)
 {
-    imd_t *dev = imd[drive];
-    int    effective_sectors;
-    char  *r_map;
-    int    track_spt;
+    imd_t       *dev = imd[drive];
+    int          effective_sectors;
+    const char  *r_map;
+    int          track_spt;
 
     effective_sectors = 0;
 
@@ -263,9 +262,9 @@ track_is_interleave(int drive, int side, int track)
 static void
 sector_to_buffer(int drive, int track, int side, uint8_t *buffer, int sector, int len)
 {
-    imd_t  *dev  = imd[drive];
-    int     type = dev->buffer[dev->tracks[track][side].sector_data_offs[sector]];
-    uint8_t fill_char;
+    const imd_t  *dev  = imd[drive];
+    int           type = dev->buffer[dev->tracks[track][side].sector_data_offs[sector]];
+    uint8_t       fill_char;
 
     if (type == 0)
         memset(buffer, 0x00, len);
@@ -282,35 +281,35 @@ sector_to_buffer(int drive, int track, int side, uint8_t *buffer, int sector, in
 static void
 imd_seek(int drive, int track)
 {
-    uint32_t track_buf_pos[2] = { 0, 0 };
-    uint8_t  id[4]            = { 0, 0, 0, 0 };
-    uint8_t  type;
-    imd_t   *dev = imd[drive];
-    int      sector;
-    int      current_pos;
-    int      c = 0;
-    int      h;
-    int      n;
-    int      ssize           = 512;
-    int      track_rate      = 0;
-    int      track_gap2      = 22;
-    int      track_gap3      = 12;
-    int      xdf_type        = 0;
-    int      interleave_type = 0;
-    int      is_trackx       = 0;
-    int      xdf_spt         = 0;
-    int      xdf_sector      = 0;
-    int      ordered_pos     = 0;
-    int      real_sector     = 0;
-    int      actual_sector   = 0;
-    char    *c_map           = NULL;
-    char    *h_map           = NULL;
-    char    *r_map;
-    char    *n_map = NULL;
-    uint8_t *data;
-    int      flags = 0x00;
+    uint32_t    track_buf_pos[2] = { 0, 0 };
+    uint8_t     id[4]            = { 0, 0, 0, 0 };
+    uint8_t     type;
+    imd_t      *dev = imd[drive];
+    int         sector;
+    int         current_pos;
+    int         c = 0;
+    int         h;
+    int         n;
+    int         ssize           = 512;
+    int         track_rate      = 0;
+    int         track_gap2      = 22;
+    int         track_gap3      = 12;
+    int         xdf_type        = 0;
+    int         interleave_type = 0;
+    int         is_trackx       = 0;
+    int         xdf_spt         = 0;
+    int         xdf_sector      = 0;
+    int         ordered_pos     = 0;
+    int         real_sector     = 0;
+    int         actual_sector   = 0;
+    const char *c_map           = NULL;
+    const char *h_map           = NULL;
+    const char *r_map;
+    const char *n_map = NULL;
+    uint8_t    *data;
+    int         flags = 0x00;
 
-    if (dev->f == NULL)
+    if (dev->fp == NULL)
         return;
 
     if (!dev->track_width && fdd_doublestep_40(drive))
@@ -452,7 +451,7 @@ imd_seek(int drive, int track)
 static uint16_t
 disk_flags(int drive)
 {
-    imd_t *dev = imd[drive];
+    const imd_t *dev = imd[drive];
 
     return (dev->disk_flags);
 }
@@ -460,9 +459,9 @@ disk_flags(int drive)
 static uint16_t
 side_flags(int drive)
 {
-    imd_t   *dev    = imd[drive];
-    int      side   = 0;
-    uint16_t sflags = 0;
+    const imd_t   *dev    = imd[drive];
+    int            side   = 0;
+    uint16_t       sflags = 0;
 
     side   = fdd_get_head(drive);
     sflags = dev->current_side_flags[side];
@@ -473,19 +472,19 @@ side_flags(int drive)
 static void
 set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
 {
-    imd_t  *dev   = imd[drive];
-    int     track = dev->track;
-    int     sc;
-    int     sh;
-    int     sn;
-    char   *c_map = NULL;
-    char   *h_map = NULL;
-    char   *r_map = NULL;
-    char   *n_map = NULL;
-    uint8_t id[4] = { 0, 0, 0, 0 };
-    sc            = dev->tracks[track][side].params[1];
-    sh            = dev->tracks[track][side].params[2];
-    sn            = dev->tracks[track][side].params[4];
+    imd_t      *dev   = imd[drive];
+    int         track = dev->track;
+    int         sc;
+    int         sh;
+    int         sn;
+    const char *c_map = NULL;
+    const char *h_map = NULL;
+    const char *r_map = NULL;
+    const char *n_map = NULL;
+    uint8_t     id[4] = { 0, 0, 0, 0 };
+    sc                = dev->tracks[track][side].params[1];
+    sh                = dev->tracks[track][side].params[2];
+    sn                = dev->tracks[track][side].params[4];
 
     if (sh & 0x80)
         c_map = dev->buffer + dev->tracks[track][side].c_map_offs;
@@ -513,39 +512,39 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
 static void
 imd_writeback(int drive)
 {
-    imd_t   *dev = imd[drive];
-    int      track = dev->track;
-    char    *n_map = 0;
-    uint8_t  h;
-    uint8_t  n;
-    uint8_t spt;
-    uint32_t ssize;
+    imd_t      *dev = imd[drive];
+    int         track = dev->track;
+    const char *n_map = 0;
+    uint8_t     h;
+    uint8_t     n;
+    uint8_t     spt;
+    uint32_t    ssize;
 
     if (writeprot[drive])
         return;
 
     for (int side = 0; side < dev->sides; side++) {
         if (dev->tracks[track][side].is_present) {
-            fseek(dev->f, dev->tracks[track][side].file_offs, SEEK_SET);
+            fseek(dev->fp, dev->tracks[track][side].file_offs, SEEK_SET);
             h   = dev->tracks[track][side].params[2];
             spt = dev->tracks[track][side].params[3];
             n   = dev->tracks[track][side].params[4];
-            fwrite(dev->tracks[track][side].params, 1, 5, dev->f);
+            fwrite(dev->tracks[track][side].params, 1, 5, dev->fp);
 
             if (h & 0x80)
-                fwrite(dev->buffer + dev->tracks[track][side].c_map_offs, 1, spt, dev->f);
+                fwrite(dev->buffer + dev->tracks[track][side].c_map_offs, 1, spt, dev->fp);
 
             if (h & 0x40)
-                fwrite(dev->buffer + dev->tracks[track][side].h_map_offs, 1, spt, dev->f);
+                fwrite(dev->buffer + dev->tracks[track][side].h_map_offs, 1, spt, dev->fp);
 
             if (n == 0xFF) {
                 n_map = dev->buffer + dev->tracks[track][side].n_map_offs;
-                fwrite(n_map, 1, spt, dev->f);
+                fwrite(n_map, 1, spt, dev->fp);
             }
             for (uint8_t i = 0; i < spt; i++) {
                 ssize = (n == 0xFF) ? n_map[i] : n;
                 ssize = 128 << ssize;
-                fwrite(dev->buffer + dev->tracks[track][side].sector_data_offs[i], 1, ssize, dev->f);
+                fwrite(dev->buffer + dev->tracks[track][side].sector_data_offs[i], 1, ssize, dev->fp);
             }
         }
     }
@@ -554,8 +553,8 @@ imd_writeback(int drive)
 static uint8_t
 poll_read_data(int drive, int side, uint16_t pos)
 {
-    imd_t *dev  = imd[drive];
-    int    type = dev->current_data[side][0];
+    const imd_t *dev  = imd[drive];
+    int          type = dev->current_data[side][0];
 
     if ((type == 0) || (type > 8))
         return 0xf6; /* Should never happen. */
@@ -569,8 +568,8 @@ poll_read_data(int drive, int side, uint16_t pos)
 static void
 poll_write_data(int drive, int side, uint16_t pos, uint8_t data)
 {
-    imd_t *dev  = imd[drive];
-    int    type = dev->current_data[side][0];
+    const imd_t *dev  = imd[drive];
+    int          type = dev->current_data[side][0];
 
     if (writeprot[drive])
         return;
@@ -584,10 +583,10 @@ poll_write_data(int drive, int side, uint16_t pos, uint8_t data)
 static int
 format_conditions(int drive)
 {
-    imd_t *dev   = imd[drive];
-    int    track = dev->track;
-    int    side;
-    int    temp;
+    const imd_t *dev   = imd[drive];
+    int          track = dev->track;
+    int          side;
+    int          temp;
 
     side = fdd_get_head(drive);
     temp = (fdc_get_format_sectors(imd_fdc) == dev->tracks[track][side].params[3]);
@@ -605,29 +604,28 @@ imd_init(void)
 void
 imd_load(int drive, char *fn)
 {
-    uint32_t magic = 0;
-    uint32_t fsize = 0;
-    char    *buffer;
-    char    *buffer2;
-    imd_t   *dev;
-    int      i            = 0;
-    int      track_spt    = 0;
-    int      sector_size  = 0;
-    int      track        = 0;
-    int      side         = 0;
-    int      extra        = 0;
-    uint32_t last_offset  = 0;
-    uint32_t data_size    = 512;
-    uint32_t mfm          = 0;
-    uint32_t pre_sector   = 0;
-    uint32_t track_total  = 0;
-    uint32_t raw_tsize    = 0;
-    uint32_t minimum_gap3 = 0;
-    uint32_t minimum_gap4 = 0;
-    uint8_t  converted_rate;
-    uint8_t  type;
-    int      size_diff;
-    int      gap_sum;
+    uint32_t    magic = 0;
+    uint32_t    fsize = 0;
+    const char *buffer;
+    const char *buffer2;
+    imd_t      *dev;
+    int         track_spt    = 0;
+    int         sector_size  = 0;
+    int         track        = 0;
+    int         side         = 0;
+    int         extra        = 0;
+    uint32_t    last_offset  = 0;
+    uint32_t    data_size    = 512;
+    uint32_t    mfm          = 0;
+    uint32_t    pre_sector   = 0;
+    uint32_t    track_total  = 0;
+    uint32_t    raw_tsize    = 0;
+    uint32_t    minimum_gap3 = 0;
+    uint32_t    minimum_gap4 = 0;
+    uint8_t     converted_rate;
+    uint8_t     type;
+    int         size_diff;
+    int         gap_sum;
 
     d86f_unregister(drive);
 
@@ -637,10 +635,10 @@ imd_load(int drive, char *fn)
     dev = (imd_t *) malloc(sizeof(imd_t));
     memset(dev, 0x00, sizeof(imd_t));
 
-    dev->f = plat_fopen(fn, "rb+");
-    if (dev->f == NULL) {
-        dev->f = plat_fopen(fn, "rb");
-        if (dev->f == NULL) {
+    dev->fp = plat_fopen(fn, "rb+");
+    if (dev->fp == NULL) {
+        dev->fp = plat_fopen(fn, "rb");
+        if (dev->fp == NULL) {
             memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
             free(dev);
             return;
@@ -652,40 +650,40 @@ imd_load(int drive, char *fn)
         writeprot[drive] = 1;
     fwriteprot[drive] = writeprot[drive];
 
-    if (fseek(dev->f, 0, SEEK_SET) == -1)
+    if (fseek(dev->fp, 0, SEEK_SET) == -1)
         fatal("imd_load(): Error seeking to the beginning of the file\n");
-    if (fread(&magic, 1, 4, dev->f) != 4)
+    if (fread(&magic, 1, 4, dev->fp) != 4)
         fatal("imd_load(): Error reading the magic number\n");
     if (magic != 0x20444D49) {
         imd_log("IMD: Not a valid ImageDisk image\n");
-        fclose(dev->f);
+        fclose(dev->fp);
         free(dev);
         memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
         return;
     } else
         imd_log("IMD: Valid ImageDisk image\n");
 
-    if (fseek(dev->f, 0, SEEK_END) == -1)
+    if (fseek(dev->fp, 0, SEEK_END) == -1)
         fatal("imd_load(): Error seeking to the end of the file\n");
-    fsize = ftell(dev->f);
+    fsize = ftell(dev->fp);
     if (fsize <= 0) {
         imd_log("IMD: Too small ImageDisk image\n");
-        fclose(dev->f);
+        fclose(dev->fp);
         free(dev);
         memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
         return;
     }
-    if (fseek(dev->f, 0, SEEK_SET) == -1)
+    if (fseek(dev->fp, 0, SEEK_SET) == -1)
         fatal("imd_load(): Error seeking to the beginning of the file again\n");
     dev->buffer = malloc(fsize);
-    if (fread(dev->buffer, 1, fsize, dev->f) != fsize)
+    if (fread(dev->buffer, 1, fsize, dev->fp) != fsize)
         fatal("imd_load(): Error reading data\n");
     buffer = dev->buffer;
 
     buffer2 = memchr(buffer, 0x1A, fsize);
     if (buffer2 == NULL) {
         imd_log("IMD: No ASCII EOF character\n");
-        fclose(dev->f);
+        fclose(dev->fp);
         free(dev);
         memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
         return;
@@ -696,7 +694,7 @@ imd_load(int drive, char *fn)
     buffer2++;
     if ((buffer2 - buffer) == fsize) {
         imd_log("IMD: File ends after ASCII EOF character\n");
-        fclose(dev->f);
+        fclose(dev->fp);
         free(dev);
         memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
         return;
@@ -775,7 +773,7 @@ imd_load(int drive, char *fn)
 
             dev->tracks[track][side].data_offs = last_offset;
 
-            for (i = 0; i < track_spt; i++) {
+            for (int i = 0; i < track_spt; i++) {
                 data_size                                    = buffer2[i];
                 data_size                                    = 128 << data_size;
                 dev->tracks[track][side].sector_data_offs[i] = last_offset;
@@ -784,7 +782,7 @@ imd_load(int drive, char *fn)
                     /* Invalid sector data type, possibly a malformed HxC IMG image (it outputs data errored
                        sectors with a variable amount of bytes, against the specification). */
                     imd_log("IMD: Invalid sector data type %02X\n", dev->buffer[dev->tracks[track][side].sector_data_offs[i]]);
-                    fclose(dev->f);
+                    fclose(dev->fp);
                     free(dev);
                     imd[drive] = NULL;
                     memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
@@ -807,7 +805,7 @@ imd_load(int drive, char *fn)
         } else {
             dev->tracks[track][side].data_offs = last_offset;
 
-            for (i = 0; i < track_spt; i++) {
+            for (int i = 0; i < track_spt; i++) {
                 data_size                                    = sector_size;
                 data_size                                    = 128 << data_size;
                 dev->tracks[track][side].sector_data_offs[i] = last_offset;
@@ -816,7 +814,7 @@ imd_load(int drive, char *fn)
                     /* Invalid sector data type, possibly a malformed HxC IMG image (it outputs data errored
                        sectors with a variable amount of bytes, against the specification). */
                     imd_log("IMD: Invalid sector data type %02X\n", dev->buffer[dev->tracks[track][side].sector_data_offs[i]]);
-                    fclose(dev->f);
+                    fclose(dev->fp);
                     free(dev);
                     imd[drive] = NULL;
                     memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
@@ -865,7 +863,7 @@ imd_load(int drive, char *fn)
                 if (size_diff < gap_sum) {
                     /* If we can't fit the sectors with a reasonable minimum gap even at 2% slower RPM, abort. */
                     imd_log("IMD: Unable to fit the %i sectors in a track\n", track_spt);
-                    fclose(dev->f);
+                    fclose(dev->fp);
                     free(dev);
                     imd[drive] = NULL;
                     memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
@@ -931,10 +929,10 @@ imd_close(int drive)
 
     d86f_unregister(drive);
 
-    if (dev->f != NULL) {
+    if (dev->fp != NULL) {
         free(dev->buffer);
 
-        fclose(dev->f);
+        fclose(dev->fp);
     }
 
     /* Release the memory. */

src/floppy/fdd_img.c

@@ -40,8 +40,8 @@
 #include <86box/fdd_img.h>
 #include <86box/fdc.h>
 
-typedef struct {
-    FILE    *f;
+typedef struct img_t {
+    FILE    *fp;
     uint8_t  track_data[2][688128];
     int      sectors, tracks, sides;
     uint8_t  sector_size;
@@ -418,17 +418,17 @@ write_back(int drive)
     int    ssize = 128 << ((int) dev->sector_size);
     int    size;
 
-    if (dev->f == NULL)
+    if (dev->fp == NULL)
         return;
 
     if (dev->disk_at_once)
         return;
 
-    if (fseek(dev->f, dev->base + (dev->track * dev->sectors * ssize * dev->sides), SEEK_SET) == -1)
+    if (fseek(dev->fp, dev->base + (dev->track * dev->sectors * ssize * dev->sides), SEEK_SET) == -1)
         pclog("IMG write_back(): Error seeking to the beginning of the file\n");
     for (int side = 0; side < dev->sides; side++) {
         size = dev->sectors * ssize;
-        if (fwrite(dev->track_data[side], 1, size, dev->f) != size)
+        if (fwrite(dev->track_data[side], 1, size, dev->fp) != size)
             fatal("IMG write_back(): Error writing data\n");
     }
 }
@@ -436,7 +436,7 @@ write_back(int drive)
 static uint16_t
 disk_flags(int drive)
 {
-    img_t *dev = img[drive];
+    const img_t *dev = img[drive];
 
     return (dev->disk_flags);
 }
@@ -444,7 +444,7 @@ disk_flags(int drive)
 static uint16_t
 side_flags(int drive)
 {
-    img_t *dev = img[drive];
+    const img_t *dev = img[drive];
 
     return (dev->track_flags);
 }
@@ -461,7 +461,7 @@ set_sector(int drive, UNUSED(int side), UNUSED(uint8_t c), uint8_t h, uint8_t r,
 static uint8_t
 poll_read_data(int drive, UNUSED(int side), uint16_t pos)
 {
-    img_t *dev = img[drive];
+    const img_t *dev = img[drive];
 
     return (dev->track_data[dev->current_sector_pos_side][dev->current_sector_pos + pos]);
 }
@@ -477,8 +477,8 @@ poll_write_data(int drive, UNUSED(int side), uint16_t pos, uint8_t data)
 static int
 format_conditions(int drive)
 {
-    img_t *dev  = img[drive];
-    int    temp = (fdc_get_format_sectors(img_fdc) == dev->sectors);
+    const img_t *dev  = img[drive];
+    int          temp = (fdc_get_format_sectors(img_fdc) == dev->sectors);
 
     temp = temp && (fdc_get_format_n(img_fdc) == dev->sector_size);
     temp = temp && (dev->xdf_type == 0);
@@ -507,7 +507,7 @@ img_seek(int drive, int track)
     int      ssize   = 128 << ((int) dev->sector_size);
     uint32_t cur_pos = 0;
 
-    if (dev->f == NULL)
+    if (dev->fp == NULL)
         return;
 
     if (!dev->track_width && fdd_doublestep_40(drive))
@@ -519,7 +519,7 @@ img_seek(int drive, int track)
     is_t0 = (track == 0) ? 1 : 0;
 
     if (!dev->disk_at_once) {
-        if (fseek(dev->f, dev->base + (track * dev->sectors * ssize * dev->sides), SEEK_SET) == -1)
+        if (fseek(dev->fp, dev->base + (track * dev->sectors * ssize * dev->sides), SEEK_SET) == -1)
             fatal("img_seek(): Error seeking\n");
     }
 
@@ -528,7 +528,7 @@ img_seek(int drive, int track)
             cur_pos = (track * dev->sectors * ssize * dev->sides) + (side * dev->sectors * ssize);
             memcpy(dev->track_data[side], dev->disk_data + cur_pos, (size_t) dev->sectors * ssize);
         } else {
-            read_bytes = fread(dev->track_data[side], 1, (size_t) dev->sectors * ssize, dev->f);
+            read_bytes = fread(dev->track_data[side], 1, (size_t) dev->sectors * ssize, dev->fp);
             if (read_bytes < (dev->sectors * ssize))
                 memset(dev->track_data[side] + read_bytes, 0xf6, (dev->sectors * ssize) - read_bytes);
         }
@@ -682,10 +682,10 @@ img_load(int drive, char *fn)
     dev = (img_t *) malloc(sizeof(img_t));
     memset(dev, 0x00, sizeof(img_t));
 
-    dev->f = plat_fopen(fn, "rb+");
-    if (dev->f == NULL) {
-        dev->f = plat_fopen(fn, "rb");
-        if (dev->f == NULL) {
+    dev->fp = plat_fopen(fn, "rb+");
+    if (dev->fp == NULL) {
+        dev->fp = plat_fopen(fn, "rb");
+        if (dev->fp == NULL) {
             free(dev);
             memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
             return;
@@ -710,23 +710,23 @@ img_load(int drive, char *fn)
     if (!strcasecmp(ext, "FDI")) {
         /* This is a Japanese FDI image, so let's read the header */
         img_log("img_load(): File is a Japanese FDI image...\n");
-        fseek(dev->f, 0x10, SEEK_SET);
-        (void) !fread(&bpb_bps, 1, 2, dev->f);
-        fseek(dev->f, 0x0C, SEEK_SET);
-        (void) !fread(&size, 1, 4, dev->f);
+        fseek(dev->fp, 0x10, SEEK_SET);
+        (void) !fread(&bpb_bps, 1, 2, dev->fp);
+        fseek(dev->fp, 0x0C, SEEK_SET);
+        (void) !fread(&size, 1, 4, dev->fp);
         bpb_total = size / bpb_bps;
-        fseek(dev->f, 0x08, SEEK_SET);
-        (void) !fread(&(dev->base), 1, 4, dev->f);
-        fseek(dev->f, dev->base + 0x15, SEEK_SET);
-        bpb_mid = fgetc(dev->f);
+        fseek(dev->fp, 0x08, SEEK_SET);
+        (void) !fread(&(dev->base), 1, 4, dev->fp);
+        fseek(dev->fp, dev->base + 0x15, SEEK_SET);
+        bpb_mid = fgetc(dev->fp);
         if (bpb_mid < 0xF0)
             bpb_mid = 0xF0;
-        fseek(dev->f, 0x14, SEEK_SET);
-        bpb_sectors = fgetc(dev->f);
-        fseek(dev->f, 0x18, SEEK_SET);
-        bpb_sides = fgetc(dev->f);
-        fseek(dev->f, dev->base, SEEK_SET);
-        first_byte = fgetc(dev->f);
+        fseek(dev->fp, 0x14, SEEK_SET);
+        bpb_sectors = fgetc(dev->fp);
+        fseek(dev->fp, 0x18, SEEK_SET);
+        bpb_sides = fgetc(dev->fp);
+        fseek(dev->fp, dev->base, SEEK_SET);
+        first_byte = fgetc(dev->fp);
 
         fdi               = 1;
         cqm               = 0;
@@ -734,53 +734,53 @@ img_load(int drive, char *fn)
         fdf               = 0;
     } else {
         /* Read the first four bytes. */
-        fseek(dev->f, 0x00, SEEK_SET);
-        first_byte = fgetc(dev->f);
-        fseek(dev->f, 0x01, SEEK_SET);
-        second_byte = fgetc(dev->f);
-        fseek(dev->f, 0x02, SEEK_SET);
-        third_byte = fgetc(dev->f);
-        fseek(dev->f, 0x03, SEEK_SET);
-        fourth_byte = fgetc(dev->f);
+        fseek(dev->fp, 0x00, SEEK_SET);
+        first_byte = fgetc(dev->fp);
+        fseek(dev->fp, 0x01, SEEK_SET);
+        second_byte = fgetc(dev->fp);
+        fseek(dev->fp, 0x02, SEEK_SET);
+        third_byte = fgetc(dev->fp);
+        fseek(dev->fp, 0x03, SEEK_SET);
+        fourth_byte = fgetc(dev->fp);
 
         if ((first_byte == 0x1A) && (second_byte == 'F') && (third_byte == 'D') && (fourth_byte == 'F')) {
             /* This is a FDF image. */
             img_log("img_load(): File is a FDF image...\n");
             fwriteprot[drive] = writeprot[drive] = 1;
-            fclose(dev->f);
-            dev->f = plat_fopen(fn, "rb");
+            fclose(dev->fp);
+            dev->fp = plat_fopen(fn, "rb");
 
             fdf               = 1;
             cqm               = 0;
             dev->disk_at_once = 1;
 
-            fseek(dev->f, 0x50, SEEK_SET);
-            (void) !fread(&dev->tracks, 1, 4, dev->f);
+            fseek(dev->fp, 0x50, SEEK_SET);
+            (void) !fread(&dev->tracks, 1, 4, dev->fp);
 
             /* Decode the entire file - pass 1, no write to buffer, determine length. */
-            fseek(dev->f, 0x80, SEEK_SET);
+            fseek(dev->fp, 0x80, SEEK_SET);
             size        = 0;
             track_bytes = 0;
             bpos        = dev->disk_data;
-            while (!feof(dev->f)) {
+            while (!feof(dev->fp)) {
                 if (!track_bytes) {
                     /* Skip first 3 bytes - their meaning is unknown to us but could be a checksum. */
-                    first_byte = fgetc(dev->f);
-                    (void) !fread(&track_bytes, 1, 2, dev->f);
+                    first_byte = fgetc(dev->fp);
+                    (void) !fread(&track_bytes, 1, 2, dev->fp);
                     img_log("Block header: %02X %04X ", first_byte, track_bytes);
                     /* Read the length of encoded data block. */
-                    (void) !fread(&track_bytes, 1, 2, dev->f);
+                    (void) !fread(&track_bytes, 1, 2, dev->fp);
                     img_log("%04X\n", track_bytes);
                 }
 
-                if (feof(dev->f))
+                if (feof(dev->fp))
                     break;
 
                 if (first_byte == 0xFF)
                     break;
 
                 if (first_byte) {
-                    run = fgetc(dev->f);
+                    run = fgetc(dev->fp);
 
                     /* I *HAVE* to read something because fseek tries to be smart and never hits EOF, causing an infinite loop. */
                     track_bytes--;
@@ -788,12 +788,12 @@ img_load(int drive, char *fn)
                     if (run & 0x80) {
                         /* Repeat. */
                         track_bytes--;
-                        rep_byte = fgetc(dev->f);
+                        rep_byte = fgetc(dev->fp);
                     } else {
                         /* Literal. */
                         track_bytes -= (run & 0x7f);
                         literal = (uint8_t *) malloc(run & 0x7f);
-                        (void) !fread(literal, 1, (run & 0x7f), dev->f);
+                        (void) !fread(literal, 1, (run & 0x7f), dev->fp);
                         free(literal);
                     }
                     size += (run & 0x7f);
@@ -803,12 +803,12 @@ img_load(int drive, char *fn)
                     /* Literal block. */
                     size += (track_bytes - fdf_suppress_final_byte);
                     literal = (uint8_t *) malloc(track_bytes);
-                    (void) !fread(literal, 1, track_bytes, dev->f);
+                    (void) !fread(literal, 1, track_bytes, dev->fp);
                     free(literal);
                     track_bytes = 0;
                 }
 
-                if (feof(dev->f))
+                if (feof(dev->fp))
                     break;
             }
 
@@ -816,28 +816,28 @@ img_load(int drive, char *fn)
             dev->disk_data = (uint8_t *) malloc(size);
 
             /* Decode the entire file - pass 2, write to buffer. */
-            fseek(dev->f, 0x80, SEEK_SET);
+            fseek(dev->fp, 0x80, SEEK_SET);
             track_bytes = 0;
             bpos        = dev->disk_data;
-            while (!feof(dev->f)) {
+            while (!feof(dev->fp)) {
                 if (!track_bytes) {
                     /* Skip first 3 bytes - their meaning is unknown to us but could be a checksum. */
-                    first_byte = fgetc(dev->f);
-                    (void) !fread(&track_bytes, 1, 2, dev->f);
+                    first_byte = fgetc(dev->fp);
+                    (void) !fread(&track_bytes, 1, 2, dev->fp);
                     img_log("Block header: %02X %04X ", first_byte, track_bytes);
                     /* Read the length of encoded data block. */
-                    (void) !fread(&track_bytes, 1, 2, dev->f);
+                    (void) !fread(&track_bytes, 1, 2, dev->fp);
                     img_log("%04X\n", track_bytes);
                 }
 
-                if (feof(dev->f))
+                if (feof(dev->fp))
                     break;
 
                 if (first_byte == 0xFF)
                     break;
 
                 if (first_byte) {
-                    run      = fgetc(dev->f);
+                    run      = fgetc(dev->fp);
                     real_run = (run & 0x7f);
 
                     /* I *HAVE* to read something because fseek tries to be smart and never hits EOF, causing an infinite loop. */
@@ -848,14 +848,14 @@ img_load(int drive, char *fn)
                         track_bytes--;
                         if (!track_bytes)
                             real_run -= fdf_suppress_final_byte;
-                        rep_byte = fgetc(dev->f);
+                        rep_byte = fgetc(dev->fp);
                         if (real_run)
                             memset(bpos, rep_byte, real_run);
                     } else {
                         /* Literal. */
                         track_bytes -= real_run;
                         literal = (uint8_t *) malloc(real_run);
-                        (void) !fread(literal, 1, real_run, dev->f);
+                        (void) !fread(literal, 1, real_run, dev->fp);
                         if (!track_bytes)
                             real_run -= fdf_suppress_final_byte;
                         if (run & 0x7f)
@@ -866,14 +866,14 @@ img_load(int drive, char *fn)
                 } else {
                     /* Literal block. */
                     literal = (uint8_t *) malloc(track_bytes);
-                    (void) !fread(literal, 1, track_bytes, dev->f);
+                    (void) !fread(literal, 1, track_bytes, dev->fp);
                     memcpy(bpos, literal, track_bytes - fdf_suppress_final_byte);
                     free(literal);
                     bpos += (track_bytes - fdf_suppress_final_byte);
                     track_bytes = 0;
                 }
 
-                if (feof(dev->f))
+                if (feof(dev->fp))
                     break;
             }
 
@@ -892,48 +892,48 @@ img_load(int drive, char *fn)
         if (((first_byte == 'C') && (second_byte == 'Q')) || ((first_byte == 'c') && (second_byte == 'q'))) {
             img_log("img_load(): File is a CopyQM image...\n");
             fwriteprot[drive] = writeprot[drive] = 1;
-            fclose(dev->f);
-            dev->f = plat_fopen(fn, "rb");
+            fclose(dev->fp);
+            dev->fp = plat_fopen(fn, "rb");
 
-            fseek(dev->f, 0x03, SEEK_SET);
-            (void) !fread(&bpb_bps, 1, 2, dev->f);
+            fseek(dev->fp, 0x03, SEEK_SET);
+            (void) !fread(&bpb_bps, 1, 2, dev->fp);
 #if 0
-            fseek(dev->f, 0x0B, SEEK_SET);
-            (void) !fread(&bpb_total, 1, 2, dev->f);
+            fseek(dev->fp, 0x0B, SEEK_SET);
+            (void) !fread(&bpb_total, 1, 2, dev->fp);
 #endif
-            fseek(dev->f, 0x10, SEEK_SET);
-            bpb_sectors = fgetc(dev->f);
-            fseek(dev->f, 0x12, SEEK_SET);
-            bpb_sides = fgetc(dev->f);
-            fseek(dev->f, 0x5B, SEEK_SET);
-            dev->tracks = fgetc(dev->f);
+            fseek(dev->fp, 0x10, SEEK_SET);
+            bpb_sectors = fgetc(dev->fp);
+            fseek(dev->fp, 0x12, SEEK_SET);
+            bpb_sides = fgetc(dev->fp);
+            fseek(dev->fp, 0x5B, SEEK_SET);
+            dev->tracks = fgetc(dev->fp);
 
             bpb_total = ((uint16_t) bpb_sectors) * ((uint16_t) bpb_sides) * dev->tracks;
 
-            fseek(dev->f, 0x74, SEEK_SET);
-            dev->interleave = fgetc(dev->f);
-            fseek(dev->f, 0x76, SEEK_SET);
-            dev->skew = fgetc(dev->f);
+            fseek(dev->fp, 0x74, SEEK_SET);
+            dev->interleave = fgetc(dev->fp);
+            fseek(dev->fp, 0x76, SEEK_SET);
+            dev->skew = fgetc(dev->fp);
 
             dev->disk_data = (uint8_t *) malloc(((uint32_t) bpb_total) * ((uint32_t) bpb_bps));
             memset(dev->disk_data, 0xf6, ((uint32_t) bpb_total) * ((uint32_t) bpb_bps));
 
-            fseek(dev->f, 0x6F, SEEK_SET);
-            (void) !fread(&comment_len, 1, 2, dev->f);
+            fseek(dev->fp, 0x6F, SEEK_SET);
+            (void) !fread(&comment_len, 1, 2, dev->fp);
 
-            fseek(dev->f, -1, SEEK_END);
-            size = ftell(dev->f) + 1;
+            fseek(dev->fp, -1, SEEK_END);
+            size = ftell(dev->fp) + 1;
 
-            fseek(dev->f, 133 + comment_len, SEEK_SET);
+            fseek(dev->fp, 133 + comment_len, SEEK_SET);
 
             cur_pos = 0;
 
-            while (!feof(dev->f)) {
-                (void) !fread(&block_len, 1, 2, dev->f);
+            while (!feof(dev->fp)) {
+                (void) !fread(&block_len, 1, 2, dev->fp);
 
-                if (!feof(dev->f)) {
+                if (!feof(dev->fp)) {
                     if (block_len < 0) {
-                        rep_byte  = fgetc(dev->f);
+                        rep_byte  = fgetc(dev->fp);
                         block_len = -block_len;
                         if ((cur_pos + block_len) > ((uint32_t) bpb_total) * ((uint32_t) bpb_bps)) {
                             block_len = ((uint32_t) bpb_total) * ((uint32_t) bpb_bps) - cur_pos;
@@ -946,10 +946,10 @@ img_load(int drive, char *fn)
                     } else if (block_len > 0) {
                         if ((cur_pos + block_len) > ((uint32_t) bpb_total) * ((uint32_t) bpb_bps)) {
                             block_len = ((uint32_t) bpb_total) * ((uint32_t) bpb_bps) - cur_pos;
-                            (void) !fread(dev->disk_data + cur_pos, 1, block_len, dev->f);
+                            (void) !fread(dev->disk_data + cur_pos, 1, block_len, dev->fp);
                             break;
                         } else {
-                            (void) !fread(dev->disk_data + cur_pos, 1, block_len, dev->f);
+                            (void) !fread(dev->disk_data + cur_pos, 1, block_len, dev->fp);
                             cur_pos += block_len;
                         }
                     }
@@ -969,22 +969,22 @@ img_load(int drive, char *fn)
                 fwriteprot[drive] = writeprot[drive] = 1;
             } else
                 img_log("img_load(): File is a raw image...\n");
-            fseek(dev->f, dev->base + 0x0B, SEEK_SET);
-            (void) !fread(&bpb_bps, 1, 2, dev->f);
-            fseek(dev->f, dev->base + 0x13, SEEK_SET);
-            (void) !fread(&bpb_total, 1, 2, dev->f);
-            fseek(dev->f, dev->base + 0x15, SEEK_SET);
-            bpb_mid = fgetc(dev->f);
-            fseek(dev->f, dev->base + 0x18, SEEK_SET);
-            bpb_sectors = fgetc(dev->f);
-            fseek(dev->f, dev->base + 0x1A, SEEK_SET);
-            bpb_sides = fgetc(dev->f);
+            fseek(dev->fp, dev->base + 0x0B, SEEK_SET);
+            (void) !fread(&bpb_bps, 1, 2, dev->fp);
+            fseek(dev->fp, dev->base + 0x13, SEEK_SET);
+            (void) !fread(&bpb_total, 1, 2, dev->fp);
+            fseek(dev->fp, dev->base + 0x15, SEEK_SET);
+            bpb_mid = fgetc(dev->fp);
+            fseek(dev->fp, dev->base + 0x18, SEEK_SET);
+            bpb_sectors = fgetc(dev->fp);
+            fseek(dev->fp, dev->base + 0x1A, SEEK_SET);
+            bpb_sides = fgetc(dev->fp);
 
             cqm = 0;
         }
 
-        fseek(dev->f, -1, SEEK_END);
-        size = ftell(dev->f) + 1;
+        fseek(dev->fp, -1, SEEK_END);
+        size = ftell(dev->fp) + 1;
         if (ddi)
             size -= 0x2400;
 
@@ -1125,7 +1125,7 @@ jump_if_fdf:
             dev->tracks  = 86;
         } else {
             img_log("Image is bigger than can fit on an ED floppy, ejecting...\n");
-            fclose(dev->f);
+            fclose(dev->fp);
             free(dev);
             memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
             return;
@@ -1138,9 +1138,9 @@ jump_if_fdf:
         /* The BPB readings appear to be valid, so let's set the values. */
         if (fdi) {
             /* The image is a Japanese FDI, therefore we read the number of tracks from the header. */
-            if (fseek(dev->f, 0x1C, SEEK_SET) == -1)
+            if (fseek(dev->fp, 0x1C, SEEK_SET) == -1)
                 fatal("Japanese FDI: Failed when seeking to 0x1C\n");
-            (void) !fread(&(dev->tracks), 1, 4, dev->f);
+            (void) !fread(&(dev->tracks), 1, 4, dev->fp);
         } else {
             if (!cqm && !fdf) {
                 /* Number of tracks = number of total sectors divided by sides times sectors per track. */
@@ -1182,7 +1182,7 @@ jump_if_fdf:
 
     if (temp_rate == 0xFF) {
         img_log("Image is bigger than can fit on an ED floppy, ejecting...\n");
-        fclose(dev->f);
+        fclose(dev->fp);
         free(dev);
         memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
         return;
@@ -1199,7 +1199,7 @@ jump_if_fdf:
     }
     if (!dev->gap3_size) {
         img_log("ERROR: Floppy image of unknown format was inserted into drive %c:!\n", drive + 0x41);
-        fclose(dev->f);
+        fclose(dev->fp);
         free(dev);
         memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
         return;
@@ -1259,9 +1259,9 @@ img_close(int drive)
 
     d86f_unregister(drive);
 
-    if (dev->f != NULL) {
-        fclose(dev->f);
-        dev->f = NULL;
+    if (dev->fp != NULL) {
+        fclose(dev->fp);
+        dev->fp = NULL;
     }
 
     if (dev->disk_data != NULL)

src/floppy/fdd_json.c

@@ -62,7 +62,7 @@
 #define NSIDES   2
 #define NSECTORS 256
 
-typedef struct {
+typedef struct sector_t {
     uint8_t  track;  /* ID: track number */
     uint8_t  side;   /*     side number */
     uint8_t  sector; /*     sector number 1.. */
@@ -70,8 +70,8 @@ typedef struct {
     uint8_t *data;   /* allocated data for it */
 } sector_t;
 
-typedef struct {
-    FILE *f;
+typedef struct json_t {
+    FILE *fp;
 
     /* Geometry. */
     uint8_t tracks;               /* number of tracks */
@@ -215,7 +215,7 @@ load_image(json_t *dev)
     int   level;
     char *ptr;
 
-    if (dev->f == NULL) {
+    if (dev->fp == NULL) {
         json_log("JSON: no file loaded!\n");
         return 0;
     }
@@ -232,8 +232,8 @@ load_image(json_t *dev)
     level = state = 0;
     while (state >= 0) {
         /* Get a character from the input. */
-        c = fgetc(dev->f);
-        if ((c == EOF) || ferror(dev->f)) {
+        c = fgetc(dev->fp);
+        if ((c == EOF) || ferror(dev->fp)) {
             state = -1;
             break;
         }
@@ -372,6 +372,9 @@ load_image(json_t *dev)
                 }
                 dev->track++;
                 break;
+
+            default:
+                break;
         }
     }
 
@@ -396,7 +399,7 @@ json_seek(int drive, int track)
     int     rsec;
     int     asec;
 
-    if (dev->f == NULL) {
+    if (dev->fp == NULL) {
         json_log("JSON: seek: no file loaded!\n");
         return;
     }
@@ -464,7 +467,7 @@ json_seek(int drive, int track)
 static uint16_t
 disk_flags(int drive)
 {
-    json_t *dev = images[drive];
+    const json_t *dev = images[drive];
 
     return (dev->disk_flags);
 }
@@ -472,7 +475,7 @@ disk_flags(int drive)
 static uint16_t
 track_flags(int drive)
 {
-    json_t *dev = images[drive];
+    const json_t *dev = images[drive];
 
     return (dev->track_flags);
 }
@@ -502,8 +505,8 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
 static uint8_t
 poll_read_data(int drive, int side, uint16_t pos)
 {
-    json_t *dev = images[drive];
-    uint8_t sec = dev->sector[side];
+    const json_t *dev = images[drive];
+    uint8_t       sec = dev->sector[side];
 
     return (dev->sects[dev->track][side][sec].data[pos]);
 }
@@ -517,10 +520,10 @@ json_init(void)
 void
 json_load(int drive, char *fn)
 {
-    double    bit_rate;
-    int       temp_rate;
-    sector_t *sec;
-    json_t   *dev;
+    double          bit_rate;
+    int             temp_rate;
+    const sector_t *sec;
+    json_t         *dev;
 
     /* Just in case- remove ourselves from 86F. */
     d86f_unregister(drive);
@@ -530,8 +533,8 @@ json_load(int drive, char *fn)
     memset(dev, 0x00, sizeof(json_t));
 
     /* Open the image file. */
-    dev->f = plat_fopen(fn, "rb");
-    if (dev->f == NULL) {
+    dev->fp = plat_fopen(fn, "rb");
+    if (dev->fp == NULL) {
         free(dev);
         memset(fn, 0x00, sizeof(char));
         return;
@@ -546,7 +549,7 @@ json_load(int drive, char *fn)
     /* Load all sectors from the image file. */
     if (!load_image(dev)) {
         json_log("JSON: failed to initialize\n");
-        (void) fclose(dev->f);
+        (void) fclose(dev->fp);
         free(dev);
         images[drive] = NULL;
         memset(fn, 0x00, sizeof(char));
@@ -608,8 +611,8 @@ json_load(int drive, char *fn)
 
     if (temp_rate == 0xff) {
         json_log("JSON: invalid image (temp_rate=0xff)\n");
-        (void) fclose(dev->f);
-        dev->f = NULL;
+        (void) fclose(dev->fp);
+        dev->fp = NULL;
         free(dev);
         images[drive] = NULL;
         memset(fn, 0x00, sizeof(char));
@@ -630,8 +633,8 @@ json_load(int drive, char *fn)
     if (!dev->gap3_len) {
         json_log("JSON: image of unknown format was inserted into drive %c:!\n",
                  'C' + drive);
-        (void) fclose(dev->f);
-        dev->f = NULL;
+        (void) fclose(dev->fp);
+        dev->fp = NULL;
         free(dev);
         images[drive] = NULL;
         memset(fn, 0x00, sizeof(char));
@@ -692,8 +695,8 @@ json_close(int drive)
         }
     }
 
-    if (dev->f != NULL)
-        (void) fclose(dev->f);
+    if (dev->fp != NULL)
+        (void) fclose(dev->fp);
 
     /* Release the memory. */
     free(dev);

src/floppy/fdd_mfm.c

@@ -32,7 +32,7 @@
 #include <86box/fdc.h>
 
 #pragma pack(push, 1)
-typedef struct {
+typedef struct mfm_header_t {
     uint8_t hdr_name[7];
 
     uint16_t tracks_no;
@@ -45,14 +45,14 @@ typedef struct {
     uint32_t track_list_offset;
 } mfm_header_t;
 
-typedef struct {
+typedef struct mfm_track_t {
     uint16_t track_no;
     uint8_t  side_no;
     uint32_t track_size;
     uint32_t track_offset;
 } mfm_track_t;
 
-typedef struct {
+typedef struct mfm_adv_track_t {
     uint16_t track_no;
     uint8_t  side_no;
     uint16_t rpm;
@@ -62,8 +62,8 @@ typedef struct {
 } mfm_adv_track_t;
 #pragma pack(pop)
 
-typedef struct {
-    FILE *f;
+typedef struct mfm_t {
+    FILE *fp;
 
     mfm_header_t     hdr;
     mfm_track_t     *tracks;
@@ -105,8 +105,8 @@ mfm_log(const char *fmt, ...)
 static int
 get_track_index(int drive, int side, int track)
 {
-    mfm_t *dev = mfm[drive];
-    int    ret = -1;
+    const mfm_t *dev = mfm[drive];
+    int          ret = -1;
 
     for (int i = 0; i < dev->total_tracks; i++) {
         if ((dev->tracks[i].track_no == track) && (dev->tracks[i].side_no == side)) {
@@ -121,8 +121,8 @@ get_track_index(int drive, int side, int track)
 static int
 get_adv_track_index(int drive, int side, int track)
 {
-    mfm_t *dev = mfm[drive];
-    int    ret = -1;
+    const mfm_t *dev = mfm[drive];
+    int          ret = -1;
 
     for (int i = 0; i < dev->total_tracks; i++) {
         if ((dev->adv_tracks[i].track_no == track) && (dev->adv_tracks[i].side_no == side)) {
@@ -137,9 +137,9 @@ get_adv_track_index(int drive, int side, int track)
 static void
 get_adv_track_bitrate(int drive, int side, int track, int *br, int *rpm)
 {
-    mfm_t *dev = mfm[drive];
-    int    track_index;
-    double dbr;
+    const mfm_t *dev = mfm[drive];
+    int          track_index;
+    double       dbr;
 
     track_index = get_adv_track_index(drive, side, track);
 
@@ -197,7 +197,7 @@ set_disk_flags(int drive)
 static uint16_t
 disk_flags(int drive)
 {
-    mfm_t *dev = mfm[drive];
+    const mfm_t *dev = mfm[drive];
 
     return dev->disk_flags;
 }
@@ -257,8 +257,8 @@ set_side_flags(int drive, int side)
 static uint16_t
 side_flags(int drive)
 {
-    mfm_t *dev = mfm[drive];
-    int    side;
+    const mfm_t *dev = mfm[drive];
+    int          side;
 
     side = fdd_get_head(drive);
 
@@ -268,11 +268,11 @@ side_flags(int drive)
 static uint32_t
 get_raw_size(int drive, int side)
 {
-    mfm_t *dev = mfm[drive];
-    int    track_index;
-    int    is_300_rpm;
-    int    br = 250;
-    int    rpm = 300;
+    const mfm_t *dev = mfm[drive];
+    int          track_index;
+    int          is_300_rpm;
+    int          br = 250;
+    int          rpm = 300;
 
     if (dev->hdr.if_type & 0x80) {
         track_index = get_adv_track_index(drive, side, dev->cur_track);
@@ -345,12 +345,12 @@ mfm_read_side(int drive, int side)
         memset(dev->track_data[side], 0x00, track_bytes);
     else {
         if (dev->hdr.if_type & 0x80)
-            ret = fseek(dev->f, dev->adv_tracks[track_index].track_offset, SEEK_SET);
+            ret = fseek(dev->fp, dev->adv_tracks[track_index].track_offset, SEEK_SET);
         else
-            ret = fseek(dev->f, dev->tracks[track_index].track_offset, SEEK_SET);
+            ret = fseek(dev->fp, dev->tracks[track_index].track_offset, SEEK_SET);
         if (ret == -1)
             fatal("mfm_read_side(): Error seeking to the beginning of the file\n");
-        if (fread(dev->track_data[side], 1, track_bytes, dev->f) != track_bytes)
+        if (fread(dev->track_data[side], 1, track_bytes, dev->fp) != track_bytes)
             fatal("mfm_read_side(): Error reading track bytes\n");
     }
 
@@ -373,7 +373,7 @@ mfm_seek(int drive, int track)
     dev->cur_track = track;
     d86f_set_cur_track(drive, track);
 
-    if (dev->f == NULL)
+    if (dev->fp == NULL)
         return;
 
     if (track < 0)
@@ -399,8 +399,8 @@ mfm_load(int drive, char *fn)
     dev = (mfm_t *) malloc(sizeof(mfm_t));
     memset(dev, 0x00, sizeof(mfm_t));
 
-    dev->f = plat_fopen(fn, "rb");
-    if (dev->f == NULL) {
+    dev->fp = plat_fopen(fn, "rb");
+    if (dev->fp == NULL) {
         free(dev);
         memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
         return;
@@ -410,7 +410,7 @@ mfm_load(int drive, char *fn)
 
     /* Read the header. */
     size = sizeof(mfm_header_t);
-    if (fread(&dev->hdr, 1, size, dev->f) != size)
+    if (fread(&dev->hdr, 1, size, dev->fp) != size)
         fatal("mfm_load(): Error reading header\n");
 
     /* Calculate tracks * sides, allocate the tracks array, and read it. */
@@ -418,12 +418,12 @@ mfm_load(int drive, char *fn)
     if (dev->hdr.if_type & 0x80) {
         dev->adv_tracks = (mfm_adv_track_t *) malloc(dev->total_tracks * sizeof(mfm_adv_track_t));
         size            = dev->total_tracks * sizeof(mfm_adv_track_t);
-        if (fread(dev->adv_tracks, 1, size, dev->f) != size)
+        if (fread(dev->adv_tracks, 1, size, dev->fp) != size)
             fatal("mfm_load(): Error reading advanced tracks\n");
     } else {
         dev->tracks = (mfm_track_t *) malloc(dev->total_tracks * sizeof(mfm_track_t));
         size        = dev->total_tracks * sizeof(mfm_track_t);
-        if (fread(dev->tracks, 1, size, dev->f) != size)
+        if (fread(dev->tracks, 1, size, dev->fp) != size)
             fatal("mfm_load(): Error reading tracks\n");
     }
 
@@ -504,8 +504,8 @@ mfm_close(int drive)
     if (dev->adv_tracks)
         free(dev->adv_tracks);
 
-    if (dev->f)
-        fclose(dev->f);
+    if (dev->fp)
+        fclose(dev->fp);
 
     /* Release the memory. */
     free(dev);

src/floppy/fdd_td0.c

@@ -60,7 +60,7 @@
 /* update when cumulative frequency */
 /* reaches to this value */
 
-typedef struct {
+typedef struct tdlzhuf_t {
     uint16_t r;
     uint16_t bufcnt;      /* string buffer */
     uint16_t bufndx;      /* string buffer */
@@ -72,7 +72,7 @@ typedef struct {
     uint8_t inbuf[BUFSZ]; /* input buffer */
 } tdlzhuf;
 
-typedef struct {
+typedef struct td0dsk_t {
     FILE *fdd_file;
     off_t fdd_file_offset;
 
@@ -93,7 +93,7 @@ typedef struct {
     uint8_t  getlen;
 } td0dsk_t;
 
-typedef struct {
+typedef struct td0_sector_t {
     uint8_t  track;
     uint8_t  head;
     uint8_t  sector;
@@ -103,8 +103,8 @@ typedef struct {
     uint8_t *data;
 } td0_sector_t;
 
-typedef struct {
-    FILE *f;
+typedef struct td0_t {
+    FILE *fp;
 
     int          tracks;
     int          track_width;
@@ -227,9 +227,9 @@ fdd_image_read(int drive, char *buffer, uint32_t offset, uint32_t len)
 {
     td0_t *dev = td0[drive];
 
-    if (fseek(dev->f, offset, SEEK_SET) == -1)
+    if (fseek(dev->fp, offset, SEEK_SET) == -1)
         fatal("fdd_image_read(): Error seeking to the beginning of the file\n");
-    if (fread(buffer, 1, len, dev->f) != len)
+    if (fread(buffer, 1, len, dev->fp) != len)
         fatal("fdd_image_read(): Error reading data\n");
 }
 
@@ -595,45 +595,45 @@ get_raw_tsize(int side_flags, int slower_rpm)
 static int
 td0_initialize(int drive)
 {
-    td0_t   *dev = td0[drive];
-    uint8_t  header[12];
-    int      fm;
-    int      head;
-    int      track;
-    int      track_count = 0;
-    int      head_count  = 0;
-    int      track_spt;
-    int      track_spt_adjusted;
-    int      offset    = 0;
-    int      density   = 0;
-    int      temp_rate = 0;
-    uint32_t file_size;
-    uint16_t len;
-    uint16_t rep;
-    td0dsk_t disk_decode;
-    uint8_t *hs;
-    uint16_t size;
-    uint8_t *dbuf         = dev->processed_buf;
-    uint32_t total_size   = 0;
-    uint32_t id_field     = 0;
-    uint32_t pre_sector   = 0;
-    int32_t  track_size   = 0;
-    int32_t  raw_tsize    = 0;
-    uint32_t minimum_gap3 = 0;
-    uint32_t minimum_gap4 = 0;
-    int      i;
-    int      j;
-    int      k;
-    int      size_diff;
-    int      gap_sum;
+    td0_t         *dev = td0[drive];
+    uint8_t        header[12];
+    int            fm;
+    int            head;
+    int            track;
+    int            track_count = 0;
+    int            head_count  = 0;
+    int            track_spt;
+    int            track_spt_adjusted;
+    int            offset    = 0;
+    int            density   = 0;
+    int            temp_rate = 0;
+    uint32_t       file_size;
+    uint16_t       len;
+    uint16_t       rep;
+    td0dsk_t       disk_decode;
+    const uint8_t *hs;
+    uint16_t       size;
+    uint8_t       *dbuf         = dev->processed_buf;
+    uint32_t       total_size   = 0;
+    uint32_t       id_field     = 0;
+    uint32_t       pre_sector   = 0;
+    int32_t        track_size   = 0;
+    int32_t        raw_tsize    = 0;
+    uint32_t       minimum_gap3 = 0;
+    uint32_t       minimum_gap4 = 0;
+    int            i;
+    int            j;
+    int            k;
+    int            size_diff;
+    int            gap_sum;
 
-    if (dev->f == NULL) {
+    if (dev->fp == NULL) {
         td0_log("TD0: Attempted to initialize without loading a file first\n");
         return 0;
     }
 
-    fseek(dev->f, 0, SEEK_END);
-    file_size = ftell(dev->f);
+    fseek(dev->fp, 0, SEEK_END);
+    file_size = ftell(dev->fp);
 
     if (file_size < 12) {
         td0_log("TD0: File is too small to even contain the header\n");
@@ -645,21 +645,21 @@ td0_initialize(int drive)
         return 0;
     }
 
-    fseek(dev->f, 0, SEEK_SET);
-    (void) !fread(header, 1, 12, dev->f);
+    fseek(dev->fp, 0, SEEK_SET);
+    (void) !fread(header, 1, 12, dev->fp);
     head_count = header[9];
 
     if (header[0] == 't') {
         td0_log("TD0: File is compressed\n");
-        disk_decode.fdd_file = dev->f;
+        disk_decode.fdd_file = dev->fp;
         state_init_Decode(&disk_decode);
         disk_decode.fdd_file_offset = 12;
         state_Decode(&disk_decode, dev->imagebuf, TD0_MAX_BUFSZ);
     } else {
         td0_log("TD0: File is uncompressed\n");
-        if (fseek(dev->f, 12, SEEK_SET) == -1)
+        if (fseek(dev->fp, 12, SEEK_SET) == -1)
             fatal("td0_initialize(): Error seeking to offet 12\n");
-        if (fread(dev->imagebuf, 1, file_size - 12, dev->f) != (file_size - 12))
+        if (fread(dev->imagebuf, 1, file_size - 12, dev->fp) != (file_size - 12))
             fatal("td0_initialize(): Error reading image buffer\n");
     }
 
@@ -710,6 +710,9 @@ td0_initialize(int drive)
             dev->default_track_flags = (density == 1) ? 0x00 : ((density == 2) ? 0x03 : 0x02);
             dev->max_sector_size     = (density == 1) ? 6 : ((density == 2) ? 7 : 5); /* 16384, 8192, or 4096 bytes. */
             break;
+
+        default:
+            break;
     }
 
     dev->disk_flags = header[5] & 0x06;
@@ -886,7 +889,7 @@ td0_initialize(int drive)
 static uint16_t
 disk_flags(int drive)
 {
-    td0_t *dev = td0[drive];
+    const td0_t *dev = td0[drive];
 
     return (dev->disk_flags);
 }
@@ -894,9 +897,9 @@ disk_flags(int drive)
 static uint16_t
 side_flags(int drive)
 {
-    td0_t   *dev    = td0[drive];
-    int      side   = 0;
-    uint16_t sflags = 0;
+    const td0_t   *dev    = td0[drive];
+    int            side   = 0;
+    uint16_t       sflags = 0;
 
     side   = fdd_get_head(drive);
     sflags = dev->current_side_flags[side];
@@ -923,7 +926,7 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
 static uint8_t
 poll_read_data(int drive, int side, uint16_t pos)
 {
-    td0_t *dev = td0[drive];
+    const td0_t *dev = td0[drive];
 
     return (dev->sects[dev->track][side][dev->current_sector_index[side]].data[pos]);
 }
@@ -1064,7 +1067,7 @@ td0_seek(int drive, int track)
     int     fm;
     int     sector_adjusted;
 
-    if (dev->f == NULL)
+    if (dev->fp == NULL)
         return;
 
     if (!dev->track_width && fdd_doublestep_40(drive))
@@ -1182,8 +1185,8 @@ td0_abort(int drive)
         free(dev->imagebuf);
     if (dev->processed_buf)
         free(dev->processed_buf);
-    if (dev->f)
-        fclose(dev->f);
+    if (dev->fp)
+        fclose(dev->fp);
     memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
     free(dev);
     td0[drive] = NULL;
@@ -1203,8 +1206,8 @@ td0_load(int drive, char *fn)
     memset(dev, 0x00, sizeof(td0_t));
     td0[drive] = dev;
 
-    dev->f = plat_fopen(fn, "rb");
-    if (dev->f == NULL) {
+    dev->fp = plat_fopen(fn, "rb");
+    if (dev->fp == NULL) {
         memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
         return;
     }
@@ -1285,8 +1288,8 @@ td0_close(int drive)
             memset(dev->sects[i][j], 0, sizeof(td0_sector_t));
     }
 
-    if (dev->f != NULL)
-        fclose(dev->f);
+    if (dev->fp != NULL)
+        fclose(dev->fp);
 
     /* Release resources. */
     free(dev);

src/floppy/fdi2raw.c

@@ -36,7 +36,9 @@
 #include <fdi2raw.h>
 #include <86box/plat_unused.h>
 
+#ifdef DEBUG
 #undef DEBUG
+#endif
 #define VERBOSE
 #undef VERBOSE
 
@@ -96,24 +98,24 @@ static int fdi_allocated;
 
 #ifdef DEBUG
 static void
-fdi_free(void *p)
+fdi_free(void *priv)
 {
     int size;
-    if (!p)
+    if (!priv)
         return;
-    size = ((int *) p)[-1];
+    size = ((int *) priv)[-1];
     fdi_allocated -= size;
     write_log("%d freed (%d)\n", size, fdi_allocated);
-    free((int *) p - 1);
+    free((int *) priv - 1);
 }
 static void *
 fdi_malloc(int size)
 {
-    void *p        = xmalloc(size + sizeof(int));
-    ((int *) p)[0] = size;
+    void *priv       = xmalloc(size + sizeof(int));
+    ((int *) prv)[0] = size;
     fdi_allocated += size;
     write_log("%d allocated (%d)\n", size, fdi_allocated);
-    return (int *) p + 1;
+    return (int *) priv + 1;
 }
 #else
 #    define fdi_free   free
@@ -1290,6 +1292,9 @@ track_atari_st(struct fdi *fdi, int max_sector)
         case 10:
             gap3 = 24;
             break;
+
+        default:
+            break;
     }
     s15(fdi);
     for (int i = 0; i < max_sector; i++) {
@@ -1915,9 +1920,9 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_
 static void
 fdi2_celltiming(FDI *fdi, uint32_t totalavg, int bitoffset, uint16_t *out)
 {
-    uint16_t *pt2;
-    uint16_t *pt;
-    double    avg_bit_len;
+    const uint16_t *pt2;
+    uint16_t       *pt;
+    double          avg_bit_len;
 
     avg_bit_len = (double) totalavg / (double) bitoffset;
     pt2         = fdi->track_dst_buffer_timing;
@@ -1935,27 +1940,27 @@ fdi2_celltiming(FDI *fdi, uint32_t totalavg, int bitoffset, uint16_t *out)
 static int
 decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
 {
-    uint8_t  *p1;
-    uint32_t *p2;
-    uint32_t *avgp;
-    uint32_t *minp = 0;
-    uint32_t *maxp = 0;
-    uint8_t  *idxp = 0;
-    uint32_t  maxidx;
-    uint32_t  totalavg;
-    uint32_t  weakbits;
-    int       i;
-    int       j;
-    int       len;
-    int       pulses;
-    int       indexoffset;
-    int       avg_free;
-    int       min_free = 0;
-    int       max_free = 0;
-    int       idx_free;
-    int       idx_off1 = 0;
-    int       idx_off2 = 0;
-    int       idx_off3 = 0;
+    uint8_t        *p1;
+    const uint32_t *p2;
+    uint32_t       *avgp;
+    uint32_t       *minp = 0;
+    uint32_t       *maxp = 0;
+    uint8_t        *idxp = 0;
+    uint32_t        maxidx;
+    uint32_t        totalavg;
+    uint32_t        weakbits;
+    int             j;
+    int             k;
+    int             len;
+    int             pulses;
+    int             indexoffset;
+    int             avg_free;
+    int             min_free = 0;
+    int             max_free = 0;
+    int             idx_free;
+    int             idx_off1 = 0;
+    int             idx_off2 = 0;
+    int             idx_off3 = 0;
 
     p1     = fdi->track_src;
     pulses = get_u32(p1);
@@ -1974,7 +1979,7 @@ decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
         maxp = (uint32_t *) fdi_decompress(pulses, p1 + 6, p1 + len, &max_free);
         len += get_u24(p1 + 6) & 0x3fffff;
         /* Computes the real min and max values */
-        for (i = 0; i < pulses; i++) {
+        for (int i = 0; i < pulses; i++) {
             maxp[i] = avgp[i] + minp[i] - maxp[i];
             minp[i] = avgp[i] - minp[i];
         }
@@ -2000,7 +2005,7 @@ decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
     } else {
         idxp     = fdi_malloc(pulses * 2);
         idx_free = 1;
-        for (i = 0; i < pulses; i++) {
+        for (int i = 0; i < pulses; i++) {
             idxp[i * 2 + 0] = 2;
             idxp[i * 2 + 1] = 0;
         }
@@ -2011,43 +2016,43 @@ decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
     maxidx      = 0;
     indexoffset = 0;
     p1          = idxp;
-    for (i = 0; i < pulses; i++) {
+    for (int i = 0; i < pulses; i++) {
         if ((uint32_t) p1[idx_off1] + (uint32_t) p1[idx_off2] > maxidx)
             maxidx = p1[idx_off1] + p1[idx_off2];
         p1 += idx_off3;
     }
     p1 = idxp;
-    for (i = 0; (i < pulses) && (p1[idx_off2] != 0); i++) /* falling edge, replace with idx_off1 for rising edge */
+    for (k = 0; (k < pulses) && (p1[idx_off2] != 0); k++) /* falling edge, replace with idx_off1 for rising edge */
         p1 += idx_off3;
-    if (i < pulses) {
-        j = i;
+    if (k < pulses) {
+        j = k;
         do {
-            i++;
+            k++;
             p1 += idx_off3;
-            if (i >= pulses) {
-                i  = 0;
+            if (k >= pulses) {
+                k  = 0;
                 p1 = idxp;
             }
-        } while ((i != j) && (p1[idx_off2] == 0)); /* falling edge, replace with idx_off1 for rising edge */
-        if (i != j)                                /* index pulse detected */
+        } while ((k != j) && (p1[idx_off2] == 0)); /* falling edge, replace with idx_off1 for rising edge */
+        if (k != j)                                /* index pulse detected */
         {
-            while ((i != j) && (p1[idx_off1] > p1[idx_off2])) { /* falling edge, replace with "<" for rising edge */
-                i++;
+            while ((k != j) && (p1[idx_off1] > p1[idx_off2])) { /* falling edge, replace with "<" for rising edge */
+                k++;
                 p1 += idx_off3;
-                if (i >= pulses) {
-                    i  = 0;
+                if (k >= pulses) {
+                    k  = 0;
                     p1 = idxp;
                 }
             }
-            if (i != j)
-                indexoffset = i; /* index position detected */
+            if (k != j)
+                indexoffset = k; /* index position detected */
         }
     }
     p1       = idxp;
     p2       = avgp;
     totalavg = 0;
     weakbits = 0;
-    for (i = 0; i < pulses; i++) {
+    for (int i = 0; i < pulses; i++) {
         uint32_t sum = p1[idx_off1] + p1[idx_off2];
         if (sum >= maxidx) {
             totalavg += *p2;
@@ -2254,7 +2259,7 @@ fdi2raw_loadrevolution_2(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int
     *tracklength = len;
 
     for (int i = 0; i < (len + 15) / (2 * 8); i++) {
-        uint8_t *data = fdi->track_dst_buffer + i * 2;
+        const uint8_t *data = fdi->track_dst_buffer + i * 2;
         *mfmbuf++     = 256 * *data + *(data + 1);
     }
     fdi2_celltiming(fdi, cache->totalavg, len, tracktiming);
@@ -2273,7 +2278,7 @@ fdi2raw_loadrevolution(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int tr
 int
 fdi2raw_loadtrack(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track, int *tracklength, int *indexoffsetp, int *multirev, int mfm)
 {
-    uint8_t          *p;
+    const uint8_t    *p;
     int               outlen;
     struct fdi_cache *cache = &fdi->cache[track];
 
@@ -2347,8 +2352,8 @@ fdi2raw_loadtrack(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track,
             return fdi2raw_loadrevolution_2(fdi, mfmbuf, tracktiming, track, tracklength, indexoffsetp, multirev, mfm);
         *tracklength = fdi->out;
         for (int i = 0; i < ((*tracklength) + 15) / (2 * 8); i++) {
-            uint8_t *data = fdi->track_dst_buffer + i * 2;
-            *mfmbuf++     = 256 * *data + *(data + 1);
+            const uint8_t *data = fdi->track_dst_buffer + i * 2;
+            *mfmbuf++           = 256 * *data + *(data + 1);
         }
     }
     return outlen;

src/gdbstub.c

@@ -120,13 +120,20 @@ typedef struct _gdbstub_client_ {
     int                socket;
     struct sockaddr_in addr;
 
-    char packet[16384], response[16384];
-    int  has_packet : 1, first_packet_received : 1, ida_mode : 1, waiting_stop : 1,
-        packet_pos, response_pos;
+    char    packet[16384], response[16384];
+    uint8_t has_packet : 1;
+    uint8_t first_packet_received : 1;
+    uint8_t ida_mode : 1;
+    uint8_t waiting_stop : 1;
+    int     packet_pos;
+    int     response_pos;
 
-    event_t *processed_event, *response_event;
+    event_t *processed_event;
+    event_t *response_event;
 
-    uint16_t last_io_base, last_io_len, last_io_value;
+    uint16_t last_io_base;
+    uint16_t last_io_len;
+    uint16_t last_io_value;
 
     struct _gdbstub_client_ *next;
 } gdbstub_client_t;
@@ -339,7 +346,8 @@ static gdbstub_breakpoint_t *first_rwatch = NULL;
 static gdbstub_breakpoint_t *first_wwatch = NULL;
 static gdbstub_breakpoint_t *first_awatch = NULL;
 
-int      gdbstub_step = 0, gdbstub_next_asap = 0;
+int      gdbstub_step = 0;
+int      gdbstub_next_asap = 0;
 uint64_t gdbstub_watch_pages[(((uint32_t) -1) >> (MEM_GRANULARITY_BITS + 6)) + 1];
 
 static void
@@ -461,6 +469,9 @@ gdbstub_num_decode(char *p, int *dest, int mode)
                 else
                     return 0;
                 break;
+
+            default:
+                break;
         }
         p++;
     }
@@ -476,8 +487,8 @@ gdbstub_num_decode(char *p, int *dest, int mode)
 static int
 gdbstub_client_read_word(gdbstub_client_t *client, int *dest)
 {
-    char *p = &client->packet[client->packet_pos];
-    char *q = p;
+    const char *p = &client->packet[client->packet_pos];
+    const char *q = p;
     while (((*p >= '0') && (*p <= '9')) || ((*p >= 'A') && (*p <= 'F')) || ((*p >= 'a') && (*p <= 'f')))
         *dest = ((*dest) << 4) | gdbstub_hex_decode(*p++);
     return p - q;
@@ -1491,7 +1502,6 @@ gdbstub_client_thread(void *priv)
     gdbstub_client_t *client = (gdbstub_client_t *) priv;
     uint8_t           buf[256];
     ssize_t           bytes_read;
-    int               i;
 
     gdbstub_log("GDB Stub: New connection from %s:%d\n", inet_ntoa(client->addr.sin_addr), client->addr.sin_port);
 
@@ -1500,7 +1510,7 @@ gdbstub_client_thread(void *priv)
 
     /* Read data from client. */
     while ((bytes_read = recv(client->socket, (char *) buf, sizeof(buf), 0)) > 0) {
-        for (i = 0; i < bytes_read; i++) {
+        for (ssize_t i = 0; i < bytes_read; i++) {
             switch (buf[i]) {
                 case '$': /* packet start */
                     /* Wait for any existing packets to be processed. */