X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=kll_lib%2Fcontainers.py;h=66aa2f26469492066709293e69108ec41d12bb05;hb=cf5bba703932f11bb686d9968d0c4bb9eab2a32c;hp=d54ff1029e8d7e3a5b5c8a244ba59c93056c0d44;hpb=bbf2c3ffaf4d579a5865c36c986720202d11f04a;p=kiibohd-kll.git diff --git a/kll_lib/containers.py b/kll_lib/containers.py index d54ff10..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 @@ -31,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 ): @@ -85,6 +148,9 @@ class Macros: # Default layer (0) self.layer = 0 + # Unique ScanCode Hash Id Lookup + self.scanCodeStore = ScanCodeStore() + # Macro Storage self.macros = [ dict() ] @@ -99,6 +165,8 @@ class Macros: self.triggersIndexSorted = [] self.triggerList = [] self.maxScanCode = [] + self.firstScanCode = [] + self.interconnectOffset = [] # USBCode Assignment Cache self.assignmentCache = [] @@ -143,7 +211,8 @@ class Macros: self.macros[ self.layer ][ trigger ] = [ result ] # Mark layer scan code, so it won't be removed later - if not self.baseLayout is None: + # 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 @@ -155,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 @@ -185,6 +264,7 @@ class Macros: def generate( self ): self.generateIndices() self.sortIndexLists() + self.generateOffsetTable() self.generateTriggerLists() # Generates Index of Results and Triggers @@ -215,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 ) ): @@ -234,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 ]: @@ -252,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 +