X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=kll_lib%2Fcontainers.py;h=66aa2f26469492066709293e69108ec41d12bb05;hb=cf5bba703932f11bb686d9968d0c4bb9eab2a32c;hp=a6c205ad96a6997b549fbc0e67b89a2734e009a2;hpb=e8d498a0d6a9e6ca00920383e0eaeef4262f31f0;p=kiibohd-kll.git diff --git a/kll_lib/containers.py b/kll_lib/containers.py index a6c205a..66aa2f2 100644 --- a/kll_lib/containers.py +++ b/kll_lib/containers.py @@ -1,7 +1,7 @@ #!/usr/bin/env python3 # KLL Compiler Containers # -# Copyright (C) 2014 by Jacob Alexander +# Copyright (C) 2014-2015 by Jacob Alexander # # This file is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -18,6 +18,8 @@ ### Imports ### +import copy + ### Decorators ### @@ -29,7 +31,70 @@ ERROR = '\033[5;1;31mERROR\033[0m:' ### Parsing ### + ## Containers + +class ScanCode: + # Container for ScanCodes + # + # scancode - Non-interconnect adjusted scan code + # interconnect_id - Unique id for the interconnect node + def __init__( self, scancode, interconnect_id ): + self.scancode = scancode + self.interconnect_id = interconnect_id + + def __eq__( self, other ): + return self.dict() == other.dict() + + def __repr__( self ): + return repr( self.dict() ) + + def dict( self ): + return { + 'ScanCode' : self.scancode, + 'Id' : self.interconnect_id, + } + + # Calculate the actual scancode using the offset list + def offset( self, offsetList ): + if self.interconnect_id > 0: + return self.scancode + offsetList[ self.interconnect_id - 1 ] + else: + return self.scancode + + +class ScanCodeStore: + # Unique lookup for ScanCodes + def __init__( self ): + self.scancodes = [] + + def __getitem__( self, name ): + # First check if this is a ScanCode object + if isinstance( name, ScanCode ): + # Do a reverse lookup + for idx, scancode in enumerate( self.scancodes ): + if scancode == name: + return idx + + # Could not find scancode + return None + + # Return scancode using unique id + return self.scancodes[ name ] + + # Attempt add ScanCode to list, return unique id + def append( self, new_scancode ): + # Iterate through list to make sure this is a unique ScanCode + for idx, scancode in enumerate( self.scancodes ): + if new_scancode == scancode: + return idx + + # Unique entry, add to the list + self.scancodes.append( new_scancode ) + + return len( self.scancodes ) - 1 + + class Capabilities: # Container for capabilities dictionary and convenience functions def __init__( self ): @@ -83,9 +148,16 @@ class Macros: # Default layer (0) self.layer = 0 + # Unique ScanCode Hash Id Lookup + self.scanCodeStore = ScanCodeStore() + # Macro Storage self.macros = [ dict() ] + # Base Layout Storage + self.baseLayout = None + self.layerLayoutMarkers = [] + # Correlated Macro Data self.resultsIndex = dict() self.triggersIndex = dict() @@ -93,6 +165,8 @@ class Macros: self.triggersIndexSorted = [] self.triggerList = [] self.maxScanCode = [] + self.firstScanCode = [] + self.interconnectOffset = [] # USBCode Assignment Cache self.assignmentCache = [] @@ -100,10 +174,23 @@ class Macros: def __repr__( self ): return "{0}".format( self.macros ) + def completeBaseLayout( self ): + # Copy base layout for later use when creating partial layers and add marker + self.baseLayout = copy.deepcopy( self.macros[ 0 ] ) + self.layerLayoutMarkers.append( copy.deepcopy( self.baseLayout ) ) # Not used for default layer, just simplifies coding + + def removeUnmarked( self ): + # Remove all of the unmarked mappings from the partial layer + for trigger in self.layerLayoutMarkers[ self.layer ].keys(): + del self.macros[ self.layer ][ trigger ] + def addLayer( self ): # Increment layer count, and append another macros dictionary self.layer += 1 - self.macros.append( dict() ) + self.macros.append( copy.deepcopy( self.baseLayout ) ) + + # Add a layout marker for each layer + self.layerLayoutMarkers.append( copy.deepcopy( self.baseLayout ) ) # Use for ScanCode trigger macros def appendScanCode( self, trigger, result ): @@ -123,6 +210,11 @@ class Macros: def replaceScanCode( self, trigger, result ): self.macros[ self.layer ][ trigger ] = [ result ] + # Mark layer scan code, so it won't be removed later + # Also check to see if it hasn't already been removed before + if not self.baseLayout is None and trigger in self.layerLayoutMarkers[ self.layer ]: + del self.layerLayoutMarkers[ self.layer ][ trigger ] + # Return a list of ScanCode triggers with the given USB Code trigger def lookupUSBCodes( self, usbCode ): scanCodeList = [] @@ -132,6 +224,16 @@ class Macros: if usbCode in self.macros[ self.layer ][ macro ]: scanCodeList.append( macro ) + if len(scanCodeList) == 0: + if len(usbCode) > 1 or len(usbCode[0]) > 1: + for combo in usbCode: + comboCodes = list() + for key in combo: + scanCode = self.lookupUSBCodes(((key,),)) + comboCodes.append(scanCode[0][0][0]) + scanCodeList.append(tuple(code for code in comboCodes)) + scanCodeList = [tuple(scanCodeList)] + return scanCodeList # Cache USBCode Assignment @@ -162,6 +264,7 @@ class Macros: def generate( self ): self.generateIndices() self.sortIndexLists() + self.generateOffsetTable() self.generateTriggerLists() # Generates Index of Results and Triggers @@ -192,6 +295,34 @@ class Macros: for trigger in self.triggersIndex.keys(): self.triggersIndexSorted[ self.triggersIndex[ trigger ] ] = trigger + # Generates list of offsets for each of the interconnect ids + def generateOffsetTable( self ): + idMaxScanCode = [ 0 ] + + # Iterate over each layer to get list of max scancodes associated with each interconnect id + for layer in range( 0, len( self.macros ) ): + # Iterate through each trigger/sequence in the layer + for sequence in self.macros[ layer ].keys(): + # Iterate over the trigger to locate the ScanCodes + for combo in sequence: + # Iterate over each scancode id in the combo + for scancode_id in combo: + # Lookup ScanCode + scancode_obj = self.scanCodeStore[ scancode_id ] + + # Extend list if not large enough + if scancode_obj.interconnect_id >= len( idMaxScanCode ): + idMaxScanCode.extend( [ 0 ] * ( scancode_obj.interconnect_id - len( idMaxScanCode ) + 1 ) ) + + # Determine if the max seen id for this interconnect id + if scancode_obj.scancode > idMaxScanCode[ scancode_obj.interconnect_id ]: + idMaxScanCode[ scancode_obj.interconnect_id ] = scancode_obj.scancode + + # Generate interconnect offsets + self.interconnectOffset = [ idMaxScanCode[0] + 1 ] + for index in range( 1, len( idMaxScanCode ) ): + self.interconnectOffset.append( self.interconnectOffset[ index - 1 ] + idMaxScanCode[ index ] ) + # Generates Trigger Lists per layer using index lists def generateTriggerLists( self ): for layer in range( 0, len( self.macros ) ): @@ -211,7 +342,8 @@ class Macros: # Iterate over the trigger to locate the ScanCodes for sequence in trigger: - for combo in sequence: + for combo_id in sequence: + combo = self.scanCodeStore[ combo_id ].offset( self.interconnectOffset ) # Append triggerIndex for each found scanCode of the Trigger List # Do not re-add if triggerIndex is already in the Trigger List if not triggerIndex in self.triggerList[ layer ][ combo ]: @@ -229,9 +361,90 @@ class Macros: # Shrink triggerList to actual max size self.triggerList[ layer ] = self.triggerList[ layer ][ : self.maxScanCode[ layer ] + 1 ] + # Calculate first scan code for layer, useful for uC implementations trying to save RAM + firstScanCode = 0 + for triggerList in range( 0, len( self.triggerList[ layer ] ) ): + firstScanCode = triggerList + + # Break if triggerList has items + if len( self.triggerList[ layer ][ triggerList ] ) > 0: + break; + self.firstScanCode.append( firstScanCode ) + # Determine overall maxScanCode self.overallMaxScanCode = 0x00 for maxVal in self.maxScanCode: if maxVal > self.overallMaxScanCode: self.overallMaxScanCode = maxVal + +class Variables: + # Container for variables + # Stores three sets of variables, the overall combined set, per layer, and per file + def __init__( self ): + # Dictionaries of variables + self.baseLayout = dict() + self.fileVariables = dict() + self.layerVariables = [ dict() ] + self.overallVariables = dict() + self.defines = dict() + + self.currentFile = "" + self.currentLayer = 0 + self.baseLayoutEnabled = True + + def baseLayoutFinished( self ): + self.baseLayoutEnabled = False + + def setCurrentFile( self, name ): + # Store using filename and current layer + self.currentFile = name + self.fileVariables[ name ] = dict() + + # If still processing BaseLayout + if self.baseLayoutEnabled: + if '*LayerFiles' in self.baseLayout.keys(): + self.baseLayout['*LayerFiles'] += [ name ] + else: + self.baseLayout['*LayerFiles'] = [ name ] + # Set for the current layer + else: + if '*LayerFiles' in self.layerVariables[ self.currentLayer ].keys(): + self.layerVariables[ self.currentLayer ]['*LayerFiles'] += [ name ] + else: + self.layerVariables[ self.currentLayer ]['*LayerFiles'] = [ name ] + + def incrementLayer( self ): + # Store using layer index + self.currentLayer += 1 + self.layerVariables.append( dict() ) + + def assignVariable( self, key, value ): + # Overall set of variables + self.overallVariables[ key ] = value + + # The Name variable is a special accumulation case + if key == 'Name': + # BaseLayout still being processed + if self.baseLayoutEnabled: + if '*NameStack' in self.baseLayout.keys(): + self.baseLayout['*NameStack'] += [ value ] + else: + self.baseLayout['*NameStack'] = [ value ] + # Layers + else: + if '*NameStack' in self.layerVariables[ self.currentLayer ].keys(): + self.layerVariables[ self.currentLayer ]['*NameStack'] += [ value ] + else: + self.layerVariables[ self.currentLayer ]['*NameStack'] = [ value ] + + # If still processing BaseLayout + if self.baseLayoutEnabled: + self.baseLayout[ key ] = value + # Set for the current layer + else: + self.layerVariables[ self.currentLayer ][ key ] = value + + # File context variables + self.fileVariables[ self.currentFile ][ key ] = value +