From fdef73e0e65ebb5aa2bf33e226ba5b108a7a43fb Mon Sep 17 00:00:00 2001 From: Andre Weissflog Date: Sat, 30 May 2020 16:05:34 +0200 Subject: [PATCH] fix clang/gcc unused-parameter warnings --- chips/am40010.h | 8 ++++---- chips/fdd.h | 2 ++ chips/m6522.h | 8 ++++---- chips/m6526.h | 12 ++++++------ chips/m6569.h | 1 + chips/upd765.h | 2 ++ systems/atom.h | 2 ++ systems/bombjack.h | 2 ++ systems/c1541.h | 4 ++++ systems/cpc.h | 13 +++++++++---- systems/kc85.h | 13 +++++++++---- systems/lc80.h | 5 +++++ systems/namco.h | 2 ++ systems/z1013.h | 3 +++ systems/z9001.h | 12 ++++++++---- systems/zx.h | 2 ++ ui/ui_atom.h | 2 ++ ui/ui_bombjack.h | 1 + ui/ui_c64.h | 4 ++++ ui/ui_cpc.h | 3 +++ ui/ui_dbg.h | 8 ++++++-- ui/ui_kbd.h | 5 ++--- ui/ui_lc80.h | 8 ++++++++ ui/ui_m6561.h | 4 ++-- ui/ui_m6569.h | 4 ++-- ui/ui_vic20.h | 1 + ui/ui_z1013.h | 2 ++ ui/ui_z9001.h | 2 ++ 28 files changed, 100 insertions(+), 35 deletions(-) diff --git a/chips/am40010.h b/chips/am40010.h index d2b8f470..59792d43 100644 --- a/chips/am40010.h +++ b/chips/am40010.h @@ -325,7 +325,7 @@ static void _am40010_init_video(am40010_t* ga) { } /* initialize the crt init */ -static void _am40010_init_crt(am40010_t* ga, const am40010_desc_t* desc) { +static void _am40010_init_crt(am40010_t* ga) { memset(&ga->crt, 0, sizeof(ga->crt)); } @@ -372,7 +372,7 @@ void am40010_init(am40010_t* ga, const am40010_desc_t* desc) { ga->user_data = desc->user_data; _am40010_init_regs(ga); _am40010_init_video(ga); - _am40010_init_crt(ga, desc); + _am40010_init_crt(ga); _am40010_init_colors(ga); ga->bankswitch_cb(ga->ram_config, ga->regs.config, ga->rom_select, ga->user_data); } @@ -787,7 +787,7 @@ static inline void _am40010_do_cclk(am40010_t* ga, uint64_t crtc_pins) { with a clock cycle where the CPU samples the WAIT pin, the CPU will be stopped until the READY pin goes inactive again. */ -static inline int _am40010_wait_scan_tick(am40010_t* ga, int num_ticks, uint64_t pins) { +static inline int _am40010_wait_scan_tick(uint64_t pins) { int wait_scan_tick = -1; /* NOTE: these offsets are important for proper computation of the CCLK clock */ if (pins & Z80_MREQ) { @@ -810,7 +810,7 @@ static inline int _am40010_wait_scan_tick(am40010_t* ga, int num_ticks, uint64_t /* the tick function must be called at 4 MHz */ uint64_t am40010_tick(am40010_t* ga, int num_ticks, uint64_t pins) { /* determine at what clock cycle the CPU samples the WAIT pin */ - int wait_scan_tick = _am40010_wait_scan_tick(ga, num_ticks, pins); + int wait_scan_tick = _am40010_wait_scan_tick(pins); /* for each 4 MHz tick... */ uint32_t wait_cycles = 0; diff --git a/chips/fdd.h b/chips/fdd.h index 3afd6130..e087fee8 100644 --- a/chips/fdd.h +++ b/chips/fdd.h @@ -241,6 +241,8 @@ int fdd_seek_track(fdd_t* fdd, int track) { int fdd_seek_sector(fdd_t* fdd, uint8_t c, uint8_t h, uint8_t r, uint8_t n) { CHIPS_ASSERT(fdd); CHIPS_ASSERT(h < FDD_MAX_SIDES); + (void)c; // FIXME (?) + (void)n; // FIXME (?) if (fdd->has_disc && fdd->motor_on) { fdd->cur_side = h; const fdd_track_t* track = &fdd->disc.tracks[h][fdd->cur_track_index]; diff --git a/chips/m6522.h b/chips/m6522.h index e5518373..678fe661 100644 --- a/chips/m6522.h +++ b/chips/m6522.h @@ -510,7 +510,7 @@ static inline void _m6522_write_ifr(m6522_t* c, uint8_t data) { (essentially: T1 is always reloaded from latch, both in continuous and oneshot mode, while T2 is never reloaded) */ -static void _m6522_tick_t1(m6522_t* c, uint64_t pins) { +static void _m6522_tick_t1(m6522_t* c) { m6522_timer_t* t = &c->t1; /* decrement counter? */ @@ -590,7 +590,7 @@ static void _m6522_tick_pipeline(m6522_t* c) { c->intr.pip = (c->intr.pip >> 1) & 0x7F7F; } -static void _m6522_update_cab(m6522_t* c, uint64_t pins) { +static void _m6522_update_cab(m6522_t* c) { if (c->pa.c1_triggered) { _m6522_set_intr(c, M6522_IRQ_CA1); if (M6522_PCR_CA2_AUTO_HS(c)) { @@ -632,8 +632,8 @@ static uint64_t _m6522_update_irq(m6522_t* c, uint64_t pins) { /* perform a tick */ static uint64_t _m6522_tick(m6522_t* c, uint64_t pins) { _m6522_read_port_pins(c, pins); - _m6522_update_cab(c, pins); - _m6522_tick_t1(c, pins); + _m6522_update_cab(c); + _m6522_tick_t1(c); _m6522_tick_t2(c, pins); pins = _m6522_update_irq(c, pins); pins = _m6522_write_port_pins(c, pins); diff --git a/chips/m6526.h b/chips/m6526.h index c498f20c..a80bc8de 100644 --- a/chips/m6526.h +++ b/chips/m6526.h @@ -432,7 +432,7 @@ static uint64_t _m6526_update_irq(m6526_t* c, uint64_t pins) { (since this is different for timer A and B) check here for the details: https://ist.uwaterloo.ca/~schepers/MJK/cia6526.html */ -static void _m6526_tick_timer(m6526_t* c, m6526_timer_t* t) { +static void _m6526_tick_timer(m6526_timer_t* t) { /* decrement counter? */ if (_M6526_PIP_TEST(t->pip, M6526_PIP_TIMER_COUNT, 0)) { t->counter--; @@ -523,15 +523,15 @@ static void _m6526_tick_pipeline(m6526_t* c) { static uint64_t _m6526_tick(m6526_t* c, uint64_t pins) { _m6526_read_port_pins(c, pins); - _m6526_tick_timer(c, &c->ta); - _m6526_tick_timer(c, &c->tb); + _m6526_tick_timer(&c->ta); + _m6526_tick_timer(&c->tb); pins = _m6526_update_irq(c, pins); pins = _m6526_write_port_pins(c, pins); _m6526_tick_pipeline(c); return pins; } -static inline void _m6526_write_cr(m6526_t* c, m6526_timer_t* t, uint8_t data) { +static inline void _m6526_write_cr(m6526_timer_t* t, uint8_t data) { /* if the start bit goes from 0 to 1, set the current toggle-bit-state to 1 */ if (!M6526_TIMER_STARTED(t->cr) && M6526_TIMER_STARTED(data)) { t->t_bit = true; @@ -620,10 +620,10 @@ static void _m6526_write(m6526_t* c, uint8_t addr, uint8_t data) { _m6526_write_icr(c, data); break; case M6526_REG_CRA: - _m6526_write_cr(c, &c->ta, data); + _m6526_write_cr(&c->ta, data); break; case M6526_REG_CRB: - _m6526_write_cr(c, &c->tb, data); + _m6526_write_cr(&c->tb, data); break; } } diff --git a/chips/m6569.h b/chips/m6569.h index e911ee3f..80bf621c 100644 --- a/chips/m6569.h +++ b/chips/m6569.h @@ -525,6 +525,7 @@ static inline void _m6569_io_update_gunit_mode(m6569_graphics_unit_t* gu, uint8_ /* update sprite unit positions and sizes when updating registers */ static void _m6569_io_update_sunit(m6569_t* vic, int i, uint8_t mx, uint8_t my, uint8_t mx8, uint8_t mxe, uint8_t mye) { + (void)my; // FIXME: my is really unused? m6569_sprite_unit_t* su = &vic->sunit; /* mxb: MSB for each xpos */ uint16_t xpos = ((mx8 & (1<valid); + (void)sys; return MC6847_DISPLAY_WIDTH; } int atom_display_height(atom_t* sys) { CHIPS_ASSERT(sys && sys->valid); + (void)sys; return MC6847_DISPLAY_HEIGHT; } diff --git a/systems/bombjack.h b/systems/bombjack.h index 2b7fa8ed..d2453144 100644 --- a/systems/bombjack.h +++ b/systems/bombjack.h @@ -424,10 +424,12 @@ int bombjack_display_size(void) { } int bombjack_display_width(bombjack_t* sys) { + (void)sys; return _BOMBJACK_DISPLAY_WIDTH; } int bombjack_display_height(bombjack_t* sys) { + (void)sys; return _BOMBJACK_DISPLAY_HEIGHT; } diff --git a/systems/c1541.h b/systems/c1541.h index a4eb98f4..5c0b2dfe 100644 --- a/systems/c1541.h +++ b/systems/c1541.h @@ -162,10 +162,14 @@ void c1541_tick(c1541_t* sys) { void c1541_insert_disc(c1541_t* sys, const uint8_t* ptr, int num_bytes) { // FIXME + (void)sys; + (void)ptr; + (void)num_bytes; } void c1541_remove_disc(c1541_t* sys) { // FIXME + (void)sys; } #endif /* CHIPS_IMPL */ diff --git a/systems/cpc.h b/systems/cpc.h index ccf93870..fdc9678e 100644 --- a/systems/cpc.h +++ b/systems/cpc.h @@ -648,6 +648,9 @@ static uint64_t _cpc_cclk(void* user_data) { /* PSG OUT callback (nothing to do here) */ static void _cpc_psg_out(int port_id, uint8_t data, void* user_data) { /* this shouldn't be called */ + (void)port_id; + (void)data; + (void)user_data; } /* PSG IN callback (read keyboard matrix and joystick port) */ @@ -933,14 +936,14 @@ typedef struct { uint8_t pad_5[0x60]; } _cpc_bin_header; -static bool _cpc_is_valid_bin(const uint8_t* ptr, int num_bytes) { +static bool _cpc_is_valid_bin(int num_bytes) { if (num_bytes <= (int)sizeof(_cpc_bin_header)) { return false; } return true; } -static bool _cpc_load_bin(cpc_t* sys, const uint8_t* ptr, int num_bytes) { +static bool _cpc_load_bin(cpc_t* sys, const uint8_t* ptr) { const _cpc_bin_header* hdr = (const _cpc_bin_header*) ptr; ptr += sizeof(_cpc_bin_header); const uint16_t load_addr = (hdr->load_addr_h<<8)|hdr->load_addr_l; @@ -961,8 +964,8 @@ bool cpc_quickload(cpc_t* sys, const uint8_t* ptr, int num_bytes) { if (_cpc_is_valid_sna(ptr, num_bytes)) { return _cpc_load_sna(sys, ptr, num_bytes); } - else if (_cpc_is_valid_bin(ptr, num_bytes)) { - return _cpc_load_bin(sys, ptr, num_bytes); + else if (_cpc_is_valid_bin(num_bytes)) { + return _cpc_load_bin(sys, ptr); } else { /* not a known file type, or not enough data */ @@ -973,6 +976,8 @@ bool cpc_quickload(cpc_t* sys, const uint8_t* ptr, int num_bytes) { /*=== CASSETTE TAPE FILE LOADING =============================================*/ /* CPU trap handler to check for casread */ static int _cpc_trap_cb(uint16_t pc, uint32_t ticks, uint64_t pins, void* user_data) { + (void)ticks; + (void)pins; cpc_t* sys = (cpc_t*) user_data; return (pc == sys->casread_trap) ? 1 : 0; } diff --git a/systems/kc85.h b/systems/kc85.h index c96c5b6a..6ba29aac 100644 --- a/systems/kc85.h +++ b/systems/kc85.h @@ -613,10 +613,12 @@ int kc85_max_display_size(void) { } int kc85_display_width(kc85_t* sys) { + (void)sys; return _KC85_DISPLAY_WIDTH; } int kc85_display_height(kc85_t* sys) { + (void)sys; return _KC85_DISPLAY_HEIGHT; } @@ -1012,6 +1014,8 @@ static uint64_t _kc85_tick(int num_ticks, uint64_t pins, void* user_data) { } static uint8_t _kc85_pio_in(int port_id, void* user_data) { + (void)port_id; + (void)user_data; return 0xFF; } @@ -1201,6 +1205,7 @@ static void _kc85_exp_init(kc85_t* sys) { } static void _kc85_exp_reset(kc85_t* sys) { + (void)sys; /* FIXME? */ } @@ -1573,7 +1578,7 @@ static bool _kc85_is_valid_kcc(const uint8_t* ptr, int num_bytes) { return true; } -static bool _kc85_load_kcc(kc85_t* sys, const uint8_t* ptr, int num_bytes) { +static bool _kc85_load_kcc(kc85_t* sys, const uint8_t* ptr) { const _kc85_kcc_header* hdr = (_kc85_kcc_header*) ptr; uint16_t addr = hdr->load_addr_h<<8 | hdr->load_addr_l; uint16_t end_addr = hdr->end_addr_h<<8 | hdr->end_addr_l; @@ -1630,7 +1635,7 @@ static bool _kc85_is_valid_kctap(const uint8_t* ptr, int num_bytes) { return true; } -static bool _kc85_load_kctap(kc85_t* sys, const uint8_t* ptr, int num_bytes) { +static bool _kc85_load_kctap(kc85_t* sys, const uint8_t* ptr) { const _kc85_kctap_header* hdr = (const _kc85_kctap_header*) ptr; uint16_t addr = hdr->kcc.load_addr_h<<8 | hdr->kcc.load_addr_l; uint16_t end_addr = hdr->kcc.end_addr_h<<8 | hdr->kcc.end_addr_l; @@ -1654,10 +1659,10 @@ bool kc85_quickload(kc85_t* sys, const uint8_t* ptr, int num_bytes) { CHIPS_ASSERT(sys && sys->valid && ptr); /* first check for KC-TAP format, since this can be properly identified */ if (_kc85_is_valid_kctap(ptr, num_bytes)) { - return _kc85_load_kctap(sys, ptr, num_bytes); + return _kc85_load_kctap(sys, ptr); } else if (_kc85_is_valid_kcc(ptr, num_bytes)) { - return _kc85_load_kcc(sys, ptr, num_bytes); + return _kc85_load_kcc(sys, ptr); } else { /* not a known file type, or not enough data */ diff --git a/systems/lc80.h b/systems/lc80.h index 71152c75..8b7c17ac 100644 --- a/systems/lc80.h +++ b/systems/lc80.h @@ -572,6 +572,8 @@ static uint32_t _lc80_vqe23_write(uint32_t vqe23, int digit, uint8_t data) { } uint8_t _lc80_pio_sys_in(int port_id, void* user_data) { + (void)port_id; + (void)user_data; // FIXME: TAPE IN return 0xFF; } @@ -651,6 +653,9 @@ uint8_t _lc80_pio_usr_in(int port_id, void* user_data) { void _lc80_pio_usr_out(int port_id, uint8_t data, void* user_data) { // FIXME + (void)port_id; + (void)data; + (void)user_data; } #endif /* CHIPS_IMPL */ diff --git a/systems/namco.h b/systems/namco.h index a54aa391..b143d7f2 100644 --- a/systems/namco.h +++ b/systems/namco.h @@ -912,10 +912,12 @@ int namco_std_display_height(void) { } int namco_display_width(namco_t* sys) { + (void)sys; return NAMCO_DISPLAY_WIDTH; } int namco_display_height(namco_t* sys) { + (void)sys; return NAMCO_DISPLAY_HEIGHT; } diff --git a/systems/z1013.h b/systems/z1013.h index 0655e91e..73ba50a5 100644 --- a/systems/z1013.h +++ b/systems/z1013.h @@ -308,10 +308,12 @@ int z1013_max_display_size(void) { } int z1013_display_width(z1013_t* sys) { + (void)sys; return _Z1013_DISPLAY_WIDTH; } int z1013_display_height(z1013_t* sys) { + (void)sys; return _Z1013_DISPLAY_HEIGHT; } @@ -343,6 +345,7 @@ void z1013_key_up(z1013_t* sys, int key_code) { } static uint64_t _z1013_tick(int num_ticks, uint64_t pins, void* user_data) { + (void)num_ticks; z1013_t* sys = (z1013_t*) user_data; if (pins & Z80_MREQ) { /* a memory request */ diff --git a/systems/z9001.h b/systems/z9001.h index ccf9eaf4..2873163f 100644 --- a/systems/z9001.h +++ b/systems/z9001.h @@ -397,10 +397,12 @@ int z9001_max_display_size(void) { } int z9001_display_width(z9001_t* sys) { + (void)sys; return _Z9001_DISPLAY_WIDTH; } int z9001_display_height(z9001_t* sys) { + (void)sys; return _Z9001_DISPLAY_HEIGHT; } @@ -542,10 +544,12 @@ static uint64_t _z9001_tick(int num_ticks, uint64_t pins, void* user_data) { static uint8_t _z9001_pio1_in(int port_id, void* user_data) { + (void)port_id; (void)user_data; return 0x00; } static void _z9001_pio1_out(int port_id, uint8_t data, void* user_data) { + (void)data; (void)user_data; if (Z80PIO_PORT_A == port_id) { /* PIO1-A bits: @@ -707,7 +711,7 @@ static bool _z9001_is_valid_kcc(const uint8_t* ptr, int num_bytes) { return true; } -static bool _z9001_load_kcc(z9001_t* sys, const uint8_t* ptr, int num_bytes) { +static bool _z9001_load_kcc(z9001_t* sys, const uint8_t* ptr) { const _z9001_kcc_header* hdr = (_z9001_kcc_header*) ptr; uint16_t addr = hdr->load_addr_h<<8 | hdr->load_addr_l; uint16_t end_addr = hdr->end_addr_h<<8 | hdr->end_addr_l; @@ -759,7 +763,7 @@ static bool _z9001_is_valid_kctap(const uint8_t* ptr, int num_bytes) { return true; } -static bool _z9001_load_kctap(z9001_t* sys, const uint8_t* ptr, int num_bytes) { +static bool _z9001_load_kctap(z9001_t* sys, const uint8_t* ptr) { const _z9001_kctap_header* hdr = (const _z9001_kctap_header*) ptr; uint16_t addr = hdr->kcc.load_addr_h<<8 | hdr->kcc.load_addr_l; uint16_t end_addr = hdr->kcc.end_addr_h<<8 | hdr->kcc.end_addr_l; @@ -782,10 +786,10 @@ bool z9001_quickload(z9001_t* sys, const uint8_t* ptr, int num_bytes) { CHIPS_ASSERT(sys && sys->valid && ptr); /* first check for KC TAP, since this can be properly identified */ if (_z9001_is_valid_kctap(ptr, num_bytes)) { - return _z9001_load_kctap(sys, ptr, num_bytes); + return _z9001_load_kctap(sys, ptr); } else if (_z9001_is_valid_kcc(ptr, num_bytes)) { - return _z9001_load_kcc(sys, ptr, num_bytes); + return _z9001_load_kcc(sys, ptr); } else { /* not a known file type, or not enough data */ diff --git a/systems/zx.h b/systems/zx.h index 5874ad0f..3e6ed9ab 100644 --- a/systems/zx.h +++ b/systems/zx.h @@ -294,10 +294,12 @@ int zx_max_display_size(void) { } int zx_display_width(zx_t* sys) { + (void)sys; return _ZX_DISPLAY_WIDTH; } int zx_display_height(zx_t* sys) { + (void)sys; return _ZX_DISPLAY_HEIGHT; } diff --git a/ui/ui_atom.h b/ui/ui_atom.h index c7ca60e6..d1126cc8 100644 --- a/ui/ui_atom.h +++ b/ui/ui_atom.h @@ -173,12 +173,14 @@ static void _ui_atom_draw_menu(ui_atom_t* ui, double time_ms) { static uint8_t _ui_atom_mem_read(int layer, uint16_t addr, void* user_data) { CHIPS_ASSERT(user_data); + (void)layer; atom_t* atom = (atom_t*) user_data; return mem_rd(&atom->mem, addr); } static void _ui_atom_mem_write(int layer, uint16_t addr, uint8_t data, void* user_data) { CHIPS_ASSERT(user_data); + (void)layer; atom_t* atom = (atom_t*) user_data; mem_wr(&atom->mem, addr, data); } diff --git a/ui/ui_bombjack.h b/ui/ui_bombjack.h index b112b826..4a9c6bee 100644 --- a/ui/ui_bombjack.h +++ b/ui/ui_bombjack.h @@ -434,6 +434,7 @@ static uint8_t _ui_bombjack_set_bits(uint8_t val, uint8_t mask, uint8_t bits) { } static uint8_t _ui_bombjack_toggle_bits(uint8_t val, uint8_t mask, uint8_t bits) { + (void)mask; return val ^ bits; } diff --git a/ui/ui_c64.h b/ui/ui_c64.h index a955d9cd..3f7feaa8 100644 --- a/ui/ui_c64.h +++ b/ui/ui_c64.h @@ -217,6 +217,7 @@ static const char* _ui_c64_memlayer_names[_UI_C64_MEMLAYER_NUM] = { }; static uint8_t _ui_c64_c1541_mem_read(int layer, uint16_t addr, void* user_data) { + (void)layer; ui_c64_t* ui = (ui_c64_t*) user_data; CHIPS_ASSERT(ui && ui->c64->c1541.valid); return mem_rd(&ui->c64->c1541.mem, addr); @@ -333,6 +334,9 @@ static void _ui_c64_update_memmap(ui_c64_t* ui) { } static int _ui_c64_eval_bp(ui_dbg_t* dbg_win, uint16_t pc, int ticks, uint64_t pins, void* user_data) { + (void)pc; + (void)ticks; + (void)pins; CHIPS_ASSERT(user_data); ui_c64_t* ui = (ui_c64_t*) user_data; c64_t* c64 = ui->c64; diff --git a/ui/ui_cpc.h b/ui/ui_cpc.h index a14c45be..7ddedc23 100644 --- a/ui/ui_cpc.h +++ b/ui/ui_cpc.h @@ -356,6 +356,9 @@ static void _ui_cpc_mem_write(int layer, uint16_t addr, uint8_t data, void* user } static int _ui_cpc_eval_bp(ui_dbg_t* dbg_win, uint16_t pc, int ticks, uint64_t pins, void* user_data) { + (void)pc; + (void)ticks; + (void)pins; CHIPS_ASSERT(user_data); ui_cpc_t* ui_cpc = (ui_cpc_t*) user_data; cpc_t* cpc = ui_cpc->cpc; diff --git a/ui/ui_dbg.h b/ui/ui_dbg.h index 5ccecd59..2931d155 100644 --- a/ui/ui_dbg.h +++ b/ui/ui_dbg.h @@ -464,6 +464,7 @@ static bool _ui_dbg_is_controlflow_op(uint8_t opcode0, uint8_t opcode1) { return false; } #elif defined(UI_DBG_USE_M6502) + (void)opcode1; switch (opcode0) { /* BRK */ case 0x00: @@ -1124,7 +1125,7 @@ static void _ui_dbg_bp_draw(ui_dbg_t* win) { } /*== HEATMAP =================================================================*/ -static void _ui_dbg_heatmap_init(ui_dbg_t* win, ui_dbg_desc_t* desc) { +static void _ui_dbg_heatmap_init(ui_dbg_t* win) { win->heatmap.tex_width = 256; win->heatmap.tex_height = 256; win->heatmap.tex_width_uicombo_state = 4; @@ -1911,7 +1912,7 @@ void ui_dbg_init(ui_dbg_t* win, ui_dbg_desc_t* desc) { win->user_data = desc->user_data; _ui_dbg_dbgstate_init(win, desc); _ui_dbg_uistate_init(win, desc); - _ui_dbg_heatmap_init(win, desc); + _ui_dbg_heatmap_init(win); } void ui_dbg_discard(ui_dbg_t* win) { @@ -2008,6 +2009,9 @@ void ui_dbg_tick(ui_dbg_t* win, uint64_t pins) { } win->cpu_ticks++; win->op_ticks++; + #else + (void)win; + (void)pins; #endif } diff --git a/ui/ui_kbd.h b/ui/ui_kbd.h index 1201fa83..f0ed502b 100644 --- a/ui/ui_kbd.h +++ b/ui/ui_kbd.h @@ -218,7 +218,7 @@ static void _ui_kbd_draw_plane_combo(ui_kbd_t* win) { ImGui::PopItemWidth(); } -static void _ui_kbd_draw_matrix(ui_kbd_t* win, const ImVec2& canvas_pos, const ImVec2& canvas_size, uint32_t mask) { +static void _ui_kbd_draw_matrix(ui_kbd_t* win, const ImVec2& canvas_pos, uint32_t mask) { const uint32_t line_bits = _ui_kbd_line_bits(mask); const uint32_t column_bits = _ui_kbd_column_bits(mask); ImDrawList* dl = ImGui::GetWindowDrawList(); @@ -279,7 +279,6 @@ void ui_kbd_draw(ui_kbd_t* win) { if (ImGui::Begin(win->title, &win->open)) { _ui_kbd_draw_plane_combo(win); const ImVec2 canvas_pos = ImGui::GetCursorScreenPos(); - const ImVec2 canvas_size = ImGui::GetContentRegionAvail(); uint32_t mask = 0; for (int i = 0; i < KBD_MAX_PRESSED_KEYS; i++) { mask |= win->kbd->key_buffer[i].mask; @@ -291,7 +290,7 @@ void ui_kbd_draw(ui_kbd_t* win) { if (win->last_key_mask && (win->last_key_frame_count++ > 30)) { win->last_key_mask = 0; } - _ui_kbd_draw_matrix(win, canvas_pos, canvas_size, win->last_key_mask); + _ui_kbd_draw_matrix(win, canvas_pos, win->last_key_mask); } ImGui::End(); } diff --git a/ui/ui_lc80.h b/ui/ui_lc80.h index 9965b356..e12fd8fd 100644 --- a/ui/ui_lc80.h +++ b/ui/ui_lc80.h @@ -494,6 +494,7 @@ static void _ui_lc80_draw_hovered_wire(ui_lc80_t* ui) { } static void _ui_lc80_draw_ctrl_wires(ui_lc80_t* ui, const _ui_lc80_mb_config& c) { + (void)c; auto& mb = ui->mb; for (int i = 0; i < 8; i++) { _ui_lc80_wire_type_t type = _UI_LC80_WIRETYPE_CTRL; @@ -539,6 +540,7 @@ static void _ui_lc80_draw_ctrl_wires(ui_lc80_t* ui, const _ui_lc80_mb_config& c) } static void _ui_lc80_draw_data_bus(ui_lc80_t* ui, const _ui_lc80_mb_config& c) { + (void)c; auto& mb = ui->mb; for (int i = 0; i < 8; i++) { _ui_lc80_wire_type_t type = _UI_LC80_WIRETYPE_DATA; @@ -563,6 +565,7 @@ static void _ui_lc80_draw_data_bus(ui_lc80_t* ui, const _ui_lc80_mb_config& c) { } static void _ui_lc80_draw_addr_bus(ui_lc80_t* ui, const _ui_lc80_mb_config& c) { + (void)c; auto& mb = ui->mb; for (int i = 0; i < 16; i++) { _ui_lc80_wire_type_t type = _UI_LC80_WIRETYPE_ADDR; @@ -615,6 +618,7 @@ static void _ui_lc80_draw_addr_bus(ui_lc80_t* ui, const _ui_lc80_mb_config& c) { } static void _ui_lc80_draw_chip_select(ui_lc80_t* ui, const _ui_lc80_mb_config& c) { + (void)c; auto& mb = ui->mb; _ui_lc80_wire_type_t type = _UI_LC80_WIRETYPE_SELECT; { @@ -629,6 +633,7 @@ static void _ui_lc80_draw_chip_select(ui_lc80_t* ui, const _ui_lc80_mb_config& c } static void _ui_lc80_draw_display_wires(ui_lc80_t* ui, const _ui_lc80_mb_config& c) { + (void)c; auto& mb = ui->mb; for (int i = 0; i < 8; i++) { _ui_lc80_wire_type_t type = _UI_LC80_WIRETYPE_DISPLAY; @@ -652,6 +657,7 @@ static void _ui_lc80_draw_display_wires(ui_lc80_t* ui, const _ui_lc80_mb_config& } static void _ui_lc80_draw_led_wires(ui_lc80_t* ui, const _ui_lc80_mb_config& c) { + (void)c; auto& mb = ui->mb; ui_chip_vec2_t p0 = _ui_lc80_pin_pos(&mb.pio_sys, Z80PIO_PB1); ui_chip_vec2_t p1 = { 656, 384 }; @@ -1013,6 +1019,7 @@ static void _ui_lc80_init_motherboard(ui_lc80_t* ui) { } static uint8_t _ui_lc80_mem_read(int layer, uint16_t addr, void* user_data) { + (void)layer; CHIPS_ASSERT(user_data); lc80_t* sys = (lc80_t*) user_data; if (addr < 0x0800) { @@ -1027,6 +1034,7 @@ static uint8_t _ui_lc80_mem_read(int layer, uint16_t addr, void* user_data) { } void _ui_lc80_mem_write(int layer, uint16_t addr, uint8_t data, void* user_data) { + (void)layer; CHIPS_ASSERT(user_data); lc80_t* sys = (lc80_t*) user_data; if (addr < 0x0800) { diff --git a/ui/ui_m6561.h b/ui/ui_m6561.h index 2cc3d174..05831c9a 100644 --- a/ui/ui_m6561.h +++ b/ui/ui_m6561.h @@ -121,7 +121,7 @@ void ui_m6561_discard(ui_m6561_t* win) { win->valid = false; } -static void _ui_m6561_draw_hwcolors(ui_m6561_t* win) { +static void _ui_m6561_draw_hwcolors(void) { if (ImGui::CollapsingHeader("Hardware Colors", ImGuiTreeNodeFlags_DefaultOpen)) { ImVec4 c; const ImVec2 size(18,18); @@ -261,7 +261,7 @@ void ui_m6561_draw(ui_m6561_t* win) { if (ImGui::Button("Tint Framebuffer")) { _ui_m6561_tint_framebuffer(win); } - _ui_m6561_draw_hwcolors(win); + _ui_m6561_draw_hwcolors(); _ui_m6561_draw_registers(win); _ui_m6561_draw_raster_unit(win); _ui_m6561_draw_memory_unit(win); diff --git a/ui/ui_m6569.h b/ui/ui_m6569.h index 92f862e9..6d847961 100644 --- a/ui/ui_m6569.h +++ b/ui/ui_m6569.h @@ -118,7 +118,7 @@ void ui_m6569_discard(ui_m6569_t* win) { win->valid = false; } -static void _ui_m6569_draw_hwcolors(ui_m6569_t* win) { +static void _ui_m6569_draw_hwcolors(void) { if (ImGui::CollapsingHeader("Hardware Colors")) { ImVec4 c; const ImVec2 size(18,18); @@ -315,7 +315,7 @@ void ui_m6569_draw(ui_m6569_t* win) { if (ImGui::Button("Tint Framebuffer")) { _ui_m6569_tint_framebuffer(win); } - _ui_m6569_draw_hwcolors(win); + _ui_m6569_draw_hwcolors(); _ui_m6569_draw_registers(win); _ui_m6569_draw_raster_unit(win); _ui_m6569_draw_memory_unit(win); diff --git a/ui/ui_vic20.h b/ui/ui_vic20.h index 7cd01ba3..8b58e5c6 100644 --- a/ui/ui_vic20.h +++ b/ui/ui_vic20.h @@ -250,6 +250,7 @@ static void _ui_vic20_update_memmap(ui_vic20_t* ui) { } static int _ui_vic20_eval_bp(ui_dbg_t* dbg_win, uint16_t pc, int ticks, uint64_t pins, void* user_data) { + (void)pc; (void)ticks; (void)pins; CHIPS_ASSERT(user_data); ui_vic20_t* ui = (ui_vic20_t*) user_data; vic20_t* vic20 = ui->vic20; diff --git a/ui/ui_z1013.h b/ui/ui_z1013.h index 5776741c..e77be57a 100644 --- a/ui/ui_z1013.h +++ b/ui/ui_z1013.h @@ -253,12 +253,14 @@ static const ui_chip_pin_t _ui_z1013_pio_pins[] = { }; static uint8_t _ui_z1013_mem_read(int layer, uint16_t addr, void* user_data) { + (void)layer; CHIPS_ASSERT(user_data); z1013_t* z1013 = (z1013_t*) user_data; return mem_rd(&z1013->mem, addr); } void _ui_z1013_mem_write(int layer, uint16_t addr, uint8_t data, void* user_data) { + (void)layer; CHIPS_ASSERT(user_data); z1013_t* z1013 = (z1013_t*) user_data; mem_wr(&z1013->mem, addr, data); diff --git a/ui/ui_z9001.h b/ui/ui_z9001.h index 865a8a71..52212d36 100644 --- a/ui/ui_z9001.h +++ b/ui/ui_z9001.h @@ -291,12 +291,14 @@ static const ui_chip_pin_t _ui_z9001_ctc_pins[] = { }; static uint8_t _ui_z9001_mem_read(int layer, uint16_t addr, void* user_data) { + (void)layer; CHIPS_ASSERT(user_data); z9001_t* z9001 = (z9001_t*) user_data; return mem_rd(&z9001->mem, addr); } void _ui_z9001_mem_write(int layer, uint16_t addr, uint8_t data, void* user_data) { + (void)layer; CHIPS_ASSERT(user_data); z9001_t* z9001 = (z9001_t*) user_data; mem_wr(&z9001->mem, addr, data);