- Only keep state for the scan code that are available for the layer - Also properly implemented scan code range checking (was not done before, only worked because the KLL compiler was well behaved)

9 yıl önce · df82ffeff7
--- a/Macro/PartialMap/kll.h
+++ b/Macro/PartialMap/kll.h
@@ -118,7 +118,7 @@ typedef enum TriggerMacroState {
 // TriggerMacro struct, one is created per TriggerMacro, no duplicates
 typedef struct TriggerMacro {
 const uint8_t *guide;
 var_uint_t result;
 const var_uint_t result;
 var_uint_t pos;
 TriggerMacroState state;
 } TriggerMacro;
@@ -137,8 +137,8 @@ typedef struct TriggerGuide {

 // Capability
 typedef struct Capability {
 void *func;
 uint8_t argCount;
 const void *func;
 const uint8_t argCount;
 } Capability;

 // Total Number of Capabilities
@@ -205,28 +205,31 @@ typedef struct Capability {
 // * Shift - 0x01
 // * Latch - 0x02
 // * Lock - 0x04
 // Layer states are stored in the LayerState array
 //
 // Except for Off, all states an exist simultaneously for each layer
 // For example:
 // state -> 0x04 + 0x01 = 0x05 (Shift + Lock), which is effectively Off (0x00)
 //
 // Max defines the maximum number of keys in the map, maximum of 0xFF
 // First defines the first used scan code (most keyboards start at 0, some start higher e.g. 0x40)
 // - Compiler calculates this
 //
 // Last defines the last scan code used (helps reduce RAM usage)
 //
 // The name is defined for cli debugging purposes (Null terminated string)

 typedef struct Layer {
 const nat_ptr_t **triggerMap;
 const char *name;
 const uint8_t max;
 uint8_t state;
 const uint8_t first;
 const uint8_t last;
 } Layer;


 // Layer_IN( map, name );
 // * map - Trigger map
 // * name - Name of the trigger map
 #define Layer_IN( map, name ) { map, name, sizeof( map ) / sizeof( nat_ptr_t ) - 1, 0 }
 // Layer_IN( map, name, first );
 //  * map - Trigger map
 // * name - Name of the trigger map
 // * first - First scan code used (most keyboards start at 0, some start higher e.g. 0x40)
 #define Layer_IN( map, name, first ) { map, name, first, sizeof( map ) / sizeof( nat_ptr_t ) - 1 + first }

 // Total number of layers
 #define LayerNum sizeof( LayerIndex ) / sizeof( Layer )
--- a/Macro/PartialMap/macro.c
+++ b/Macro/PartialMap/macro.c
@@ -155,15 +155,15 @@ void Macro_layerState( uint8_t state, uint8_t stateType, uint16_t layer, uint8_t
 }

 // Toggle Layer State Byte
 if ( LayerIndex[ layer ].state & layerState )
 if ( LayerState[ layer ] & layerState )
 {
 // Unset
 LayerIndex[ layer ].state &= ~layerState;
 LayerState[ layer ] &= ~layerState;
 }
 else
 {
 // Set
 LayerIndex[ layer ].state |= layerState;
 LayerState[ layer ] |= layerState;
 }

 // If the layer was not in the LayerIndexStack add it
@@ -173,7 +173,7 @@ void Macro_layerState( uint8_t state, uint8_t stateType, uint16_t layer, uint8_t
 }

 // If the layer is in the LayerIndexStack and the state is 0x00, remove
 if ( LayerIndex[ layer ].state == 0x00 && inLayerIndexStack )
 if ( LayerState[ layer ] == 0x00 && inLayerIndexStack )
 {
 // Remove the layer from the LayerIndexStack
 // Using the already positioned stackItem variable from the loop above
@@ -302,43 +302,55 @@ nat_ptr_t *Macro_layerLookup( uint8_t scanCode )
 for ( uint16_t layerIndex = 0; layerIndex < macroLayerIndexStackSize; layerIndex++ )
 {
 // Lookup Layer
 Layer *layer = &LayerIndex[ macroLayerIndexStack[ layerIndex ] ];
 const Layer *layer = &LayerIndex[ macroLayerIndexStack[ layerIndex ] ];

 // Check if latch has been pressed for this layer
 // XXX Regardless of whether a key is found, the latch is removed on first lookup
 uint8_t latch = layer->state & 0x02;
 uint8_t latch = LayerState[ layerIndex ] & 0x02;
 if ( latch )
 {
 layer->state &= ~0x02;
 LayerState[ layerIndex ] &= ~0x02;
 }

 // Only use layer, if state is valid
 // XOR each of the state bits
 // If only two are enabled, do not use this state
 if ( (layer->state & 0x01) ^ (latch>>1) ^ ((layer->state & 0x04)>>2) )
 if ( (LayerState[ layerIndex ] & 0x01) ^ (latch>>1) ^ ((LayerState[ layerIndex ] & 0x04)>>2) )
 {
 // Lookup layer
 nat_ptr_t **map = (nat_ptr_t**)layer->triggerMap;

 // Determine if layer has key defined
 if ( map != 0 && *map[ scanCode ] != 0 )
 return map[ scanCode ];
 // Make sure scanCode is between layer first and last scancodes
 if ( map != 0
 && scanCode < layer->last
 && scanCode > layer->first
 && *map[ scanCode - layer->first ] != 0 )
 {
 return map[ scanCode - layer->first ];
 }
 }
 }

 // Do lookup on default layer
 nat_ptr_t **map = (nat_ptr_t**)LayerIndex[0].triggerMap;

 // Determine if layer has key defined
 if ( map == 0 && *map[ scanCode ] == 0 )
 // Lookup default layer
 const Layer *layer = &LayerIndex[ macroLayerIndexStack[ 0 ] ];

 // Make sure scanCode is between layer first and last scancodes
 if ( map != 0
 && scanCode < layer->last
 && scanCode > layer->first
 && *map[ scanCode - layer->first ] != 0 )
 {
 erro_msg("Scan Code has no defined Trigger Macro: ");
 printHex( scanCode );
 return 0;
 return map[ scanCode - layer->first ];
 }

 // Return lookup result
 return map[ scanCode ];
 // Otherwise no defined Trigger Macro
 erro_msg("Scan Code has no defined Trigger Macro: ");
 printHex( scanCode );
 return 0;
 }


@@ -1157,11 +1169,13 @@ void cliFunc_layerList( char* args )

 // Layer State
 print( NL "\t\t Layer State: " );
 printHex( LayerIndex[ layer ].state );
 printHex( LayerState[ layer ] );

 // Max Index
 print(" Max Index: ");
 printHex( LayerIndex[ layer ].max );
 // First -> Last Indices
 print(" First -> Last Indices: ");
 printHex( LayerIndex[ layer ].first );
 print(" -> ");
 printHex( LayerIndex[ layer ].last );
 }
 }

@@ -1206,7 +1220,7 @@ void cliFunc_layerState( char* args )
 printHex( arg2 );

 // Set the layer state
 LayerIndex[ arg1 ].state = arg2;
 LayerState[ arg1 ] = arg2;
 break;
 }
 }