Make the macro parser store the data it extracts into macro_action_t variables

right/src/config_parser/parse_macro.c

@@ -2,7 +2,7 @@
 #include "config_globals.h"
 #include "macros.h"
 
-parser_error_t parseKeyMacroAction(config_buffer_t *buffer, serialized_macro_action_type_t macroActionType) {
+parser_error_t parseKeyMacroAction(config_buffer_t *buffer, macro_action_t *macroAction, serialized_macro_action_type_t macroActionType) {
     uint8_t keyMacroType = macroActionType - SerializedMacroActionType_KeyMacroAction;
     uint8_t action = keyMacroType & 0b11;
     uint8_t type;
@@ -12,77 +12,80 @@ parser_error_t parseKeyMacroAction(config_buffer_t *buffer, serialized_macro_act
     keyMacroType >>= 2;
     type = keyMacroType & 0b11;
     keyMacroType >>= 2;
-    if (keyMacroType & 0b10) {
+    scancode = keyMacroType & 0b10 ? readUInt8(buffer) : 0;
-        scancode = readUInt8(buffer);
+    modifierMask = keyMacroType & 0b01 ? readUInt8(buffer) : 0;
-    }
+    macroAction->type = MacroActionType_Key;
-    if (keyMacroType & 0b01) {
+    macroAction->key.action = action;
-        modifierMask = readUInt8(buffer);
+    macroAction->key.type = type;
-    }
+    macroAction->key.scancode = scancode;
-    (void)action;
+    macroAction->key.modifierMask = modifierMask;
-    (void)type;
-    (void)scancode;
-    (void)modifierMask;
     return ParserError_Success;
 }
 
-parser_error_t parseMouseButtonMacroAction(config_buffer_t *buffer, serialized_macro_action_type_t macroActionType) {
+parser_error_t parseMouseButtonMacroAction(config_buffer_t *buffer, macro_action_t *macroAction, serialized_macro_action_type_t macroActionType) {
     uint8_t action = macroActionType - SerializedMacroActionType_MouseButtonMacroAction;
     uint8_t mouseButtonsMask = readUInt8(buffer);
 
-    (void)action;
+    macroAction->type = MacroActionType_MouseButton;
-    (void)mouseButtonsMask;
+    macroAction->mouseButton.action = action;
+    macroAction->mouseButton.mouseButtonsMask = mouseButtonsMask;
     return ParserError_Success;
 }
 
-parser_error_t parseMoveMouseMacroAction(config_buffer_t *buffer) {
+parser_error_t parseMoveMouseMacroAction(config_buffer_t *buffer, macro_action_t *macroAction) {
     int16_t x = readInt16(buffer);
     int16_t y = readInt16(buffer);
 
-    (void)x;
+    macroAction->type = MacroActionType_MoveMouse;
-    (void)y;
+    macroAction->moveMouse.x = x;
+    macroAction->moveMouse.y = y;
     return ParserError_Success;
 }
 
-parser_error_t parseScrollMouseMacroAction(config_buffer_t *buffer) {
+parser_error_t parseScrollMouseMacroAction(config_buffer_t *buffer, macro_action_t *macroAction) {
     int16_t x = readInt16(buffer);
     int16_t y = readInt16(buffer);
 
-    (void)x;
+    macroAction->type = MacroActionType_ScrollMouse;
-    (void)y;
+    macroAction->scrollMouse.x = x;
+    macroAction->scrollMouse.y = y;
     return ParserError_Success;
 }
 
-parser_error_t parseDelayMacroAction(config_buffer_t *buffer) {
+parser_error_t parseDelayMacroAction(config_buffer_t *buffer, macro_action_t *macroAction) {
     int16_t delay = readInt16(buffer);
 
-    (void)delay;
+    macroAction->type = MacroActionType_Delay;
+    macroAction->delay.delay = delay;
     return ParserError_Success;
 }
 
-parser_error_t parseTextMacroAction(config_buffer_t *buffer) {
+parser_error_t parseTextMacroAction(config_buffer_t *buffer, macro_action_t *macroAction) {
     uint16_t textLen;
     const char *text = readString(buffer, &textLen);
 
-    (void)text;
+    macroAction->type = MacroActionType_Text;
+    macroAction->text.text = text;
+    macroAction->text.textLen = textLen;
     return ParserError_Success;
 }
 
-parser_error_t parseMacroAction(config_buffer_t *buffer) {
+parser_error_t parseMacroAction(config_buffer_t *buffer, macro_action_t *macroAction) {
     uint8_t macroActionType = readUInt8(buffer);
 
     switch (macroActionType) {
         case SerializedMacroActionType_KeyMacroAction ... SerializedMacroActionType_LastKeyMacroAction:
-            return parseKeyMacroAction(buffer, macroActionType);
+            return parseKeyMacroAction(buffer, macroAction, macroActionType);
         case SerializedMacroActionType_MouseButtonMacroAction ... SerializedMacroActionType_LastMouseButtonMacroAction:
-            return parseMouseButtonMacroAction(buffer, macroActionType);
+            return parseMouseButtonMacroAction(buffer, macroAction, macroActionType);
         case SerializedMacroActionType_MoveMouseMacroAction:
-            return parseMoveMouseMacroAction(buffer);
+            return parseMoveMouseMacroAction(buffer, macroAction);
         case SerializedMacroActionType_ScrollMouseMacroAction:
-            return parseScrollMouseMacroAction(buffer);
+            return parseScrollMouseMacroAction(buffer, macroAction);
         case SerializedMacroActionType_DelayMacroAction:
-            return parseDelayMacroAction(buffer);
+            return parseDelayMacroAction(buffer, macroAction);
         case SerializedMacroActionType_TextMacroAction:
-            return parseTextMacroAction(buffer);
+            return parseTextMacroAction(buffer, macroAction);
     }
     return ParserError_InvalidSerializedMacroActionType;
 }
@@ -95,6 +98,7 @@ parser_error_t ParseMacro(config_buffer_t *buffer, uint8_t macroIdx) {
     bool isPrivate = readBool(buffer);
     const char *name = readString(buffer, &nameLen);
     uint16_t macroActionsCount = readCompactLength(buffer);
+    macro_action_t dummyMacroAction;
 
     (void)isLooped;
     (void)isPrivate;
@@ -104,7 +108,7 @@ parser_error_t ParseMacro(config_buffer_t *buffer, uint8_t macroIdx) {
         AllMacros[macroIdx].macroActionsCount = macroActionsCount;
     }
     for (uint16_t i = 0; i < macroActionsCount; i++) {
-        errorCode = parseMacroAction(buffer);
+        errorCode = parseMacroAction(buffer, &dummyMacroAction);
         if (errorCode != ParserError_Success) {
             return errorCode;
         }

right/src/macros.h

@@ -4,6 +4,7 @@
 // Includes:
 
     #include <stdint.h>
+    #include "key_action.h"
 
 // Macros:
 
@@ -16,6 +17,52 @@
         uint16_t macroActionsCount;
     } macro_reference_t;
 
+    typedef enum {
+        MacroSubAction_Press,
+        MacroSubAction_Hold,
+        MacroSubAction_Release,
+    } macro_sub_action_t;
+
+    typedef enum {
+        MacroActionType_Key,
+        MacroActionType_MouseButton,
+        MacroActionType_MoveMouse,
+        MacroActionType_ScrollMouse,
+        MacroActionType_Delay,
+        MacroActionType_Text,
+    } macro_action_type_t;
+
+    typedef struct {
+        union {
+            struct {
+                macro_sub_action_t action;
+                keystroke_type_t type;
+                uint8_t scancode;
+                uint8_t modifierMask;
+            } __attribute__ ((packed)) key;
+            struct {
+                macro_sub_action_t action;
+                uint8_t mouseButtonsMask;
+            } __attribute__ ((packed)) mouseButton;
+            struct {
+                int16_t x;
+                int16_t y;
+            } __attribute__ ((packed)) moveMouse;
+            struct {
+                int16_t x;
+                int16_t y;
+            } __attribute__ ((packed)) scrollMouse;
+            struct {
+                int16_t delay;
+            } __attribute__ ((packed)) delay;
+            struct {
+                const char *text;
+                uint16_t textLen;
+            } __attribute__ ((packed)) text;
+        };
+        macro_action_type_t type;
+    } __attribute__ ((packed)) macro_action_t;
+
 // Variables:
 
     extern macro_reference_t AllMacros[MAX_MACRO_NUM];