Update source code to fix some new clang-tidy warnings

Author: giomba

src/bios.c

@@ -1,8 +1,11 @@
 #include "bios.h"
 
 #include "conf.h"
+#include "module.h"
+#include "type.h"
 #include "units.h"
 
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -12,9 +15,10 @@
 #define ROM_BIOS_PATH "rom/V1.01_ROM.bin"
 #define ROM_BIOS_SIZE (ceda_size_t)(4 * KiB)
 
-static zuint8 bios[ROM_BIOS_SIZE] = {0};
+static uint8_t bios[ROM_BIOS_SIZE] = {0};
 
 static bool rom_bios_start(void) {
+    bool ret = false;
     const char *rom_path = ROM_BIOS_PATH;
     const char *rom_path_cfg = conf_getString("path", "bios_rom");
 
@@ -27,21 +31,24 @@ static bool rom_bios_start(void) {
 
     if (fp == NULL) {
         LOG_ERR("missing bios rom file\n");
-        return false;
+        ret = false;
+        goto err_missingFile;
     }
 
     const size_t read = fread(bios, 1, ROM_BIOS_SIZE, fp);
     if (read != ROM_BIOS_SIZE) {
         LOG_ERR("bad bios rom file size: %lu\n", read);
-        return false;
+        ret = false;
+        goto err_cannotRead;
     }
 
-    if (fclose(fp) != 0) {
-        LOG_ERR("error closing bios rom file\n");
-        return false;
-    }
+    ret = true;
 
-    return true;
+err_cannotRead:
+    if (fclose(fp) != 0)
+        LOG_WARN("error closing bios rom file\n");
+err_missingFile:
+    return ret;
 }
 
 void rom_bios_init(CEDAModule *mod) {
@@ -51,7 +58,7 @@ void rom_bios_init(CEDAModule *mod) {
 }
 
 uint8_t rom_bios_read(ceda_address_t address) {
-    const zuint8 value = bios[address];
+    const uint8_t value = bios[address];
     LOG_DEBUG("ROM [%04x] => %02x\n", address, value);
     return value;
 }

src/bus.c

@@ -1,20 +1,20 @@
 #include "bus.h"
 
 #include "bios.h"
-#include "cpu.h"
 #include "crtc.h"
 #include "fdc.h"
 #include "macro.h"
+#include "module.h"
 #include "ram/auxram.h"
 #include "ram/dynamic.h"
 #include "sio2.h"
 #include "speaker.h"
 #include "timer.h"
+#include "type.h"
 #include "ubus.h"
 #include "upd8255.h"
 #include "video.h"
 
-#include <Z80.h>
 #include <inttypes.h>
 #include <stdint.h>
 #include <string.h>
@@ -74,7 +74,7 @@ uint8_t bus_mem_read(ceda_address_t address) {
             const struct bus_mem_slot *slot = &bus_mem_slots[i];
             if (address >= slot->base && address < slot->top) {
                 if (slot->read) {
-                    const zuint8 value = slot->read(address - slot->base);
+                    const uint8_t value = slot->read(address - slot->base);
                     LOG_DEBUG("%s: [%04x] => %02x\n", __func__, address, value);
                     return value;
                 }
@@ -83,15 +83,15 @@ uint8_t bus_mem_read(ceda_address_t address) {
     }
 
     // default: read from dynamic ram
-    const zuint8 value = dyn_ram_read(address);
+    const uint8_t value = dyn_ram_read(address);
     LOG_DEBUG("%s: [%04x] => %02x\n", __func__, address, value);
     return value;
 }
 
 void bus_mem_readsome(uint8_t *blob, ceda_address_t address, ceda_size_t len) {
     LOG_DEBUG("%s: [%04x] x %hu\n", __func__, address, len);
 
-    for (zuint16 i = 0; i < len; ++i) {
+    for (uint16_t i = 0; i < len; ++i) {
         blob[i] = bus_mem_read(address + i);
     }
 }
@@ -119,7 +119,7 @@ void bus_mem_write(ceda_address_t address, uint8_t value) {
 }
 
 uint8_t bus_io_in(ceda_ioaddr_t address) {
-    LOG_DEBUG("%s: [%02x]\n", __func__, (zuint8)address);
+    LOG_DEBUG("%s: [%02x]\n", __func__, (uint8_t)address);
 
     // IO access, rom override condition is de-asserted
     is_bios_rom_switched = false;
@@ -137,7 +137,7 @@ uint8_t bus_io_in(ceda_ioaddr_t address) {
 }
 
 void bus_io_out(ceda_ioaddr_t _address, uint8_t value) {
-    const zuint8 address = (zuint8)_address;
+    const uint8_t address = (uint8_t)_address;
     LOG_DEBUG("%s: [%02x] <= %02x\n", __func__, address, value);
 
     // IO access, rom override condition is de-asserted

src/ceda.c

@@ -15,6 +15,7 @@
 #include "serial.h"
 #include "sio2.h"
 #include "speaker.h"
+#include "time.h"
 #include "timer.h"
 #include "ubus.h"
 #include "upd8255.h"
@@ -24,6 +25,7 @@
 #include "charmon.h"
 
 #include <assert.h>
+
 #include <unistd.h>
 
 #include "log.h"
@@ -101,7 +103,7 @@ static void ceda_remaining(void) {
         wait = MIN(remaining(), wait);
     }
     if (wait > 0) {
-        usleep((__useconds_t)wait);
+        usleep((__useconds_t)wait); /* NOLINT */
     }
 }
 

src/ceda_string.c

@@ -1,10 +1,13 @@
 #include "ceda_string.h"
 
 #include "macro.h"
+#include "type.h"
 
+#include <assert.h>
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -85,7 +88,7 @@ void ceda_string_cat(ceda_string_t *str, const char *data) {
 
     // concatenate data, overwriting old null-terminator
     --str->used;
-    for (ceda_size_t i = 0; i < strlen_data; ++i) {
+    for (ceda_size_t i = 0; i < (ceda_size_t)strlen_data; ++i) {
         str->data[str->used++] = data[i];
     }
     str->data[str->used++] = '\0';

src/charmon.c

@@ -1,8 +1,11 @@
 #include "charmon.h"
 
 #include "conf.h"
+#include "module.h"
+#include "type.h"
 #include "ubus.h"
 
+#include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 

src/cli.c

@@ -1,3 +1,4 @@
+// NOLINTBEGIN
 #include "cli.h"
 
 #include "3rd/disassembler.h"
@@ -11,13 +12,15 @@
 #include "serial.h"
 #include "time.h"
 #include "tokenizer.h"
+#include "type.h"
 
 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
 #include <inttypes.h>
 #include <netinet/in.h>
 #include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/select.h>
@@ -163,7 +166,7 @@ static ceda_string_t *cli_break(const char *arg) {
         ceda_string_cpy(msg, USER_BAD_ARG_STR "address must be 16 bit\n");
         return msg;
     }
-    const zuint16 address = (zuint16)_address;
+    const uint16_t address = (uint16_t)_address;
 
     // actually set breakpoint
     bool ret = cpu_addBreakpoint(address);
@@ -255,7 +258,7 @@ static ceda_string_t *cli_read(const char *arg) {
     // read some mem
     const ceda_size_t BLOB_SIZE = 8 * (size_t)16;
     uint8_t blob[BLOB_SIZE];
-    bus_mem_readsome(blob, (zuint16)address, BLOB_SIZE);
+    bus_mem_readsome(blob, (uint16_t)address, BLOB_SIZE);
 
     // print nice hexdump
     uint8_t ascii[16 + 1] = {0};
@@ -266,7 +269,7 @@ static ceda_string_t *cli_read(const char *arg) {
             ceda_string_printf(msg, "%04x\t", address + i);
         }
 
-        ceda_string_printf(msg, "%02x ", ((unsigned int)(c)) & 0xff);
+        ceda_string_printf(msg, "%02x ", ((unsigned int)c) & 0xff);
         ascii[i % 16] = isprint(c) ? c : '.';
 
         if (i % 16 == 8 - 1) {
@@ -301,10 +304,10 @@ static ceda_string_t *cli_write(const char *arg) {
         ceda_string_cpy(msg, USER_BAD_ARG_STR "address must be 16 bit\n");
         return msg;
     }
-    const zuint16 address = (zuint16)_address;
+    const uint16_t address = (uint16_t)_address;
 
     // read values, and put them in memory
-    for (zuint16 i = 0;; ++i) {
+    for (uint16_t i = 0;; ++i) {
         // extract value
         unsigned int _value;
         arg = tokenizer_next_hex(&_value, arg);
@@ -324,7 +327,7 @@ static ceda_string_t *cli_write(const char *arg) {
             ceda_string_cpy(msg, USER_BAD_ARG_STR "value must be 8 bit\n");
             return msg;
         }
-        const zuint8 value = (zuint8)_value;
+        const uint8_t value = (uint8_t)_value;
 
         bus_mem_write(address + i, value);
     }
@@ -353,7 +356,7 @@ static ceda_string_t *cli_dis(const char *arg) {
     char line[LINE_BUFFER_SIZE];
     uint8_t blob[CPU_MAX_OPCODE_LEN];
     for (int i = 0; i < 16; ++i) {
-        bus_mem_readsome(blob, (zuint16)(address + (unsigned int)disb),
+        bus_mem_readsome(blob, (uint16_t)(address + (unsigned int)disb),
                          CPU_MAX_OPCODE_LEN);
         disb += disassemble(blob, (int)address + disb, line, BLOCK_BUFFER_SIZE);
         ceda_string_printf(msg, "%s\n", line);
@@ -440,7 +443,7 @@ static ceda_string_t *cli_save(const char *arg) {
     blob[0] = lsb;
     blob[1] = msb;
     // payload
-    bus_mem_readsome(&blob[2], (zuint16)start_address, data_size);
+    bus_mem_readsome(&blob[2], (uint16_t)start_address, data_size);
     // write
     size_t written = fwrite(blob, 1, alloc_size, fp);
     if (written != alloc_size) {
@@ -545,7 +548,7 @@ static ceda_string_t *cli_load_and_run(const char *arg, bool run) {
         ret = fread(&c, 1, 1, fp);
         if (ret == 0)
             break;
-        bus_mem_write((zuint16)address++, (zuint8)c);
+        bus_mem_write((uint16_t)address++, (uint8_t)c);
     }
 
     (void)fclose(fp);
@@ -662,7 +665,7 @@ static ceda_string_t *cli_goto(const char *arg) {
     }
 
     // inconditional jump
-    cpu_goto((zuint16)address);
+    cpu_goto((uint16_t)address);
     return NULL;
 }
 
@@ -728,7 +731,7 @@ static ceda_string_t *cli_in(const char *arg) {
         return msg;
     }
 
-    const zuint8 value = bus_io_in((ceda_ioaddr_t)address);
+    const uint8_t value = bus_io_in((ceda_ioaddr_t)address);
     ceda_string_printf(msg, "%02x\n", value);
     return msg;
 }
@@ -764,7 +767,7 @@ static ceda_string_t *cli_out(const char *arg) {
         return msg;
     }
 
-    bus_io_out((ceda_ioaddr_t)address, (zuint8)value);
+    bus_io_out((ceda_ioaddr_t)address, (uint8_t)value);
 
     ceda_string_delete(msg);
     return NULL;
@@ -1201,3 +1204,5 @@ Test(cli, delete, .init = cli_test_setup) {
 }
 
 #endif
+//NOLINTEND
+