Partial generation of execute helpers

data/templates/xap/firmware/xap_generated.h.j2

@@ -72,8 +72,12 @@ typedef struct {
 } __attribute__((__packed__)) {{ this_prefix_lc | to_snake | lower }}_arg_t;
 _Static_assert(sizeof({{ this_prefix_lc | to_snake | lower }}_arg_t) == {{ data.request_struct_length }}, "{{ this_prefix_lc | to_snake | lower }}_arg_t needs to be {{ data.request_struct_length }} bytes in size");
 {% elif 'request_type' in data %}
+{% if '[' in data.request_type %}
+typedef struct __attribute__((__packed__)) { {{ data.request_type | type_to_c('x') }}; } {{ this_prefix_lc }}_arg_t;
+{% else %}
 typedef {{ data.request_type | type_to_c(this_prefix_lc+'_arg_t') }};
 {% endif %}
+{% endif %}
 
 {% if 'return_struct_members' in data %}
 typedef struct {
@@ -88,8 +92,8 @@ typedef struct __attribute__((__packed__)) { {{ data.return_type | type_to_c('x'
 {% else %}
 typedef {{ data.return_type | type_to_c(this_prefix_lc+'_t') }};
 {% endif %}
-
 {% endif %}
+
 {{ export_route_types(this_prefix_lc, data) }}
 {% endfor %}
 {% endif %}

data/templates/xap/firmware/xap_generated.inl.j2

@@ -32,18 +32,40 @@ void {{ xap.broadcast_messages.define_prefix | lower }}_{{ data.define | to_snak
 ////////////////////////////////////////////////////////////////////////////////
 // Decl
 
-{% macro export_route_declaration(container) %}
+{% macro export_route_declaration(prefix, container) %}
 {% if 'routes' in container %}
 {% for route, data in container.routes | dictsort %}
+{% set this_prefix_uc = (prefix + '_' + data.define) | upper %}
+{% set this_prefix_lc = this_prefix_uc | lower %}
 {% if 'return_execute' in data %}
-bool xap_respond_{{ data.return_execute }}(xap_token_t token, const uint8_t *data, size_t data_len);
+
+{% if 'request_struct_members' in data %}
+{% set arg_type = ( this_prefix_lc | to_snake | lower ) + '_arg_t' %}
+{% set arg_var = arg_type + ' arg' %}
+{% elif 'request_type' in data %}
+{% set arg_type = data.request_type | type_to_c() %}
+{% set arg_var = data.request_type | type_to_c('arg') %}
 {% endif %}
-{{ export_route_declaration(data) }}
+
+__attribute__((weak)) bool xap_execute_{{ data.return_execute }}(xap_token_t token{% if arg_type %}, {{ arg_type }}{{ '*' if 'xap_route' in arg_type else '' }}{% endif %}) { return false; }
+__attribute__((weak)) bool xap_respond_{{ data.return_execute }}(xap_token_t token, const uint8_t *data, size_t data_len) {
+{% if arg_type %}
+    if (data_len != sizeof({{ arg_type }})) {
+        return false;
+    }
+    {{ arg_var }};
+    memcpy(&arg, data, sizeof({{ arg_type }}));
+{% endif %}
+
+    return xap_execute_{{ data.return_execute }}(token{% if arg_type %}, {{ '&' if 'xap_route' in arg_type else '' }}arg{% endif %});
+}
+{% endif %}
+{{ export_route_declaration(this_prefix_lc, data) }}
 {% endfor %}
 {% endif %}
 {% endmacro %}
 
-{{ export_route_declaration(xap) }}
+{{ export_route_declaration('xap_route', xap) }}
 
 ////////////////////////////////////////////////////////////////////////////////
 // Data

quantum/xap/handlers/audio.c

@@ -9,7 +9,7 @@
 
 extern audio_config_t audio_config;
 
-bool xap_respond_get_audio_config(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_get_audio_config(xap_token_t token) {
     xap_route_audio_get_config_t ret;
 
     ret.enable        = audio_config.enable;
@@ -18,20 +18,14 @@ bool xap_respond_get_audio_config(xap_token_t token, const void *data, size_t le
     return xap_respond_data(token, &ret, sizeof(ret));
 }
 
-bool xap_respond_set_audio_config(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_set_audio_config(xap_token_t token, xap_route_audio_set_config_arg_t* arg) {
-    if (length != sizeof(xap_route_audio_set_config_arg_t)) {
-        return false;
-    }
-
-    xap_route_audio_set_config_arg_t *arg = (xap_route_audio_set_config_arg_t *)data;
-
     audio_config.enable        = arg->enable;
     audio_config.clicky_enable = arg->clicky_enable;
 
     return xap_respond_success(token);
 }
 
-bool xap_respond_save_audio_config(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_save_audio_config(xap_token_t token) {
     eeconfig_update_audio_current();
 
     return xap_respond_success(token);

quantum/xap/handlers/core.c

@@ -5,14 +5,7 @@
 #include "xap.h"
 #include "hardware_id.h"
 
-bool xap_respond_get_config_blob_chunk(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_get_config_blob_chunk(xap_token_t token, uint16_t offset) {
-    if (length != sizeof(uint16_t)) {
-        return false;
-    }
-
-    uint16_t offset;
-    memcpy(&offset, data, sizeof(uint16_t));
-
     xap_route_qmk_config_blob_chunk_t ret = {0};
 
     bool get_config_blob_chunk(uint16_t offset, uint8_t * data, uint8_t data_len);
@@ -23,23 +16,23 @@ bool xap_respond_get_config_blob_chunk(xap_token_t token, const void *data, size
     return xap_respond_data(token, &ret, sizeof(ret));
 }
 
-bool xap_respond_secure_status(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_secure_status(xap_token_t token) {
     uint8_t ret = secure_get_status();
     return xap_respond_data(token, &ret, sizeof(ret));
 }
 
-bool xap_respond_secure_unlock(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_secure_unlock(xap_token_t token) {
     secure_request_unlock();
     return xap_respond_success(token);
 }
 
-bool xap_respond_secure_lock(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_secure_lock(xap_token_t token) {
     secure_lock();
     return xap_respond_success(token);
 }
 
 #ifdef BOOTLOADER_JUMP_SUPPORTED
-bool xap_respond_request_bootloader_jump(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_request_bootloader(xap_token_t token) {
     uint8_t ret = secure_is_unlocked();
 
     // TODO: post to deferred queue so this request can return?
@@ -50,7 +43,7 @@ bool xap_respond_request_bootloader_jump(xap_token_t token, const void *data, si
 #endif
 
 #ifndef NO_RESET
-bool xap_respond_request_eeprom_reset(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_request_eeprom_reset(xap_token_t token) {
     uint8_t ret = secure_is_unlocked();
 
     // TODO: post to deferred queue so this request can return?
@@ -61,7 +54,7 @@ bool xap_respond_request_eeprom_reset(xap_token_t token, const void *data, size_
 }
 #endif
 
-bool xap_respond_get_hardware_id(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_get_hardware_id(xap_token_t token) {
     hardware_id_t ret = get_hardware_id();
     return xap_respond_data(token, &ret, sizeof(ret));
 }

quantum/xap/handlers/lighting.c

@@ -11,7 +11,7 @@
 
 extern backlight_config_t backlight_config;
 
-bool xap_respond_get_backlight_config(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_get_backlight_config(xap_token_t token) {
     xap_route_lighting_backlight_get_config_t ret;
 
     ret.enable = backlight_config.enable;
@@ -21,13 +21,7 @@ bool xap_respond_get_backlight_config(xap_token_t token, const void *data, size_
     return xap_respond_data(token, &ret, sizeof(ret));
 }
 
-bool xap_respond_set_backlight_config(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_set_backlight_config(xap_token_t token, xap_route_lighting_backlight_set_config_arg_t* arg) {
-    if (length != sizeof(xap_route_lighting_backlight_set_config_arg_t)) {
-        return false;
-    }
-
-    xap_route_lighting_backlight_set_config_arg_t *arg = (xap_route_lighting_backlight_set_config_arg_t *)data;
-
     if (arg->enable) {
         backlight_level_noeeprom(arg->val);
     } else {
@@ -45,7 +39,7 @@ bool xap_respond_set_backlight_config(xap_token_t token, const void *data, size_
     return xap_respond_success(token);
 }
 
-bool xap_respond_save_backlight_config(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_save_backlight_config(xap_token_t token) {
     eeconfig_update_backlight_current();
 
     return xap_respond_success(token);
@@ -60,7 +54,7 @@ extern rgblight_config_t rgblight_config;
 uint8_t rgblight_effect_to_id(uint8_t val);
 uint8_t rgblight_id_to_effect(uint8_t val);
 
-bool xap_respond_get_rgblight_config(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_get_rgblight_config(xap_token_t token) {
     xap_route_lighting_rgblight_get_config_t ret;
 
     ret.enable = rgblight_config.enable;
@@ -73,13 +67,7 @@ bool xap_respond_get_rgblight_config(xap_token_t token, const void *data, size_t
     return xap_respond_data(token, &ret, sizeof(ret));
 }
 
-bool xap_respond_set_rgblight_config(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_set_rgblight_config(xap_token_t token, xap_route_lighting_rgblight_set_config_arg_t* arg) {
-    if (length != sizeof(xap_route_lighting_rgblight_set_config_arg_t)) {
-        return false;
-    }
-
-    xap_route_lighting_rgblight_set_config_arg_t *arg = (xap_route_lighting_rgblight_set_config_arg_t *)data;
-
     uint8_t mode = rgblight_id_to_effect(arg->mode);
     if (mode == INVALID_EFFECT) {
         return false;
@@ -93,7 +81,7 @@ bool xap_respond_set_rgblight_config(xap_token_t token, const void *data, size_t
     return xap_respond_success(token);
 }
 
-bool xap_respond_save_rgblight_config(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_save_rgblight_config(xap_token_t token) {
     eeconfig_update_rgblight_current();
 
     return xap_respond_success(token);
@@ -112,7 +100,7 @@ void rgb_matrix_enabled_noeeprom(bool val) {
     val ? rgb_matrix_enable_noeeprom() : rgb_matrix_disable_noeeprom();
 }
 
-bool xap_respond_get_rgb_matrix_config(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_get_rgb_matrix_config(xap_token_t token) {
     xap_route_lighting_rgb_matrix_get_config_t ret;
 
     ret.enable = rgb_matrix_config.enable;
@@ -126,13 +114,7 @@ bool xap_respond_get_rgb_matrix_config(xap_token_t token, const void *data, size
     return xap_respond_data(token, &ret, sizeof(ret));
 }
 
-bool xap_respond_set_rgb_matrix_config(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_set_rgb_matrix_config(xap_token_t token, xap_route_lighting_rgb_matrix_set_config_arg_t* arg) {
-    if (length != sizeof(xap_route_lighting_rgb_matrix_set_config_arg_t)) {
-        return false;
-    }
-
-    xap_route_lighting_rgb_matrix_set_config_arg_t *arg = (xap_route_lighting_rgb_matrix_set_config_arg_t *)data;
-
     uint8_t mode = rgb_matrix_id_to_effect(arg->mode);
     if (mode == INVALID_EFFECT) {
         return false;
@@ -147,7 +129,7 @@ bool xap_respond_set_rgb_matrix_config(xap_token_t token, const void *data, size
     return xap_respond_success(token);
 }
 
-bool xap_respond_save_rgb_matrix_config(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_save_rgb_matrix_config(xap_token_t token) {
     eeconfig_update_rgb_matrix();
 
     return xap_respond_success(token);

quantum/xap/handlers/remapping.c

@@ -10,18 +10,13 @@
 #    define keymap_max_layer_count() keymap_layer_count()
 #endif
 
-bool xap_respond_keymap_get_layer_count(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_keymap_get_layer_count_impl(xap_token_t token) {
     uint8_t ret = keymap_max_layer_count();
     return xap_respond_data(token, &ret, sizeof(ret));
 }
 
-bool xap_respond_get_keymap_keycode(xap_token_t token, const void *data, size_t length) {
-    if (length != sizeof(xap_route_keymap_get_keymap_keycode_arg_t)) {
-        return false;
-    }
-
-    xap_route_keymap_get_keymap_keycode_arg_t *arg = (xap_route_keymap_get_keymap_keycode_arg_t *)data;
 
+bool xap_execute_get_keymap_keycode_impl(xap_token_t token, const xap_route_keymap_get_keymap_keycode_arg_t *arg) {
     if (arg->layer >= keymap_max_layer_count()) {
         return false;
     }
@@ -31,13 +26,7 @@ bool xap_respond_get_keymap_keycode(xap_token_t token, const void *data, size_t
 }
 
 #if ((defined(ENCODER_MAP_ENABLE)))
-bool xap_respond_get_encoder_keycode(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_get_encoder_keycode_impl(xap_token_t token, const xap_route_keymap_get_encoder_keycode_arg_t *arg) {
-    if (length != sizeof(xap_route_keymap_get_encoder_keycode_arg_t)) {
-        return false;
-    }
-
-    xap_route_keymap_get_encoder_keycode_arg_t *arg = (xap_route_keymap_get_encoder_keycode_arg_t *)data;
-
     if (arg->layer >= keymap_max_layer_count()) {
         return false;
     }
@@ -48,13 +37,7 @@ bool xap_respond_get_encoder_keycode(xap_token_t token, const void *data, size_t
 #endif
 
 #if ((defined(DYNAMIC_KEYMAP_ENABLE)))
-bool xap_respond_dynamic_keymap_set_keycode(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_dynamic_keymap_set_keycode_impl(xap_token_t token, const xap_route_remapping_set_keymap_keycode_arg_t *arg) {
-    if (length != sizeof(xap_route_remapping_set_keymap_keycode_arg_t)) {
-        return false;
-    }
-
-    xap_route_remapping_set_keymap_keycode_arg_t *arg = (xap_route_remapping_set_keymap_keycode_arg_t *)data;
-
     if (arg->layer >= keymap_max_layer_count()) {
         return false;
     }
@@ -65,13 +48,7 @@ bool xap_respond_dynamic_keymap_set_keycode(xap_token_t token, const void *data,
 #endif
 
 #if ((defined(DYNAMIC_KEYMAP_ENABLE) && defined(ENCODER_MAP_ENABLE)))
-bool xap_respond_dynamic_encoder_set_keycode(xap_token_t token, const void *data, size_t length) {
+bool xap_execute_dynamic_encoder_set_keycode_impl(xap_token_t token, const xap_route_remapping_set_encoder_keycode_arg_t *arg) {
-    if (length != sizeof(xap_route_remapping_set_encoder_keycode_arg_t)) {
-        return false;
-    }
-
-    xap_route_remapping_set_encoder_keycode_arg_t *arg = (xap_route_remapping_set_encoder_keycode_arg_t *)data;
-
     if (arg->layer >= keymap_max_layer_count()) {
         return false;
     }