From 515dd18c2801663bbac0e59f683c2a93e4bd9b1a Mon Sep 17 00:00:00 2001 From: precondition Date: Tue, 13 Dec 2022 12:20:07 +0100 Subject: Remove IGNORE_MOD_TAP_INTERRUPT_PER_KEY in favour of HOLD_ON_OTHER_KEY_PRESS_PER_KEY (#15741) --- quantum/process_keycode/process_auto_shift.c | 41 ++++++++++------------------ 1 file changed, 15 insertions(+), 26 deletions(-) (limited to 'quantum/process_keycode/process_auto_shift.c') diff --git a/quantum/process_keycode/process_auto_shift.c b/quantum/process_keycode/process_auto_shift.c index 35d4851ee5..b7ac449198 100644 --- a/quantum/process_keycode/process_auto_shift.c +++ b/quantum/process_keycode/process_auto_shift.c @@ -397,8 +397,17 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) { break; # endif } - // If Retro Shift is disabled, possible custom actions shouldn't happen. - // clang-format off + // If Retro Shift is disabled, possible custom actions shouldn't happen. + // clang-format off +# if defined(RETRO_SHIFT) && !defined(NO_ACTION_TAPPING) +# if defined(HOLD_ON_OTHER_KEY_PRESS_PER_KEY) + const bool is_hold_on_interrupt = get_hold_on_other_key_press(keycode, record); +# elif defined(IGNORE_MOD_TAP_INTERRUPT) + const bool is_hold_on_interrupt = false; +# else + const bool is_hold_on_interrupt = IS_MT(keycode); +# endif +# endif if (IS_RETRO(keycode) # if defined(RETRO_SHIFT) && !defined(NO_ACTION_TAPPING) // Not tapped or #defines mean that rolls should use hold action. @@ -407,27 +416,7 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) { # ifdef RETRO_TAPPING_PER_KEY || !get_retro_tapping(keycode, record) # endif - || (record->tap.interrupted && (IS_LT(keycode) -# if defined(HOLD_ON_OTHER_KEY_PRESS) || defined(HOLD_ON_OTHER_KEY_PRESS_PER_KEY) -# ifdef HOLD_ON_OTHER_KEY_PRESS_PER_KEY - ? get_hold_on_other_key_press(keycode, record) -# else - ? true -# endif -# else - ? false -# endif -# if defined(IGNORE_MOD_TAP_INTERRUPT) || defined(IGNORE_MOD_TAP_INTERRUPT_PER_KEY) -# ifdef IGNORE_MOD_TAP_INTERRUPT_PER_KEY - : !get_ignore_mod_tap_interrupt(keycode, record) -# else - : false -# endif -# else - : true -# endif - )) - ) + || (record->tap.interrupted && is_hold_on_interrupt)) # endif ) { // clang-format on @@ -454,10 +443,10 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) { # endif ) { // Fixes modifiers not being applied to rolls with AUTO_SHIFT_MODIFIERS set. -# if !defined(IGNORE_MOD_TAP_INTERRUPT) || defined(IGNORE_MOD_TAP_INTERRUPT_PER_KEY) +# if !defined(IGNORE_MOD_TAP_INTERRUPT) || defined(HOLD_ON_OTHER_KEY_PRESS_PER_KEY) if (autoshift_flags.in_progress -# ifdef IGNORE_MOD_TAP_INTERRUPT_PER_KEY - && !get_ignore_mod_tap_interrupt(keycode, record) +# ifdef HOLD_ON_OTHER_KEY_PRESS_PER_KEY + && get_hold_on_other_key_press(keycode, record) # endif ) { autoshift_end(KC_NO, now, false, &autoshift_lastrecord); -- cgit v1.2.3 From 962e4c0e1854b10612bab547c3d842c5f967dd23 Mon Sep 17 00:00:00 2001 From: Stefan Kerkmann Date: Wed, 14 Dec 2022 16:31:08 +0100 Subject: [Test] Reset timer for every unit test and provide timestamps for log messages (#17028) --- builddefs/build_full_test.mk | 2 + lib/python/qmk/cli/__init__.py | 1 + lib/python/qmk/cli/generate/keycodes_tests.py | 39 ++ platforms/test/timer.c | 3 +- quantum/action_tapping.c | 4 +- quantum/process_keycode/process_auto_shift.c | 2 +- quantum/process_keycode/process_auto_shift.h | 5 +- tests/basic/test_keycode_util.cpp | 52 ++ tests/caps_word/test_caps_word.cpp | 9 +- tests/test_common/keyboard_report_util.cpp | 45 +- tests/test_common/keycode_table.cpp | 663 ++++++++++++++++++++++++++ tests/test_common/keycode_util.cpp | 128 +++++ tests/test_common/keycode_util.hpp | 5 + tests/test_common/matrix.c | 8 +- tests/test_common/test_common.hpp | 1 + tests/test_common/test_fixture.cpp | 29 +- tests/test_common/test_keymap_key.cpp | 16 +- tests/test_common/test_keymap_key.hpp | 16 +- tests/test_common/test_logger.cpp | 16 +- tests/test_common/test_logger.hpp | 8 +- 20 files changed, 1011 insertions(+), 41 deletions(-) create mode 100644 lib/python/qmk/cli/generate/keycodes_tests.py create mode 100644 tests/basic/test_keycode_util.cpp create mode 100644 tests/test_common/keycode_table.cpp create mode 100644 tests/test_common/keycode_util.cpp create mode 100644 tests/test_common/keycode_util.hpp (limited to 'quantum/process_keycode/process_auto_shift.c') diff --git a/builddefs/build_full_test.mk b/builddefs/build_full_test.mk index 35f0a05b99..964ba773d4 100644 --- a/builddefs/build_full_test.mk +++ b/builddefs/build_full_test.mk @@ -24,6 +24,8 @@ $(TEST)_SRC := \ tests/test_common/matrix.c \ tests/test_common/test_driver.cpp \ tests/test_common/keyboard_report_util.cpp \ + tests/test_common/keycode_util.cpp \ + tests/test_common/keycode_table.cpp \ tests/test_common/test_fixture.cpp \ tests/test_common/test_keymap_key.cpp \ tests/test_common/test_logger.cpp \ diff --git a/lib/python/qmk/cli/__init__.py b/lib/python/qmk/cli/__init__.py index 4e3ce63da3..a6d53c1cb6 100644 --- a/lib/python/qmk/cli/__init__.py +++ b/lib/python/qmk/cli/__init__.py @@ -57,6 +57,7 @@ subcommands = [ 'qmk.cli.generate.keyboard_c', 'qmk.cli.generate.keyboard_h', 'qmk.cli.generate.keycodes', + 'qmk.cli.generate.keycodes_tests', 'qmk.cli.generate.rgb_breathe_table', 'qmk.cli.generate.rules_mk', 'qmk.cli.generate.version_h', diff --git a/lib/python/qmk/cli/generate/keycodes_tests.py b/lib/python/qmk/cli/generate/keycodes_tests.py new file mode 100644 index 0000000000..453b4693a7 --- /dev/null +++ b/lib/python/qmk/cli/generate/keycodes_tests.py @@ -0,0 +1,39 @@ +"""Used by the make system to generate a keycode lookup table from keycodes_{version}.json +""" +from milc import cli + +from qmk.constants import GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE +from qmk.commands import dump_lines +from qmk.path import normpath +from qmk.keycodes import load_spec + + +def _generate_defines(lines, keycodes): + lines.append('') + lines.append('std::map KEYCODE_ID_TABLE = {') + for key, value in keycodes["keycodes"].items(): + lines.append(f' {{{value.get("key")}, "{value.get("key")}"}},') + lines.append('};') + + +@cli.argument('-v', '--version', arg_only=True, required=True, help='Version of keycodes to generate.') +@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to') +@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages") +@cli.subcommand('Used by the make system to generate a keycode lookup table from keycodes_{version}.json', hidden=True) +def generate_keycodes_tests(cli): + """Generates a keycode to identifier lookup table for unit test output. + """ + + # Build the keycodes.h file. + keycodes_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '// clang-format off'] + keycodes_h_lines.append('extern "C" {\n#include \n}') + keycodes_h_lines.append('#include ') + keycodes_h_lines.append('#include ') + keycodes_h_lines.append('#include ') + + keycodes = load_spec(cli.args.version) + + _generate_defines(keycodes_h_lines, keycodes) + + # Show the results + dump_lines(cli.args.output, keycodes_h_lines, cli.args.quiet) diff --git a/platforms/test/timer.c b/platforms/test/timer.c index e0acd1b16d..320cc57782 100644 --- a/platforms/test/timer.c +++ b/platforms/test/timer.c @@ -15,8 +15,9 @@ */ #include "timer.h" +#include -static uint32_t current_time = 0; +static atomic_uint_least32_t current_time = 0; void timer_init(void) { current_time = 0; diff --git a/quantum/action_tapping.c b/quantum/action_tapping.c index ca0f31f12e..507b8144aa 100644 --- a/quantum/action_tapping.c +++ b/quantum/action_tapping.c @@ -143,8 +143,8 @@ void action_tapping_process(keyrecord_t record) { # define TAP_GET_RETRO_TAPPING true # endif # define MAYBE_RETRO_SHIFTING(ev) (TAP_GET_RETRO_TAPPING && (RETRO_SHIFT + 0) != 0 && TIMER_DIFF_16((ev).time, tapping_key.event.time) < (RETRO_SHIFT + 0)) -# define TAP_IS_LT IS_LT(tapping_keycode) -# define TAP_IS_MT IS_MT(tapping_keycode) +# define TAP_IS_LT IS_QK_LAYER_TAP(tapping_keycode) +# define TAP_IS_MT IS_QK_MOD_TAP(tapping_keycode) # define TAP_IS_RETRO IS_RETRO(tapping_keycode) # else # define TAP_GET_RETRO_TAPPING false diff --git a/quantum/process_keycode/process_auto_shift.c b/quantum/process_keycode/process_auto_shift.c index b7ac449198..aaf0cf9142 100644 --- a/quantum/process_keycode/process_auto_shift.c +++ b/quantum/process_keycode/process_auto_shift.c @@ -405,7 +405,7 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) { # elif defined(IGNORE_MOD_TAP_INTERRUPT) const bool is_hold_on_interrupt = false; # else - const bool is_hold_on_interrupt = IS_MT(keycode); + const bool is_hold_on_interrupt = IS_QK_MOD_TAP(keycode); # endif # endif if (IS_RETRO(keycode) diff --git a/quantum/process_keycode/process_auto_shift.h b/quantum/process_keycode/process_auto_shift.h index 86adb04985..66a4b3138a 100644 --- a/quantum/process_keycode/process_auto_shift.h +++ b/quantum/process_keycode/process_auto_shift.h @@ -22,9 +22,8 @@ # define AUTO_SHIFT_TIMEOUT 175 #endif -#define IS_LT(kc) ((kc) >= QK_LAYER_TAP && (kc) <= QK_LAYER_TAP_MAX) -#define IS_MT(kc) ((kc) >= QK_MOD_TAP && (kc) <= QK_MOD_TAP_MAX) -#define IS_RETRO(kc) (IS_MT(kc) || IS_LT(kc)) +#define IS_RETRO(kc) (IS_QK_MOD_TAP(kc) || IS_QK_LAYER_TAP(kc)) + #define DO_GET_AUTOSHIFT_TIMEOUT(keycode, record, ...) record // clang-format off #define AUTO_SHIFT_ALPHA KC_A ... KC_Z diff --git a/tests/basic/test_keycode_util.cpp b/tests/basic/test_keycode_util.cpp new file mode 100644 index 0000000000..693334676e --- /dev/null +++ b/tests/basic/test_keycode_util.cpp @@ -0,0 +1,52 @@ +// Copyright 2022 Stefan Kerkmann +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "test_common.hpp" + +class KeycodeToIdentifierSuite : public ::testing::TestWithParam> {}; + +TEST_P(KeycodeToIdentifierSuite, ConversionTests) { + ASSERT_EQ(get_keycode_identifier_or_default(GetParam().first), GetParam().second); +} + +INSTANTIATE_TEST_CASE_P(ConversionTestsP, KeycodeToIdentifierSuite, + // clang-format off +::testing::Values( + // Goto layer + std::make_pair(TO(0), "TO(0)"), + std::make_pair(TO(0x1F), "TO(31)"), + // Momentary switch layer + std::make_pair(MO(0), "MO(0)"), + std::make_pair(MO(0x1F), "MO(31)"), + // Set default layer + std::make_pair(DF(0), "DF(0)"), + std::make_pair(DF(0x1F), "DF(31)"), + // Toggle layer + std::make_pair(TG(0), "TG(0)"), + std::make_pair(TG(0x1F), "TG(31)"), + // One-shot layer + std::make_pair(OSL(0), "OSL(0)"), + std::make_pair(OSL(0x1F), "OSL(31)"), + // One-shot mod + std::make_pair(OSM(MOD_LSFT), "OSM(MOD_LSFT)"), + std::make_pair(OSM(MOD_LSFT | MOD_LCTL), "OSM(MOD_LCTL | MOD_LSFT)"), + // Layer Mod + std::make_pair(LM(0, MOD_LSFT), "LM(0, MOD_LSFT)"), + std::make_pair(LM(0xF, MOD_LSFT), "LM(15, MOD_LSFT)"), + std::make_pair(LM(0xF, MOD_LSFT | MOD_LCTL), "LM(15, MOD_LCTL | MOD_LSFT)"), + // Layer tap toggle + std::make_pair(TT(0), "TT(0)"), + std::make_pair(TT(0x1F), "TT(31)"), + // Layer tap + std::make_pair(LT(0, KC_A), "LT(0, KC_A)"), + std::make_pair(LT(0xF, KC_SPACE), "LT(15, KC_SPACE)"), + std::make_pair(LT(1, KC_SPC), "LT(1, KC_SPACE)"), + // Mod tap + std::make_pair(MT(MOD_LCTL, KC_A), "MT(MOD_LCTL, KC_A)"), + std::make_pair(MT(MOD_LCTL | MOD_LSFT, KC_A), "MT(MOD_LCTL | MOD_LSFT, KC_A)"), + std::make_pair(ALT_T(KC_TAB), "MT(MOD_LALT, KC_TAB)"), + // Mods + std::make_pair(LCTL(KC_A), "QK_MODS(KC_A, QK_LCTL)"), + std::make_pair(HYPR(KC_SPACE), "QK_MODS(KC_SPACE, QK_LCTL | QK_LSFT | QK_LALT | QK_LGUI)") +)); +// clang-format on diff --git a/tests/caps_word/test_caps_word.cpp b/tests/caps_word/test_caps_word.cpp index e5ecbb844e..fa970c7d0e 100644 --- a/tests/caps_word/test_caps_word.cpp +++ b/tests/caps_word/test_caps_word.cpp @@ -505,7 +505,8 @@ class CapsWordDoubleTapShift : public ::testing::WithParamInterface #include #include + using namespace testing; +extern std::map KEYCODE_ID_TABLE; + namespace { + std::vector get_keys(const report_keyboard_t& report) { std::vector result; #if defined(NKRO_ENABLE) @@ -36,6 +41,19 @@ std::vector get_keys(const report_keyboard_t& report) { std::sort(result.begin(), result.end()); return result; } + +std::vector get_mods(const report_keyboard_t& report) { + std::vector result; + for (size_t i = 0; i < 8; i++) { + if (report.mods & (1 << i)) { + uint8_t code = KC_LEFT_CTRL + i; + result.emplace_back(code); + } + } + std::sort(result.begin(), result.end()); + return result; +} + } // namespace bool operator==(const report_keyboard_t& lhs, const report_keyboard_t& rhs) { @@ -44,21 +62,36 @@ bool operator==(const report_keyboard_t& lhs, const report_keyboard_t& rhs) { return lhs.mods == rhs.mods && lhskeys == rhskeys; } -std::ostream& operator<<(std::ostream& stream, const report_keyboard_t& report) { +std::ostream& operator<<(std::ostream& os, const report_keyboard_t& report) { auto keys = get_keys(report); + auto mods = get_mods(report); - // TODO: This should probably print friendly names for the keys - stream << "Keyboard Report: Mods (" << (uint32_t)report.mods << ") Keys ("; + os << std::setw(10) << std::left << "report: "; + + if (!keys.size() && !mods.size()) { + return os << "empty" << std::endl; + } + os << "("; for (auto key = keys.cbegin(); key != keys.cend();) { - stream << +(*key); + os << KEYCODE_ID_TABLE.at(*key); key++; if (key != keys.cend()) { - stream << ","; + os << ", "; + } + } + + os << ") ["; + + for (auto mod = mods.cbegin(); mod != mods.cend();) { + os << KEYCODE_ID_TABLE.at(*mod); + mod++; + if (mod != mods.cend()) { + os << ", "; } } - return stream << ")" << std::endl; + return os << "]" << std::endl; } KeyboardReportMatcher::KeyboardReportMatcher(const std::vector& keys) { diff --git a/tests/test_common/keycode_table.cpp b/tests/test_common/keycode_table.cpp new file mode 100644 index 0000000000..63350c272d --- /dev/null +++ b/tests/test_common/keycode_table.cpp @@ -0,0 +1,663 @@ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later + +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ + +// clang-format off +extern "C" { +#include +} +#include +#include +#include + +std::map KEYCODE_ID_TABLE = { + {KC_NO, "KC_NO"}, + {KC_TRANSPARENT, "KC_TRANSPARENT"}, + {KC_A, "KC_A"}, + {KC_B, "KC_B"}, + {KC_C, "KC_C"}, + {KC_D, "KC_D"}, + {KC_E, "KC_E"}, + {KC_F, "KC_F"}, + {KC_G, "KC_G"}, + {KC_H, "KC_H"}, + {KC_I, "KC_I"}, + {KC_J, "KC_J"}, + {KC_K, "KC_K"}, + {KC_L, "KC_L"}, + {KC_M, "KC_M"}, + {KC_N, "KC_N"}, + {KC_O, "KC_O"}, + {KC_P, "KC_P"}, + {KC_Q, "KC_Q"}, + {KC_R, "KC_R"}, + {KC_S, "KC_S"}, + {KC_T, "KC_T"}, + {KC_U, "KC_U"}, + {KC_V, "KC_V"}, + {KC_W, "KC_W"}, + {KC_X, "KC_X"}, + {KC_Y, "KC_Y"}, + {KC_Z, "KC_Z"}, + {KC_1, "KC_1"}, + {KC_2, "KC_2"}, + {KC_3, "KC_3"}, + {KC_4, "KC_4"}, + {KC_5, "KC_5"}, + {KC_6, "KC_6"}, + {KC_7, "KC_7"}, + {KC_8, "KC_8"}, + {KC_9, "KC_9"}, + {KC_0, "KC_0"}, + {KC_ENTER, "KC_ENTER"}, + {KC_ESCAPE, "KC_ESCAPE"}, + {KC_BACKSPACE, "KC_BACKSPACE"}, + {KC_TAB, "KC_TAB"}, + {KC_SPACE, "KC_SPACE"}, + {KC_MINUS, "KC_MINUS"}, + {KC_EQUAL, "KC_EQUAL"}, + {KC_LEFT_BRACKET, "KC_LEFT_BRACKET"}, + {KC_RIGHT_BRACKET, "KC_RIGHT_BRACKET"}, + {KC_BACKSLASH, "KC_BACKSLASH"}, + {KC_NONUS_HASH, "KC_NONUS_HASH"}, + {KC_SEMICOLON, "KC_SEMICOLON"}, + {KC_QUOTE, "KC_QUOTE"}, + {KC_GRAVE, "KC_GRAVE"}, + {KC_COMMA, "KC_COMMA"}, + {KC_DOT, "KC_DOT"}, + {KC_SLASH, "KC_SLASH"}, + {KC_CAPS_LOCK, "KC_CAPS_LOCK"}, + {KC_F1, "KC_F1"}, + {KC_F2, "KC_F2"}, + {KC_F3, "KC_F3"}, + {KC_F4, "KC_F4"}, + {KC_F5, "KC_F5"}, + {KC_F6, "KC_F6"}, + {KC_F7, "KC_F7"}, + {KC_F8, "KC_F8"}, + {KC_F9, "KC_F9"}, + {KC_F10, "KC_F10"}, + {KC_F11, "KC_F11"}, + {KC_F12, "KC_F12"}, + {KC_PRINT_SCREEN, "KC_PRINT_SCREEN"}, + {KC_SCROLL_LOCK, "KC_SCROLL_LOCK"}, + {KC_PAUSE, "KC_PAUSE"}, + {KC_INSERT, "KC_INSERT"}, + {KC_HOME, "KC_HOME"}, + {KC_PAGE_UP, "KC_PAGE_UP"}, + {KC_DELETE, "KC_DELETE"}, + {KC_END, "KC_END"}, + {KC_PAGE_DOWN, "KC_PAGE_DOWN"}, + {KC_RIGHT, "KC_RIGHT"}, + {KC_LEFT, "KC_LEFT"}, + {KC_DOWN, "KC_DOWN"}, + {KC_UP, "KC_UP"}, + {KC_NUM_LOCK, "KC_NUM_LOCK"}, + {KC_KP_SLASH, "KC_KP_SLASH"}, + {KC_KP_ASTERISK, "KC_KP_ASTERISK"}, + {KC_KP_MINUS, "KC_KP_MINUS"}, + {KC_KP_PLUS, "KC_KP_PLUS"}, + {KC_KP_ENTER, "KC_KP_ENTER"}, + {KC_KP_1, "KC_KP_1"}, + {KC_KP_2, "KC_KP_2"}, + {KC_KP_3, "KC_KP_3"}, + {KC_KP_4, "KC_KP_4"}, + {KC_KP_5, "KC_KP_5"}, + {KC_KP_6, "KC_KP_6"}, + {KC_KP_7, "KC_KP_7"}, + {KC_KP_8, "KC_KP_8"}, + {KC_KP_9, "KC_KP_9"}, + {KC_KP_0, "KC_KP_0"}, + {KC_KP_DOT, "KC_KP_DOT"}, + {KC_NONUS_BACKSLASH, "KC_NONUS_BACKSLASH"}, + {KC_APPLICATION, "KC_APPLICATION"}, + {KC_KB_POWER, "KC_KB_POWER"}, + {KC_KP_EQUAL, "KC_KP_EQUAL"}, + {KC_F13, "KC_F13"}, + {KC_F14, "KC_F14"}, + {KC_F15, "KC_F15"}, + {KC_F16, "KC_F16"}, + {KC_F17, "KC_F17"}, + {KC_F18, "KC_F18"}, + {KC_F19, "KC_F19"}, + {KC_F20, "KC_F20"}, + {KC_F21, "KC_F21"}, + {KC_F22, "KC_F22"}, + {KC_F23, "KC_F23"}, + {KC_F24, "KC_F24"}, + {KC_EXECUTE, "KC_EXECUTE"}, + {KC_HELP, "KC_HELP"}, + {KC_MENU, "KC_MENU"}, + {KC_SELECT, "KC_SELECT"}, + {KC_STOP, "KC_STOP"}, + {KC_AGAIN, "KC_AGAIN"}, + {KC_UNDO, "KC_UNDO"}, + {KC_CUT, "KC_CUT"}, + {KC_COPY, "KC_COPY"}, + {KC_PASTE, "KC_PASTE"}, + {KC_FIND, "KC_FIND"}, + {KC_KB_MUTE, "KC_KB_MUTE"}, + {KC_KB_VOLUME_UP, "KC_KB_VOLUME_UP"}, + {KC_KB_VOLUME_DOWN, "KC_KB_VOLUME_DOWN"}, + {KC_LOCKING_CAPS_LOCK, "KC_LOCKING_CAPS_LOCK"}, + {KC_LOCKING_NUM_LOCK, "KC_LOCKING_NUM_LOCK"}, + {KC_LOCKING_SCROLL_LOCK, "KC_LOCKING_SCROLL_LOCK"}, + {KC_KP_COMMA, "KC_KP_COMMA"}, + {KC_KP_EQUAL_AS400, "KC_KP_EQUAL_AS400"}, + {KC_INTERNATIONAL_1, "KC_INTERNATIONAL_1"}, + {KC_INTERNATIONAL_2, "KC_INTERNATIONAL_2"}, + {KC_INTERNATIONAL_3, "KC_INTERNATIONAL_3"}, + {KC_INTERNATIONAL_4, "KC_INTERNATIONAL_4"}, + {KC_INTERNATIONAL_5, "KC_INTERNATIONAL_5"}, + {KC_INTERNATIONAL_6, "KC_INTERNATIONAL_6"}, + {KC_INTERNATIONAL_7, "KC_INTERNATIONAL_7"}, + {KC_INTERNATIONAL_8, "KC_INTERNATIONAL_8"}, + {KC_INTERNATIONAL_9, "KC_INTERNATIONAL_9"}, + {KC_LANGUAGE_1, "KC_LANGUAGE_1"}, + {KC_LANGUAGE_2, "KC_LANGUAGE_2"}, + {KC_LANGUAGE_3, "KC_LANGUAGE_3"}, + {KC_LANGUAGE_4, "KC_LANGUAGE_4"}, + {KC_LANGUAGE_5, "KC_LANGUAGE_5"}, + {KC_LANGUAGE_6, "KC_LANGUAGE_6"}, + {KC_LANGUAGE_7, "KC_LANGUAGE_7"}, + {KC_LANGUAGE_8, "KC_LANGUAGE_8"}, + {KC_LANGUAGE_9, "KC_LANGUAGE_9"}, + {KC_ALTERNATE_ERASE, "KC_ALTERNATE_ERASE"}, + {KC_SYSTEM_REQUEST, "KC_SYSTEM_REQUEST"}, + {KC_CANCEL, "KC_CANCEL"}, + {KC_CLEAR, "KC_CLEAR"}, + {KC_PRIOR, "KC_PRIOR"}, + {KC_RETURN, "KC_RETURN"}, + {KC_SEPARATOR, "KC_SEPARATOR"}, + {KC_OUT, "KC_OUT"}, + {KC_OPER, "KC_OPER"}, + {KC_CLEAR_AGAIN, "KC_CLEAR_AGAIN"}, + {KC_CRSEL, "KC_CRSEL"}, + {KC_EXSEL, "KC_EXSEL"}, + {KC_SYSTEM_POWER, "KC_SYSTEM_POWER"}, + {KC_SYSTEM_SLEEP, "KC_SYSTEM_SLEEP"}, + {KC_SYSTEM_WAKE, "KC_SYSTEM_WAKE"}, + {KC_AUDIO_MUTE, "KC_AUDIO_MUTE"}, + {KC_AUDIO_VOL_UP, "KC_AUDIO_VOL_UP"}, + {KC_AUDIO_VOL_DOWN, "KC_AUDIO_VOL_DOWN"}, + {KC_MEDIA_NEXT_TRACK, "KC_MEDIA_NEXT_TRACK"}, + {KC_MEDIA_PREV_TRACK, "KC_MEDIA_PREV_TRACK"}, + {KC_MEDIA_STOP, "KC_MEDIA_STOP"}, + {KC_MEDIA_PLAY_PAUSE, "KC_MEDIA_PLAY_PAUSE"}, + {KC_MEDIA_SELECT, "KC_MEDIA_SELECT"}, + {KC_MEDIA_EJECT, "KC_MEDIA_EJECT"}, + {KC_MAIL, "KC_MAIL"}, + {KC_CALCULATOR, "KC_CALCULATOR"}, + {KC_MY_COMPUTER, "KC_MY_COMPUTER"}, + {KC_WWW_SEARCH, "KC_WWW_SEARCH"}, + {KC_WWW_HOME, "KC_WWW_HOME"}, + {KC_WWW_BACK, "KC_WWW_BACK"}, + {KC_WWW_FORWARD, "KC_WWW_FORWARD"}, + {KC_WWW_STOP, "KC_WWW_STOP"}, + {KC_WWW_REFRESH, "KC_WWW_REFRESH"}, + {KC_WWW_FAVORITES, "KC_WWW_FAVORITES"}, + {KC_MEDIA_FAST_FORWARD, "KC_MEDIA_FAST_FORWARD"}, + {KC_MEDIA_REWIND, "KC_MEDIA_REWIND"}, + {KC_BRIGHTNESS_UP, "KC_BRIGHTNESS_UP"}, + {KC_BRIGHTNESS_DOWN, "KC_BRIGHTNESS_DOWN"}, + {KC_CONTROL_PANEL, "KC_CONTROL_PANEL"}, + {KC_ASSISTANT, "KC_ASSISTANT"}, + {KC_MS_UP, "KC_MS_UP"}, + {KC_MS_DOWN, "KC_MS_DOWN"}, + {KC_MS_LEFT, "KC_MS_LEFT"}, + {KC_MS_RIGHT, "KC_MS_RIGHT"}, + {KC_MS_BTN1, "KC_MS_BTN1"}, + {KC_MS_BTN2, "KC_MS_BTN2"}, + {KC_MS_BTN3, "KC_MS_BTN3"}, + {KC_MS_BTN4, "KC_MS_BTN4"}, + {KC_MS_BTN5, "KC_MS_BTN5"}, + {KC_MS_BTN6, "KC_MS_BTN6"}, + {KC_MS_BTN7, "KC_MS_BTN7"}, + {KC_MS_BTN8, "KC_MS_BTN8"}, + {KC_MS_WH_UP, "KC_MS_WH_UP"}, + {KC_MS_WH_DOWN, "KC_MS_WH_DOWN"}, + {KC_MS_WH_LEFT, "KC_MS_WH_LEFT"}, + {KC_MS_WH_RIGHT, "KC_MS_WH_RIGHT"}, + {KC_MS_ACCEL0, "KC_MS_ACCEL0"}, + {KC_MS_ACCEL1, "KC_MS_ACCEL1"}, + {KC_MS_ACCEL2, "KC_MS_ACCEL2"}, + {KC_LEFT_CTRL, "KC_LEFT_CTRL"}, + {KC_LEFT_SHIFT, "KC_LEFT_SHIFT"}, + {KC_LEFT_ALT, "KC_LEFT_ALT"}, + {KC_LEFT_GUI, "KC_LEFT_GUI"}, + {KC_RIGHT_CTRL, "KC_RIGHT_CTRL"}, + {KC_RIGHT_SHIFT, "KC_RIGHT_SHIFT"}, + {KC_RIGHT_ALT, "KC_RIGHT_ALT"}, + {KC_RIGHT_GUI, "KC_RIGHT_GUI"}, + {SH_TG, "SH_TG"}, + {SH_TT, "SH_TT"}, + {SH_MON, "SH_MON"}, + {SH_MOFF, "SH_MOFF"}, + {SH_OFF, "SH_OFF"}, + {SH_ON, "SH_ON"}, + {SH_OS, "SH_OS"}, + {MAGIC_SWAP_CONTROL_CAPSLOCK, "MAGIC_SWAP_CONTROL_CAPSLOCK"}, + {MAGIC_UNSWAP_CONTROL_CAPSLOCK, "MAGIC_UNSWAP_CONTROL_CAPSLOCK"}, + {MAGIC_TOGGLE_CONTROL_CAPSLOCK, "MAGIC_TOGGLE_CONTROL_CAPSLOCK"}, + {MAGIC_UNCAPSLOCK_TO_CONTROL, "MAGIC_UNCAPSLOCK_TO_CONTROL"}, + {MAGIC_CAPSLOCK_TO_CONTROL, "MAGIC_CAPSLOCK_TO_CONTROL"}, + {MAGIC_SWAP_LALT_LGUI, "MAGIC_SWAP_LALT_LGUI"}, + {MAGIC_UNSWAP_LALT_LGUI, "MAGIC_UNSWAP_LALT_LGUI"}, + {MAGIC_SWAP_RALT_RGUI, "MAGIC_SWAP_RALT_RGUI"}, + {MAGIC_UNSWAP_RALT_RGUI, "MAGIC_UNSWAP_RALT_RGUI"}, + {MAGIC_UNNO_GUI, "MAGIC_UNNO_GUI"}, + {MAGIC_NO_GUI, "MAGIC_NO_GUI"}, + {MAGIC_TOGGLE_GUI, "MAGIC_TOGGLE_GUI"}, + {MAGIC_SWAP_GRAVE_ESC, "MAGIC_SWAP_GRAVE_ESC"}, + {MAGIC_UNSWAP_GRAVE_ESC, "MAGIC_UNSWAP_GRAVE_ESC"}, + {MAGIC_SWAP_BACKSLASH_BACKSPACE, "MAGIC_SWAP_BACKSLASH_BACKSPACE"}, + {MAGIC_UNSWAP_BACKSLASH_BACKSPACE, "MAGIC_UNSWAP_BACKSLASH_BACKSPACE"}, + {MAGIC_TOGGLE_BACKSLASH_BACKSPACE, "MAGIC_TOGGLE_BACKSLASH_BACKSPACE"}, + {MAGIC_HOST_NKRO, "MAGIC_HOST_NKRO"}, + {MAGIC_UNHOST_NKRO, "MAGIC_UNHOST_NKRO"}, + {MAGIC_TOGGLE_NKRO, "MAGIC_TOGGLE_NKRO"}, + {MAGIC_SWAP_ALT_GUI, "MAGIC_SWAP_ALT_GUI"}, + {MAGIC_UNSWAP_ALT_GUI, "MAGIC_UNSWAP_ALT_GUI"}, + {MAGIC_TOGGLE_ALT_GUI, "MAGIC_TOGGLE_ALT_GUI"}, + {MAGIC_SWAP_LCTL_LGUI, "MAGIC_SWAP_LCTL_LGUI"}, + {MAGIC_UNSWAP_LCTL_LGUI, "MAGIC_UNSWAP_LCTL_LGUI"}, + {MAGIC_SWAP_RCTL_RGUI, "MAGIC_SWAP_RCTL_RGUI"}, + {MAGIC_UNSWAP_RCTL_RGUI, "MAGIC_UNSWAP_RCTL_RGUI"}, + {MAGIC_SWAP_CTL_GUI, "MAGIC_SWAP_CTL_GUI"}, + {MAGIC_UNSWAP_CTL_GUI, "MAGIC_UNSWAP_CTL_GUI"}, + {MAGIC_TOGGLE_CTL_GUI, "MAGIC_TOGGLE_CTL_GUI"}, + {MAGIC_EE_HANDS_LEFT, "MAGIC_EE_HANDS_LEFT"}, + {MAGIC_EE_HANDS_RIGHT, "MAGIC_EE_HANDS_RIGHT"}, + {MAGIC_SWAP_ESCAPE_CAPSLOCK, "MAGIC_SWAP_ESCAPE_CAPSLOCK"}, + {MAGIC_UNSWAP_ESCAPE_CAPSLOCK, "MAGIC_UNSWAP_ESCAPE_CAPSLOCK"}, + {MAGIC_TOGGLE_ESCAPE_CAPSLOCK, "MAGIC_TOGGLE_ESCAPE_CAPSLOCK"}, + {QK_MIDI_ON, "QK_MIDI_ON"}, + {QK_MIDI_OFF, "QK_MIDI_OFF"}, + {QK_MIDI_TOGGLE, "QK_MIDI_TOGGLE"}, + {QK_MIDI_NOTE_C_0, "QK_MIDI_NOTE_C_0"}, + {QK_MIDI_NOTE_C_SHARP_0, "QK_MIDI_NOTE_C_SHARP_0"}, + {QK_MIDI_NOTE_D_0, "QK_MIDI_NOTE_D_0"}, + {QK_MIDI_NOTE_D_SHARP_0, "QK_MIDI_NOTE_D_SHARP_0"}, + {QK_MIDI_NOTE_E_0, "QK_MIDI_NOTE_E_0"}, + {QK_MIDI_NOTE_F_0, "QK_MIDI_NOTE_F_0"}, + {QK_MIDI_NOTE_F_SHARP_0, "QK_MIDI_NOTE_F_SHARP_0"}, + {QK_MIDI_NOTE_G_0, "QK_MIDI_NOTE_G_0"}, + {QK_MIDI_NOTE_G_SHARP_0, "QK_MIDI_NOTE_G_SHARP_0"}, + {QK_MIDI_NOTE_A_0, "QK_MIDI_NOTE_A_0"}, + {QK_MIDI_NOTE_A_SHARP_0, "QK_MIDI_NOTE_A_SHARP_0"}, + {QK_MIDI_NOTE_B_0, "QK_MIDI_NOTE_B_0"}, + {QK_MIDI_NOTE_C_1, "QK_MIDI_NOTE_C_1"}, + {QK_MIDI_NOTE_C_SHARP_1, "QK_MIDI_NOTE_C_SHARP_1"}, + {QK_MIDI_NOTE_D_1, "QK_MIDI_NOTE_D_1"}, + {QK_MIDI_NOTE_D_SHARP_1, "QK_MIDI_NOTE_D_SHARP_1"}, + {QK_MIDI_NOTE_E_1, "QK_MIDI_NOTE_E_1"}, + {QK_MIDI_NOTE_F_1, "QK_MIDI_NOTE_F_1"}, + {QK_MIDI_NOTE_F_SHARP_1, "QK_MIDI_NOTE_F_SHARP_1"}, + {QK_MIDI_NOTE_G_1, "QK_MIDI_NOTE_G_1"}, + {QK_MIDI_NOTE_G_SHARP_1, "QK_MIDI_NOTE_G_SHARP_1"}, + {QK_MIDI_NOTE_A_1, "QK_MIDI_NOTE_A_1"}, + {QK_MIDI_NOTE_A_SHARP_1, "QK_MIDI_NOTE_A_SHARP_1"}, + {QK_MIDI_NOTE_B_1, "QK_MIDI_NOTE_B_1"}, + {QK_MIDI_NOTE_C_2, "QK_MIDI_NOTE_C_2"}, + {QK_MIDI_NOTE_C_SHARP_2, "QK_MIDI_NOTE_C_SHARP_2"}, + {QK_MIDI_NOTE_D_2, "QK_MIDI_NOTE_D_2"}, + {QK_MIDI_NOTE_D_SHARP_2, "QK_MIDI_NOTE_D_SHARP_2"}, + {QK_MIDI_NOTE_E_2, "QK_MIDI_NOTE_E_2"}, + {QK_MIDI_NOTE_F_2, "QK_MIDI_NOTE_F_2"}, + {QK_MIDI_NOTE_F_SHARP_2, "QK_MIDI_NOTE_F_SHARP_2"}, + {QK_MIDI_NOTE_G_2, "QK_MIDI_NOTE_G_2"}, + {QK_MIDI_NOTE_G_SHARP_2, "QK_MIDI_NOTE_G_SHARP_2"}, + {QK_MIDI_NOTE_A_2, "QK_MIDI_NOTE_A_2"}, + {QK_MIDI_NOTE_A_SHARP_2, "QK_MIDI_NOTE_A_SHARP_2"}, + {QK_MIDI_NOTE_B_2, "QK_MIDI_NOTE_B_2"}, + {QK_MIDI_NOTE_C_3, "QK_MIDI_NOTE_C_3"}, + {QK_MIDI_NOTE_C_SHARP_3, "QK_MIDI_NOTE_C_SHARP_3"}, + {QK_MIDI_NOTE_D_3, "QK_MIDI_NOTE_D_3"}, + {QK_MIDI_NOTE_D_SHARP_3, "QK_MIDI_NOTE_D_SHARP_3"}, + {QK_MIDI_NOTE_E_3, "QK_MIDI_NOTE_E_3"}, + {QK_MIDI_NOTE_F_3, "QK_MIDI_NOTE_F_3"}, + {QK_MIDI_NOTE_F_SHARP_3, "QK_MIDI_NOTE_F_SHARP_3"}, + {QK_MIDI_NOTE_G_3, "QK_MIDI_NOTE_G_3"}, + {QK_MIDI_NOTE_G_SHARP_3, "QK_MIDI_NOTE_G_SHARP_3"}, + {QK_MIDI_NOTE_A_3, "QK_MIDI_NOTE_A_3"}, + {QK_MIDI_NOTE_A_SHARP_3, "QK_MIDI_NOTE_A_SHARP_3"}, + {QK_MIDI_NOTE_B_3, "QK_MIDI_NOTE_B_3"}, + {QK_MIDI_NOTE_C_4, "QK_MIDI_NOTE_C_4"}, + {QK_MIDI_NOTE_C_SHARP_4, "QK_MIDI_NOTE_C_SHARP_4"}, + {QK_MIDI_NOTE_D_4, "QK_MIDI_NOTE_D_4"}, + {QK_MIDI_NOTE_D_SHARP_4, "QK_MIDI_NOTE_D_SHARP_4"}, + {QK_MIDI_NOTE_E_4, "QK_MIDI_NOTE_E_4"}, + {QK_MIDI_NOTE_F_4, "QK_MIDI_NOTE_F_4"}, + {QK_MIDI_NOTE_F_SHARP_4, "QK_MIDI_NOTE_F_SHARP_4"}, + {QK_MIDI_NOTE_G_4, "QK_MIDI_NOTE_G_4"}, + {QK_MIDI_NOTE_G_SHARP_4, "QK_MIDI_NOTE_G_SHARP_4"}, + {QK_MIDI_NOTE_A_4, "QK_MIDI_NOTE_A_4"}, + {QK_MIDI_NOTE_A_SHARP_4, "QK_MIDI_NOTE_A_SHARP_4"}, + {QK_MIDI_NOTE_B_4, "QK_MIDI_NOTE_B_4"}, + {QK_MIDI_NOTE_C_5, "QK_MIDI_NOTE_C_5"}, + {QK_MIDI_NOTE_C_SHARP_5, "QK_MIDI_NOTE_C_SHARP_5"}, + {QK_MIDI_NOTE_D_5, "QK_MIDI_NOTE_D_5"}, + {QK_MIDI_NOTE_D_SHARP_5, "QK_MIDI_NOTE_D_SHARP_5"}, + {QK_MIDI_NOTE_E_5, "QK_MIDI_NOTE_E_5"}, + {QK_MIDI_NOTE_F_5, "QK_MIDI_NOTE_F_5"}, + {QK_MIDI_NOTE_F_SHARP_5, "QK_MIDI_NOTE_F_SHARP_5"}, + {QK_MIDI_NOTE_G_5, "QK_MIDI_NOTE_G_5"}, + {QK_MIDI_NOTE_G_SHARP_5, "QK_MIDI_NOTE_G_SHARP_5"}, + {QK_MIDI_NOTE_A_5, "QK_MIDI_NOTE_A_5"}, + {QK_MIDI_NOTE_A_SHARP_5, "QK_MIDI_NOTE_A_SHARP_5"}, + {QK_MIDI_NOTE_B_5, "QK_MIDI_NOTE_B_5"}, + {QK_MIDI_OCTAVE_N2, "QK_MIDI_OCTAVE_N2"}, + {QK_MIDI_OCTAVE_N1, "QK_MIDI_OCTAVE_N1"}, + {QK_MIDI_OCTAVE_0, "QK_MIDI_OCTAVE_0"}, + {QK_MIDI_OCTAVE_1, "QK_MIDI_OCTAVE_1"}, + {QK_MIDI_OCTAVE_2, "QK_MIDI_OCTAVE_2"}, + {QK_MIDI_OCTAVE_3, "QK_MIDI_OCTAVE_3"}, + {QK_MIDI_OCTAVE_4, "QK_MIDI_OCTAVE_4"}, + {QK_MIDI_OCTAVE_5, "QK_MIDI_OCTAVE_5"}, + {QK_MIDI_OCTAVE_6, "QK_MIDI_OCTAVE_6"}, + {QK_MIDI_OCTAVE_7, "QK_MIDI_OCTAVE_7"}, + {QK_MIDI_OCTAVE_DOWN, "QK_MIDI_OCTAVE_DOWN"}, + {QK_MIDI_OCTAVE_UP, "QK_MIDI_OCTAVE_UP"}, + {QK_MIDI_TRANSPOSE_N6, "QK_MIDI_TRANSPOSE_N6"}, + {QK_MIDI_TRANSPOSE_N5, "QK_MIDI_TRANSPOSE_N5"}, + {QK_MIDI_TRANSPOSE_N4, "QK_MIDI_TRANSPOSE_N4"}, + {QK_MIDI_TRANSPOSE_N3, "QK_MIDI_TRANSPOSE_N3"}, + {QK_MIDI_TRANSPOSE_N2, "QK_MIDI_TRANSPOSE_N2"}, + {QK_MIDI_TRANSPOSE_N1, "QK_MIDI_TRANSPOSE_N1"}, + {QK_MIDI_TRANSPOSE_0, "QK_MIDI_TRANSPOSE_0"}, + {QK_MIDI_TRANSPOSE_1, "QK_MIDI_TRANSPOSE_1"}, + {QK_MIDI_TRANSPOSE_2, "QK_MIDI_TRANSPOSE_2"}, + {QK_MIDI_TRANSPOSE_3, "QK_MIDI_TRANSPOSE_3"}, + {QK_MIDI_TRANSPOSE_4, "QK_MIDI_TRANSPOSE_4"}, + {QK_MIDI_TRANSPOSE_5, "QK_MIDI_TRANSPOSE_5"}, + {QK_MIDI_TRANSPOSE_6, "QK_MIDI_TRANSPOSE_6"}, + {QK_MIDI_TRANSPOSE_DOWN, "QK_MIDI_TRANSPOSE_DOWN"}, + {QK_MIDI_TRANSPOSE_UP, "QK_MIDI_TRANSPOSE_UP"}, + {QK_MIDI_VELOCITY_0, "QK_MIDI_VELOCITY_0"}, + {QK_MIDI_VELOCITY_1, "QK_MIDI_VELOCITY_1"}, + {QK_MIDI_VELOCITY_2, "QK_MIDI_VELOCITY_2"}, + {QK_MIDI_VELOCITY_3, "QK_MIDI_VELOCITY_3"}, + {QK_MIDI_VELOCITY_4, "QK_MIDI_VELOCITY_4"}, + {QK_MIDI_VELOCITY_5, "QK_MIDI_VELOCITY_5"}, + {QK_MIDI_VELOCITY_6, "QK_MIDI_VELOCITY_6"}, + {QK_MIDI_VELOCITY_7, "QK_MIDI_VELOCITY_7"}, + {QK_MIDI_VELOCITY_8, "QK_MIDI_VELOCITY_8"}, + {QK_MIDI_VELOCITY_9, "QK_MIDI_VELOCITY_9"}, + {QK_MIDI_VELOCITY_10, "QK_MIDI_VELOCITY_10"}, + {QK_MIDI_VELOCITY_DOWN, "QK_MIDI_VELOCITY_DOWN"}, + {QK_MIDI_VELOCITY_UP, "QK_MIDI_VELOCITY_UP"}, + {QK_MIDI_CHANNEL_1, "QK_MIDI_CHANNEL_1"}, + {QK_MIDI_CHANNEL_2, "QK_MIDI_CHANNEL_2"}, + {QK_MIDI_CHANNEL_3, "QK_MIDI_CHANNEL_3"}, + {QK_MIDI_CHANNEL_4, "QK_MIDI_CHANNEL_4"}, + {QK_MIDI_CHANNEL_5, "QK_MIDI_CHANNEL_5"}, + {QK_MIDI_CHANNEL_6, "QK_MIDI_CHANNEL_6"}, + {QK_MIDI_CHANNEL_7, "QK_MIDI_CHANNEL_7"}, + {QK_MIDI_CHANNEL_8, "QK_MIDI_CHANNEL_8"}, + {QK_MIDI_CHANNEL_9, "QK_MIDI_CHANNEL_9"}, + {QK_MIDI_CHANNEL_10, "QK_MIDI_CHANNEL_10"}, + {QK_MIDI_CHANNEL_11, "QK_MIDI_CHANNEL_11"}, + {QK_MIDI_CHANNEL_12, "QK_MIDI_CHANNEL_12"}, + {QK_MIDI_CHANNEL_13, "QK_MIDI_CHANNEL_13"}, + {QK_MIDI_CHANNEL_14, "QK_MIDI_CHANNEL_14"}, + {QK_MIDI_CHANNEL_15, "QK_MIDI_CHANNEL_15"}, + {QK_MIDI_CHANNEL_16, "QK_MIDI_CHANNEL_16"}, + {QK_MIDI_CHANNEL_DOWN, "QK_MIDI_CHANNEL_DOWN"}, + {QK_MIDI_CHANNEL_UP, "QK_MIDI_CHANNEL_UP"}, + {QK_MIDI_ALL_NOTES_OFF, "QK_MIDI_ALL_NOTES_OFF"}, + {QK_MIDI_SUSTAIN, "QK_MIDI_SUSTAIN"}, + {QK_MIDI_PORTAMENTO, "QK_MIDI_PORTAMENTO"}, + {QK_MIDI_SOSTENUTO, "QK_MIDI_SOSTENUTO"}, + {QK_MIDI_SOFT, "QK_MIDI_SOFT"}, + {QK_MIDI_LEGATO, "QK_MIDI_LEGATO"}, + {QK_MIDI_MODULATION, "QK_MIDI_MODULATION"}, + {QK_MIDI_MODULATION_SPEED_DOWN, "QK_MIDI_MODULATION_SPEED_DOWN"}, + {QK_MIDI_MODULATION_SPEED_UP, "QK_MIDI_MODULATION_SPEED_UP"}, + {QK_MIDI_PITCH_BEND_DOWN, "QK_MIDI_PITCH_BEND_DOWN"}, + {QK_MIDI_PITCH_BEND_UP, "QK_MIDI_PITCH_BEND_UP"}, + {SQ_ON, "SQ_ON"}, + {SQ_OFF, "SQ_OFF"}, + {SQ_TOG, "SQ_TOG"}, + {SQ_TMPD, "SQ_TMPD"}, + {SQ_TMPU, "SQ_TMPU"}, + {SQ_RESD, "SQ_RESD"}, + {SQ_RESU, "SQ_RESU"}, + {SQ_SALL, "SQ_SALL"}, + {SQ_SCLR, "SQ_SCLR"}, + {QK_JOYSTICK_BUTTON_0, "QK_JOYSTICK_BUTTON_0"}, + {QK_JOYSTICK_BUTTON_1, "QK_JOYSTICK_BUTTON_1"}, + {QK_JOYSTICK_BUTTON_2, "QK_JOYSTICK_BUTTON_2"}, + {QK_JOYSTICK_BUTTON_3, "QK_JOYSTICK_BUTTON_3"}, + {QK_JOYSTICK_BUTTON_4, "QK_JOYSTICK_BUTTON_4"}, + {QK_JOYSTICK_BUTTON_5, "QK_JOYSTICK_BUTTON_5"}, + {QK_JOYSTICK_BUTTON_6, "QK_JOYSTICK_BUTTON_6"}, + {QK_JOYSTICK_BUTTON_7, "QK_JOYSTICK_BUTTON_7"}, + {QK_JOYSTICK_BUTTON_8, "QK_JOYSTICK_BUTTON_8"}, + {QK_JOYSTICK_BUTTON_9, "QK_JOYSTICK_BUTTON_9"}, + {QK_JOYSTICK_BUTTON_10, "QK_JOYSTICK_BUTTON_10"}, + {QK_JOYSTICK_BUTTON_11, "QK_JOYSTICK_BUTTON_11"}, + {QK_JOYSTICK_BUTTON_12, "QK_JOYSTICK_BUTTON_12"}, + {QK_JOYSTICK_BUTTON_13, "QK_JOYSTICK_BUTTON_13"}, + {QK_JOYSTICK_BUTTON_14, "QK_JOYSTICK_BUTTON_14"}, + {QK_JOYSTICK_BUTTON_15, "QK_JOYSTICK_BUTTON_15"}, + {QK_JOYSTICK_BUTTON_16, "QK_JOYSTICK_BUTTON_16"}, + {QK_JOYSTICK_BUTTON_17, "QK_JOYSTICK_BUTTON_17"}, + {QK_JOYSTICK_BUTTON_18, "QK_JOYSTICK_BUTTON_18"}, + {QK_JOYSTICK_BUTTON_19, "QK_JOYSTICK_BUTTON_19"}, + {QK_JOYSTICK_BUTTON_20, "QK_JOYSTICK_BUTTON_20"}, + {QK_JOYSTICK_BUTTON_21, "QK_JOYSTICK_BUTTON_21"}, + {QK_JOYSTICK_BUTTON_22, "QK_JOYSTICK_BUTTON_22"}, + {QK_JOYSTICK_BUTTON_23, "QK_JOYSTICK_BUTTON_23"}, + {QK_JOYSTICK_BUTTON_24, "QK_JOYSTICK_BUTTON_24"}, + {QK_JOYSTICK_BUTTON_25, "QK_JOYSTICK_BUTTON_25"}, + {QK_JOYSTICK_BUTTON_26, "QK_JOYSTICK_BUTTON_26"}, + {QK_JOYSTICK_BUTTON_27, "QK_JOYSTICK_BUTTON_27"}, + {QK_JOYSTICK_BUTTON_28, "QK_JOYSTICK_BUTTON_28"}, + {QK_JOYSTICK_BUTTON_29, "QK_JOYSTICK_BUTTON_29"}, + {QK_JOYSTICK_BUTTON_30, "QK_JOYSTICK_BUTTON_30"}, + {QK_JOYSTICK_BUTTON_31, "QK_JOYSTICK_BUTTON_31"}, + {QK_PROGRAMMABLE_BUTTON_1, "QK_PROGRAMMABLE_BUTTON_1"}, + {QK_PROGRAMMABLE_BUTTON_2, "QK_PROGRAMMABLE_BUTTON_2"}, + {QK_PROGRAMMABLE_BUTTON_3, "QK_PROGRAMMABLE_BUTTON_3"}, + {QK_PROGRAMMABLE_BUTTON_4, "QK_PROGRAMMABLE_BUTTON_4"}, + {QK_PROGRAMMABLE_BUTTON_5, "QK_PROGRAMMABLE_BUTTON_5"}, + {QK_PROGRAMMABLE_BUTTON_6, "QK_PROGRAMMABLE_BUTTON_6"}, + {QK_PROGRAMMABLE_BUTTON_7, "QK_PROGRAMMABLE_BUTTON_7"}, + {QK_PROGRAMMABLE_BUTTON_8, "QK_PROGRAMMABLE_BUTTON_8"}, + {QK_PROGRAMMABLE_BUTTON_9, "QK_PROGRAMMABLE_BUTTON_9"}, + {QK_PROGRAMMABLE_BUTTON_10, "QK_PROGRAMMABLE_BUTTON_10"}, + {QK_PROGRAMMABLE_BUTTON_11, "QK_PROGRAMMABLE_BUTTON_11"}, + {QK_PROGRAMMABLE_BUTTON_12, "QK_PROGRAMMABLE_BUTTON_12"}, + {QK_PROGRAMMABLE_BUTTON_13, "QK_PROGRAMMABLE_BUTTON_13"}, + {QK_PROGRAMMABLE_BUTTON_14, "QK_PROGRAMMABLE_BUTTON_14"}, + {QK_PROGRAMMABLE_BUTTON_15, "QK_PROGRAMMABLE_BUTTON_15"}, + {QK_PROGRAMMABLE_BUTTON_16, "QK_PROGRAMMABLE_BUTTON_16"}, + {QK_PROGRAMMABLE_BUTTON_17, "QK_PROGRAMMABLE_BUTTON_17"}, + {QK_PROGRAMMABLE_BUTTON_18, "QK_PROGRAMMABLE_BUTTON_18"}, + {QK_PROGRAMMABLE_BUTTON_19, "QK_PROGRAMMABLE_BUTTON_19"}, + {QK_PROGRAMMABLE_BUTTON_20, "QK_PROGRAMMABLE_BUTTON_20"}, + {QK_PROGRAMMABLE_BUTTON_21, "QK_PROGRAMMABLE_BUTTON_21"}, + {QK_PROGRAMMABLE_BUTTON_22, "QK_PROGRAMMABLE_BUTTON_22"}, + {QK_PROGRAMMABLE_BUTTON_23, "QK_PROGRAMMABLE_BUTTON_23"}, + {QK_PROGRAMMABLE_BUTTON_24, "QK_PROGRAMMABLE_BUTTON_24"}, + {QK_PROGRAMMABLE_BUTTON_25, "QK_PROGRAMMABLE_BUTTON_25"}, + {QK_PROGRAMMABLE_BUTTON_26, "QK_PROGRAMMABLE_BUTTON_26"}, + {QK_PROGRAMMABLE_BUTTON_27, "QK_PROGRAMMABLE_BUTTON_27"}, + {QK_PROGRAMMABLE_BUTTON_28, "QK_PROGRAMMABLE_BUTTON_28"}, + {QK_PROGRAMMABLE_BUTTON_29, "QK_PROGRAMMABLE_BUTTON_29"}, + {QK_PROGRAMMABLE_BUTTON_30, "QK_PROGRAMMABLE_BUTTON_30"}, + {QK_PROGRAMMABLE_BUTTON_31, "QK_PROGRAMMABLE_BUTTON_31"}, + {QK_PROGRAMMABLE_BUTTON_32, "QK_PROGRAMMABLE_BUTTON_32"}, + {QK_AUDIO_ON, "QK_AUDIO_ON"}, + {QK_AUDIO_OFF, "QK_AUDIO_OFF"}, + {QK_AUDIO_TOGGLE, "QK_AUDIO_TOGGLE"}, + {QK_AUDIO_CLICKY_TOGGLE, "QK_AUDIO_CLICKY_TOGGLE"}, + {QK_AUDIO_CLICKY_ON, "QK_AUDIO_CLICKY_ON"}, + {QK_AUDIO_CLICKY_OFF, "QK_AUDIO_CLICKY_OFF"}, + {QK_AUDIO_CLICKY_UP, "QK_AUDIO_CLICKY_UP"}, + {QK_AUDIO_CLICKY_DOWN, "QK_AUDIO_CLICKY_DOWN"}, + {QK_AUDIO_CLICKY_RESET, "QK_AUDIO_CLICKY_RESET"}, + {QK_MUSIC_ON, "QK_MUSIC_ON"}, + {QK_MUSIC_OFF, "QK_MUSIC_OFF"}, + {QK_MUSIC_TOGGLE, "QK_MUSIC_TOGGLE"}, + {QK_MUSIC_MODE_NEXT, "QK_MUSIC_MODE_NEXT"}, + {QK_AUDIO_VOICE_NEXT, "QK_AUDIO_VOICE_NEXT"}, + {QK_AUDIO_VOICE_PREVIOUS, "QK_AUDIO_VOICE_PREVIOUS"}, + {QK_STENO_BOLT, "QK_STENO_BOLT"}, + {QK_STENO_GEMINI, "QK_STENO_GEMINI"}, + {QK_STENO_COMB, "QK_STENO_COMB"}, + {QK_STENO_COMB_MAX, "QK_STENO_COMB_MAX"}, + {QK_MACRO_0, "QK_MACRO_0"}, + {QK_MACRO_1, "QK_MACRO_1"}, + {QK_MACRO_2, "QK_MACRO_2"}, + {QK_MACRO_3, "QK_MACRO_3"}, + {QK_MACRO_4, "QK_MACRO_4"}, + {QK_MACRO_5, "QK_MACRO_5"}, + {QK_MACRO_6, "QK_MACRO_6"}, + {QK_MACRO_7, "QK_MACRO_7"}, + {QK_MACRO_8, "QK_MACRO_8"}, + {QK_MACRO_9, "QK_MACRO_9"}, + {QK_MACRO_10, "QK_MACRO_10"}, + {QK_MACRO_11, "QK_MACRO_11"}, + {QK_MACRO_12, "QK_MACRO_12"}, + {QK_MACRO_13, "QK_MACRO_13"}, + {QK_MACRO_14, "QK_MACRO_14"}, + {QK_MACRO_15, "QK_MACRO_15"}, + {QK_MACRO_16, "QK_MACRO_16"}, + {QK_MACRO_17, "QK_MACRO_17"}, + {QK_MACRO_18, "QK_MACRO_18"}, + {QK_MACRO_19, "QK_MACRO_19"}, + {QK_MACRO_20, "QK_MACRO_20"}, + {QK_MACRO_21, "QK_MACRO_21"}, + {QK_MACRO_22, "QK_MACRO_22"}, + {QK_MACRO_23, "QK_MACRO_23"}, + {QK_MACRO_24, "QK_MACRO_24"}, + {QK_MACRO_25, "QK_MACRO_25"}, + {QK_MACRO_26, "QK_MACRO_26"}, + {QK_MACRO_27, "QK_MACRO_27"}, + {QK_MACRO_28, "QK_MACRO_28"}, + {QK_MACRO_29, "QK_MACRO_29"}, + {QK_MACRO_30, "QK_MACRO_30"}, + {QK_MACRO_31, "QK_MACRO_31"}, + {QK_BACKLIGHT_ON, "QK_BACKLIGHT_ON"}, + {QK_BACKLIGHT_OFF, "QK_BACKLIGHT_OFF"}, + {QK_BACKLIGHT_TOGGLE, "QK_BACKLIGHT_TOGGLE"}, + {QK_BACKLIGHT_DOWN, "QK_BACKLIGHT_DOWN"}, + {QK_BACKLIGHT_UP, "QK_BACKLIGHT_UP"}, + {QK_BACKLIGHT_STEP, "QK_BACKLIGHT_STEP"}, + {QK_BACKLIGHT_TOGGLE_BREATHING, "QK_BACKLIGHT_TOGGLE_BREATHING"}, + {RGB_TOG, "RGB_TOG"}, + {RGB_MODE_FORWARD, "RGB_MODE_FORWARD"}, + {RGB_MODE_REVERSE, "RGB_MODE_REVERSE"}, + {RGB_HUI, "RGB_HUI"}, + {RGB_HUD, "RGB_HUD"}, + {RGB_SAI, "RGB_SAI"}, + {RGB_SAD, "RGB_SAD"}, + {RGB_VAI, "RGB_VAI"}, + {RGB_VAD, "RGB_VAD"}, + {RGB_SPI, "RGB_SPI"}, + {RGB_SPD, "RGB_SPD"}, + {RGB_MODE_PLAIN, "RGB_MODE_PLAIN"}, + {RGB_MODE_BREATHE, "RGB_MODE_BREATHE"}, + {RGB_MODE_RAINBOW, "RGB_MODE_RAINBOW"}, + {RGB_MODE_SWIRL, "RGB_MODE_SWIRL"}, + {RGB_MODE_SNAKE, "RGB_MODE_SNAKE"}, + {RGB_MODE_KNIGHT, "RGB_MODE_KNIGHT"}, + {RGB_MODE_XMAS, "RGB_MODE_XMAS"}, + {RGB_MODE_GRADIENT, "RGB_MODE_GRADIENT"}, + {RGB_MODE_RGBTEST, "RGB_MODE_RGBTEST"}, + {RGB_MODE_TWINKLE, "RGB_MODE_TWINKLE"}, + {QK_BOOTLOADER, "QK_BOOTLOADER"}, + {QK_REBOOT, "QK_REBOOT"}, + {QK_DEBUG_TOGGLE, "QK_DEBUG_TOGGLE"}, + {QK_CLEAR_EEPROM, "QK_CLEAR_EEPROM"}, + {QK_MAKE, "QK_MAKE"}, + {QK_AUTO_SHIFT_DOWN, "QK_AUTO_SHIFT_DOWN"}, + {QK_AUTO_SHIFT_UP, "QK_AUTO_SHIFT_UP"}, + {QK_AUTO_SHIFT_REPORT, "QK_AUTO_SHIFT_REPORT"}, + {QK_AUTO_SHIFT_ON, "QK_AUTO_SHIFT_ON"}, + {QK_AUTO_SHIFT_OFF, "QK_AUTO_SHIFT_OFF"}, + {QK_AUTO_SHIFT_TOGGLE, "QK_AUTO_SHIFT_TOGGLE"}, + {QK_GRAVE_ESCAPE, "QK_GRAVE_ESCAPE"}, + {QK_VELOCIKEY_TOGGLE, "QK_VELOCIKEY_TOGGLE"}, + {QK_SPACE_CADET_LEFT_CTRL_PARENTHESIS_OPEN, "QK_SPACE_CADET_LEFT_CTRL_PARENTHESIS_OPEN"}, + {QK_SPACE_CADET_RIGHT_CTRL_PARENTHESIS_CLOSE, "QK_SPACE_CADET_RIGHT_CTRL_PARENTHESIS_CLOSE"}, + {QK_SPACE_CADET_LEFT_SHIFT_PARENTHESIS_OPEN, "QK_SPACE_CADET_LEFT_SHIFT_PARENTHESIS_OPEN"}, + {QK_SPACE_CADET_RIGHT_SHIFT_PARENTHESIS_CLOSE, "QK_SPACE_CADET_RIGHT_SHIFT_PARENTHESIS_CLOSE"}, + {QK_SPACE_CADET_LEFT_ALT_PARENTHESIS_OPEN, "QK_SPACE_CADET_LEFT_ALT_PARENTHESIS_OPEN"}, + {QK_SPACE_CADET_RIGHT_ALT_PARENTHESIS_CLOSE, "QK_SPACE_CADET_RIGHT_ALT_PARENTHESIS_CLOSE"}, + {QK_SPACE_CADET_RIGHT_SHIFT_ENTER, "QK_SPACE_CADET_RIGHT_SHIFT_ENTER"}, + {QK_OUTPUT_AUTO, "QK_OUTPUT_AUTO"}, + {QK_OUTPUT_USB, "QK_OUTPUT_USB"}, + {QK_OUTPUT_BLUETOOTH, "QK_OUTPUT_BLUETOOTH"}, + {QK_UNICODE_MODE_NEXT, "QK_UNICODE_MODE_NEXT"}, + {QK_UNICODE_MODE_PREVIOUS, "QK_UNICODE_MODE_PREVIOUS"}, + {QK_UNICODE_MODE_MACOS, "QK_UNICODE_MODE_MACOS"}, + {QK_UNICODE_MODE_LINUX, "QK_UNICODE_MODE_LINUX"}, + {QK_UNICODE_MODE_WINDOWS, "QK_UNICODE_MODE_WINDOWS"}, + {QK_UNICODE_MODE_BSD, "QK_UNICODE_MODE_BSD"}, + {QK_UNICODE_MODE_WINCOMPOSE, "QK_UNICODE_MODE_WINCOMPOSE"}, + {QK_UNICODE_MODE_EMACS, "QK_UNICODE_MODE_EMACS"}, + {QK_HAPTIC_ON, "QK_HAPTIC_ON"}, + {QK_HAPTIC_OFF, "QK_HAPTIC_OFF"}, + {QK_HAPTIC_TOGGLE, "QK_HAPTIC_TOGGLE"}, + {QK_HAPTIC_RESET, "QK_HAPTIC_RESET"}, + {QK_HAPTIC_FEEDBACK_TOGGLE, "QK_HAPTIC_FEEDBACK_TOGGLE"}, + {QK_HAPTIC_BUZZ_TOGGLE, "QK_HAPTIC_BUZZ_TOGGLE"}, + {QK_HAPTIC_MODE_NEXT, "QK_HAPTIC_MODE_NEXT"}, + {QK_HAPTIC_MODE_PREVIOUS, "QK_HAPTIC_MODE_PREVIOUS"}, + {QK_HAPTIC_CONTINUOUS_TOGGLE, "QK_HAPTIC_CONTINUOUS_TOGGLE"}, + {QK_HAPTIC_CONTINUOUS_UP, "QK_HAPTIC_CONTINUOUS_UP"}, + {QK_HAPTIC_CONTINUOUS_DOWN, "QK_HAPTIC_CONTINUOUS_DOWN"}, + {QK_HAPTIC_DWELL_UP, "QK_HAPTIC_DWELL_UP"}, + {QK_HAPTIC_DWELL_DOWN, "QK_HAPTIC_DWELL_DOWN"}, + {QK_COMBO_ON, "QK_COMBO_ON"}, + {QK_COMBO_OFF, "QK_COMBO_OFF"}, + {QK_COMBO_TOGGLE, "QK_COMBO_TOGGLE"}, + {QK_DYNAMIC_MACRO_RECORD_START_1, "QK_DYNAMIC_MACRO_RECORD_START_1"}, + {QK_DYNAMIC_MACRO_RECORD_START_2, "QK_DYNAMIC_MACRO_RECORD_START_2"}, + {QK_DYNAMIC_MACRO_RECORD_STOP, "QK_DYNAMIC_MACRO_RECORD_STOP"}, + {QK_DYNAMIC_MACRO_PLAY_1, "QK_DYNAMIC_MACRO_PLAY_1"}, + {QK_DYNAMIC_MACRO_PLAY_2, "QK_DYNAMIC_MACRO_PLAY_2"}, + {QK_LEADER, "QK_LEADER"}, + {QK_LOCK, "QK_LOCK"}, + {QK_ONE_SHOT_ON, "QK_ONE_SHOT_ON"}, + {QK_ONE_SHOT_OFF, "QK_ONE_SHOT_OFF"}, + {QK_ONE_SHOT_TOGGLE, "QK_ONE_SHOT_TOGGLE"}, + {QK_KEY_OVERRIDE_TOGGLE, "QK_KEY_OVERRIDE_TOGGLE"}, + {QK_KEY_OVERRIDE_ON, "QK_KEY_OVERRIDE_ON"}, + {QK_KEY_OVERRIDE_OFF, "QK_KEY_OVERRIDE_OFF"}, + {QK_SECURE_LOCK, "QK_SECURE_LOCK"}, + {QK_SECURE_UNLOCK, "QK_SECURE_UNLOCK"}, + {QK_SECURE_TOGGLE, "QK_SECURE_TOGGLE"}, + {QK_SECURE_REQUEST, "QK_SECURE_REQUEST"}, + {QK_DYNAMIC_TAPPING_TERM_PRINT, "QK_DYNAMIC_TAPPING_TERM_PRINT"}, + {QK_DYNAMIC_TAPPING_TERM_UP, "QK_DYNAMIC_TAPPING_TERM_UP"}, + {QK_DYNAMIC_TAPPING_TERM_DOWN, "QK_DYNAMIC_TAPPING_TERM_DOWN"}, + {QK_CAPS_WORD_TOGGLE, "QK_CAPS_WORD_TOGGLE"}, + {QK_AUTOCORRECT_ON, "QK_AUTOCORRECT_ON"}, + {QK_AUTOCORRECT_OFF, "QK_AUTOCORRECT_OFF"}, + {QK_AUTOCORRECT_TOGGLE, "QK_AUTOCORRECT_TOGGLE"}, + {SAFE_RANGE, "SAFE_RANGE"}, +}; diff --git a/tests/test_common/keycode_util.cpp b/tests/test_common/keycode_util.cpp new file mode 100644 index 0000000000..9f88d40ec7 --- /dev/null +++ b/tests/test_common/keycode_util.cpp @@ -0,0 +1,128 @@ +#include "keycode_util.hpp" +#include +extern "C" { +#include "action_code.h" +#include "keycode.h" +#include "quantum_keycodes.h" +#include "util.h" +} +#include +#include +#include + +extern std::map KEYCODE_ID_TABLE; + +std::string get_mods(uint8_t mods) { + std::stringstream s; + if ((mods & MOD_RCTL) == MOD_RCTL) { + s << XSTR(MOD_RCTL) << " | "; + } else if ((mods & MOD_LCTL) == MOD_LCTL) { + s << XSTR(MOD_LCTL) << " | "; + } + + if ((mods & MOD_RSFT) == MOD_RSFT) { + s << XSTR(MOD_RSFT) << " | "; + } else if ((mods & MOD_LSFT) == MOD_LSFT) { + s << XSTR(MOD_LSFT) << " | "; + } + + if ((mods & MOD_RALT) == MOD_RALT) { + s << XSTR(MOD_RALT) << " | "; + } else if ((mods & MOD_LALT) == MOD_LALT) { + s << XSTR(MOD_LALT) << " | "; + } + + if ((mods & MOD_RGUI) == MOD_RGUI) { + s << XSTR(MOD_RGUI) << " | "; + } else if ((mods & MOD_LGUI) == MOD_LGUI) { + s << XSTR(MOD_LGUI) << " | "; + } + + auto _mods = s.str(); + + if (_mods.size()) { + _mods.resize(_mods.size() - 3); + } + + return std::string(_mods); +} + +std::string get_qk_mods(uint16_t keycode) { + std::stringstream s; + if ((keycode & QK_RCTL) == QK_RCTL) { + s << XSTR(QK_RCTL) << " | "; + } else if ((keycode & QK_LCTL) == QK_LCTL) { + s << XSTR(QK_LCTL) << " | "; + } + + if ((keycode & QK_RSFT) == QK_RSFT) { + s << XSTR(QK_RSFT) << " | "; + } else if ((keycode & QK_LSFT) == QK_LSFT) { + s << XSTR(QK_LSFT) << " | "; + } + + if ((keycode & QK_RALT) == QK_RALT) { + s << XSTR(QK_RALT) << " | "; + } else if ((keycode & QK_LALT) == QK_LALT) { + s << XSTR(QK_LALT) << " | "; + } + + if ((keycode & QK_RGUI) == QK_RGUI) { + s << XSTR(QK_RGUI) << " | "; + } else if ((keycode & QK_LGUI) == QK_LGUI) { + s << XSTR(QK_LGUI) << " | "; + } + + auto _mods = s.str(); + + if (_mods.size()) { + _mods.resize(_mods.size() - 3); + } + + return std::string(_mods); +} + +std::string generate_identifier(uint16_t kc) { + std::stringstream s; + if (IS_QK_MOD_TAP(kc)) { + s << "MT(" << get_mods(QK_MOD_TAP_GET_MODS(kc)) << ", " << KEYCODE_ID_TABLE.at(kc & 0xFF) << ")"; + } else if (IS_QK_LAYER_TAP(kc)) { + s << "LT(" << +QK_LAYER_TAP_GET_LAYER(kc) << ", " << KEYCODE_ID_TABLE.at(kc & 0xFF) << ")"; + } else if (IS_QK_TO(kc)) { + s << "TO(" << +QK_TO_GET_LAYER(kc) << ")"; + } else if (IS_QK_MOMENTARY(kc)) { + s << "MO(" << +QK_MOMENTARY_GET_LAYER(kc) << ")"; + } else if (IS_QK_DEF_LAYER(kc)) { + s << "DF(" << +QK_DEF_LAYER_GET_LAYER(kc) << ")"; + } else if (IS_QK_TOGGLE_LAYER(kc)) { + s << "TG(" << +QK_TOGGLE_LAYER_GET_LAYER(kc) << ")"; + } else if (IS_QK_LAYER_TAP_TOGGLE(kc)) { + s << "TT(" << +QK_LAYER_TAP_TOGGLE_GET_LAYER(kc) << ")"; + } else if (IS_QK_ONE_SHOT_LAYER(kc)) { + s << "OSL(" << +QK_ONE_SHOT_LAYER_GET_LAYER(kc) << ")"; + } else if (IS_QK_LAYER_MOD(kc)) { + s << "LM(" << +QK_LAYER_MOD_GET_LAYER(kc) << ", " << get_mods(QK_LAYER_MOD_GET_MODS(kc)) << ")"; + } else if (IS_QK_ONE_SHOT_MOD(kc)) { + s << "OSM(" << get_mods(QK_ONE_SHOT_MOD_GET_MODS(kc)) << ")"; + } else if (IS_QK_MODS(kc)) { + s << "QK_MODS(" << KEYCODE_ID_TABLE.at(QK_MODS_GET_BASIC_KEYCODE(kc)) << ", " << get_qk_mods(kc) << ")"; + } else if (IS_QK_TAP_DANCE(kc)) { + s << "TD(" << +(kc & 0xFF) << ")"; + } else { + // Fallback - we didn't found any matching keycode, generate the hex representation. + s << "unknown keycode: 0x" << std::hex << kc << ". Add conversion to " << XSTR(generate_identifier); + } + + return std::string(s.str()); +} + +std::string get_keycode_identifier_or_default(uint16_t keycode) { + auto identifier = KEYCODE_ID_TABLE.find(keycode); + if (identifier != KEYCODE_ID_TABLE.end()) { + return identifier->second; + } + + KEYCODE_ID_TABLE[keycode] = generate_identifier(keycode); + + return KEYCODE_ID_TABLE[keycode]; +} diff --git a/tests/test_common/keycode_util.hpp b/tests/test_common/keycode_util.hpp new file mode 100644 index 0000000000..d5a520d4b2 --- /dev/null +++ b/tests/test_common/keycode_util.hpp @@ -0,0 +1,5 @@ +#pragma once + +#include + +std::string get_keycode_identifier_or_default(uint16_t keycode); diff --git a/tests/test_common/matrix.c b/tests/test_common/matrix.c index 7b24d560e3..45e76d32c5 100644 --- a/tests/test_common/matrix.c +++ b/tests/test_common/matrix.c @@ -41,11 +41,15 @@ void matrix_init_kb(void) {} void matrix_scan_kb(void) {} void press_key(uint8_t col, uint8_t row) { - matrix[row] |= 1 << col; + matrix[row] |= (matrix_row_t)1 << col; } void release_key(uint8_t col, uint8_t row) { - matrix[row] &= ~(1 << col); + matrix[row] &= ~((matrix_row_t)1 << col); +} + +bool matrix_is_on(uint8_t row, uint8_t col) { + return (matrix[row] & ((matrix_row_t)1 << col)); } void clear_all_keys(void) { diff --git a/tests/test_common/test_common.hpp b/tests/test_common/test_common.hpp index a88fa8d7b8..295a6083cd 100644 --- a/tests/test_common/test_common.hpp +++ b/tests/test_common/test_common.hpp @@ -22,5 +22,6 @@ extern "C" { } #include "test_driver.hpp" #include "test_matrix.h" +#include "test_keymap_key.hpp" #include "keyboard_report_util.hpp" #include "test_fixture.hpp" diff --git a/tests/test_common/test_fixture.cpp b/tests/test_common/test_fixture.cpp index 44694cd390..5dc5db1848 100644 --- a/tests/test_common/test_fixture.cpp +++ b/tests/test_common/test_fixture.cpp @@ -12,6 +12,7 @@ #include "test_logger.hpp" #include "test_matrix.h" #include "test_keymap_key.hpp" +#include "timer.h" extern "C" { #include "action.h" @@ -41,7 +42,7 @@ extern "C" uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t position) { } void TestFixture::SetUpTestCase() { - test_logger.info() << "TestFixture setup-up start." << std::endl; + test_logger.info() << "test fixture setup-up start." << std::endl; // The following is enough to bootstrap the values set in main eeconfig_init_quantum(); @@ -50,17 +51,19 @@ void TestFixture::SetUpTestCase() { TestDriver driver; keyboard_init(); - test_logger.info() << "TestFixture setup-up end." << std::endl; + test_logger.info() << "test fixture setup-up end." << std::endl; } void TestFixture::TearDownTestCase() {} TestFixture::TestFixture() { m_this = this; + timer_clear(); + test_logger.info() << "tapping term is " << +GET_TAPPING_TERM(KC_TRANSPARENT, &(keyrecord_t){}) << "ms" << std::endl; } TestFixture::~TestFixture() { - test_logger.info() << "TestFixture clean-up start." << std::endl; + test_logger.info() << "test fixture clean-up start." << std::endl; TestDriver driver; /* Reset keyboard state. */ @@ -85,17 +88,15 @@ TestFixture::~TestFixture() { EXPECT_NO_REPORT(driver); idle_for(TAPPING_TERM * 10); testing::Mock::VerifyAndClearExpectations(&driver); - m_this = nullptr; - test_logger.info() << "TestFixture clean-up end." << std::endl; - + test_logger.info() << "test fixture clean-up end." << std::endl; print_test_log(); } void TestFixture::add_key(KeymapKey key) { if (this->find_key(key.layer, key.position)) { - FAIL() << "Key is already mapped for layer " << +key.layer << " and (column,row) (" << +key.position.col << "," << +key.position.row << ")"; + FAIL() << "key is already mapped for layer " << +key.layer << " and (column,row) (" << +key.position.col << "," << +key.position.row << ")"; } this->keymap.push_back(key); @@ -149,7 +150,7 @@ void TestFixture::get_keycode(const layer_t layer, const keypos_t position, uint /* See if this is done in hardware as well, because this is 100% out of bounds reads on all QMK keebs out there. */ auto msg = [&]() { std::stringstream msg; - msg << "Keycode for position (" << +position.col << "," << +position.row << ") requested! This is out of bounds." << std::endl; + msg << "keycode for position (" << +position.col << "," << +position.row << ") requested! This is out of bounds." << std::endl; return msg.str(); }(); @@ -164,17 +165,18 @@ void TestFixture::get_keycode(const layer_t layer, const keypos_t position, uint return; } - FAIL() << "No key is mapped for layer " << +layer << " and (column,row) " << +position.col << "," << +position.row << ")"; + FAIL() << "no key is mapped for layer " << +layer << " and (column,row) " << +position.col << "," << +position.row << ")"; } void TestFixture::run_one_scan_loop() { - keyboard_task(); - advance_time(1); + this->idle_for(1); } void TestFixture::idle_for(unsigned time) { + test_logger.trace() << +time << " keyboard task " << (time > 1 ? "loops" : "loop") << std::endl; for (unsigned i = 0; i < time; i++) { - run_one_scan_loop(); + keyboard_task(); + advance_time(1); } } @@ -182,12 +184,13 @@ void TestFixture::print_test_log() const { const ::testing::TestInfo* const test_info = ::testing::UnitTest::GetInstance()->current_test_info(); if (HasFailure()) { std::cerr << test_info->test_case_name() << "." << test_info->name() << " failed!" << std::endl; + test_logger.print_header(); test_logger.print_log(); } test_logger.reset(); } void TestFixture::expect_layer_state(layer_t layer_state) const { - test_logger.trace() << "Layer state: (" << +layer_state << ") Highest layer bit: (" << +get_highest_layer(layer_state) << ")" << std::endl; + test_logger.trace() << "layer state: (" << +layer_state << ") highest layer bit: (" << +get_highest_layer(layer_state) << ")" << std::endl; EXPECT_TRUE(layer_state_is(layer_state)); } diff --git a/tests/test_common/test_keymap_key.cpp b/tests/test_common/test_keymap_key.cpp index 878ae097bf..63ae29975b 100644 --- a/tests/test_common/test_keymap_key.cpp +++ b/tests/test_common/test_keymap_key.cpp @@ -15,16 +15,26 @@ */ #include "test_keymap_key.hpp" +#include +#include +#include "matrix.h" #include "test_logger.hpp" #include "gtest/gtest-message.h" #include "gtest/gtest.h" +#include "timer.h" void KeymapKey::press() { - test_logger.trace() << "Key pressed: (" << +this->position.col << "," << +this->position.row << ")" << std::endl; + EXPECT_FALSE(matrix_is_on(position.row, position.col)) << "tried to press key " << this->name << " that was already pressed! Check the test code." << std::endl; + press_key(this->position.col, this->position.row); + this->timestamp_pressed = timer_read32(); + test_logger.trace() << std::setw(10) << std::left << "pressed: " << this->name << std::endl; } void KeymapKey::release() { - test_logger.trace() << "Key released: (" << +this->position.col << "," << +this->position.row << ")" << std::endl; + EXPECT_TRUE(matrix_is_on(this->position.row, this->position.col)) << "tried to release key " << this->name << " that wasn't pressed before! Check the test code." << std::endl; + release_key(this->position.col, this->position.row); -} \ No newline at end of file + uint32_t now = timer_read32(); + test_logger.trace() << std::setw(10) << std::left << "released: " << this->name << " was pressed for " << now - this->timestamp_pressed << "ms" << std::endl; +} diff --git a/tests/test_common/test_keymap_key.hpp b/tests/test_common/test_keymap_key.hpp index 7861cb4a32..37b4c827e4 100644 --- a/tests/test_common/test_keymap_key.hpp +++ b/tests/test_common/test_keymap_key.hpp @@ -16,6 +16,9 @@ #pragma once +#include +#include +#include "keycode_util.hpp" extern "C" { #include "keyboard.h" #include "test_matrix.h" @@ -26,8 +29,13 @@ extern "C" { typedef uint8_t layer_t; struct KeymapKey { - KeymapKey(layer_t layer, uint8_t col, uint8_t row, uint16_t keycode) : layer(layer), position({.col = col, .row = row}), code(keycode), report_code(keycode) { validate(); } - KeymapKey(layer_t layer, uint8_t col, uint8_t row, uint16_t keycode, uint16_t report_code) : layer(layer), position({.col = col, .row = row}), code(keycode), report_code(report_code) { validate(); } + KeymapKey(layer_t layer, uint8_t col, uint8_t row, uint16_t keycode) : layer(layer), position({.col = col, .row = row}), code(keycode), report_code(keycode), name(get_keycode_identifier_or_default(keycode)) { + validate(); + } + + KeymapKey(layer_t layer, uint8_t col, uint8_t row, uint16_t keycode, uint16_t report_code) : layer(layer), position({.col = col, .row = row}), code(keycode), report_code(report_code), name{get_keycode_identifier_or_default(keycode)} { + validate(); + } void press(); void release(); @@ -35,6 +43,7 @@ struct KeymapKey { const layer_t layer; const keypos_t position; const uint16_t code; + std::string name; /* Sometimes the keycode does not match the code that is send in the usb report, so we provide it here. */ const uint16_t report_code; @@ -43,4 +52,5 @@ struct KeymapKey { assert(position.col <= MATRIX_COLS); assert(position.row <= MATRIX_ROWS); } -}; \ No newline at end of file + uint32_t timestamp_pressed; +}; diff --git a/tests/test_common/test_logger.cpp b/tests/test_common/test_logger.cpp index efc7719d13..0ff4e686ee 100644 --- a/tests/test_common/test_logger.cpp +++ b/tests/test_common/test_logger.cpp @@ -14,30 +14,40 @@ * along with this program. If not, see . */ +#include #include #include "test_logger.hpp" +#include "timer.h" TestLogger test_logger; TestLogger& TestLogger::info() { *this << "[ INFO ] "; - return *this; + return this->timestamp(); } TestLogger& TestLogger::trace() { *this << "[ TRACE ] "; - return *this; + return this->timestamp(); } TestLogger& TestLogger::error() { *this << "[ ERROR ] "; - return *this; + return this->timestamp(); } +TestLogger& TestLogger::timestamp() { + *this << std::setw(6) << timer_read32() << " "; + return *this; +} void TestLogger::reset() { this->m_log.str(""); }; +void TestLogger::print_header() { + std::cerr << "[ LEVEL ] [TIME] [EVENT]" << std::endl; +} + void TestLogger::print_log() { std::cerr << this->m_log.str(); } diff --git a/tests/test_common/test_logger.hpp b/tests/test_common/test_logger.hpp index 348af7fab8..4964583ded 100644 --- a/tests/test_common/test_logger.hpp +++ b/tests/test_common/test_logger.hpp @@ -25,11 +25,13 @@ class TestLogger : public std::ostream { TestLogger& info(); TestLogger& trace(); TestLogger& error(); - void print_log(); - void reset(); + void print_log(); + void print_header(); + void reset(); private: + TestLogger& timestamp(); std::stringbuf m_log; }; -extern TestLogger test_logger; \ No newline at end of file +extern TestLogger test_logger; -- cgit v1.2.3 From cf935d97ae479e7a1e1f2f2f248b93e52e4cc69e Mon Sep 17 00:00:00 2001 From: Ryan Date: Sat, 21 Jan 2023 03:21:17 +1100 Subject: Fix functions with empty params (#19647) * Fix functions with empty params * Found a bunch more--- docs/gpio_control.md | 2 +- docs/quantum_painter_lvgl.md | 2 +- drivers/lcd/hd44780.c | 2 +- drivers/sensors/adns9800.c | 2 +- drivers/sensors/cirque_pinnacle.c | 2 +- drivers/usb2422.c | 8 ++++---- keyboards/40percentclub/gherkin/keymaps/mjt/keymap.c | 4 ++-- keyboards/40percentclub/gherkin/keymaps/steno/keymap.c | 2 +- keyboards/40percentclub/mf68/keymaps/delivrance/keymap.c | 2 +- keyboards/40percentclub/ut47/ut47.c | 2 +- keyboards/annepro2/annepro2.c | 2 +- keyboards/annepro2/ap2_led.c | 12 ++++++------ keyboards/bemeier/bmek/bmek.c | 2 +- keyboards/bpiphany/frosty_flake/20130602/20130602.c | 2 +- keyboards/bpiphany/frosty_flake/20140521/20140521.c | 2 +- keyboards/cannonkeys/satisfaction75/satisfaction75.c | 4 ++-- keyboards/cannonkeys/satisfaction75/satisfaction_encoder.c | 10 +++++----- keyboards/cannonkeys/satisfaction75/satisfaction_oled.c | 4 ++-- keyboards/capsunlocked/cu75/cu75.c | 2 +- keyboards/converter/adb_usb/adb.c | 6 +++--- keyboards/converter/hp_46010a/matrix.c | 2 +- keyboards/converter/ibm_terminal/keymaps/priyadi/keymap.c | 2 +- keyboards/converter/m0110_usb/m0110.c | 12 ++++++------ .../keymaps/jpe230/oled/avr/master/oled_master_handler.c | 2 +- .../crkbd/keymaps/jpe230/oled/avr/slave/oled_slave_handler.c | 2 +- keyboards/crkbd/keymaps/jpe230/oled/oled_handler.c | 2 +- .../keymaps/jpe230/oled/rp2040/master/oled_master_handler.c | 2 +- .../keymaps/jpe230/oled/rp2040/slave/oled_slave_handler.c | 2 +- keyboards/dmqdesign/spin/keymaps/spidey3_pad/keymap.c | 2 +- keyboards/dp60/matrix.c | 2 +- keyboards/duck/jetfire/jetfire.c | 2 +- keyboards/duck/lightsaver/matrix.c | 2 +- keyboards/dumbpad/v0x/v0x.c | 2 +- keyboards/dumbpad/v0x_dualencoder/v0x_dualencoder.c | 2 +- keyboards/dumbpad/v0x_right/v0x_right.c | 2 +- keyboards/dumbpad/v1x/v1x.c | 2 +- keyboards/dumbpad/v1x_dualencoder/v1x_dualencoder.c | 2 +- keyboards/dumbpad/v1x_right/v1x_right.c | 2 +- keyboards/dumbpad/v3x/v3x.c | 2 +- keyboards/dz60/keymaps/marianas/relativity.c | 4 ++-- keyboards/eco/keymaps/that_canadian/keymap.c | 4 ++-- keyboards/eyeohdesigns/babyv/keymaps/bghull/keymap.c | 2 +- keyboards/gboards/butterstick/sten.c | 2 +- keyboards/gboards/engine/engine.c | 4 ++-- keyboards/gboards/g/engine.c | 4 ++-- keyboards/gboards/georgi/sten.c | 2 +- keyboards/gmmk/pro/rev1/ansi/keymaps/andrebrait/keymap.c | 4 ++-- keyboards/gmmk/pro/rev1/ansi/keymaps/byungyoonc/keymap.c | 6 +++--- keyboards/gmmk/pro/rev1/ansi/keymaps/hachetman/keymap.c | 6 +++--- keyboards/gmmk/pro/rev1/ansi/keymaps/lalitmaganti/keymap.c | 4 ++-- keyboards/gmmk/pro/rev1/ansi/keymaps/macos/keymap.c | 4 ++-- keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/encoder.c | 6 +++--- .../gmmk/pro/rev1/ansi/keymaps/mike1808/process_record.c | 2 +- .../gmmk/pro/rev1/ansi/keymaps/mike1808/rgb_matrix_ledmaps.c | 4 ++-- keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/utils.c | 2 +- keyboards/gmmk/pro/rev1/ansi/keymaps/stickandgum/keymap.c | 8 ++++---- keyboards/gmmk/pro/rev1/ansi/keymaps/trwnh/keymap.c | 8 ++++---- keyboards/hadron/ver2/keymaps/side_numpad/keymap.c | 4 ++-- keyboards/handwired/atreus50/keymaps/default/keymap.c | 4 ++-- keyboards/handwired/jotanck/jotanck.c | 2 +- keyboards/handwired/jotpad16/jotpad16.c | 2 +- .../handwired/jscotto/scotto36/keymaps/default/keymap.c | 2 +- .../handwired/jscotto/scottocmd/keymaps/default/keymap.c | 2 +- keyboards/handwired/onekey/keymaps/digitizer/keymap.c | 2 +- keyboards/handwired/onekey/keymaps/joystick/keymap.c | 2 +- keyboards/handwired/ortho5x13/keymaps/default/keymap.c | 4 ++-- keyboards/handwired/promethium/keymaps/default/keymap.c | 6 +++--- keyboards/handwired/promethium/keymaps/priyadi/keymap.c | 6 +++--- keyboards/helix/pico/keymaps/default/keymap.c | 4 ++-- keyboards/helix/pico/keymaps/mtei/keymap.c | 4 ++-- keyboards/helix/rev2/keymaps/default/keymap.c | 4 ++-- keyboards/helix/rev2/keymaps/froggy/keymap.c | 4 ++-- keyboards/helix/rev2/keymaps/yshrsmz/keymap.c | 4 ++-- keyboards/ibnuda/squiggle/keymaps/rick-complicated/keymap.c | 2 +- keyboards/input_club/ergodox_infinity/ergodox_infinity.c | 2 +- .../ergodox_infinity/keymaps/dudeofawesome/keymap.c | 2 +- keyboards/input_club/k_type/keymaps/andrew-fahmy/keymap.c | 2 +- keyboards/jels/jels88/jels88.c | 2 +- keyboards/kbdfans/niu_mini/keymaps/yttyx/keymap.c | 2 +- keyboards/keebio/iris/keymaps/edvorakjp/keymap.c | 2 +- keyboards/keebio/levinson/keymaps/steno/keymap.c | 2 +- keyboards/knops/mini/keymaps/mverteuil/keymap.c | 2 +- keyboards/lazydesigners/dimple/staggered/staggered.c | 4 ++-- keyboards/lazydesigners/the50/the50.c | 4 ++-- keyboards/lfkeyboards/TWIlib.c | 4 ++-- keyboards/lfkeyboards/lfk65_hs/lfk65_hs.c | 2 +- keyboards/lfkeyboards/lfk78/lfk78.c | 2 +- keyboards/lfkeyboards/lfk87/lfk87.c | 2 +- keyboards/lfkeyboards/lighting.c | 4 ++-- keyboards/lfkeyboards/mini1800/mini1800.c | 2 +- keyboards/lfkeyboards/smk65/revb/revb.c | 2 +- keyboards/macrocat/macrocat.c | 4 ++-- keyboards/makeymakey/makeymakey.c | 2 +- keyboards/matrix/noah/keymaps/blockader/keymap.c | 2 +- keyboards/mechwild/bbs/bbs.c | 2 +- keyboards/nek_type_a/mcp23017.c | 4 ++-- keyboards/neopad/rev1/rev1.c | 2 +- keyboards/opendeck/32/rev1/rev1.c | 2 +- keyboards/planck/keymaps/circuit/keymap.c | 4 ++-- keyboards/planck/keymaps/dbroqua/keymap.c | 4 ++-- keyboards/planck/keymaps/dcompact/keymap.c | 2 +- keyboards/planck/keymaps/dr_notsokind/keymap.c | 4 ++-- keyboards/planck/keymaps/emilyh/keymap.c | 4 ++-- keyboards/planck/keymaps/experimental/keymap.c | 4 ++-- keyboards/planck/keymaps/gunp/keymap.c | 4 ++-- keyboards/planck/keymaps/handwired_binaryplease/keymap.c | 4 ++-- keyboards/planck/keymaps/impossible/keymap.c | 4 ++-- keyboards/planck/keymaps/ishtob/keymap.c | 4 ++-- keyboards/planck/keymaps/jhenahan/keymap.c | 4 ++-- keyboards/planck/keymaps/lae3/keymap.c | 4 ++-- keyboards/planck/keymaps/mjt/keymap.c | 4 ++-- keyboards/planck/keymaps/mjtnumsym/keymap.c | 4 ++-- keyboards/planck/keymaps/originerd/keymap.c | 4 ++-- keyboards/planck/keymaps/premek/keymap.c | 4 ++-- keyboards/planck/keymaps/sgoodwin/keymap.c | 4 ++-- keyboards/planck/keymaps/smt/keymap.c | 4 ++-- keyboards/planck/keymaps/that_canadian/keymap.c | 4 ++-- keyboards/planck/keymaps/vaire/keymap.c | 4 ++-- keyboards/planck/keymaps/yttyx/keymap.c | 2 +- keyboards/planck/keymaps/zach/zach_common_functions.c | 2 +- keyboards/preonic/keymaps/0xdec/keymap.c | 4 ++-- keyboards/preonic/keymaps/bucktooth/keymap.c | 4 ++-- keyboards/preonic/keymaps/jacwib/keymap.c | 4 ++-- keyboards/preonic/keymaps/mverteuil/keymap.c | 2 +- keyboards/preonic/keymaps/mverteuil_2x2u/keymap.c | 2 +- keyboards/preonic/keymaps/nikchi/keymap.c | 4 ++-- keyboards/preonic/keymaps/smt/keymap.c | 4 ++-- keyboards/preonic/keymaps/that_canadian/keymap.c | 4 ++-- keyboards/preonic/keymaps/trigotometry/keymap.c | 2 +- keyboards/preonic/keymaps/zach/zach_common_functions.c | 2 +- keyboards/reviung/reviung41/keymaps/ciutadellla/keymap.c | 2 +- keyboards/rgbkb/sol3/rev1/rev1.c | 2 +- keyboards/sekigon/grs_70ec/grs_70ec.c | 2 +- keyboards/sneakbox/aliceclone/aliceclone.c | 2 +- keyboards/splitkb/kyria/keymaps/cwebster2/keymap.c | 2 +- keyboards/stenokeyboards/the_uni/keymaps/default/keymap.c | 2 +- keyboards/thevankeyboards/minivan/keymaps/josjoha/keymap.c | 2 +- keyboards/wilba_tech/wt65_xt/keymaps/zunger/keymap.c | 2 +- keyboards/wilba_tech/wt70_jb/wt70_jb.c | 2 +- keyboards/woodkeys/meira/TWIlib.c | 4 ++-- keyboards/woodkeys/meira/lighting.c | 4 ++-- keyboards/woodkeys/meira/meira.c | 2 +- keyboards/xiudi/xd75/keymaps/colinta/keymap.c | 2 +- keyboards/xiudi/xd96/keymaps/uuupah/keymap.c | 2 +- platforms/avr/drivers/audio_pwm_hardware.c | 4 ++-- platforms/chibios/drivers/audio_dac_additive.c | 2 +- platforms/chibios/drivers/audio_dac_basic.c | 2 +- quantum/action.c | 2 +- quantum/action_util.c | 4 ++-- quantum/audio/audio.c | 4 ++-- quantum/audio/voices.c | 4 ++-- quantum/joystick.c | 2 +- quantum/keyboard.c | 2 +- quantum/process_keycode/process_audio.c | 4 ++-- quantum/process_keycode/process_auto_shift.c | 4 ++-- quantum/process_keycode/process_music.c | 6 +++--- quantum/process_keycode/process_steno.c | 2 +- quantum/process_keycode/process_tap_dance.c | 2 +- quantum/quantum.c | 8 ++++---- tmk_core/protocol/lufa/lufa.c | 4 ++-- users/arkag/arkag.c | 4 ++-- users/d4mation/d4mation.c | 4 ++-- users/danielo515/danielo515.c | 4 ++-- users/edvorakjp/edvorakjp.c | 2 +- users/ericgebhart/extensions/oneshot.c | 4 ++-- users/ericgebhart/oled/oled_stuff.c | 2 +- users/miles2go/babblePaste.c | 4 ++-- users/ninjonas/ninjonas.c | 2 +- users/spidey3/layer_rgb.c | 2 +- users/talljoe/macros.c | 6 +++--- 170 files changed, 276 insertions(+), 276 deletions(-) (limited to 'quantum/process_keycode/process_auto_shift.c') diff --git a/docs/gpio_control.md b/docs/gpio_control.md index e1f1515b71..12413dfc8e 100644 --- a/docs/gpio_control.md +++ b/docs/gpio_control.md @@ -30,7 +30,7 @@ The above functions are not always guaranteed to work atomically. Therefore, if eg. ```c -void some_function() { +void some_function(void) { // some process ATOMIC_BLOCK_FORCEON { // Atomic Processing diff --git a/docs/quantum_painter_lvgl.md b/docs/quantum_painter_lvgl.md index 3edb37fbce..4d10160baf 100644 --- a/docs/quantum_painter_lvgl.md +++ b/docs/quantum_painter_lvgl.md @@ -45,7 +45,7 @@ To init. the display please read the [Display Initialisation](quantum_painter.md ### Quantum Painter LVGL Detach :id=lvgl-api-init ```c -void qp_lvgl_detach() +void qp_lvgl_detach(void) ``` The `qp_lvgl_detach` function stops the internal LVGL ticks and releases resources related to it. diff --git a/drivers/lcd/hd44780.c b/drivers/lcd/hd44780.c index c988ebe56c..ccc50117ab 100644 --- a/drivers/lcd/hd44780.c +++ b/drivers/lcd/hd44780.c @@ -158,7 +158,7 @@ void hd44780_on(bool cursor, bool blink) { } } -void hd44780_off() { +void hd44780_off(void) { hd44780_command(HD44780_CMD_DISPLAY); } diff --git a/drivers/sensors/adns9800.c b/drivers/sensors/adns9800.c index 3633f23e52..083ab34d9f 100644 --- a/drivers/sensors/adns9800.c +++ b/drivers/sensors/adns9800.c @@ -99,7 +99,7 @@ uint8_t adns9800_read(uint8_t reg_addr) { return data; } -void adns9800_init() { +void adns9800_init(void) { setPinOutput(ADNS9800_CS_PIN); spi_init(); diff --git a/drivers/sensors/cirque_pinnacle.c b/drivers/sensors/cirque_pinnacle.c index 4aed5fe67a..3131805c20 100644 --- a/drivers/sensors/cirque_pinnacle.c +++ b/drivers/sensors/cirque_pinnacle.c @@ -87,7 +87,7 @@ void cirque_pinnacle_scale_data(pinnacle_data_t* coordinates, uint16_t xResoluti } // Clears Status1 register flags (SW_CC and SW_DR) -void cirque_pinnacle_clear_flags() { +void cirque_pinnacle_clear_flags(void) { RAP_Write(HOSTREG__STATUS1, HOSTREG__STATUS1_DEFVAL & ~(HOSTREG__STATUS1__COMMAND_COMPLETE | HOSTREG__STATUS1__DATA_READY)); wait_us(50); } diff --git a/drivers/usb2422.c b/drivers/usb2422.c index 8ee54b24ee..1d33b5acf8 100644 --- a/drivers/usb2422.c +++ b/drivers/usb2422.c @@ -344,7 +344,7 @@ static void USB2422_write_block(void) { // *************************************************************** -void USB2422_init() { +void USB2422_init(void) { #ifdef USB2422_RESET_PIN setPinOutput(USB2422_RESET_PIN); #endif @@ -355,7 +355,7 @@ void USB2422_init() { i2c_init(); // IC2 clk must be high at USB2422 reset release time to signal SMB configuration } -void USB2422_configure() { +void USB2422_configure(void) { static const char SERNAME[] = "Unavailable"; memset(&config, 0, sizeof(Usb2422_t)); @@ -385,7 +385,7 @@ void USB2422_configure() { USB2422_write_block(); } -void USB2422_reset() { +void USB2422_reset(void) { #ifdef USB2422_RESET_PIN writePinLow(USB2422_RESET_PIN); wait_us(2); @@ -393,7 +393,7 @@ void USB2422_reset() { #endif } -bool USB2422_active() { +bool USB2422_active(void) { #ifdef USB2422_ACTIVE_PIN return readPin(USB2422_ACTIVE_PIN); #else diff --git a/keyboards/40percentclub/gherkin/keymaps/mjt/keymap.c b/keyboards/40percentclub/gherkin/keymaps/mjt/keymap.c index 312fbfaf57..40c11739fb 100644 --- a/keyboards/40percentclub/gherkin/keymaps/mjt/keymap.c +++ b/keyboards/40percentclub/gherkin/keymaps/mjt/keymap.c @@ -174,13 +174,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/40percentclub/gherkin/keymaps/steno/keymap.c b/keyboards/40percentclub/gherkin/keymaps/steno/keymap.c index c7ee63d126..5f78ba1cde 100644 --- a/keyboards/40percentclub/gherkin/keymaps/steno/keymap.c +++ b/keyboards/40percentclub/gherkin/keymaps/steno/keymap.c @@ -8,6 +8,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { STN_NUM, STN_NUM, STN_A, STN_O, STN_NUM, STN_E, STN_U, STN_NUM, STN_NUM, STN_NUM), }; -void matrix_init_user() { +void matrix_init_user(void) { steno_set_mode(STENO_MODE_GEMINI); // or STENO_MODE_BOLT } \ No newline at end of file diff --git a/keyboards/40percentclub/mf68/keymaps/delivrance/keymap.c b/keyboards/40percentclub/mf68/keymaps/delivrance/keymap.c index ed98d947e5..8d69a5a8af 100644 --- a/keyboards/40percentclub/mf68/keymaps/delivrance/keymap.c +++ b/keyboards/40percentclub/mf68/keymaps/delivrance/keymap.c @@ -197,7 +197,7 @@ void led_set_user(uint8_t usb_led) { static uint32_t timer; static bool is_idle; -void matrix_scan_user() { +void matrix_scan_user(void) { // Check the timer only if the keyboard is not idle if (!is_idle) { if (timer_elapsed32(timer) >= (uint32_t) BACKLIGHT_IDLE_TIMEOUT * 1000) { diff --git a/keyboards/40percentclub/ut47/ut47.c b/keyboards/40percentclub/ut47/ut47.c index 864edaeb57..9d46a4679d 100644 --- a/keyboards/40percentclub/ut47/ut47.c +++ b/keyboards/40percentclub/ut47/ut47.c @@ -17,7 +17,7 @@ #ifdef LED_ENABLE #include "uart.h" -void matrix_init_kb() { +void matrix_init_kb(void) { uart_init(9600); } #endif diff --git a/keyboards/annepro2/annepro2.c b/keyboards/annepro2/annepro2.c index f4ced65436..e1292b3517 100644 --- a/keyboards/annepro2/annepro2.c +++ b/keyboards/annepro2/annepro2.c @@ -111,7 +111,7 @@ void keyboard_post_init_kb(void) { keyboard_post_init_user(); } -void matrix_scan_kb() { +void matrix_scan_kb(void) { // if there's stuff on the ble serial buffer // read it into the capslock struct while (!sdGetWouldBlock(&SD1)) { diff --git a/keyboards/annepro2/ap2_led.c b/keyboards/annepro2/ap2_led.c index 339df103bf..c1d7c8166e 100644 --- a/keyboards/annepro2/ap2_led.c +++ b/keyboards/annepro2/ap2_led.c @@ -60,15 +60,15 @@ void ap2_led_enable(void) { proto_tx(CMD_LED_ON, NULL, 0, 3); } void ap2_led_set_profile(uint8_t prof) { proto_tx(CMD_LED_SET_PROFILE, &prof, sizeof(prof), 3); } -void ap2_led_get_status() { proto_tx(CMD_LED_GET_STATUS, NULL, 0, 3); } +void ap2_led_get_status(void) { proto_tx(CMD_LED_GET_STATUS, NULL, 0, 3); } -void ap2_led_next_profile() { proto_tx(CMD_LED_NEXT_PROFILE, NULL, 0, 3); } +void ap2_led_next_profile(void) { proto_tx(CMD_LED_NEXT_PROFILE, NULL, 0, 3); } -void ap2_led_next_intensity() { proto_tx(CMD_LED_NEXT_INTENSITY, NULL, 0, 3); } +void ap2_led_next_intensity(void) { proto_tx(CMD_LED_NEXT_INTENSITY, NULL, 0, 3); } -void ap2_led_next_animation_speed() { proto_tx(CMD_LED_NEXT_ANIMATION_SPEED, NULL, 0, 3); } +void ap2_led_next_animation_speed(void) { proto_tx(CMD_LED_NEXT_ANIMATION_SPEED, NULL, 0, 3); } -void ap2_led_prev_profile() { proto_tx(CMD_LED_PREV_PROFILE, NULL, 0, 3); } +void ap2_led_prev_profile(void) { proto_tx(CMD_LED_PREV_PROFILE, NULL, 0, 3); } void ap2_led_mask_set_key(uint8_t row, uint8_t col, ap2_led_t color) { uint8_t payload[] = {row, col, color.p.blue, color.p.green, color.p.red, color.p.alpha}; @@ -127,7 +127,7 @@ void ap2_led_set_foreground_color(uint8_t red, uint8_t green, uint8_t blue) { ap2_led_mask_set_mono(color); } -void ap2_led_reset_foreground_color() { +void ap2_led_reset_foreground_color(void) { ap2_led_t color = { .p.red = 0, .p.green = 0, diff --git a/keyboards/bemeier/bmek/bmek.c b/keyboards/bemeier/bmek/bmek.c index 47e8742695..31209fdca2 100755 --- a/keyboards/bemeier/bmek/bmek.c +++ b/keyboards/bemeier/bmek/bmek.c @@ -16,7 +16,7 @@ #include "bmek.h" __attribute__((weak)) -void shutdown_user() { +void shutdown_user(void) { #ifdef RGBLIGHT_ENABLE rgblight_setrgb(255, 0, 0); #endif diff --git a/keyboards/bpiphany/frosty_flake/20130602/20130602.c b/keyboards/bpiphany/frosty_flake/20130602/20130602.c index 2c875d1a7f..2c8e7517b9 100644 --- a/keyboards/bpiphany/frosty_flake/20130602/20130602.c +++ b/keyboards/bpiphany/frosty_flake/20130602/20130602.c @@ -1,6 +1,6 @@ #include "frosty_flake.h" -void keyboard_pre_init_kb() { +void keyboard_pre_init_kb(void) { setPinOutput(B7); // caps lock writePinHigh(B7); setPinOutput(C5); // num lock diff --git a/keyboards/bpiphany/frosty_flake/20140521/20140521.c b/keyboards/bpiphany/frosty_flake/20140521/20140521.c index be4e1a3124..65c40ab86e 100644 --- a/keyboards/bpiphany/frosty_flake/20140521/20140521.c +++ b/keyboards/bpiphany/frosty_flake/20140521/20140521.c @@ -1,6 +1,6 @@ #include "frosty_flake.h" -void keyboard_pre_init_kb() { +void keyboard_pre_init_kb(void) { setPinOutput(B7); // num lock writePinHigh(B7); setPinOutput(C5); // caps lock diff --git a/keyboards/cannonkeys/satisfaction75/satisfaction75.c b/keyboards/cannonkeys/satisfaction75/satisfaction75.c index 13b44b85db..ce870c49af 100644 --- a/keyboards/cannonkeys/satisfaction75/satisfaction75.c +++ b/keyboards/cannonkeys/satisfaction75/satisfaction75.c @@ -361,11 +361,11 @@ void custom_config_reset(void){ eeprom_update_byte((uint8_t*)EEPROM_ENABLED_ENCODER_MODES, 0x1F); } -void backlight_config_save(){ +void backlight_config_save(void){ eeprom_update_byte((uint8_t*)EEPROM_CUSTOM_BACKLIGHT, kb_backlight_config.raw); } -void custom_config_load(){ +void custom_config_load(void){ kb_backlight_config.raw = eeprom_read_byte((uint8_t*)EEPROM_CUSTOM_BACKLIGHT); #ifdef DYNAMIC_KEYMAP_ENABLE oled_mode = eeprom_read_byte((uint8_t*)EEPROM_DEFAULT_OLED); diff --git a/keyboards/cannonkeys/satisfaction75/satisfaction_encoder.c b/keyboards/cannonkeys/satisfaction75/satisfaction_encoder.c index c40815a8d8..c8bb999df4 100644 --- a/keyboards/cannonkeys/satisfaction75/satisfaction_encoder.c +++ b/keyboards/cannonkeys/satisfaction75/satisfaction_encoder.c @@ -1,7 +1,7 @@ #include "satisfaction75.h" #include "eeprom.h" -void pre_encoder_mode_change(){ +void pre_encoder_mode_change(void){ if(encoder_mode == ENC_MODE_CLOCK_SET){ RTCDateTime timespec; timespec.year = year_config; @@ -16,7 +16,7 @@ void pre_encoder_mode_change(){ } } -void post_encoder_mode_change(){ +void post_encoder_mode_change(void){ if(encoder_mode == ENC_MODE_CLOCK_SET){ hour_config = (last_minute / 60); minute_config = last_minute % 60; @@ -86,7 +86,7 @@ void update_time_config(int8_t increment){ } } -uint16_t handle_encoder_clockwise(){ +uint16_t handle_encoder_clockwise(void){ uint16_t mapped_code = 0; switch(encoder_mode){ default: @@ -130,7 +130,7 @@ uint16_t handle_encoder_clockwise(){ return mapped_code; } -uint16_t handle_encoder_ccw(){ +uint16_t handle_encoder_ccw(void){ uint16_t mapped_code = 0; switch(encoder_mode){ default: @@ -175,7 +175,7 @@ uint16_t handle_encoder_ccw(){ return mapped_code; } -uint16_t handle_encoder_press(){ +uint16_t handle_encoder_press(void){ uint16_t mapped_code = 0; switch(encoder_mode){ case ENC_MODE_VOLUME: diff --git a/keyboards/cannonkeys/satisfaction75/satisfaction_oled.c b/keyboards/cannonkeys/satisfaction75/satisfaction_oled.c index 1e8465387c..0fd69ca59b 100644 --- a/keyboards/cannonkeys/satisfaction75/satisfaction_oled.c +++ b/keyboards/cannonkeys/satisfaction75/satisfaction_oled.c @@ -168,7 +168,7 @@ static char* get_date(void) { return date_str; } -void draw_default() { +void draw_default(void) { oled_write_P(PSTR("LAYER "), false); oled_write_char(get_highest_layer(layer_state) + 0x30, true); @@ -220,7 +220,7 @@ void draw_default() { draw_line_v(71, 0, 8); } -void draw_clock() { +void draw_clock(void) { oled_set_cursor(0, 0); oled_write(get_date(), false); oled_set_cursor(0, 2); diff --git a/keyboards/capsunlocked/cu75/cu75.c b/keyboards/capsunlocked/cu75/cu75.c index 690d72055a..fff0c10ef6 100644 --- a/keyboards/capsunlocked/cu75/cu75.c +++ b/keyboards/capsunlocked/cu75/cu75.c @@ -98,7 +98,7 @@ bool process_record_kb(uint16_t keycode, keyrecord_t* record) return process_record_user(keycode, record); } -void reset_keyboard_kb(){ +void reset_keyboard_kb(void){ #ifdef WATCHDOG_ENABLE MCUSR = 0; wdt_disable(); diff --git a/keyboards/converter/adb_usb/adb.c b/keyboards/converter/adb_usb/adb.c index 28f14c9fe8..c05bbb53ca 100644 --- a/keyboards/converter/adb_usb/adb.c +++ b/keyboards/converter/adb_usb/adb.c @@ -238,15 +238,15 @@ void adb_host_kbd_led(uint8_t led) { } #ifdef ADB_PSW_BIT -static inline void psw_lo() { +static inline void psw_lo(void) { ADB_DDR |= (1 << ADB_PSW_BIT); ADB_PORT &= ~(1 << ADB_PSW_BIT); } -static inline void psw_hi() { +static inline void psw_hi(void) { ADB_PORT |= (1 << ADB_PSW_BIT); ADB_DDR &= ~(1 << ADB_PSW_BIT); } -static inline bool psw_in() { +static inline bool psw_in(void) { ADB_PORT |= (1 << ADB_PSW_BIT); ADB_DDR &= ~(1 << ADB_PSW_BIT); return ADB_PIN & (1 << ADB_PSW_BIT); diff --git a/keyboards/converter/hp_46010a/matrix.c b/keyboards/converter/hp_46010a/matrix.c index 03fcb2424f..eafe320a3d 100644 --- a/keyboards/converter/hp_46010a/matrix.c +++ b/keyboards/converter/hp_46010a/matrix.c @@ -145,7 +145,7 @@ void Matrix_ThrowByte(void) { return ; } -void matrix_init () { +void matrix_init (void) { // debug_matrix = 1; // PB0 (SS) and PB1 (SCLK) set to outputs DDRB |= RESET | SCLK ; diff --git a/keyboards/converter/ibm_terminal/keymaps/priyadi/keymap.c b/keyboards/converter/ibm_terminal/keymaps/priyadi/keymap.c index f16b349664..0e11fa6779 100644 --- a/keyboards/converter/ibm_terminal/keymaps/priyadi/keymap.c +++ b/keyboards/converter/ibm_terminal/keymaps/priyadi/keymap.c @@ -297,6 +297,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { return true; } -void matrix_init_user() { +void matrix_init_user(void) { set_unicode_input_mode(UNICODE_MODE_LINUX); } diff --git a/keyboards/converter/m0110_usb/m0110.c b/keyboards/converter/m0110_usb/m0110.c index 64f2fa50ab..f3097fb465 100644 --- a/keyboards/converter/m0110_usb/m0110.c +++ b/keyboards/converter/m0110_usb/m0110.c @@ -318,31 +318,31 @@ static inline uint8_t instant(void) { return data; } -static inline void clock_lo() { +static inline void clock_lo(void) { M0110_CLOCK_PORT &= ~(1 << M0110_CLOCK_BIT); M0110_CLOCK_DDR |= (1 << M0110_CLOCK_BIT); } -static inline void clock_hi() { +static inline void clock_hi(void) { /* input with pull up */ M0110_CLOCK_DDR &= ~(1 << M0110_CLOCK_BIT); M0110_CLOCK_PORT |= (1 << M0110_CLOCK_BIT); } -static inline bool clock_in() { +static inline bool clock_in(void) { M0110_CLOCK_DDR &= ~(1 << M0110_CLOCK_BIT); M0110_CLOCK_PORT |= (1 << M0110_CLOCK_BIT); _delay_us(1); return M0110_CLOCK_PIN & (1 << M0110_CLOCK_BIT); } -static inline void data_lo() { +static inline void data_lo(void) { M0110_DATA_PORT &= ~(1 << M0110_DATA_BIT); M0110_DATA_DDR |= (1 << M0110_DATA_BIT); } -static inline void data_hi() { +static inline void data_hi(void) { /* input with pull up */ M0110_DATA_DDR &= ~(1 << M0110_DATA_BIT); M0110_DATA_PORT |= (1 << M0110_DATA_BIT); } -static inline bool data_in() { +static inline bool data_in(void) { M0110_DATA_DDR &= ~(1 << M0110_DATA_BIT); M0110_DATA_PORT |= (1 << M0110_DATA_BIT); _delay_us(1); diff --git a/keyboards/crkbd/keymaps/jpe230/oled/avr/master/oled_master_handler.c b/keyboards/crkbd/keymaps/jpe230/oled/avr/master/oled_master_handler.c index 9a75e9fa9a..f0f6f3f62f 100644 --- a/keyboards/crkbd/keymaps/jpe230/oled/avr/master/oled_master_handler.c +++ b/keyboards/crkbd/keymaps/jpe230/oled/avr/master/oled_master_handler.c @@ -63,7 +63,7 @@ void oled_render_keylog(void) { oled_write((const char *)&logged_char, false); } -void render_master_oled() { +void render_master_oled(void) { if (timer_elapsed32(oled_timer) > CUSTOM_OLED_TIMEOUT) { oled_off(); return; diff --git a/keyboards/crkbd/keymaps/jpe230/oled/avr/slave/oled_slave_handler.c b/keyboards/crkbd/keymaps/jpe230/oled/avr/slave/oled_slave_handler.c index 159413d083..c47fb2a07b 100644 --- a/keyboards/crkbd/keymaps/jpe230/oled/avr/slave/oled_slave_handler.c +++ b/keyboards/crkbd/keymaps/jpe230/oled/avr/slave/oled_slave_handler.c @@ -3,7 +3,7 @@ #include "jpe230.h" -void render_slave_oled() { +void render_slave_oled(void) { static const char PROGMEM crkbd_logo[] = { 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, diff --git a/keyboards/crkbd/keymaps/jpe230/oled/oled_handler.c b/keyboards/crkbd/keymaps/jpe230/oled/oled_handler.c index 67861e5b27..9e130dae38 100644 --- a/keyboards/crkbd/keymaps/jpe230/oled/oled_handler.c +++ b/keyboards/crkbd/keymaps/jpe230/oled/oled_handler.c @@ -12,7 +12,7 @@ __attribute__ ((weak)) void handle_oled_keypress(uint16_t keycode, keyrecord_t * __attribute__ ((weak)) oled_rotation_t rotate_master(oled_rotation_t rotation) {return rotation;} __attribute__ ((weak)) oled_rotation_t rotate_slave(oled_rotation_t rotation) {return rotation;} -void oled_timer_reset() { oled_timer = timer_read32(); } +void oled_timer_reset(void) { oled_timer = timer_read32(); } oled_rotation_t oled_init_user(oled_rotation_t rotation) { diff --git a/keyboards/crkbd/keymaps/jpe230/oled/rp2040/master/oled_master_handler.c b/keyboards/crkbd/keymaps/jpe230/oled/rp2040/master/oled_master_handler.c index a2230e5ee1..ffd3edb792 100644 --- a/keyboards/crkbd/keymaps/jpe230/oled/rp2040/master/oled_master_handler.c +++ b/keyboards/crkbd/keymaps/jpe230/oled/rp2040/master/oled_master_handler.c @@ -40,7 +40,7 @@ void oled_render_layer_state(void) { } -void render_master_oled() { +void render_master_oled(void) { if (timer_elapsed32(oled_timer) > CUSTOM_OLED_TIMEOUT) { oled_off(); return; diff --git a/keyboards/crkbd/keymaps/jpe230/oled/rp2040/slave/oled_slave_handler.c b/keyboards/crkbd/keymaps/jpe230/oled/rp2040/slave/oled_slave_handler.c index ef38fd8c44..31166b3b43 100644 --- a/keyboards/crkbd/keymaps/jpe230/oled/rp2040/slave/oled_slave_handler.c +++ b/keyboards/crkbd/keymaps/jpe230/oled/rp2040/slave/oled_slave_handler.c @@ -4,7 +4,7 @@ #include "jpe230.h" #include "ocean_dream.h" -void render_slave_oled() { +void render_slave_oled(void) { render_stars(); } diff --git a/keyboards/dmqdesign/spin/keymaps/spidey3_pad/keymap.c b/keyboards/dmqdesign/spin/keymaps/spidey3_pad/keymap.c index 00b144a2f4..2ee5fa34c0 100644 --- a/keyboards/dmqdesign/spin/keymaps/spidey3_pad/keymap.c +++ b/keyboards/dmqdesign/spin/keymaps/spidey3_pad/keymap.c @@ -147,7 +147,7 @@ void keyboard_post_init_user(void) { do_rgb_layers(layer_state, LAYER_BASE, LAYER_BASE_END); } -void shutdown_user() { +void shutdown_user(void) { clear_rgb_layers(); rgblight_enable(); rgblight_mode_noeeprom(RGBLIGHT_MODE_STATIC_LIGHT); diff --git a/keyboards/dp60/matrix.c b/keyboards/dp60/matrix.c index a9974757dd..dbcc68056d 100644 --- a/keyboards/dp60/matrix.c +++ b/keyboards/dp60/matrix.c @@ -123,7 +123,7 @@ static void init_rows(void) setPinInputHigh(D4); } -static uint8_t read_rows() +static uint8_t read_rows(void) { return ((readPin(E6) ? 0 : (1 << 0)) | (readPin(F6) ? 0 : (1 << 1)) | diff --git a/keyboards/duck/jetfire/jetfire.c b/keyboards/duck/jetfire/jetfire.c index 7bebd7ad21..d42cb22ff3 100644 --- a/keyboards/duck/jetfire/jetfire.c +++ b/keyboards/duck/jetfire/jetfire.c @@ -76,7 +76,7 @@ void backlight_set(uint8_t level) backlight_toggle_rgb(level & BACKLIGHT_RGB); } -void backlight_update_state() +void backlight_update_state(void) { cli(); send_color(backlight_state_led & (1< 0 if (effect_started_time > 0) { /* Render blinking EFFECTS */ @@ -262,7 +262,7 @@ bool rgb_matrix_indicators_user() { } #if RGB_CONFIRMATION_BLINKING_TIME > 0 -static void start_effects() { +static void start_effects(void) { effect_started_time = sync_timer_read(); if (!rgb_matrix_is_enabled()) { /* Turn it ON, signal the cause (EFFECTS) */ @@ -286,7 +286,7 @@ static void start_effects() { // 87, led 07 88, led 18 // 91, led 08 92, led 19 -static void set_rgb_caps_leds() { +static void set_rgb_caps_leds(void) { rgb_matrix_set_color(67, 0xFF, 0x0, 0x0); // Left side LED 1 rgb_matrix_set_color(68, 0xFF, 0x0, 0x0); // Right side LED 1 rgb_matrix_set_color(70, 0xFF, 0x0, 0x0); // Left side LED 2 diff --git a/keyboards/gmmk/pro/rev1/ansi/keymaps/lalitmaganti/keymap.c b/keyboards/gmmk/pro/rev1/ansi/keymaps/lalitmaganti/keymap.c index 46e0a128f9..83ef8c765a 100644 --- a/keyboards/gmmk/pro/rev1/ansi/keymaps/lalitmaganti/keymap.c +++ b/keyboards/gmmk/pro/rev1/ansi/keymaps/lalitmaganti/keymap.c @@ -73,14 +73,14 @@ bool encoder_update_user(uint8_t index, bool clockwise) { static void set_rgb_side_leds(void); -static void set_rgb_side_leds() { +static void set_rgb_side_leds(void) { rgb_matrix_set_color(67, RGB_WHITE); // Left side LED 1 rgb_matrix_set_color(68, RGB_WHITE); // Right side LED 1 rgb_matrix_set_color(91, RGB_WHITE); // Left side LED 8 rgb_matrix_set_color(92, RGB_WHITE); // Right side LED 8 } -bool rgb_matrix_indicators_user() { +bool rgb_matrix_indicators_user(void) { rgb_matrix_set_color_all(0x0, 0x0, 0x0); if (IS_HOST_LED_ON(USB_LED_CAPS_LOCK)) { rgb_matrix_set_color(3, RGB_WHITE); // CAPS diff --git a/keyboards/gmmk/pro/rev1/ansi/keymaps/macos/keymap.c b/keyboards/gmmk/pro/rev1/ansi/keymaps/macos/keymap.c index 8740bfe89c..50a2ac6ca3 100644 --- a/keyboards/gmmk/pro/rev1/ansi/keymaps/macos/keymap.c +++ b/keyboards/gmmk/pro/rev1/ansi/keymaps/macos/keymap.c @@ -414,7 +414,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { } #if RGB_CONFIRMATION_BLINKING_TIME > 0 - static void start_effects() { + static void start_effects(void) { effect_started_time = sync_timer_read(); if (!rgb_matrix_is_enabled()) { /* Turn it ON, signal the cause (EFFECTS) */ @@ -427,7 +427,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { } #endif // RGB_CONFIRMATION_BLINKING_TIME > 0 - static void set_rgb_caps_leds() { + static void set_rgb_caps_leds(void) { rgb_matrix_set_color(67, 0xFF, 0x0, 0x0); // Left side LED 1 rgb_matrix_set_color(68, 0xFF, 0x0, 0x0); // Right side LED 1 rgb_matrix_set_color(70, 0xFF, 0x0, 0x0); // Left side LED 2 diff --git a/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/encoder.c b/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/encoder.c index 43ed195fbb..c912806217 100644 --- a/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/encoder.c +++ b/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/encoder.c @@ -36,9 +36,9 @@ const encoder_callback encoder_mapping[][2] = { // clang-format on -void volume_up() { tap_code(KC_VOLU); } +void volume_up(void) { tap_code(KC_VOLU); } -void volume_down() { tap_code(KC_VOLD); } +void volume_down(void) { tap_code(KC_VOLD); } bool encoder_update_user(uint8_t index, bool clockwise) { dprintf("current encoder state is: %d\n", state); @@ -65,7 +65,7 @@ void handle_rgb_key(bool pressed) { static KeyPressState *rgb_state; -void keyboard_post_init_encoder() { +void keyboard_post_init_encoder(void) { rgb_state = NewKeyPressState(handle_rgb_key); } diff --git a/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/process_record.c b/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/process_record.c index ac0164e73f..a21b58a36c 100644 --- a/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/process_record.c +++ b/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/process_record.c @@ -116,4 +116,4 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { process_record_fun(keycode, record); } -void keyboard_post_init_user() { keyboard_post_init_encoder(); } +void keyboard_post_init_user(void) { keyboard_post_init_encoder(); } diff --git a/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/rgb_matrix_ledmaps.c b/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/rgb_matrix_ledmaps.c index 0106d80c14..b213abc998 100644 --- a/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/rgb_matrix_ledmaps.c +++ b/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/rgb_matrix_ledmaps.c @@ -58,12 +58,12 @@ void set_layer_rgb(uint8_t led_min, uint8_t led_max, int layer) { } } -void rgb_matrix_layers_enable() { +void rgb_matrix_layers_enable(void) { dprintf("ledmaps are enabled\n"); enabled = true; } -void rgb_matrix_layers_disable() { +void rgb_matrix_layers_disable(void) { dprintf("ledmaps are disabled\n"); enabled = false; } diff --git a/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/utils.c b/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/utils.c index 35ae20b126..009e826423 100644 --- a/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/utils.c +++ b/keyboards/gmmk/pro/rev1/ansi/keymaps/mike1808/utils.c @@ -15,7 +15,7 @@ */ #include "utils.h" -void store_rgb_state_to_eeprom() { +void store_rgb_state_to_eeprom(void) { uint8_t mode = rgb_matrix_get_mode(); uint8_t speed = rgb_matrix_get_speed(); HSV color = rgb_matrix_get_hsv(); diff --git a/keyboards/gmmk/pro/rev1/ansi/keymaps/stickandgum/keymap.c b/keyboards/gmmk/pro/rev1/ansi/keymaps/stickandgum/keymap.c index 6ba850b3e5..9a3123a0a7 100644 --- a/keyboards/gmmk/pro/rev1/ansi/keymaps/stickandgum/keymap.c +++ b/keyboards/gmmk/pro/rev1/ansi/keymaps/stickandgum/keymap.c @@ -247,7 +247,7 @@ bool rgb_matrix_indicators_user(void) { // 87, led 07 88, led 18 // 91, led 08 92, led 19 -static void set_rgb_caps_leds_on() { +static void set_rgb_caps_leds_on(void) { rgb_matrix_set_color(0, 255, 0, 0); //Escape Key rgb_matrix_set_color(3, 255, 0, 0); //capslock key rgb_matrix_set_color(5, 255, 0, 0); //Left CTRL key @@ -269,7 +269,7 @@ static void set_rgb_caps_leds_on() { rgb_matrix_set_color(92, 255, 255, 255); //Right LED 19 } -static void set_rgb_caps_leds_off() { +static void set_rgb_caps_leds_off(void) { rgb_matrix_set_color(0, 0, 0, 0); //Escape Key rgb_matrix_set_color(3, 0, 0, 0); //capslock key rgb_matrix_set_color(5, 0, 0, 0); //Left CTRL key @@ -291,11 +291,11 @@ static void set_rgb_caps_leds_off() { rgb_matrix_set_color(92, 0, 0, 0); //Right LED 19 } -static void set_rgb_scroll_leds_on() { +static void set_rgb_scroll_leds_on(void) { rgb_matrix_set_color(72, 255, 255, 255); // Under Rotary (HOME) } -static void set_rgb_scroll_leds_off() { +static void set_rgb_scroll_leds_off(void) { rgb_matrix_set_color(72, 0, 0, 0); // Under Rotary (HOME) } diff --git a/keyboards/gmmk/pro/rev1/ansi/keymaps/trwnh/keymap.c b/keyboards/gmmk/pro/rev1/ansi/keymaps/trwnh/keymap.c index 8d425cdf1e..303861c676 100644 --- a/keyboards/gmmk/pro/rev1/ansi/keymaps/trwnh/keymap.c +++ b/keyboards/gmmk/pro/rev1/ansi/keymaps/trwnh/keymap.c @@ -62,7 +62,7 @@ const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][2] = { static void set_rgb_caps_leds_off(void); static void set_rgb_scroll_leds_off(void); - static void set_rgb_caps_leds_on() { + static void set_rgb_caps_leds_on(void) { // Set alpha and capslock to red rgb_matrix_set_color( 3, 255, 0, 0); // Caps @@ -97,7 +97,7 @@ const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][2] = { rgb_matrix_set_color(43, 255, 0, 0); // M } - static void set_rgb_caps_leds_off() { + static void set_rgb_caps_leds_off(void) { // Set alpha and capslock to black rgb_matrix_set_color( 3, 0, 0, 0); // Caps @@ -132,11 +132,11 @@ const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][2] = { rgb_matrix_set_color(43, 0, 0, 0); // M } - static void set_rgb_scroll_leds_on() { + static void set_rgb_scroll_leds_on(void) { rgb_matrix_set_color(72, 255, 255, 255); // Under Rotary (HOME) } - static void set_rgb_scroll_leds_off() { + static void set_rgb_scroll_leds_off(void) { rgb_matrix_set_color(72, 0, 0, 0); // Under Rotary (HOME) } diff --git a/keyboards/hadron/ver2/keymaps/side_numpad/keymap.c b/keyboards/hadron/ver2/keymaps/side_numpad/keymap.c index 04b30e3437..f352b1c851 100644 --- a/keyboards/hadron/ver2/keymaps/side_numpad/keymap.c +++ b/keyboards/hadron/ver2/keymaps/side_numpad/keymap.c @@ -325,13 +325,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) {cc PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/handwired/atreus50/keymaps/default/keymap.c b/keyboards/handwired/atreus50/keymaps/default/keymap.c index 6feed5e070..cbcc5fc6f8 100644 --- a/keyboards/handwired/atreus50/keymaps/default/keymap.c +++ b/keyboards/handwired/atreus50/keymaps/default/keymap.c @@ -187,13 +187,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/handwired/jotanck/jotanck.c b/keyboards/handwired/jotanck/jotanck.c index af650b129e..23e2b9634c 100644 --- a/keyboards/handwired/jotanck/jotanck.c +++ b/keyboards/handwired/jotanck/jotanck.c @@ -1,6 +1,6 @@ #include "jotanck.h" -void keyboard_pre_init_kb() { +void keyboard_pre_init_kb(void) { setPinOutput(JOTANCK_LED1); setPinOutput(JOTANCK_LED2); diff --git a/keyboards/handwired/jotpad16/jotpad16.c b/keyboards/handwired/jotpad16/jotpad16.c index dfff7e1679..439cfc7b1e 100644 --- a/keyboards/handwired/jotpad16/jotpad16.c +++ b/keyboards/handwired/jotpad16/jotpad16.c @@ -1,6 +1,6 @@ #include "jotpad16.h" -void keyboard_pre_init_kb() { +void keyboard_pre_init_kb(void) { setPinOutput(JOTPAD16_LED1); setPinOutput(JOTPAD16_LED2); diff --git a/keyboards/handwired/jscotto/scotto36/keymaps/default/keymap.c b/keyboards/handwired/jscotto/scotto36/keymaps/default/keymap.c index 3c6e61aea0..ad8451ac09 100644 --- a/keyboards/handwired/jscotto/scotto36/keymaps/default/keymap.c +++ b/keyboards/handwired/jscotto/scotto36/keymaps/default/keymap.c @@ -216,7 +216,7 @@ static void render_animation(void) { } // Draw to OLED -bool oled_task_user() { +bool oled_task_user(void) { // Render Bongo Cat render_animation(); diff --git a/keyboards/handwired/jscotto/scottocmd/keymaps/default/keymap.c b/keyboards/handwired/jscotto/scottocmd/keymaps/default/keymap.c index 97d2c206a8..b1c77ae944 100644 --- a/keyboards/handwired/jscotto/scottocmd/keymaps/default/keymap.c +++ b/keyboards/handwired/jscotto/scottocmd/keymaps/default/keymap.c @@ -349,7 +349,7 @@ static void render_animation(void) { } // Draw to OLED -bool oled_task_user() { +bool oled_task_user(void) { // Caps lock text led_t led_state = host_keyboard_led_state(); oled_set_cursor(0,1); diff --git a/keyboards/handwired/onekey/keymaps/digitizer/keymap.c b/keyboards/handwired/onekey/keymaps/digitizer/keymap.c index dcc0adc59b..49fe3d66c8 100644 --- a/keyboards/handwired/onekey/keymaps/digitizer/keymap.c +++ b/keyboards/handwired/onekey/keymaps/digitizer/keymap.c @@ -32,7 +32,7 @@ void keyboard_post_init_user(void) { digitizer_in_range_on(); } -void matrix_scan_user() { +void matrix_scan_user(void) { if (timer_elapsed32(timer) < 200) { return; } diff --git a/keyboards/handwired/onekey/keymaps/joystick/keymap.c b/keyboards/handwired/onekey/keymaps/joystick/keymap.c index 6463900b7b..3bcdf2c58e 100644 --- a/keyboards/handwired/onekey/keymaps/joystick/keymap.c +++ b/keyboards/handwired/onekey/keymaps/joystick/keymap.c @@ -8,7 +8,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { LAYOUT_ortho_1x1(JS_0) }; -void matrix_scan_user() { +void matrix_scan_user(void) { int16_t val = (((uint32_t)timer_read() % 5000 - 2500) * 255) / 5000; joystick_set_axis(1, val); } diff --git a/keyboards/handwired/ortho5x13/keymaps/default/keymap.c b/keyboards/handwired/ortho5x13/keymaps/default/keymap.c index f043bd1be2..ef975a215d 100644 --- a/keyboards/handwired/ortho5x13/keymaps/default/keymap.c +++ b/keyboards/handwired/ortho5x13/keymaps/default/keymap.c @@ -256,13 +256,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/handwired/promethium/keymaps/default/keymap.c b/keyboards/handwired/promethium/keymaps/default/keymap.c index 534a2986cb..21dd99d95a 100644 --- a/keyboards/handwired/promethium/keymaps/default/keymap.c +++ b/keyboards/handwired/promethium/keymaps/default/keymap.c @@ -1272,7 +1272,7 @@ void set_output_user(uint8_t output) { #endif } -void matrix_init_user() { +void matrix_init_user(void) { wait_ms(500); // give time for usb to initialize set_unicode_input_mode(UNICODE_MODE_LINUX); @@ -1292,7 +1292,7 @@ void matrix_init_user() { #endif } -void turn_off_capslock() { +void turn_off_capslock(void) { if (capslock) { register_code(KC_CAPS); unregister_code(KC_CAPS); @@ -1323,7 +1323,7 @@ void turn_off_capslock() { #endif #ifdef PS2_MOUSE_ENABLE - void ps2_mouse_init_user() { + void ps2_mouse_init_user(void) { uint8_t rcv; // set TrackPoint sensitivity diff --git a/keyboards/handwired/promethium/keymaps/priyadi/keymap.c b/keyboards/handwired/promethium/keymaps/priyadi/keymap.c index 4271073549..1ebf63037b 100644 --- a/keyboards/handwired/promethium/keymaps/priyadi/keymap.c +++ b/keyboards/handwired/promethium/keymaps/priyadi/keymap.c @@ -1275,7 +1275,7 @@ void set_output_user(uint8_t output) { #endif } -void matrix_init_user() { +void matrix_init_user(void) { wait_ms(500); // give time for usb to initialize set_unicode_input_mode(UNICODE_MODE_LINUX); @@ -1295,7 +1295,7 @@ void matrix_init_user() { #endif } -void turn_off_capslock() { +void turn_off_capslock(void) { if (capslock) { register_code(KC_CAPS); unregister_code(KC_CAPS); @@ -1326,7 +1326,7 @@ void turn_off_capslock() { #endif #ifdef PS2_MOUSE_ENABLE - void ps2_mouse_init_user() { + void ps2_mouse_init_user(void) { uint8_t rcv; // set TrackPoint sensitivity diff --git a/keyboards/helix/pico/keymaps/default/keymap.c b/keyboards/helix/pico/keymaps/default/keymap.c index 21418f2d2f..101a54bda6 100644 --- a/keyboards/helix/pico/keymaps/default/keymap.c +++ b/keyboards/helix/pico/keymaps/default/keymap.c @@ -340,12 +340,12 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(50); // gets rid of tick } -void shutdown_user() +void shutdown_user(void) { _delay_ms(150); stop_all_notes(); diff --git a/keyboards/helix/pico/keymaps/mtei/keymap.c b/keyboards/helix/pico/keymaps/mtei/keymap.c index 17a98f4d7f..6a5f7d295a 100644 --- a/keyboards/helix/pico/keymaps/mtei/keymap.c +++ b/keyboards/helix/pico/keymaps/mtei/keymap.c @@ -344,12 +344,12 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(50); // gets rid of tick } -void shutdown_user() +void shutdown_user(void) { _delay_ms(150); stop_all_notes(); diff --git a/keyboards/helix/rev2/keymaps/default/keymap.c b/keyboards/helix/rev2/keymaps/default/keymap.c index cc61ec4caa..464b8bbd80 100644 --- a/keyboards/helix/rev2/keymaps/default/keymap.c +++ b/keyboards/helix/rev2/keymaps/default/keymap.c @@ -479,12 +479,12 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick } -void shutdown_user() +void shutdown_user(void) { _delay_ms(150); stop_all_notes(); diff --git a/keyboards/helix/rev2/keymaps/froggy/keymap.c b/keyboards/helix/rev2/keymaps/froggy/keymap.c index 3b6d3f2065..ae96f576af 100644 --- a/keyboards/helix/rev2/keymaps/froggy/keymap.c +++ b/keyboards/helix/rev2/keymaps/froggy/keymap.c @@ -464,12 +464,12 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick } -void shutdown_user() +void shutdown_user(void) { _delay_ms(150); stop_all_notes(); diff --git a/keyboards/helix/rev2/keymaps/yshrsmz/keymap.c b/keyboards/helix/rev2/keymaps/yshrsmz/keymap.c index d2a460d0b5..5f22ed2741 100644 --- a/keyboards/helix/rev2/keymaps/yshrsmz/keymap.c +++ b/keyboards/helix/rev2/keymaps/yshrsmz/keymap.c @@ -459,12 +459,12 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick } -void shutdown_user() +void shutdown_user(void) { _delay_ms(150); stop_all_notes(); diff --git a/keyboards/ibnuda/squiggle/keymaps/rick-complicated/keymap.c b/keyboards/ibnuda/squiggle/keymaps/rick-complicated/keymap.c index b8c0d9f844..c33bf71741 100644 --- a/keyboards/ibnuda/squiggle/keymaps/rick-complicated/keymap.c +++ b/keyboards/ibnuda/squiggle/keymaps/rick-complicated/keymap.c @@ -183,7 +183,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { LEADER_EXTERNS(); -void matrix_scan_user() { +void matrix_scan_user(void) { LEADER_DICTIONARY() { leading = false; leader_end(); diff --git a/keyboards/input_club/ergodox_infinity/ergodox_infinity.c b/keyboards/input_club/ergodox_infinity/ergodox_infinity.c index 6f7de7ff29..fbe1bdb77f 100644 --- a/keyboards/input_club/ergodox_infinity/ergodox_infinity.c +++ b/keyboards/input_club/ergodox_infinity/ergodox_infinity.c @@ -94,7 +94,7 @@ __attribute__ ((weak)) void matrix_init_user(void) {} __attribute__ ((weak)) void matrix_scan_user(void) {} -void keyboard_pre_init_kb() { +void keyboard_pre_init_kb(void) { #ifdef LED_MATRIX_ENABLE // Turn on LED controller setPinOutput(B16); diff --git a/keyboards/input_club/ergodox_infinity/keymaps/dudeofawesome/keymap.c b/keyboards/input_club/ergodox_infinity/keymaps/dudeofawesome/keymap.c index ebdedcbe6b..d1665ecb1f 100644 --- a/keyboards/input_club/ergodox_infinity/keymaps/dudeofawesome/keymap.c +++ b/keyboards/input_club/ergodox_infinity/keymaps/dudeofawesome/keymap.c @@ -470,7 +470,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; -void matrix_init_user() { +void matrix_init_user(void) { led_matrix_enable_noeeprom(); led_matrix_set_val_noeeprom(UINT8_MAX); } diff --git a/keyboards/input_club/k_type/keymaps/andrew-fahmy/keymap.c b/keyboards/input_club/k_type/keymaps/andrew-fahmy/keymap.c index 87a6404326..264c760414 100644 --- a/keyboards/input_club/k_type/keymaps/andrew-fahmy/keymap.c +++ b/keyboards/input_club/k_type/keymaps/andrew-fahmy/keymap.c @@ -52,7 +52,7 @@ void keyboard_post_init_user(void) { #ifdef RGB_MATRIX_ENABLE // Turn off SDB -void keyboard_pre_init_user() { +void keyboard_pre_init_user(void) { palSetPadMode(GPIOB, 16, PAL_MODE_OUTPUT_PUSHPULL); palSetPad(GPIOB, 16); } diff --git a/keyboards/jels/jels88/jels88.c b/keyboards/jels/jels88/jels88.c index bd8e30e4ee..a5ae732d3e 100644 --- a/keyboards/jels/jels88/jels88.c +++ b/keyboards/jels/jels88/jels88.c @@ -22,7 +22,7 @@ #define CAPS_LED D5 #define SCROLL_LED D4 -void keyboard_pre_init_kb() { +void keyboard_pre_init_kb(void) { setPinOutput(CAPS_LED); setPinOutput(SCROLL_LED); keyboard_pre_init_user(); diff --git a/keyboards/kbdfans/niu_mini/keymaps/yttyx/keymap.c b/keyboards/kbdfans/niu_mini/keymaps/yttyx/keymap.c index c7db9d5023..55d5a80228 100644 --- a/keyboards/kbdfans/niu_mini/keymaps/yttyx/keymap.c +++ b/keyboards/kbdfans/niu_mini/keymaps/yttyx/keymap.c @@ -90,6 +90,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; -void matrix_init_user() { +void matrix_init_user(void) { steno_set_mode(STENO_MODE_GEMINI); } diff --git a/keyboards/keebio/iris/keymaps/edvorakjp/keymap.c b/keyboards/keebio/iris/keymaps/edvorakjp/keymap.c index e593051db8..97c9f48f89 100644 --- a/keyboards/keebio/iris/keymaps/edvorakjp/keymap.c +++ b/keyboards/keebio/iris/keymaps/edvorakjp/keymap.c @@ -50,7 +50,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; // clang-format on -void matrix_init_keymap() {} +void matrix_init_keymap(void) {} #ifdef RGBLIGHT_EFFECT_STATIC_GRADIENT layer_state_t layer_state_set_keymap(layer_state_t state) { diff --git a/keyboards/keebio/levinson/keymaps/steno/keymap.c b/keyboards/keebio/levinson/keymaps/steno/keymap.c index 33b80ca194..854ef41999 100644 --- a/keyboards/keebio/levinson/keymaps/steno/keymap.c +++ b/keyboards/keebio/levinson/keymaps/steno/keymap.c @@ -91,7 +91,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = }; -void matrix_init_user() { +void matrix_init_user(void) { steno_set_mode(STENO_MODE_GEMINI); // or STENO_MODE_BOLT } diff --git a/keyboards/knops/mini/keymaps/mverteuil/keymap.c b/keyboards/knops/mini/keymaps/mverteuil/keymap.c index 45765a7aba..2e8d678f26 100644 --- a/keyboards/knops/mini/keymaps/mverteuil/keymap.c +++ b/keyboards/knops/mini/keymaps/mverteuil/keymap.c @@ -222,7 +222,7 @@ void set_layer_led(int layerLedMode) { } } -void led_init_animation() { +void led_init_animation(void) { for (int i = ALL_LAYERS_OFF; i <= ALL_LAYERS_ON; i++) { led_set_layer(i); } diff --git a/keyboards/lazydesigners/dimple/staggered/staggered.c b/keyboards/lazydesigners/dimple/staggered/staggered.c index 2cd8c018db..b871868afa 100644 --- a/keyboards/lazydesigners/dimple/staggered/staggered.c +++ b/keyboards/lazydesigners/dimple/staggered/staggered.c @@ -14,10 +14,10 @@ * along with this program. If not, see . */ #include "staggered.h" -void dimple_led_on() { +void dimple_led_on(void) { writePinLow(E6); } - void dimple_led_off() { + void dimple_led_off(void) { writePinHigh(E6); } diff --git a/keyboards/lazydesigners/the50/the50.c b/keyboards/lazydesigners/the50/the50.c index 4ceb3da6ab..35c678fd5e 100644 --- a/keyboards/lazydesigners/the50/the50.c +++ b/keyboards/lazydesigners/the50/the50.c @@ -1,9 +1,9 @@ #include "the50.h" -void the50_led_on() { +void the50_led_on(void) { DDRB |= (1 << 7); PORTB &= ~(1 << 7); } -void the50_led_off() { +void the50_led_off(void) { DDRB &= ~(1 << 7); PORTB &= ~(1 << 7); } diff --git a/keyboards/lfkeyboards/TWIlib.c b/keyboards/lfkeyboards/TWIlib.c index d50ce72895..0d52322c64 100644 --- a/keyboards/lfkeyboards/TWIlib.c +++ b/keyboards/lfkeyboards/TWIlib.c @@ -24,7 +24,7 @@ int RXBuffLen; // The total number of bytes to read (should be less than RXMAXBU TWIInfoStruct TWIInfo; -void TWIInit() +void TWIInit(void) { TWIInfo.mode = Ready; TWIInfo.errorCode = 0xFF; @@ -37,7 +37,7 @@ void TWIInit() TWCR = (1 << TWIE) | (1 << TWEN); } -uint8_t isTWIReady() +uint8_t isTWIReady(void) { if ( (TWIInfo.mode == Ready) | (TWIInfo.mode == RepeatedStartSent) ) { diff --git a/keyboards/lfkeyboards/lfk65_hs/lfk65_hs.c b/keyboards/lfkeyboards/lfk65_hs/lfk65_hs.c index 7326e812ec..3d273e8aec 100644 --- a/keyboards/lfkeyboards/lfk65_hs/lfk65_hs.c +++ b/keyboards/lfkeyboards/lfk65_hs/lfk65_hs.c @@ -13,7 +13,7 @@ bool process_record_kb(uint16_t keycode, keyrecord_t* record) return process_record_user(keycode, record); } -void reset_keyboard_kb(){ +void reset_keyboard_kb(void){ #ifdef WATCHDOG_ENABLE MCUSR = 0; wdt_disable(); diff --git a/keyboards/lfkeyboards/lfk78/lfk78.c b/keyboards/lfkeyboards/lfk78/lfk78.c index 110bbd4168..6f4c062ad8 100644 --- a/keyboards/lfkeyboards/lfk78/lfk78.c +++ b/keyboards/lfkeyboards/lfk78/lfk78.c @@ -137,7 +137,7 @@ bool process_record_kb(uint16_t keycode, keyrecord_t* record) { return process_record_user(keycode, record); } -void reset_keyboard_kb() { +void reset_keyboard_kb(void) { #ifdef WATCHDOG_ENABLE MCUSR = 0; wdt_disable(); diff --git a/keyboards/lfkeyboards/lfk87/lfk87.c b/keyboards/lfkeyboards/lfk87/lfk87.c index 18ddd86adc..ce81aa7d27 100644 --- a/keyboards/lfkeyboards/lfk87/lfk87.c +++ b/keyboards/lfkeyboards/lfk87/lfk87.c @@ -116,7 +116,7 @@ bool process_record_kb(uint16_t keycode, keyrecord_t* record) return process_record_user(keycode, record); } -void reset_keyboard_kb(){ +void reset_keyboard_kb(void){ #ifdef WATCHDOG_ENABLE MCUSR = 0; wdt_disable(); diff --git a/keyboards/lfkeyboards/lighting.c b/keyboards/lfkeyboards/lighting.c index f4940ec079..5f3ab46e46 100644 --- a/keyboards/lfkeyboards/lighting.c +++ b/keyboards/lfkeyboards/lighting.c @@ -112,7 +112,7 @@ void set_backlight_by_keymap(uint8_t col, uint8_t row){ #endif } -void force_issi_refresh(){ +void force_issi_refresh(void){ #ifdef ISSI_ENABLE issi_devices[0]->led_dirty = true; update_issi(0, true); @@ -121,7 +121,7 @@ void force_issi_refresh(){ #endif } -void led_test(){ +void led_test(void){ #ifdef ISSI_ENABLE #ifdef WATCHDOG_ENABLE // This test take a long time to run, disable the WTD until its complete diff --git a/keyboards/lfkeyboards/mini1800/mini1800.c b/keyboards/lfkeyboards/mini1800/mini1800.c index cf7e42f134..fb92137be8 100644 --- a/keyboards/lfkeyboards/mini1800/mini1800.c +++ b/keyboards/lfkeyboards/mini1800/mini1800.c @@ -122,7 +122,7 @@ bool process_record_kb(uint16_t keycode, keyrecord_t* record) return process_record_user(keycode, record); } -void reset_keyboard_kb(){ +void reset_keyboard_kb(void){ #ifdef WATCHDOG_ENABLE MCUSR = 0; wdt_disable(); diff --git a/keyboards/lfkeyboards/smk65/revb/revb.c b/keyboards/lfkeyboards/smk65/revb/revb.c index 9e78107eca..858305244a 100644 --- a/keyboards/lfkeyboards/smk65/revb/revb.c +++ b/keyboards/lfkeyboards/smk65/revb/revb.c @@ -81,7 +81,7 @@ bool process_record_kb(uint16_t keycode, keyrecord_t* record) return process_record_user(keycode, record); } -void reset_keyboard_kb(){ +void reset_keyboard_kb(void){ #ifdef WATCHDOG_ENABLE MCUSR = 0; wdt_disable(); diff --git a/keyboards/macrocat/macrocat.c b/keyboards/macrocat/macrocat.c index aec76d1912..f00bb01410 100644 --- a/keyboards/macrocat/macrocat.c +++ b/keyboards/macrocat/macrocat.c @@ -126,12 +126,12 @@ void encoder_double_click(void) { void encoder_triple_click(void) { tap_code(KC_MPRV); } -void matrix_init_kb() { +void matrix_init_kb(void) { matrix_init_user(); setPinInputHigh(ENCODER_SWITCH); } -void matrix_scan_kb() { +void matrix_scan_kb(void) { matrix_scan_user(); if (readPin(ENCODER_SWITCH)) { if (encoder_pressed) { // release switch diff --git a/keyboards/makeymakey/makeymakey.c b/keyboards/makeymakey/makeymakey.c index 77794416b2..ade9200de4 100644 --- a/keyboards/makeymakey/makeymakey.c +++ b/keyboards/makeymakey/makeymakey.c @@ -108,7 +108,7 @@ void cycle_leds(void) { } } -void matrix_scan_kb() { +void matrix_scan_kb(void) { cycle_leds(); matrix_scan_user(); } diff --git a/keyboards/matrix/noah/keymaps/blockader/keymap.c b/keyboards/matrix/noah/keymaps/blockader/keymap.c index cec0905677..b6caf43f91 100644 --- a/keyboards/matrix/noah/keymaps/blockader/keymap.c +++ b/keyboards/matrix/noah/keymaps/blockader/keymap.c @@ -645,7 +645,7 @@ bool process_record_user(uint16_t key, keyrecord_t* record) { return handle_common_key(key, record); } -void keyboard_post_init_user() { +void keyboard_post_init_user(void) { rgblight_disable_noeeprom(); rgb_matrix_disable(); common_layer_data.back = false; diff --git a/keyboards/mechwild/bbs/bbs.c b/keyboards/mechwild/bbs/bbs.c index 02c5f43dd9..9a7253e5da 100644 --- a/keyboards/mechwild/bbs/bbs.c +++ b/keyboards/mechwild/bbs/bbs.c @@ -16,7 +16,7 @@ bool dip_switch_update_kb(uint8_t index, bool active) { } #endif -void eeconfig_init_kb() { +void eeconfig_init_kb(void) { steno_set_mode(STENO_MODE_GEMINI); // or STENO_MODE_BOLT eeconfig_init_user(); } \ No newline at end of file diff --git a/keyboards/nek_type_a/mcp23017.c b/keyboards/nek_type_a/mcp23017.c index 1434fa56c4..6c8ccb4ff1 100644 --- a/keyboards/nek_type_a/mcp23017.c +++ b/keyboards/nek_type_a/mcp23017.c @@ -53,7 +53,7 @@ void expander_init(void) { } // set IN and HI -void expander_unselect_all() { +void expander_unselect_all(void) { expander_write(EXPANDER_REG_IODIRA, 0xff); expander_write(EXPANDER_REG_IODIRB, 0xff); expander_write(EXPANDER_REG_OLATA, 0xff); @@ -74,7 +74,7 @@ void expander_select(uint8_t pin) { wait_us(EXPANDER_PAUSE); } -void expander_config() { +void expander_config(void) { // set everything to input expander_write(EXPANDER_REG_IODIRA, 0xff); expander_write(EXPANDER_REG_IODIRB, 0xff); diff --git a/keyboards/neopad/rev1/rev1.c b/keyboards/neopad/rev1/rev1.c index 20e2c4d055..665294451a 100755 --- a/keyboards/neopad/rev1/rev1.c +++ b/keyboards/neopad/rev1/rev1.c @@ -22,7 +22,7 @@ void keyboard_pre_init_kb(void) { keyboard_pre_init_user(); } -void shutdown_user() { +void shutdown_user(void) { // Shutdown LEDs writePinLow(LED_00); writePinLow(LED_01); diff --git a/keyboards/opendeck/32/rev1/rev1.c b/keyboards/opendeck/32/rev1/rev1.c index b803682b7d..5d546afb29 100644 --- a/keyboards/opendeck/32/rev1/rev1.c +++ b/keyboards/opendeck/32/rev1/rev1.c @@ -102,7 +102,7 @@ void keyboard_pre_init_kb(void) { setPinInput(RGB_IRQ_N_PIN); } -void keyboard_post_init_user() { +void keyboard_post_init_user(void) { // RGB enabled by default, no way to turn off. No need to expend EEPROM write cycles here. rgb_matrix_enable_noeeprom(); } diff --git a/keyboards/planck/keymaps/circuit/keymap.c b/keyboards/planck/keymaps/circuit/keymap.c index 4b3db082a7..d150905dc8 100644 --- a/keyboards/planck/keymaps/circuit/keymap.c +++ b/keyboards/planck/keymaps/circuit/keymap.c @@ -219,13 +219,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/dbroqua/keymap.c b/keyboards/planck/keymaps/dbroqua/keymap.c index 6096b51dde..95d0b85408 100644 --- a/keyboards/planck/keymaps/dbroqua/keymap.c +++ b/keyboards/planck/keymaps/dbroqua/keymap.c @@ -192,13 +192,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/dcompact/keymap.c b/keyboards/planck/keymaps/dcompact/keymap.c index 0e09d21efb..a63f86e7a8 100644 --- a/keyboards/planck/keymaps/dcompact/keymap.c +++ b/keyboards/planck/keymaps/dcompact/keymap.c @@ -357,6 +357,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { return true; } -void matrix_init_user() { +void matrix_init_user(void) { steno_set_mode(STENO_MODE_GEMINI); } diff --git a/keyboards/planck/keymaps/dr_notsokind/keymap.c b/keyboards/planck/keymaps/dr_notsokind/keymap.c index 0338e1806e..ffceef11cc 100644 --- a/keyboards/planck/keymaps/dr_notsokind/keymap.c +++ b/keyboards/planck/keymaps/dr_notsokind/keymap.c @@ -312,13 +312,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/emilyh/keymap.c b/keyboards/planck/keymaps/emilyh/keymap.c index 91e5c5fb37..17bbc98b7e 100644 --- a/keyboards/planck/keymaps/emilyh/keymap.c +++ b/keyboards/planck/keymaps/emilyh/keymap.c @@ -282,13 +282,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/experimental/keymap.c b/keyboards/planck/keymaps/experimental/keymap.c index ecb13848d1..e0ade650fe 100644 --- a/keyboards/planck/keymaps/experimental/keymap.c +++ b/keyboards/planck/keymaps/experimental/keymap.c @@ -347,13 +347,13 @@ void matrix_init_user(void) { } #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/gunp/keymap.c b/keyboards/planck/keymaps/gunp/keymap.c index 555b073839..7c2f6c0bd5 100644 --- a/keyboards/planck/keymaps/gunp/keymap.c +++ b/keyboards/planck/keymaps/gunp/keymap.c @@ -293,13 +293,13 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { float music_scale[][2] = SONG(MUSIC_SCALE_SOUND); #endif -void startup_user() { +void startup_user(void) { #ifdef AUDIO_ENABLE PLAY_SONG(tone_startup); #endif } -void shutdown_user() { +void shutdown_user(void) { #ifdef AUDIO_ENABLE PLAY_SONG(tone_goodbye); stop_all_notes(); diff --git a/keyboards/planck/keymaps/handwired_binaryplease/keymap.c b/keyboards/planck/keymaps/handwired_binaryplease/keymap.c index b5e8484bdd..13917e516d 100644 --- a/keyboards/planck/keymaps/handwired_binaryplease/keymap.c +++ b/keyboards/planck/keymaps/handwired_binaryplease/keymap.c @@ -280,13 +280,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/impossible/keymap.c b/keyboards/planck/keymaps/impossible/keymap.c index 07872d0d7f..9145ad79aa 100644 --- a/keyboards/planck/keymaps/impossible/keymap.c +++ b/keyboards/planck/keymaps/impossible/keymap.c @@ -205,13 +205,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/ishtob/keymap.c b/keyboards/planck/keymaps/ishtob/keymap.c index 48cce59420..eebafddbed 100644 --- a/keyboards/planck/keymaps/ishtob/keymap.c +++ b/keyboards/planck/keymaps/ishtob/keymap.c @@ -321,7 +321,7 @@ void matrix_init_keymap(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { #ifdef RGB_MATRIX_ENABLE rgblight_mode(RGB_MATRIX_CYCLE_ALL); @@ -330,7 +330,7 @@ void startup_user() PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); wait_ms(150); diff --git a/keyboards/planck/keymaps/jhenahan/keymap.c b/keyboards/planck/keymaps/jhenahan/keymap.c index 92b3d16e2e..21c489922d 100644 --- a/keyboards/planck/keymaps/jhenahan/keymap.c +++ b/keyboards/planck/keymaps/jhenahan/keymap.c @@ -277,13 +277,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/lae3/keymap.c b/keyboards/planck/keymaps/lae3/keymap.c index 87845b0f32..7b6175d543 100644 --- a/keyboards/planck/keymaps/lae3/keymap.c +++ b/keyboards/planck/keymaps/lae3/keymap.c @@ -227,13 +227,13 @@ void matrix_init_user(void) #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(100); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/mjt/keymap.c b/keyboards/planck/keymaps/mjt/keymap.c index 2b5ce9d206..e927627e1f 100644 --- a/keyboards/planck/keymaps/mjt/keymap.c +++ b/keyboards/planck/keymaps/mjt/keymap.c @@ -248,13 +248,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/mjtnumsym/keymap.c b/keyboards/planck/keymaps/mjtnumsym/keymap.c index 81ba8d9ee0..3fa05ad178 100644 --- a/keyboards/planck/keymaps/mjtnumsym/keymap.c +++ b/keyboards/planck/keymaps/mjtnumsym/keymap.c @@ -247,13 +247,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/originerd/keymap.c b/keyboards/planck/keymaps/originerd/keymap.c index 917e59f0bb..85e5cd3b16 100644 --- a/keyboards/planck/keymaps/originerd/keymap.c +++ b/keyboards/planck/keymaps/originerd/keymap.c @@ -158,13 +158,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/premek/keymap.c b/keyboards/planck/keymaps/premek/keymap.c index 402a603ece..76d3cabfbc 100644 --- a/keyboards/planck/keymaps/premek/keymap.c +++ b/keyboards/planck/keymaps/premek/keymap.c @@ -194,13 +194,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/sgoodwin/keymap.c b/keyboards/planck/keymaps/sgoodwin/keymap.c index 1b88afd952..e61cd4de68 100644 --- a/keyboards/planck/keymaps/sgoodwin/keymap.c +++ b/keyboards/planck/keymaps/sgoodwin/keymap.c @@ -198,13 +198,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/smt/keymap.c b/keyboards/planck/keymaps/smt/keymap.c index 3c6eb6e74c..6320e11fcf 100644 --- a/keyboards/planck/keymaps/smt/keymap.c +++ b/keyboards/planck/keymaps/smt/keymap.c @@ -230,13 +230,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/that_canadian/keymap.c b/keyboards/planck/keymaps/that_canadian/keymap.c index bb9ff261ee..9f3a415fa3 100644 --- a/keyboards/planck/keymaps/that_canadian/keymap.c +++ b/keyboards/planck/keymaps/that_canadian/keymap.c @@ -182,13 +182,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/planck/keymaps/vaire/keymap.c b/keyboards/planck/keymaps/vaire/keymap.c index 3b411e6185..05f7f4a520 100644 --- a/keyboards/planck/keymaps/vaire/keymap.c +++ b/keyboards/planck/keymaps/vaire/keymap.c @@ -124,13 +124,13 @@ void led_set_user(uint8_t usb_led) } -void startup_user() +void startup_user(void) { _delay_ms(30); // gets rid of tick PLAY_SONG(tone_my_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_my_goodbye); _delay_ms(3000); diff --git a/keyboards/planck/keymaps/yttyx/keymap.c b/keyboards/planck/keymaps/yttyx/keymap.c index 8c989da8a8..1201163ac7 100644 --- a/keyboards/planck/keymaps/yttyx/keymap.c +++ b/keyboards/planck/keymaps/yttyx/keymap.c @@ -90,6 +90,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; -void matrix_init_user() { +void matrix_init_user(void) { steno_set_mode(STENO_MODE_GEMINI); } diff --git a/keyboards/planck/keymaps/zach/zach_common_functions.c b/keyboards/planck/keymaps/zach/zach_common_functions.c index 97b650d9cb..6ad1c7bed3 100644 --- a/keyboards/planck/keymaps/zach/zach_common_functions.c +++ b/keyboards/planck/keymaps/zach/zach_common_functions.c @@ -427,7 +427,7 @@ void play_goodbye_tone(void){ _delay_ms(150); } -void shutdown_user(){ +void shutdown_user(void){ PLAY_SONG(tone_goodbye); _delay_ms(150); stop_all_notes(); diff --git a/keyboards/preonic/keymaps/0xdec/keymap.c b/keyboards/preonic/keymaps/0xdec/keymap.c index 4cf3a21049..fafa5c4460 100644 --- a/keyboards/preonic/keymaps/0xdec/keymap.c +++ b/keyboards/preonic/keymaps/0xdec/keymap.c @@ -98,11 +98,11 @@ float tone_game[][2] = { float tone_goodbye[][2] = SONG(GOODBYE_SOUND); float music_scale[][2] = SONG(MUSIC_SCALE_SOUND); -void startup_user() { +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() { +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); stop_all_notes(); diff --git a/keyboards/preonic/keymaps/bucktooth/keymap.c b/keyboards/preonic/keymaps/bucktooth/keymap.c index b68a93ba3c..593083f201 100644 --- a/keyboards/preonic/keymaps/bucktooth/keymap.c +++ b/keyboards/preonic/keymaps/bucktooth/keymap.c @@ -91,12 +91,12 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); stop_all_notes(); diff --git a/keyboards/preonic/keymaps/jacwib/keymap.c b/keyboards/preonic/keymaps/jacwib/keymap.c index 774b2a0c4e..9de460c2a4 100644 --- a/keyboards/preonic/keymaps/jacwib/keymap.c +++ b/keyboards/preonic/keymaps/jacwib/keymap.c @@ -258,13 +258,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/preonic/keymaps/mverteuil/keymap.c b/keyboards/preonic/keymaps/mverteuil/keymap.c index 332e2877b2..e81f38362a 100644 --- a/keyboards/preonic/keymaps/mverteuil/keymap.c +++ b/keyboards/preonic/keymaps/mverteuil/keymap.c @@ -242,7 +242,7 @@ float s_audio_on[][2] = AUDIO_ON_SONG; float s_layer_lower[][2] = LAYER_LOWER_SONG; float s_layer_raise[][2] = LAYER_RAISE_SONG; -void audio_on_user() { PLAY_SONG(s_audio_on); }; +void audio_on_user(void) { PLAY_SONG(s_audio_on); }; bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { diff --git a/keyboards/preonic/keymaps/mverteuil_2x2u/keymap.c b/keyboards/preonic/keymaps/mverteuil_2x2u/keymap.c index c6cad0fe5f..cab5cdcb05 100644 --- a/keyboards/preonic/keymaps/mverteuil_2x2u/keymap.c +++ b/keyboards/preonic/keymaps/mverteuil_2x2u/keymap.c @@ -218,7 +218,7 @@ float s_audio_on[][2] = AUDIO_ON_SONG; float s_layer_lower[][2] = LAYER_LOWER_SONG; float s_layer_raise[][2] = LAYER_RAISE_SONG; -void audio_on_user() { PLAY_SONG(s_audio_on); }; +void audio_on_user(void) { PLAY_SONG(s_audio_on); }; bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { diff --git a/keyboards/preonic/keymaps/nikchi/keymap.c b/keyboards/preonic/keymaps/nikchi/keymap.c index 9510791d2a..e14f8f0052 100644 --- a/keyboards/preonic/keymaps/nikchi/keymap.c +++ b/keyboards/preonic/keymaps/nikchi/keymap.c @@ -186,13 +186,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/preonic/keymaps/smt/keymap.c b/keyboards/preonic/keymaps/smt/keymap.c index 80c704de32..7dd9545261 100644 --- a/keyboards/preonic/keymaps/smt/keymap.c +++ b/keyboards/preonic/keymaps/smt/keymap.c @@ -251,13 +251,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/preonic/keymaps/that_canadian/keymap.c b/keyboards/preonic/keymaps/that_canadian/keymap.c index 0c2a05fa14..8af796821c 100644 --- a/keyboards/preonic/keymaps/that_canadian/keymap.c +++ b/keyboards/preonic/keymaps/that_canadian/keymap.c @@ -210,13 +210,13 @@ void matrix_init_user(void) { #ifdef AUDIO_ENABLE -void startup_user() +void startup_user(void) { _delay_ms(20); // gets rid of tick PLAY_SONG(tone_startup); } -void shutdown_user() +void shutdown_user(void) { PLAY_SONG(tone_goodbye); _delay_ms(150); diff --git a/keyboards/preonic/keymaps/trigotometry/keymap.c b/keyboards/preonic/keymaps/trigotometry/keymap.c index aa734328b5..419f7a10ba 100644 --- a/keyboards/preonic/keymaps/trigotometry/keymap.c +++ b/keyboards/preonic/keymaps/trigotometry/keymap.c @@ -157,7 +157,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { // {NOTE_E5, 8} // }; -// void startup_user() +// void startup_user(void) // { // _delay_ms(20); // gets rid of tick // PLAY_SONG(tone_startup); diff --git a/keyboards/preonic/keymaps/zach/zach_common_functions.c b/keyboards/preonic/keymaps/zach/zach_common_functions.c index 97b650d9cb..6ad1c7bed3 100644 --- a/keyboards/preonic/keymaps/zach/zach_common_functions.c +++ b/keyboards/preonic/keymaps/zach/zach_common_functions.c @@ -427,7 +427,7 @@ void play_goodbye_tone(void){ _delay_ms(150); } -void shutdown_user(){ +void shutdown_user(void){ PLAY_SONG(tone_goodbye); _delay_ms(150); stop_all_notes(); diff --git a/keyboards/reviung/reviung41/keymaps/ciutadellla/keymap.c b/keyboards/reviung/reviung41/keymaps/ciutadellla/keymap.c index d6962664b1..98dda7fe19 100644 --- a/keyboards/reviung/reviung41/keymaps/ciutadellla/keymap.c +++ b/keyboards/reviung/reviung41/keymaps/ciutadellla/keymap.c @@ -132,7 +132,7 @@ }; - void matrix_init_user(){ + void matrix_init_user(void){ set_unicode_input_mode(UNICODE_MODE_MACOS); } diff --git a/keyboards/rgbkb/sol3/rev1/rev1.c b/keyboards/rgbkb/sol3/rev1/rev1.c index c66e145e80..de5836e061 100644 --- a/keyboards/rgbkb/sol3/rev1/rev1.c +++ b/keyboards/rgbkb/sol3/rev1/rev1.c @@ -105,7 +105,7 @@ bool touch_encoder_tapped_kb(uint8_t index, uint8_t section) { return false; } -void matrix_slave_scan_kb() { +void matrix_slave_scan_kb(void) { dip_switch_read(false); matrix_slave_scan_user(); } diff --git a/keyboards/sekigon/grs_70ec/grs_70ec.c b/keyboards/sekigon/grs_70ec/grs_70ec.c index e8791c00c1..e855a80dcf 100644 --- a/keyboards/sekigon/grs_70ec/grs_70ec.c +++ b/keyboards/sekigon/grs_70ec/grs_70ec.c @@ -23,7 +23,7 @@ void led_on(void) { void led_off(void) { writePinLow(D2); } -void keyboard_post_init_kb() { +void keyboard_post_init_kb(void) { led_on(); keyboard_post_init_user(); diff --git a/keyboards/sneakbox/aliceclone/aliceclone.c b/keyboards/sneakbox/aliceclone/aliceclone.c index 9457c641df..9cfb4e551d 100644 --- a/keyboards/sneakbox/aliceclone/aliceclone.c +++ b/keyboards/sneakbox/aliceclone/aliceclone.c @@ -17,7 +17,7 @@ along with this program. If not, see . #include "aliceclone.h" -void keyboard_pre_init_kb() { +void keyboard_pre_init_kb(void) { setPinOutput(D7); setPinOutput(D6); setPinOutput(D4); diff --git a/keyboards/splitkb/kyria/keymaps/cwebster2/keymap.c b/keyboards/splitkb/kyria/keymaps/cwebster2/keymap.c index 1abf865010..9c31e2617c 100644 --- a/keyboards/splitkb/kyria/keymaps/cwebster2/keymap.c +++ b/keyboards/splitkb/kyria/keymaps/cwebster2/keymap.c @@ -252,7 +252,7 @@ bool led_update_user(led_t led_state) { #endif #ifdef OLED_ENABLE -void suspend_power_down_user() { +void suspend_power_down_user(void) { oled_clear(); oled_off(); } diff --git a/keyboards/stenokeyboards/the_uni/keymaps/default/keymap.c b/keyboards/stenokeyboards/the_uni/keymaps/default/keymap.c index 492c7a3c94..74aa207bd5 100644 --- a/keyboards/stenokeyboards/the_uni/keymaps/default/keymap.c +++ b/keyboards/stenokeyboards/the_uni/keymaps/default/keymap.c @@ -31,6 +31,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; - void matrix_init_user() { + void matrix_init_user(void) { steno_set_mode(STENO_MODE_GEMINI); // or STENO_MODE_BOLT } diff --git a/keyboards/thevankeyboards/minivan/keymaps/josjoha/keymap.c b/keyboards/thevankeyboards/minivan/keymaps/josjoha/keymap.c index 92356446fd..a1d82e9923 100644 --- a/keyboards/thevankeyboards/minivan/keymaps/josjoha/keymap.c +++ b/keyboards/thevankeyboards/minivan/keymaps/josjoha/keymap.c @@ -288,7 +288,7 @@ void speed_led (int speed) { // do this in one place to handle left/right leds being off here -void isolate_rgblight_set () { +void isolate_rgblight_set (void) { # ifdef RGBLIGHT_ENABLE if (!leds_on) { // left/right leds are off diff --git a/keyboards/wilba_tech/wt65_xt/keymaps/zunger/keymap.c b/keyboards/wilba_tech/wt65_xt/keymaps/zunger/keymap.c index 45778e1698..b0dfa3e03c 100644 --- a/keyboards/wilba_tech/wt65_xt/keymaps/zunger/keymap.c +++ b/keyboards/wilba_tech/wt65_xt/keymaps/zunger/keymap.c @@ -435,7 +435,7 @@ void toggle_os_mode(void) { set_os_mode((os_mode + 1) % _OS_MODES_MAX); } -void keyboard_post_init_user() { +void keyboard_post_init_user(void) { set_os_mode(_WINDOWS); } diff --git a/keyboards/wilba_tech/wt70_jb/wt70_jb.c b/keyboards/wilba_tech/wt70_jb/wt70_jb.c index d4f2c5c8da..df44b2f9b8 100644 --- a/keyboards/wilba_tech/wt70_jb/wt70_jb.c +++ b/keyboards/wilba_tech/wt70_jb/wt70_jb.c @@ -49,7 +49,7 @@ void via_init_kb(void) } } -void keyboard_post_init_kb() { +void keyboard_post_init_kb(void) { // This is a workaround to ensure "EEPROM cleared" PCBs will // start with the RGB test mode, essential for testing LEDs. if ( g_first_execution ) { diff --git a/keyboards/woodkeys/meira/TWIlib.c b/keyboards/woodkeys/meira/TWIlib.c index 8f5658fcdb..89e03a73d4 100755 --- a/keyboards/woodkeys/meira/TWIlib.c +++ b/keyboards/woodkeys/meira/TWIlib.c @@ -24,7 +24,7 @@ int RXBuffLen; // The total number of bytes to read (should be less than RXMAXBU TWIInfoStruct TWIInfo; -void TWIInit() +void TWIInit(void) { TWIInfo.mode = Ready; TWIInfo.errorCode = 0xFF; @@ -37,7 +37,7 @@ void TWIInit() TWCR = (1 << TWIE) | (1 << TWEN); } -uint8_t isTWIReady() +uint8_t isTWIReady(void) { if ( (TWIInfo.mode == Ready) | (TWIInfo.mode == RepeatedStartSent) ) { diff --git a/keyboards/woodkeys/meira/lighting.c b/keyboards/woodkeys/meira/lighting.c index 1a3c954bcf..6cbe101dbc 100755 --- a/keyboards/woodkeys/meira/lighting.c +++ b/keyboards/woodkeys/meira/lighting.c @@ -56,14 +56,14 @@ void set_backlight_by_keymap(uint8_t col, uint8_t row){ // activateLED(matrix, led_col, led_row, 255); } -void force_issi_refresh(){ +void force_issi_refresh(void){ issi_devices[0]->led_dirty = true; update_issi(0, true); issi_devices[3]->led_dirty = true; update_issi(3, true); } -void led_test(){ +void led_test(void){ #ifdef WATCHDOG_ENABLE // This test take a long time to run, disable the WTD until its complete wdt_disable(); diff --git a/keyboards/woodkeys/meira/meira.c b/keyboards/woodkeys/meira/meira.c index 87a6d11b4e..d8c04859e2 100644 --- a/keyboards/woodkeys/meira/meira.c +++ b/keyboards/woodkeys/meira/meira.c @@ -86,7 +86,7 @@ bool process_record_kb(uint16_t keycode, keyrecord_t *record) { return process_record_user(keycode, record); } -void reset_keyboard_kb(){ +void reset_keyboard_kb(void){ #ifdef WATCHDOG_ENABLE MCUSR = 0; wdt_disable(); diff --git a/keyboards/xiudi/xd75/keymaps/colinta/keymap.c b/keyboards/xiudi/xd75/keymaps/colinta/keymap.c index 5cdbdd6c74..3cf286aeb5 100644 --- a/keyboards/xiudi/xd75/keymaps/colinta/keymap.c +++ b/keyboards/xiudi/xd75/keymaps/colinta/keymap.c @@ -205,7 +205,7 @@ void taphold_tapped(uint8_t index, bool pressed) { } } -void matrix_scan_user() { +void matrix_scan_user(void) { for (uint8_t index = 0 ; index < TH_EVENTS_COUNT ; ++index ) { tap_hold_t *th_event = &th_events[index]; if ( th_event->is_pressed && timer_elapsed(th_event->timer) > LONGPRESS_DELAY) { diff --git a/keyboards/xiudi/xd96/keymaps/uuupah/keymap.c b/keyboards/xiudi/xd96/keymaps/uuupah/keymap.c index 5fb6ed2b59..b554860c20 100644 --- a/keyboards/xiudi/xd96/keymaps/uuupah/keymap.c +++ b/keyboards/xiudi/xd96/keymaps/uuupah/keymap.c @@ -19,7 +19,7 @@ #define LT_ENT2 LT(2,KC_ENT) #ifdef RGBLIGHT_ENABLE -void matrix_init_user() { +void matrix_init_user(void) { rgblight_disable(); } #endif diff --git a/platforms/avr/drivers/audio_pwm_hardware.c b/platforms/avr/drivers/audio_pwm_hardware.c index 78776ee48a..2fc448ea58 100644 --- a/platforms/avr/drivers/audio_pwm_hardware.c +++ b/platforms/avr/drivers/audio_pwm_hardware.c @@ -217,7 +217,7 @@ void channel_2_stop(void) { } #endif -void audio_driver_initialize() { +void audio_driver_initialize(void) { #ifdef AUDIO1_PIN_SET channel_1_stop(); setPinOutput(AUDIO1_PIN); @@ -258,7 +258,7 @@ void audio_driver_initialize() { #endif } -void audio_driver_stop() { +void audio_driver_stop(void) { #ifdef AUDIO1_PIN_SET channel_1_stop(); #endif diff --git a/platforms/chibios/drivers/audio_dac_additive.c b/platforms/chibios/drivers/audio_dac_additive.c index db07c4b393..68ce13788e 100644 --- a/platforms/chibios/drivers/audio_dac_additive.c +++ b/platforms/chibios/drivers/audio_dac_additive.c @@ -281,7 +281,7 @@ static const DACConfig dac_conf = {.init = AUDIO_DAC_OFF_VALUE, .datamode = DAC_ */ static const DACConversionGroup dac_conv_cfg = {.num_channels = 1U, .end_cb = dac_end, .error_cb = dac_error, .trigger = DAC_TRG(0b000)}; -void audio_driver_initialize() { +void audio_driver_initialize(void) { if ((AUDIO_PIN == A4) || (AUDIO_PIN_ALT == A4)) { palSetLineMode(A4, PAL_MODE_INPUT_ANALOG); dacStart(&DACD1, &dac_conf); diff --git a/platforms/chibios/drivers/audio_dac_basic.c b/platforms/chibios/drivers/audio_dac_basic.c index 64439a1e3c..5f0cbf8f84 100644 --- a/platforms/chibios/drivers/audio_dac_basic.c +++ b/platforms/chibios/drivers/audio_dac_basic.c @@ -187,7 +187,7 @@ static void gpt_audio_state_cb(GPTDriver *gptp) { } } -void audio_driver_initialize() { +void audio_driver_initialize(void) { if ((AUDIO_PIN == A4) || (AUDIO_PIN_ALT == A4)) { palSetPadMode(GPIOA, 4, PAL_MODE_INPUT_ANALOG); dacStart(&DACD1, &dac_conf_ch1); diff --git a/quantum/action.c b/quantum/action.c index 79ea2b7635..6b5660af8b 100644 --- a/quantum/action.c +++ b/quantum/action.c @@ -1050,7 +1050,7 @@ void clear_keyboard_but_mods(void) { * * FIXME: Needs documentation. */ -void clear_keyboard_but_mods_and_keys() { +void clear_keyboard_but_mods_and_keys(void) { #ifdef EXTRAKEY_ENABLE host_system_send(0); host_consumer_send(0); diff --git a/quantum/action_util.c b/quantum/action_util.c index 738410a4ac..7f7d32887b 100644 --- a/quantum/action_util.c +++ b/quantum/action_util.c @@ -98,12 +98,12 @@ enum { # if (defined(ONESHOT_TIMEOUT) && (ONESHOT_TIMEOUT > 0)) static uint16_t oneshot_layer_time = 0; -inline bool has_oneshot_layer_timed_out() { +inline bool has_oneshot_layer_timed_out(void) { return TIMER_DIFF_16(timer_read(), oneshot_layer_time) >= ONESHOT_TIMEOUT && !(get_oneshot_layer_state() & ONESHOT_TOGGLED); } # ifdef SWAP_HANDS_ENABLE static uint16_t oneshot_swaphands_time = 0; -inline bool has_oneshot_swaphands_timed_out() { +inline bool has_oneshot_swaphands_timed_out(void) { return TIMER_DIFF_16(timer_read(), oneshot_swaphands_time) >= ONESHOT_TIMEOUT && (swap_hands_oneshot == SHO_ACTIVE); } # endif diff --git a/quantum/audio/audio.c b/quantum/audio/audio.c index c6523b908c..ca78a483ad 100644 --- a/quantum/audio/audio.c +++ b/quantum/audio/audio.c @@ -112,7 +112,7 @@ static bool audio_initialized = false; static bool audio_driver_stopped = true; audio_config_t audio_config; -void audio_init() { +void audio_init(void) { if (audio_initialized) { return; } @@ -185,7 +185,7 @@ bool audio_is_on(void) { return (audio_config.enable != 0); } -void audio_stop_all() { +void audio_stop_all(void) { if (audio_driver_stopped) { return; } diff --git a/quantum/audio/voices.c b/quantum/audio/voices.c index 1c08a3af36..01f257f4d4 100644 --- a/quantum/audio/voices.c +++ b/quantum/audio/voices.c @@ -36,11 +36,11 @@ void set_voice(voice_type v) { voice = v; } -void voice_iterate() { +void voice_iterate(void) { voice = (voice + 1) % number_of_voices; } -void voice_deiterate() { +void voice_deiterate(void) { voice = (voice - 1 + number_of_voices) % number_of_voices; } diff --git a/quantum/joystick.c b/quantum/joystick.c index 057a018dff..02818e4acd 100644 --- a/quantum/joystick.c +++ b/quantum/joystick.c @@ -111,7 +111,7 @@ int16_t joystick_read_axis(uint8_t axis) { return ranged_val; } -void joystick_read_axes() { +void joystick_read_axes(void) { #if JOYSTICK_AXIS_COUNT > 0 for (int i = 0; i < JOYSTICK_AXIS_COUNT; ++i) { if (joystick_axes[i].input_pin == JS_VIRTUAL_AXIS) { diff --git a/quantum/keyboard.c b/quantum/keyboard.c index 37675ded0b..1de5f1cd0c 100644 --- a/quantum/keyboard.c +++ b/quantum/keyboard.c @@ -238,7 +238,7 @@ __attribute__((weak)) void keyboard_pre_init_kb(void) { * FIXME: needs doc */ -__attribute__((weak)) void keyboard_post_init_user() {} +__attribute__((weak)) void keyboard_post_init_user(void) {} /** \brief keyboard_post_init_kb * diff --git a/quantum/process_keycode/process_audio.c b/quantum/process_keycode/process_audio.c index 03b0af9277..c189dd02b7 100644 --- a/quantum/process_keycode/process_audio.c +++ b/quantum/process_keycode/process_audio.c @@ -62,5 +62,5 @@ void process_audio_all_notes_off(void) { stop_all_notes(); } -__attribute__((weak)) void audio_on_user() {} -__attribute__((weak)) void audio_off_user() {} +__attribute__((weak)) void audio_on_user(void) {} +__attribute__((weak)) void audio_off_user(void) {} diff --git a/quantum/process_keycode/process_auto_shift.c b/quantum/process_keycode/process_auto_shift.c index aaf0cf9142..aad1a164ae 100644 --- a/quantum/process_keycode/process_auto_shift.c +++ b/quantum/process_keycode/process_auto_shift.c @@ -344,7 +344,7 @@ bool get_autoshift_state(void) { return autoshift_flags.enabled; } -uint16_t get_generic_autoshift_timeout() { +uint16_t get_generic_autoshift_timeout(void) { return autoshift_timeout; } __attribute__((weak)) uint16_t get_autoshift_timeout(uint16_t keycode, keyrecord_t *record) { @@ -484,7 +484,7 @@ void retroshift_poll_time(keyevent_t *event) { retroshift_time = timer_read(); } // Used to swap the times of Retro Shifted key and Auto Shift key that interrupted it. -void retroshift_swap_times() { +void retroshift_swap_times(void) { if (last_retroshift_time != 0 && autoshift_flags.in_progress) { uint16_t temp = retroshift_time; retroshift_time = last_retroshift_time; diff --git a/quantum/process_keycode/process_music.c b/quantum/process_keycode/process_music.c index ee697a0cc6..7c572079a7 100644 --- a/quantum/process_keycode/process_music.c +++ b/quantum/process_keycode/process_music.c @@ -317,10 +317,10 @@ void music_task(void) { } } -__attribute__((weak)) void music_on_user() {} +__attribute__((weak)) void music_on_user(void) {} -__attribute__((weak)) void midi_on_user() {} +__attribute__((weak)) void midi_on_user(void) {} -__attribute__((weak)) void music_scale_user() {} +__attribute__((weak)) void music_scale_user(void) {} #endif // defined(AUDIO_ENABLE) || (defined(MIDI_ENABLE) && defined(MIDI_BASIC)) diff --git a/quantum/process_keycode/process_steno.c b/quantum/process_keycode/process_steno.c index 30a0d4056f..8ba98bd4bb 100644 --- a/quantum/process_keycode/process_steno.c +++ b/quantum/process_keycode/process_steno.c @@ -127,7 +127,7 @@ static const uint16_t combinedmap_second[] PROGMEM = {STN_S2, STN_KL, STN_WL, ST #endif #ifdef STENO_ENABLE_ALL -void steno_init() { +void steno_init(void) { if (!eeconfig_is_enabled()) { eeconfig_init(); } diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c index fbe4ce1d33..706f5cddbb 100644 --- a/quantum/process_keycode/process_tap_dance.c +++ b/quantum/process_keycode/process_tap_dance.c @@ -162,7 +162,7 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) { return true; } -void tap_dance_task() { +void tap_dance_task(void) { tap_dance_action_t *action; if (!active_td || timer_elapsed(last_tap_time) <= GET_TAPPING_TERM(active_td, &(keyrecord_t){})) return; diff --git a/quantum/quantum.c b/quantum/quantum.c index 0fe54c60a7..0e69246f41 100644 --- a/quantum/quantum.c +++ b/quantum/quantum.c @@ -454,10 +454,10 @@ void update_tri_layer(uint8_t layer1, uint8_t layer2, uint8_t layer3) { } // TODO: remove legacy api -void matrix_init_quantum() { +void matrix_init_quantum(void) { matrix_init_kb(); } -void matrix_scan_quantum() { +void matrix_scan_quantum(void) { matrix_scan_kb(); } @@ -465,9 +465,9 @@ void matrix_scan_quantum() { // Override these functions in your keymap file to play different tunes on // different events such as startup and bootloader jump -__attribute__((weak)) void startup_user() {} +__attribute__((weak)) void startup_user(void) {} -__attribute__((weak)) void shutdown_user() {} +__attribute__((weak)) void shutdown_user(void) {} void suspend_power_down_quantum(void) { suspend_power_down_kb(); diff --git a/tmk_core/protocol/lufa/lufa.c b/tmk_core/protocol/lufa/lufa.c index 99f7d31287..20bfc8fb3c 100644 --- a/tmk_core/protocol/lufa/lufa.c +++ b/tmk_core/protocol/lufa/lufa.c @@ -298,7 +298,7 @@ void EVENT_USB_Device_Reset(void) { * * FIXME: Needs doc */ -void EVENT_USB_Device_Suspend() { +void EVENT_USB_Device_Suspend(void) { print("[S]"); usb_device_state_set_suspend(USB_Device_ConfigurationNumber != 0, USB_Device_ConfigurationNumber); @@ -311,7 +311,7 @@ void EVENT_USB_Device_Suspend() { * * FIXME: Needs doc */ -void EVENT_USB_Device_WakeUp() { +void EVENT_USB_Device_WakeUp(void) { print("[W]"); #if defined(NO_USB_STARTUP_CHECK) suspend_wakeup_init(); diff --git a/users/arkag/arkag.c b/users/arkag/arkag.c index e7c8218587..7074da18eb 100644 --- a/users/arkag/arkag.c +++ b/users/arkag/arkag.c @@ -19,11 +19,11 @@ #define TYPING_SPEED_MAX_VALUE 200 uint8_t typing_speed = 0; -void velocikey_accelerate() { +void velocikey_accelerate(void) { if (typing_speed < TYPING_SPEED_MAX_VALUE) typing_speed += (TYPING_SPEED_MAX_VALUE / 50); } -void velocikey_decelerate() { +void velocikey_decelerate(void) { static uint16_t decay_timer = 0; if (timer_elapsed(decay_timer) > 500 || decay_timer == 0) { diff --git a/users/d4mation/d4mation.c b/users/d4mation/d4mation.c index 5aa58a9f0d..5d1092cd72 100644 --- a/users/d4mation/d4mation.c +++ b/users/d4mation/d4mation.c @@ -7,12 +7,12 @@ bool process_record_keymap( uint16_t keycode, keyrecord_t *record ) { } __attribute__ ((weak)) -void matrix_init_keymap() { +void matrix_init_keymap(void) { /* If you want a matrix init specific to your keymap, you need to define this function in your keymap */ } __attribute__ ((weak)) -void matrix_scan_keymap() { +void matrix_scan_keymap(void) { /* If you want a matrix scan specific to your keymap, you need to define this function in your keymap */ } diff --git a/users/danielo515/danielo515.c b/users/danielo515/danielo515.c index ea91ec55bf..1c7718f1d2 100644 --- a/users/danielo515/danielo515.c +++ b/users/danielo515/danielo515.c @@ -7,9 +7,9 @@ bool onMac = true; LEADER_EXTERNS(); # ifdef RGBLIGHT_ENABLE -void leader_start_user() { rgblight_setrgb_range(5, 100, 199, 10, 15); }; +void leader_start_user(void) { rgblight_setrgb_range(5, 100, 199, 10, 15); }; -void leader_end_user() { rgblight_setrgb_range(200, 200, 255, 10, 15); }; +void leader_end_user(void) { rgblight_setrgb_range(200, 200, 255, 10, 15); }; # endif void matrix_scan_user(void) { diff --git a/users/edvorakjp/edvorakjp.c b/users/edvorakjp/edvorakjp.c index c95b03d981..3d3b5b0ae5 100644 --- a/users/edvorakjp/edvorakjp.c +++ b/users/edvorakjp/edvorakjp.c @@ -5,7 +5,7 @@ void matrix_init_user(void) { matrix_init_keymap(); } -__attribute__((weak)) void matrix_init_keymap() {} +__attribute__((weak)) void matrix_init_keymap(void) {} layer_state_t layer_state_set_user(layer_state_t state) { state = update_tri_layer_state(state, L_EDVORAKJP_LOWER, L_EDVORAKJP_RAISE, L_EDVORAKJP_ADJUST); diff --git a/users/ericgebhart/extensions/oneshot.c b/users/ericgebhart/extensions/oneshot.c index 55c2fa1ae3..8d4dc2f29c 100644 --- a/users/ericgebhart/extensions/oneshot.c +++ b/users/ericgebhart/extensions/oneshot.c @@ -50,7 +50,7 @@ static int8_t set_modifier_state_all(oneshot_state new_state); static void set_modifier_state_all_from_to(oneshot_state oneshot_state_from, oneshot_state oneshot_state_to); static bool all_modifiers_are_off(void); -int8_t turnoff_oneshot_modifiers() { +int8_t turnoff_oneshot_modifiers(void) { return set_modifier_state_all(ONESHOT_STATE_OFF); } @@ -163,7 +163,7 @@ void set_modifier_state_all_from_to(oneshot_state oneshot_state_from, oneshot_st } } -bool all_modifiers_are_off() { +bool all_modifiers_are_off(void) { for (int8_t i = 0; i < ONESHOT_MOD_COUNT; i++) { if (modifiers_with_state[i] != ONESHOT_STATE_OFF) { return false; diff --git a/users/ericgebhart/oled/oled_stuff.c b/users/ericgebhart/oled/oled_stuff.c index a73b5b174d..f2c4f0f394 100755 --- a/users/ericgebhart/oled/oled_stuff.c +++ b/users/ericgebhart/oled/oled_stuff.c @@ -47,7 +47,7 @@ void oled_render_mod_status(uint8_t modifiers) { oled_write_P(PSTR("G"), (modifiers & MOD_MASK_GUI)); } -void oled_render_mod_lock_status(){ +void oled_render_mod_lock_status(void){ oled_render_mod_status(get_mods() | get_oneshot_mods()); oled_render_keylock_status(host_keyboard_leds()); } diff --git a/users/miles2go/babblePaste.c b/users/miles2go/babblePaste.c index cd032882bf..65c9981186 100644 --- a/users/miles2go/babblePaste.c +++ b/users/miles2go/babblePaste.c @@ -23,7 +23,7 @@ __attribute__((weak)) void babble_modeswitch_kb(uint8_t mode) { babble_modeswitc void set_babble_mode(uint8_t id) { babble_mode = id; } -void babble_mode_increment() { +void babble_mode_increment(void) { babble_mode += 1; if (babble_mode >= BABL_MODEMAX) { babble_mode = 0; @@ -31,7 +31,7 @@ void babble_mode_increment() { babble_modeswitch_kb(babble_mode); } -void babble_mode_decrement() { +void babble_mode_decrement(void) { if (babble_mode >= 1) { babble_mode -= 1; } else { diff --git a/users/ninjonas/ninjonas.c b/users/ninjonas/ninjonas.c index d66a5b008c..8d37641aa3 100644 --- a/users/ninjonas/ninjonas.c +++ b/users/ninjonas/ninjonas.c @@ -22,7 +22,7 @@ layer_state_t layer_state_set_user (layer_state_t state) { #ifdef RGBLIGHT_ENABLE extern rgblight_config_t rgblight_config; #endif -void keyboard_post_init_user() { +void keyboard_post_init_user(void) { #ifdef RGBLIGHT_ENABLE // Cycles through the entire hue wheel and resetting to default color uint16_t default_hue = rgblight_config.hue; diff --git a/users/spidey3/layer_rgb.c b/users/spidey3/layer_rgb.c index 75a4b4c0a1..cff20898cd 100644 --- a/users/spidey3/layer_rgb.c +++ b/users/spidey3/layer_rgb.c @@ -99,7 +99,7 @@ const rgblight_segment_t *const PROGMEM _rgb_layers[] = { const uint8_t PROGMEM _n_rgb_layers = ARRAY_SIZE(_rgb_layers) - 1; -void clear_rgb_layers() { +void clear_rgb_layers(void) { for (uint8_t i = 0; i < _n_rgb_layers; i++) { rgblight_set_layer_state(i, false); } diff --git a/users/talljoe/macros.c b/users/talljoe/macros.c index e9c9b521b7..1afc1ef7f6 100644 --- a/users/talljoe/macros.c +++ b/users/talljoe/macros.c @@ -29,9 +29,9 @@ ostype_t get_os() { #define MOD_SEND(KEY) (IS_OSX() ? SEND_STRING(SS_LCMD(KEY)) : SEND_STRING(SS_LCTL(KEY))) -void macro_copy() { MOD_SEND("c"); } -void macro_paste() { MOD_SEND("v"); } -void macro_lock() { +void macro_copy(void) { MOD_SEND("c"); } +void macro_paste(void) { MOD_SEND("v"); } +void macro_lock(void) { if (IS_OSX()) { SEND_STRING(SS_LCTL(SS_LCMD("q"))); } else { -- cgit v1.2.3