X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=Macro%2FPartialMap%2Fmacro.c;h=91198372035019503a8b7466894eac7703f80075;hb=f2c3cc0082cf2487589b7517e60e45684c798a01;hp=71446840b53c33af1867f31363cc606eb24d483c;hpb=b2eaf0c8937d10df6788df36d84efad722b8e525;p=kiibohd-controller.git

diff --git a/Macro/PartialMap/macro.c b/Macro/PartialMap/macro.c
index 7144684..9119837 100644
--- a/Macro/PartialMap/macro.c
+++ b/Macro/PartialMap/macro.c
@@ -27,8 +27,7 @@
 
 // Keymaps
 #include "usb_hid.h"
-#include <defaultMap.h>
-#include "generatedKeymap.h" // TODO Use actual generated version
+#include <generatedKeymap.h> // Generated using kll at compile time, in build directory
 
 // Local Includes
 #include "macro.h"
@@ -82,20 +81,32 @@ typedef enum ResultMacroEval {
 // ----- Variables -----
 
 // Macro Module command dictionary
-const char macroCLIDictName[] = "Macro Module Commands";
-const CLIDictItem macroCLIDict[] = {
-	{ "capList",     "Prints an indexed list of all non USB keycode capabilities.", cliFunc_capList },
-	{ "capSelect",   "Triggers the specified capabilities. First two args are state and stateType." NL "\t\t\033[35mK11\033[0m Keyboard Capability 0x0B", cliFunc_capSelect },
-	{ "keyHold",     "Send key-hold events to the macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A", cliFunc_keyHold },
-	{ "keyPress",    "Send key-press events to the macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A", cliFunc_keyPress },
-	{ "keyRelease",  "Send key-release event to macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A", cliFunc_keyRelease },
-	{ "layerList",   "List available layers.", cliFunc_layerList },
-	{ "layerState",  "Modify specified indexed layer state <layer> <state byte>." NL "\t\t\033[35mL2\033[0m Indexed Layer 0x02" NL "\t\t0 Off, 1 Shift, 2 Latch, 4 Lock States", cliFunc_layerState },
-	{ "macroDebug",  "Disables/Enables sending USB keycodes to the Output Module and prints U/K codes.", cliFunc_macroDebug },
-	{ "macroList",   "List the defined trigger and result macros.", cliFunc_macroList },
-	{ "macroProc",   "Pause/Resume macro processing.", cliFunc_macroProc },
-	{ "macroShow",   "Show the macro corresponding to the given index." NL "\t\t\033[35mT16\033[0m Indexed Trigger Macro 0x10, \033[35mR12\033[0m Indexed Result Macro 0x0C", cliFunc_macroShow },
-	{ "macroStep",   "Do N macro processing steps. Defaults to 1.", cliFunc_macroStep },
+CLIDict_Entry( capList,     "Prints an indexed list of all non USB keycode capabilities." );
+CLIDict_Entry( capSelect,   "Triggers the specified capabilities. First two args are state and stateType." NL "\t\t\033[35mK11\033[0m Keyboard Capability 0x0B" );
+CLIDict_Entry( keyHold,     "Send key-hold events to the macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A" );
+CLIDict_Entry( keyPress,    "Send key-press events to the macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A" );
+CLIDict_Entry( keyRelease,  "Send key-release event to macro module. Duplicates have undefined behaviour." NL "\t\t\033[35mS10\033[0m Scancode 0x0A" );
+CLIDict_Entry( layerList,   "List available layers." );
+CLIDict_Entry( layerState,  "Modify specified indexed layer state <layer> <state byte>." NL "\t\t\033[35mL2\033[0m Indexed Layer 0x02" NL "\t\t0 Off, 1 Shift, 2 Latch, 4 Lock States" );
+CLIDict_Entry( macroDebug,  "Disables/Enables sending USB keycodes to the Output Module and prints U/K codes." );
+CLIDict_Entry( macroList,   "List the defined trigger and result macros." );
+CLIDict_Entry( macroProc,   "Pause/Resume macro processing." );
+CLIDict_Entry( macroShow,   "Show the macro corresponding to the given index." NL "\t\t\033[35mT16\033[0m Indexed Trigger Macro 0x10, \033[35mR12\033[0m Indexed Result Macro 0x0C" );
+CLIDict_Entry( macroStep,   "Do N macro processing steps. Defaults to 1." );
+
+CLIDict_Def( macroCLIDict, "Macro Module Commands" ) = {
+	CLIDict_Item( capList ),
+	CLIDict_Item( capSelect ),
+	CLIDict_Item( keyHold ),
+	CLIDict_Item( keyPress ),
+	CLIDict_Item( keyRelease ),
+	CLIDict_Item( layerList ),
+	CLIDict_Item( layerState ),
+	CLIDict_Item( macroDebug ),
+	CLIDict_Item( macroList ),
+	CLIDict_Item( macroProc ),
+	CLIDict_Item( macroShow ),
+	CLIDict_Item( macroStep ),
 	{ 0, 0, 0 } // Null entry for dictionary end
 };
 
@@ -107,7 +118,7 @@ uint8_t macroDebugMode = 0;
 uint8_t macroPauseMode = 0;
 
 // Macro step counter - If non-zero, the step counter counts down every time the macro module does one processing loop
-unsigned int macroStepCounter = 0;
+uint16_t macroStepCounter = 0;
 
 
 // Key Trigger List Buffer
@@ -119,45 +130,33 @@ uint8_t macroTriggerListBufferSize = 0;
 // TODO, figure out a good way to scale this array size without wasting too much memory, but not rejecting macros
 //       Possibly could be calculated by the KLL compiler
 // XXX It may be possible to calculate the worst case using the KLL compiler
-unsigned int macroTriggerMacroPendingList[ TriggerMacroNum ] = { 0 };
-unsigned int macroTriggerMacroPendingListSize = 0;
+uint16_t macroTriggerMacroPendingList[ TriggerMacroNum ] = { 0 };
+uint16_t macroTriggerMacroPendingListSize = 0;
 
 // Layer Index Stack
 //  * When modifying layer state and the state is non-0x0, the stack must be adjusted
-unsigned int macroLayerIndexStack[ LayerNum ] = { 0 };
-unsigned int macroLayerIndexStackSize = 0;
+uint16_t macroLayerIndexStack[ LayerNum + 1 ] = { 0 };
+uint16_t macroLayerIndexStackSize = 0;
 
 // Pending Result Macro Index List
 //  * Any result macro that needs processing from a previous macro processing loop
-unsigned int macroResultMacroPendingList[ ResultMacroNum ] = { 0 };
-unsigned int macroResultMacroPendingListSize = 0;
+uint16_t macroResultMacroPendingList[ ResultMacroNum ] = { 0 };
+uint16_t macroResultMacroPendingListSize = 0;
 
 
 
 // ----- Capabilities -----
 
-// Modifies the specified Layer control byte
-// Argument #1: Layer Index -> unsigned int
-// Argument #2: Toggle byte -> uint8_t
-void Macro_layerStateToggle_capability( uint8_t state, uint8_t stateType, uint8_t *args )
+// Sets the given layer with the specified layerState
+void Macro_layerState( uint8_t state, uint8_t stateType, uint16_t layer, uint8_t layerState )
 {
-	// Display capability name
-	if ( stateType == 0xFF && state == 0xFF )
-	{
-		print("Macro_layerState(layerIndex,toggleByte)");
+	// Ignore if layer does not exist
+	if ( layer >= LayerNum )
 		return;
-	}
-
-	// Get layer index from arguments
-	// Cast pointer to uint8_t to unsigned int then access that memory location
-	unsigned int layer = *(unsigned int*)(&args[0]);
-
-	// Get layer toggle byte
-	uint8_t toggleByte = args[ sizeof(unsigned int) ];
 
 	// Is layer in the LayerIndexStack?
 	uint8_t inLayerIndexStack = 0;
-	unsigned int stackItem = 0;
+	uint16_t stackItem = 0;
 	while ( stackItem < macroLayerIndexStackSize )
 	{
 		// Flag if layer is already in the LayerIndexStack
@@ -172,15 +171,15 @@ void Macro_layerStateToggle_capability( uint8_t state, uint8_t stateType, uint8_
 	}
 
 	// Toggle Layer State Byte
-	if ( LayerIndex[ layer ].state & toggleByte )
+	if ( LayerState[ layer ] & layerState )
 	{
 		// Unset
-		LayerIndex[ layer ].state &= ~toggleByte;
+		LayerState[ layer ] &= ~layerState;
 	}
 	else
 	{
 		// Set
-		LayerIndex[ layer ].state |= toggleByte;
+		LayerState[ layer ] |= layerState;
 	}
 
 	// If the layer was not in the LayerIndexStack add it
@@ -190,7 +189,7 @@ void Macro_layerStateToggle_capability( uint8_t state, uint8_t stateType, uint8_
 	}
 
 	// 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
@@ -205,55 +204,169 @@ void Macro_layerStateToggle_capability( uint8_t state, uint8_t stateType, uint8_
 	}
 }
 
+// Modifies the specified Layer control byte
+// Argument #1: Layer Index -> uint16_t
+// Argument #2: Layer State -> uint8_t
+void Macro_layerState_capability( uint8_t state, uint8_t stateType, uint8_t *args )
+{
+	// Display capability name
+	if ( stateType == 0xFF && state == 0xFF )
+	{
+		print("Macro_layerState(layerIndex,layerState)");
+		return;
+	}
+
+	// Only use capability on press or release
+	// TODO Analog
+	// XXX This may cause issues, might be better to implement state table here to decide -HaaTa
+	if ( stateType == 0x00 && state == 0x02 ) // Hold condition
+		return;
+
+	// Get layer index from arguments
+	// Cast pointer to uint8_t to uint16_t then access that memory location
+	uint16_t layer = *(uint16_t*)(&args[0]);
+
+	// Get layer toggle byte
+	uint8_t layerState = args[ sizeof(uint16_t) ];
+
+	Macro_layerState( state, stateType, layer, layerState );
+}
+
+
+// Latches given layer
+// Argument #1: Layer Index -> uint16_t
+void Macro_layerLatch_capability( uint8_t state, uint8_t stateType, uint8_t *args )
+{
+	// Display capability name
+	if ( stateType == 0xFF && state == 0xFF )
+	{
+		print("Macro_layerLatch(layerIndex)");
+		return;
+	}
+
+	// Only use capability on press
+	// TODO Analog
+	// XXX To make sense, this code be on press or release. Or it could even be a sticky shift (why? dunno) -HaaTa
+	if ( stateType == 0x00 && state != 0x01 ) // All normal key conditions except press
+		return;
+
+	// Get layer index from arguments
+	// Cast pointer to uint8_t to uint16_t then access that memory location
+	uint16_t layer = *(uint16_t*)(&args[0]);
+
+	Macro_layerState( state, stateType, layer, 0x02 );
+}
+
+
+// Locks given layer
+// Argument #1: Layer Index -> uint16_t
+void Macro_layerLock_capability( uint8_t state, uint8_t stateType, uint8_t *args )
+{
+	// Display capability name
+	if ( stateType == 0xFF && state == 0xFF )
+	{
+		print("Macro_layerLock(layerIndex)");
+		return;
+	}
+
+	// Only use capability on press
+	// TODO Analog
+	// XXX Could also be on release, but that's sorta dumb -HaaTa
+	if ( stateType == 0x00 && state != 0x01 ) // All normal key conditions except press
+		return;
+
+	// Get layer index from arguments
+	// Cast pointer to uint8_t to uint16_t then access that memory location
+	uint16_t layer = *(uint16_t*)(&args[0]);
+
+	Macro_layerState( state, stateType, layer, 0x04 );
+}
+
+
+// Shifts given layer
+// Argument #1: Layer Index -> uint16_t
+void Macro_layerShift_capability( uint8_t state, uint8_t stateType, uint8_t *args )
+{
+	// Display capability name
+	if ( stateType == 0xFF && state == 0xFF )
+	{
+		print("Macro_layerShift(layerIndex)");
+		return;
+	}
+
+	// Only use capability on press or release
+	// TODO Analog
+	if ( stateType == 0x00 && ( state == 0x00 || state == 0x02 ) ) // Only pass press or release conditions
+		return;
+
+	// Get layer index from arguments
+	// Cast pointer to uint8_t to uint16_t then access that memory location
+	uint16_t layer = *(uint16_t*)(&args[0]);
+
+	Macro_layerState( state, stateType, layer, 0x01 );
+}
+
 
 
 // ----- Functions -----
 
 // Looks up the trigger list for the given scan code (from the active layer)
 // NOTE: Calling function must handle the NULL pointer case
-unsigned int *Macro_layerLookup( uint8_t scanCode )
+nat_ptr_t *Macro_layerLookup( uint8_t scanCode )
 {
 	// If no trigger macro is defined at the given layer, fallthrough to the next layer
-	for ( unsigned int layerIndex = 0; layerIndex < macroLayerIndexStackSize; layerIndex++ )
+	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[ macroLayerIndexStack[ layerIndex ] ] & 0x01) ^ (latch>>1) ^ ((LayerState[ macroLayerIndexStack[ layerIndex ] ] & 0x04)>>2) )
 		{
 			// Lookup layer
-			unsigned int **map = (unsigned int**)layer->triggerMap;
+			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
-	unsigned int **map = (unsigned int**)LayerIndex[0].triggerMap;
+	nat_ptr_t **map = (nat_ptr_t**)LayerIndex[0].triggerMap;
+
+	// Lookup default layer
+	const Layer *layer = &LayerIndex[0];
 
-	// Determine if layer has key defined
-	if ( map == 0 && *map[ scanCode ] == 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;
 }
 
 
@@ -318,13 +431,13 @@ inline void Macro_ledState( uint8_t ledCode, uint8_t state )
 
 // Append result macro to pending list, checking for duplicates
 // Do nothing if duplicate
-inline void Macro_appendResultMacroToPendingList( TriggerMacro *triggerMacro )
+inline void Macro_appendResultMacroToPendingList( const TriggerMacro *triggerMacro )
 {
 	// Lookup result macro index
-	unsigned int resultMacroIndex = triggerMacro->result;
+	var_uint_t resultMacroIndex = triggerMacro->result;
 
 	// Iterate through result macro pending list, making sure this macro hasn't been added yet
-	for ( unsigned int macro = 0; macro < macroResultMacroPendingListSize; macro++ )
+	for ( var_uint_t macro = 0; macro < macroResultMacroPendingListSize; macro++ )
 	{
 		// If duplicate found, do nothing
 		if ( macroResultMacroPendingList[ macro ] == resultMacroIndex )
@@ -335,7 +448,7 @@ inline void Macro_appendResultMacroToPendingList( TriggerMacro *triggerMacro )
 	macroResultMacroPendingList[ macroResultMacroPendingListSize++ ] = resultMacroIndex;
 
 	// Lookup scanCode of the last key in the last combo
-	unsigned int pos = 0;
+	var_uint_t pos = 0;
 	for ( uint8_t comboLength = triggerMacro->guide[0]; comboLength > 0; )
 	{
 		pos += TriggerGuideSize * comboLength + 1;
@@ -349,31 +462,31 @@ inline void Macro_appendResultMacroToPendingList( TriggerMacro *triggerMacro )
 	{
 		if ( macroTriggerListBuffer[ keyIndex ].scanCode == scanCode )
 		{
-			ResultMacroList[ resultMacroIndex ].state     = macroTriggerListBuffer[ keyIndex ].state;
-			ResultMacroList[ resultMacroIndex ].stateType = macroTriggerListBuffer[ keyIndex ].type;
+			ResultMacroRecordList[ resultMacroIndex ].state     = macroTriggerListBuffer[ keyIndex ].state;
+			ResultMacroRecordList[ resultMacroIndex ].stateType = macroTriggerListBuffer[ keyIndex ].type;
 		}
 	}
 
 	// Reset the macro position
-	ResultMacroList[ resultMacroIndex ].pos = 0;
+	ResultMacroRecordList[ resultMacroIndex ].pos = 0;
 }
 
 
 // Determine if long ResultMacro (more than 1 seqence element)
-inline uint8_t Macro_isLongResultMacro( ResultMacro *macro )
+inline uint8_t Macro_isLongResultMacro( const ResultMacro *macro )
 {
 	// Check the second sequence combo length
 	// If non-zero return non-zero (long sequence)
 	// 0 otherwise (short sequence)
-	unsigned int position = 1;
-	for ( unsigned int result = 0; result < macro->guide[0]; result++ )
+	var_uint_t position = 1;
+	for ( var_uint_t result = 0; result < macro->guide[0]; result++ )
 		position += ResultGuideSize( (ResultGuide*)&macro->guide[ position ] );
 	return macro->guide[ position ];
 }
 
 
 // Determine if long TriggerMacro (more than 1 sequence element)
-inline uint8_t Macro_isLongTriggerMacro( TriggerMacro *macro )
+inline uint8_t Macro_isLongTriggerMacro( const TriggerMacro *macro )
 {
 	// Check the second sequence combo length
 	// If non-zero return non-zero (long sequence)
@@ -504,20 +617,21 @@ inline TriggerMacroVote Macro_evalLongTriggerMacroVote( TriggerGuide *key, Trigg
 
 
 // Evaluate/Update TriggerMacro
-inline TriggerMacroEval Macro_evalTriggerMacro( unsigned int triggerMacroIndex )
+inline TriggerMacroEval Macro_evalTriggerMacro( var_uint_t triggerMacroIndex )
 {
 	// Lookup TriggerMacro
-	TriggerMacro *macro = &TriggerMacroList[ triggerMacroIndex ];
+	const TriggerMacro *macro = &TriggerMacroList[ triggerMacroIndex ];
+	TriggerMacroRecord *record = &TriggerMacroRecordList[ triggerMacroIndex ];
 
 	// Check if macro has finished and should be incremented sequence elements
-	if ( macro->state == TriggerMacro_Release )
+	if ( record->state == TriggerMacro_Release )
 	{
-		macro->state = TriggerMacro_Waiting;
-		macro->pos = macro->pos + macro->guide[ macro->pos ] * TriggerGuideSize + 1;
+		record->state = TriggerMacro_Waiting;
+		record->pos = record->pos + macro->guide[ record->pos ] * TriggerGuideSize + 1;
 	}
 
 	// Current Macro position
-	unsigned int pos = macro->pos;
+	var_uint_t pos = record->pos;
 
 	// Length of the combo being processed
 	uint8_t comboLength = macro->guide[ pos ] * TriggerGuideSize;
@@ -592,11 +706,21 @@ inline TriggerMacroEval Macro_evalTriggerMacro( unsigned int triggerMacroIndex )
 	{
 		// Just doing nothing :)
 	}
+	// If ready for transition and in Press state, set to Waiting and increment combo position
+	// Position is incremented (and possibly remove the macro from the pending list) on the next iteration
+	else if ( overallVote & TriggerMacroVote_Release && record->state == TriggerMacro_Press )
+	{
+		record->state = TriggerMacro_Release;
+
+		// If this is the last combo in the sequence, remove from the pending list
+		if ( macro->guide[ record->pos + macro->guide[ record->pos ] * TriggerGuideSize + 1 ] == 0 )
+			return TriggerMacroEval_DoResultAndRemove;
+	}
 	// If passing and in Waiting state, set macro state to Press
 	else if ( overallVote & TriggerMacroVote_Pass
-	     && ( macro->state == TriggerMacro_Waiting || macro->state == TriggerMacro_Press ) )
+	     && ( record->state == TriggerMacro_Waiting || record->state == TriggerMacro_Press ) )
 	{
-		macro->state = TriggerMacro_Press;
+		record->state = TriggerMacro_Press;
 
 		// If in press state, and this is the final combo, send request for ResultMacro
 		// Check to see if the result macro only has a single element
@@ -629,21 +753,11 @@ inline TriggerMacroEval Macro_evalTriggerMacro( unsigned int triggerMacroIndex )
 			}
 		}
 	}
-	// If ready for transition and in Press state, set to Waiting and increment combo position
-	// Position is incremented (and possibly remove the macro from the pending list) on the next iteration
-	else if ( overallVote & TriggerMacroVote_Release && macro->state == TriggerMacro_Press )
-	{
-		macro->state = TriggerMacro_Release;
-
-		// If this is the last combo in the sequence, remove from the pending list
-		if ( macro->guide[ macro->pos + macro->guide[ macro->pos ] * TriggerGuideSize + 1 ] == 0 )
-			return TriggerMacroEval_Remove;
-	}
 	// Otherwise, just remove the macro on key release
-	// XXX Might cause some issues
+	// One more result has to be called to indicate to the ResultMacro that the key transitioned to the release state
 	else if ( overallVote & TriggerMacroVote_Release )
 	{
-		return TriggerMacroEval_Remove;
+		return TriggerMacroEval_DoResultAndRemove;
 	}
 
 	// If this is a short macro, just remove it
@@ -656,22 +770,23 @@ inline TriggerMacroEval Macro_evalTriggerMacro( unsigned int triggerMacroIndex )
 
 
 // Evaluate/Update ResultMacro
-inline ResultMacroEval Macro_evalResultMacro( unsigned int resultMacroIndex )
+inline ResultMacroEval Macro_evalResultMacro( var_uint_t resultMacroIndex )
 {
 	// Lookup ResultMacro
-	ResultMacro *macro = &ResultMacroList[ resultMacroIndex ];
+	const ResultMacro *macro = &ResultMacroList[ resultMacroIndex ];
+	ResultMacroRecord *record = &ResultMacroRecordList[ resultMacroIndex ];
 
 	// Current Macro position
-	unsigned int pos = macro->pos;
+	var_uint_t pos = record->pos;
 
 	// Length of combo being processed
 	uint8_t comboLength = macro->guide[ pos ];
 
 	// Function Counter, used to keep track of the combo items processed
-	unsigned int funcCount = 0;
+	var_uint_t funcCount = 0;
 
 	// Combo Item Position within the guide
-	unsigned int comboItem = pos + 1;
+	var_uint_t comboItem = pos + 1;
 
 	// Iterate through the Result Combo
 	while ( funcCount < comboLength )
@@ -683,7 +798,7 @@ inline ResultMacroEval Macro_evalResultMacro( unsigned int resultMacroIndex )
 		void (*capability)(uint8_t, uint8_t, uint8_t*) = (void(*)(uint8_t, uint8_t, uint8_t*))(CapabilitiesList[ guide->index ].func);
 
 		// Call capability
-		capability( macro->state, macro->stateType, &guide->args );
+		capability( record->state, record->stateType, &guide->args );
 
 		// Increment counters
 		funcCount++;
@@ -691,11 +806,12 @@ inline ResultMacroEval Macro_evalResultMacro( unsigned int resultMacroIndex )
 	}
 
 	// Move to next item in the sequence
-	macro->pos = comboItem;
+	record->pos = comboItem;
 
 	// If the ResultMacro is finished, remove
 	if ( macro->guide[ comboItem ] == 0 )
 	{
+		record->pos = 0;
 		return ResultMacroEval_Remove;
 	}
 
@@ -717,21 +833,21 @@ inline void Macro_updateTriggerMacroPendingList()
 			continue;
 
 		// Lookup Trigger List
-		unsigned int *triggerList = Macro_layerLookup( macroTriggerListBuffer[ key ].scanCode );
+		nat_ptr_t *triggerList = Macro_layerLookup( macroTriggerListBuffer[ key ].scanCode );
 
 		// Number of Triggers in list
-		unsigned int triggerListSize = triggerList[0];
+		nat_ptr_t triggerListSize = triggerList[0];
 
 		// Iterate over triggerList to see if any TriggerMacros need to be added
 		// First item is the number of items in the TriggerList
-		for ( unsigned int macro = 1; macro < triggerListSize + 1; macro++ )
+		for ( var_uint_t macro = 1; macro < triggerListSize + 1; macro++ )
 		{
 			// Lookup trigger macro index
-			unsigned int triggerMacroIndex = triggerList[ macro ];
+			var_uint_t triggerMacroIndex = triggerList[ macro ];
 
 			// Iterate over macroTriggerMacroPendingList to see if any macro in the scancode's
 			//  triggerList needs to be added
-			unsigned int pending = 0;
+			var_uint_t pending = 0;
 			for ( ; pending < macroTriggerMacroPendingListSize; pending++ )
 			{
 				// Stop scanning if the trigger macro index is found in the pending list
@@ -746,8 +862,8 @@ inline void Macro_updateTriggerMacroPendingList()
 				macroTriggerMacroPendingList[ macroTriggerMacroPendingListSize++ ] = triggerMacroIndex;
 
 				// Reset macro position
-				TriggerMacroList[ triggerMacroIndex ].pos   = 0;
-				TriggerMacroList[ triggerMacroIndex ].state = TriggerMacro_Waiting;
+				TriggerMacroRecordList[ triggerMacroIndex ].pos   = 0;
+				TriggerMacroRecordList[ triggerMacroIndex ].state = TriggerMacro_Waiting;
 			}
 		}
 	}
@@ -778,10 +894,10 @@ inline void Macro_process()
 
 	// Tail pointer for macroTriggerMacroPendingList
 	// Macros must be explicitly re-added
-	unsigned int macroTriggerMacroPendingListTail = 0;
+	var_uint_t macroTriggerMacroPendingListTail = 0;
 
 	// Iterate through the pending TriggerMacros, processing each of them
-	for ( unsigned int macro = 0; macro < macroTriggerMacroPendingListSize; macro++ )
+	for ( var_uint_t macro = 0; macro < macroTriggerMacroPendingListSize; macro++ )
 	{
 		switch ( Macro_evalTriggerMacro( macroTriggerMacroPendingList[ macro ] ) )
 		{
@@ -811,10 +927,10 @@ inline void Macro_process()
 
 	// Tail pointer for macroResultMacroPendingList
 	// Macros must be explicitly re-added
-	unsigned int macroResultMacroPendingListTail = 0;
+	var_uint_t macroResultMacroPendingListTail = 0;
 
 	// Iterate through the pending ResultMacros, processing each of them
-	for ( unsigned int macro = 0; macro < macroResultMacroPendingListSize; macro++ )
+	for ( var_uint_t macro = 0; macro < macroResultMacroPendingListSize; macro++ )
 	{
 		switch ( Macro_evalResultMacro( macroResultMacroPendingList[ macro ] ) )
 		{
@@ -866,18 +982,18 @@ inline void Macro_setup()
 	macroTriggerListBufferSize = 0;
 
 	// Initialize TriggerMacro states
-	for ( unsigned int macro = 0; macro < TriggerMacroNum; macro++ )
+	for ( var_uint_t macro = 0; macro < TriggerMacroNum; macro++ )
 	{
-		TriggerMacroList[ macro ].pos   = 0;
-		TriggerMacroList[ macro ].state = TriggerMacro_Waiting;
+		TriggerMacroRecordList[ macro ].pos   = 0;
+		TriggerMacroRecordList[ macro ].state = TriggerMacro_Waiting;
 	}
 
 	// Initialize ResultMacro states
-	for ( unsigned int macro = 0; macro < ResultMacroNum; macro++ )
+	for ( var_uint_t macro = 0; macro < ResultMacroNum; macro++ )
 	{
-		ResultMacroList[ macro ].pos       = 0;
-		ResultMacroList[ macro ].state     = 0;
-		ResultMacroList[ macro ].stateType = 0;
+		ResultMacroRecordList[ macro ].pos       = 0;
+		ResultMacroRecordList[ macro ].state     = 0;
+		ResultMacroRecordList[ macro ].stateType = 0;
 	}
 }
 
@@ -891,7 +1007,7 @@ void cliFunc_capList( char* args )
 	printHex( CapabilitiesNum );
 
 	// Iterate through all of the capabilities and display them
-	for ( unsigned int cap = 0; cap < CapabilitiesNum; cap++ )
+	for ( var_uint_t cap = 0; cap < CapabilitiesNum; cap++ )
 	{
 		print( NL "\t" );
 		printHex( cap );
@@ -911,15 +1027,15 @@ void cliFunc_capSelect( char* args )
 	char* arg2Ptr = args;
 
 	// Total number of args to scan (must do a lookup if a keyboard capability is selected)
-	unsigned int totalArgs = 2; // Always at least two args
-	unsigned int cap = 0;
+	var_uint_t totalArgs = 2; // Always at least two args
+	var_uint_t cap = 0;
 
 	// Arguments used for keyboard capability function
-	unsigned int argSetCount = 0;
+	var_uint_t argSetCount = 0;
 	uint8_t *argSet = (uint8_t*)args;
 
 	// Process all args
-	for ( unsigned int c = 0; argSetCount < totalArgs; c++ )
+	for ( var_uint_t c = 0; argSetCount < totalArgs; c++ )
 	{
 		curArgs = arg2Ptr;
 		CLI_argumentIsolation( curArgs, &arg1Ptr, &arg2Ptr );
@@ -1057,7 +1173,7 @@ void cliFunc_layerList( char* args )
 	info_msg("Layer List");
 
 	// Iterate through all of the layers and display them
-	for ( unsigned int layer = 0; layer < LayerNum; layer++ )
+	for ( uint16_t layer = 0; layer < LayerNum; layer++ )
 	{
 		print( NL "\t" );
 		printHex( layer );
@@ -1072,11 +1188,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 );
 	}
 }
 
@@ -1121,7 +1239,7 @@ void cliFunc_layerState( char* args )
 			printHex( arg2 );
 
 			// Set the layer state
-			LayerIndex[ arg1 ].state = arg2;
+			LayerState[ arg1 ] = arg2;
 			break;
 		}
 	}
@@ -1155,7 +1273,7 @@ void cliFunc_macroList( char* args )
 	info_msg("Pending Trigger Macros: ");
 	printInt16( (uint16_t)macroTriggerMacroPendingListSize );
 	print(" : ");
-	for ( unsigned int macro = 0; macro < macroTriggerMacroPendingListSize; macro++ )
+	for ( var_uint_t macro = 0; macro < macroTriggerMacroPendingListSize; macro++ )
 	{
 		printHex( macroTriggerMacroPendingList[ macro ] );
 		print(" ");
@@ -1166,7 +1284,7 @@ void cliFunc_macroList( char* args )
 	info_msg("Pending Result Macros: ");
 	printInt16( (uint16_t)macroResultMacroPendingListSize );
 	print(" : ");
-	for ( unsigned int macro = 0; macro < macroResultMacroPendingListSize; macro++ )
+	for ( var_uint_t macro = 0; macro < macroResultMacroPendingListSize; macro++ )
 	{
 		printHex( macroResultMacroPendingList[ macro ] );
 		print(" ");
@@ -1185,7 +1303,7 @@ void cliFunc_macroList( char* args )
 	// Show Trigger to Result Macro Links
 	print( NL );
 	info_msg("Trigger : Result Macro Pairs");
-	for ( unsigned int macro = 0; macro < TriggerMacroNum; macro++ )
+	for ( var_uint_t macro = 0; macro < TriggerMacroNum; macro++ )
 	{
 		print( NL );
 		print("\tT");
@@ -1205,14 +1323,15 @@ void cliFunc_macroProc( char* args )
 	printInt8( macroPauseMode );
 }
 
-void macroDebugShowTrigger( unsigned int index )
+void macroDebugShowTrigger( var_uint_t index )
 {
 	// Only proceed if the macro exists
 	if ( index >= TriggerMacroNum )
 		return;
 
 	// Trigger Macro Show
-	TriggerMacro *macro = &TriggerMacroList[ index ];
+	const TriggerMacro *macro = &TriggerMacroList[ index ];
+	TriggerMacroRecord *record = &TriggerMacroRecordList[ index ];
 
 	print( NL );
 	info_msg("Trigger Macro Index: ");
@@ -1220,14 +1339,14 @@ void macroDebugShowTrigger( unsigned int index )
 	print( NL );
 
 	// Read the comboLength for combo in the sequence (sequence of combos)
-	unsigned int pos = 0;
+	var_uint_t pos = 0;
 	uint8_t comboLength = macro->guide[ pos ];
 
 	// Iterate through and interpret the guide
 	while ( comboLength != 0 )
 	{
 		// Initial position of the combo
-		unsigned int comboPos = ++pos;
+		var_uint_t comboPos = ++pos;
 
 		// Iterate through the combo
 		while ( pos < comboLength * TriggerGuideSize + comboPos )
@@ -1260,7 +1379,7 @@ void macroDebugShowTrigger( unsigned int index )
 
 	// Display current position
 	print( NL "Position: " );
-	printInt16( (uint16_t)macro->pos ); // Hopefully large enough :P (can't assume 32-bit)
+	printInt16( (uint16_t)record->pos ); // Hopefully large enough :P (can't assume 32-bit)
 
 	// Display result macro index
 	print( NL "Result Macro Index: " );
@@ -1268,7 +1387,7 @@ void macroDebugShowTrigger( unsigned int index )
 
 	// Display trigger macro state
 	print( NL "Trigger Macro State: " );
-	switch ( macro->state )
+	switch ( record->state )
 	{
 	case TriggerMacro_Press:   print("Press");   break;
 	case TriggerMacro_Release: print("Release"); break;
@@ -1276,14 +1395,15 @@ void macroDebugShowTrigger( unsigned int index )
 	}
 }
 
-void macroDebugShowResult( unsigned int index )
+void macroDebugShowResult( var_uint_t index )
 {
 	// Only proceed if the macro exists
 	if ( index >= ResultMacroNum )
 		return;
 
 	// Trigger Macro Show
-	ResultMacro *macro = &ResultMacroList[ index ];
+	const ResultMacro *macro = &ResultMacroList[ index ];
+	ResultMacroRecord *record = &ResultMacroRecordList[ index ];
 
 	print( NL );
 	info_msg("Result Macro Index: ");
@@ -1291,14 +1411,14 @@ void macroDebugShowResult( unsigned int index )
 	print( NL );
 
 	// Read the comboLength for combo in the sequence (sequence of combos)
-	unsigned int pos = 0;
+	var_uint_t pos = 0;
 	uint8_t comboLength = macro->guide[ pos++ ];
 
 	// Iterate through and interpret the guide
 	while ( comboLength != 0 )
 	{
 		// Function Counter, used to keep track of the combos processed
-		unsigned int funcCount = 0;
+		var_uint_t funcCount = 0;
 
 		// Iterate through the combo
 		while ( funcCount < comboLength )
@@ -1311,7 +1431,7 @@ void macroDebugShowResult( unsigned int index )
 			print("|");
 
 			// Display Function Ptr Address
-			printHex( (unsigned int)CapabilitiesList[ guide->index ].func );
+			printHex( (nat_ptr_t)CapabilitiesList[ guide->index ].func );
 			print("|");
 
 			// Display/Lookup Capability Name (utilize debug mode of capability)
@@ -1320,7 +1440,7 @@ void macroDebugShowResult( unsigned int index )
 
 			// Display Argument(s)
 			print("(");
-			for ( unsigned int arg = 0; arg < CapabilitiesList[ guide->index ].argCount; arg++ )
+			for ( var_uint_t arg = 0; arg < CapabilitiesList[ guide->index ].argCount; arg++ )
 			{
 				// Arguments are only 8 bit values
 				printHex( (&guide->args)[ arg ] );
@@ -1352,13 +1472,13 @@ void macroDebugShowResult( unsigned int index )
 
 	// Display current position
 	print( NL "Position: " );
-	printInt16( (uint16_t)macro->pos ); // Hopefully large enough :P (can't assume 32-bit)
+	printInt16( (uint16_t)record->pos ); // Hopefully large enough :P (can't assume 32-bit)
 
 	// Display final trigger state/type
 	print( NL "Final Trigger State (State/Type): " );
-	printHex( macro->state );
+	printHex( record->state );
 	print("/");
-	printHex( macro->stateType );
+	printHex( record->stateType );
 }
 
 void cliFunc_macroShow( char* args )
@@ -1402,7 +1522,7 @@ void cliFunc_macroStep( char* args )
 	CLI_argumentIsolation( args, &arg1Ptr, &arg2Ptr );
 
 	// Default to 1, if no argument given
-	unsigned int count = (unsigned int)numToInt( arg1Ptr );
+	var_uint_t count = (var_uint_t)numToInt( arg1Ptr );
 
 	if ( count == 0 )
 		count = 1;