a008e03b22
- Enables support for running both kll 0.3d and 0.5c at the same time - Adds output support for generatedPixelmap.c - Adds a --version to 0.3d
616 lines
17 KiB
Python
616 lines
17 KiB
Python
#!/usr/bin/env python3
|
|
'''
|
|
KLL Data Organization
|
|
'''
|
|
|
|
# Copyright (C) 2016 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
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This file is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this file. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
### Imports ###
|
|
|
|
import copy
|
|
import re
|
|
|
|
|
|
|
|
### Decorators ###
|
|
|
|
## Print Decorator Variables
|
|
ERROR = '\033[5;1;31mERROR\033[0m:'
|
|
WARNING = '\033[5;1;33mWARNING\033[0m:'
|
|
|
|
ansi_escape = re.compile(r'\x1b[^m]*m')
|
|
|
|
|
|
|
|
### Classes ###
|
|
|
|
class Data:
|
|
'''
|
|
Base class for KLL datastructures
|
|
'''
|
|
# Debug output formatters
|
|
debug_output = {
|
|
'add' : "\t\033[1;42;37m++\033[0m\033[1mADD KEY\033[1;42;37m++\033[0m \033[1m<==\033[0m {0}",
|
|
'app' : "\t\033[1;45;37m**\033[0m\033[1mAPP KEY\033[1;45;37m**\033[0m \033[1m<==\033[0m {0}",
|
|
'mod' : "\t\033[1;44;37m##\033[0m\033[1mMOD KEY\033[1;44;37m##\033[0m \033[1m<==\033[0m {0}",
|
|
'rem' : "\t\033[1;41;37m--\033[0m\033[1mREM KEY\033[1;41;37m--\033[0m \033[1m<==\033[0m {0}",
|
|
'drp' : "\t\033[1;43;37m@@\033[0m\033[1mDRP KEY\033[1;43;37m@@\033[0m \033[1m<==\033[0m {0}",
|
|
'dup' : "\t\033[1;46;37m!!\033[0m\033[1mDUP KEY\033[1;46;37m!!\033[0m \033[1m<==\033[0m {0}",
|
|
}
|
|
|
|
def __init__( self, parent ):
|
|
'''
|
|
Initialize datastructure
|
|
|
|
@param parent: Parent organization, used to query data from other datastructures
|
|
'''
|
|
self.data = {}
|
|
self.parent = parent
|
|
|
|
def add_expression( self, expression, debug ):
|
|
'''
|
|
Add expression to data structure
|
|
|
|
May have multiple keys to add for a given expression
|
|
|
|
@param expression: KLL Expression (fully tokenized and parsed)
|
|
@param debug: Enable debug output
|
|
'''
|
|
# Lookup unique keys for expression
|
|
keys = expression.unique_keys()
|
|
|
|
# Add/Modify expressions in datastructure
|
|
for key, uniq_expr in keys:
|
|
# Check which operation we are trying to do, add or modify
|
|
if debug[0]:
|
|
if key in self.data.keys():
|
|
output = self.debug_output['mod'].format( key )
|
|
else:
|
|
output = self.debug_output['add'].format( key )
|
|
print( debug[1] and output or ansi_escape.sub( '', output ) )
|
|
|
|
self.data[ key ] = uniq_expr
|
|
|
|
def merge( self, merge_in, debug ):
|
|
'''
|
|
Merge in the given datastructure to this datastructure
|
|
|
|
This datastructure serves as the base.
|
|
|
|
@param merge_in: Data structure from another organization to merge into this one
|
|
@param debug: Enable debug out
|
|
'''
|
|
# The default case is just to add the expression in directly
|
|
for key, kll_expression in merge_in.data.items():
|
|
# Display key:expression being merged in
|
|
if debug[0]:
|
|
output = merge_in.elem_str( key, True )
|
|
print( debug[1] and output or ansi_escape.sub( '', output ), end="" )
|
|
|
|
self.add_expression( kll_expression, debug )
|
|
|
|
def reduction( self ):
|
|
'''
|
|
Simplifies datastructure
|
|
|
|
Most of the datastructures don't have a reduction. Just do nothing in this case.
|
|
'''
|
|
pass
|
|
|
|
def elem_str( self, key, single=False ):
|
|
'''
|
|
Debug output for a single element
|
|
|
|
@param key: Index to datastructure
|
|
@param single: Setting to True will bold the key
|
|
'''
|
|
if single:
|
|
return "\033[1;33m{0: <20}\033[0m \033[1;36;41m>\033[0m {1}\n".format( key, self.data[ key ] )
|
|
else:
|
|
return "{0: <20} \033[1;36;41m>\033[0m {1}\n".format( key, self.data[ key ] )
|
|
|
|
def __repr__( self ):
|
|
output = ""
|
|
|
|
# Display sorted list of keys, along with the internal value
|
|
for key in sorted( self.data ):
|
|
output += self.elem_str( key )
|
|
|
|
return output
|
|
|
|
|
|
class MappingData( Data ):
|
|
'''
|
|
KLL datastructure for data mapping
|
|
|
|
ScanCode trigger -> result
|
|
USBCode trigger -> result
|
|
Animation trigger -> result
|
|
'''
|
|
def add_expression( self, expression, debug ):
|
|
'''
|
|
Add expression to data structure
|
|
|
|
May have multiple keys to add for a given expression
|
|
|
|
Map expressions insert into the datastructure according to their operator.
|
|
|
|
+Operators+
|
|
: Add/Modify
|
|
:+ Append
|
|
:- Remove
|
|
:: Lazy Add/Modify
|
|
|
|
i: Add/Modify
|
|
i:+ Append
|
|
i:- Remove
|
|
i:: Lazy Add/Modify
|
|
|
|
The i or isolation operators are stored separately from the main ones.
|
|
Each key is pre-pended with an i
|
|
|
|
The :: or lazy operators act just like : operators, except that they will be ignore if the evaluation
|
|
merge cannot resolve a ScanCode.
|
|
|
|
@param expression: KLL Expression (fully tokenized and parsed)
|
|
@param debug: Enable debug output
|
|
'''
|
|
# Lookup unique keys for expression
|
|
keys = expression.unique_keys()
|
|
|
|
# Add/Modify expressions in datastructure
|
|
for key, uniq_expr in keys:
|
|
# Determine which the expression operator
|
|
operator = expression.operator
|
|
|
|
# Except for the : operator, all others have delayed action
|
|
# Meaning, they change behaviour depending on how Contexts are merged
|
|
# This means we can't simplify yet
|
|
# In addition, :+ and :- are stackable, which means each key has a list of expressions
|
|
# We append the operator to differentiate between the different types of delayed operations
|
|
key = "{0}{1}".format( operator, key )
|
|
|
|
# Determine if key exists already
|
|
exists = key in self.data.keys()
|
|
|
|
# Add/Modify
|
|
if operator in [':', '::', 'i:', 'i::']:
|
|
debug_tag = exists and 'mod' or 'add'
|
|
|
|
# Append/Remove
|
|
else:
|
|
# Check to make sure we haven't already appended expression
|
|
# Use the string representation to do the comparison (general purpose)
|
|
if exists and "{0}".format( uniq_expr ) in [ "{0}".format( elem ) for elem in self.data[ key ] ]:
|
|
debug_tag = 'dup'
|
|
|
|
# Append
|
|
elif operator in [':+', 'i:+']:
|
|
debug_tag = 'app'
|
|
|
|
# Remove
|
|
else:
|
|
debug_tag = 'rem'
|
|
|
|
# Debug output
|
|
if debug[0]:
|
|
output = self.debug_output[ debug_tag ].format( key )
|
|
print( debug[1] and output or ansi_escape.sub( '', output ) )
|
|
|
|
# Don't append if a duplicate
|
|
if debug_tag == 'dup':
|
|
continue
|
|
|
|
# Append, rather than replace
|
|
if operator in [':+', ':-', 'i:+', 'i:-']:
|
|
if exists:
|
|
self.data[ key ].append( uniq_expr )
|
|
|
|
# Create initial list
|
|
else:
|
|
self.data[ key ] = [ uniq_expr ]
|
|
else:
|
|
self.data[ key ] = [ uniq_expr ]
|
|
|
|
def set_interconnect_id( self, interconnect_id, triggers ):
|
|
'''
|
|
Traverses the sequence of combo of identifiers to set the interconnect_id
|
|
'''
|
|
for sequence in triggers:
|
|
for combo in sequence:
|
|
for identifier in combo:
|
|
identifier.interconnect_id = interconnect_id
|
|
|
|
def merge( self, merge_in, debug ):
|
|
'''
|
|
Merge in the given datastructure to this datastructure
|
|
|
|
This datastructure serves as the base.
|
|
|
|
Map expressions merge differently than insertions.
|
|
|
|
+Operators+
|
|
: Add/Modify - Replace
|
|
:+ Append - Add
|
|
:- Remove - Remove
|
|
:: Lazy Add/Modify - Replace if found, otherwise drop
|
|
|
|
i: Add/Modify - Replace
|
|
i:+ Append - Add
|
|
i:- Remove - Remove
|
|
i:: Lazy Add/Modify - Replace if found, otherwise drop
|
|
|
|
@param merge_in: Data structure from another organization to merge into this one
|
|
@param debug: Enable debug out
|
|
'''
|
|
# Check what the current interconnectId is
|
|
# If not set, we set to 0 (default)
|
|
# We use this to calculate the scancode during the DataAnalysisStage
|
|
interconnect_id = 0
|
|
if 'interconnectId' in self.parent.variable_data.data.keys():
|
|
interconnect_id = self.parent.variable_data.data['interconnectId']
|
|
|
|
# Sort different types of keys
|
|
cur_keys = merge_in.data.keys()
|
|
|
|
# Lazy Set ::
|
|
lazy_keys = [ key for key in cur_keys if key[0:2] == '::' or key[0:3] == 'i::' ]
|
|
cur_keys = list( set( cur_keys ) - set( lazy_keys ) )
|
|
|
|
# Append :+
|
|
append_keys = [ key for key in cur_keys if key[0:2] == ':+' or key[0:3] == 'i:+' ]
|
|
cur_keys = list( set( cur_keys ) - set( append_keys ) )
|
|
|
|
# Remove :-
|
|
remove_keys = [ key for key in cur_keys if key[0:2] == ':-' or key[0:3] == 'i:-' ]
|
|
cur_keys = list( set( cur_keys ) - set( remove_keys ) )
|
|
|
|
# Set :
|
|
# Everything left is just a set
|
|
set_keys = cur_keys
|
|
|
|
|
|
# First process the :: (or lazy) operators
|
|
# We need to read into this datastructure and apply those first
|
|
# Otherwise we may get undesired behaviour
|
|
for key in lazy_keys:
|
|
# Display key:expression being merged in
|
|
if debug[0]:
|
|
output = merge_in.elem_str( key, True )
|
|
print( debug[1] and output or ansi_escape.sub( '', output ), end="" )
|
|
|
|
# Construct target key
|
|
target_key = key[0] == 'i' and "i{0}".format( key[2:] ) or key[1:]
|
|
|
|
# If target key exists, replace
|
|
if target_key in self.data.keys():
|
|
debug_tag = 'mod'
|
|
else:
|
|
debug_tag = 'drp'
|
|
|
|
# Debug output
|
|
if debug[0]:
|
|
output = self.debug_output[ debug_tag ].format( key )
|
|
print( debug[1] and output or ansi_escape.sub( '', output ) )
|
|
|
|
# Only replace
|
|
if debug_tag == 'mod':
|
|
self.data[ target_key ] = merge_in.data[ key ]
|
|
|
|
# Then apply : assignment operators
|
|
for key in set_keys:
|
|
# Display key:expression being merged in
|
|
if debug[0]:
|
|
output = merge_in.elem_str( key, True )
|
|
print( debug[1] and output or ansi_escape.sub( '', output ), end="" )
|
|
|
|
# Construct target key
|
|
target_key = key
|
|
|
|
# Indicate if add or modify
|
|
if target_key in self.data.keys():
|
|
debug_tag = 'mod'
|
|
else:
|
|
debug_tag = 'add'
|
|
|
|
# Debug output
|
|
if debug[0]:
|
|
output = self.debug_output[ debug_tag ].format( key )
|
|
print( debug[1] and output or ansi_escape.sub( '', output ) )
|
|
|
|
# Set into new datastructure regardless
|
|
self.data[ target_key ] = merge_in.data[ key ]
|
|
|
|
# Only the : is used to set ScanCodes
|
|
# We need to set the interconnect_id just in case the base context has it set
|
|
# and in turn influence the new context as well
|
|
# This must be done during the merge
|
|
for elem in self.data[ target_key ]:
|
|
if elem.type == 'ScanCode':
|
|
self.set_interconnect_id( interconnect_id, elem.triggers )
|
|
|
|
# Now apply append operations
|
|
for key in append_keys:
|
|
# Display key:expression being merged in
|
|
if debug[0]:
|
|
output = merge_in.elem_str( key, True )
|
|
print( debug[1] and output or ansi_escape.sub( '', output ), end="" )
|
|
|
|
# Construct target key
|
|
target_key = key[0] == 'i' and "i:{0}".format( key[3:] ) or ":{0}".format( key[2:] )
|
|
|
|
# Alwyays appending
|
|
debug_tag = 'app'
|
|
|
|
# Debug output
|
|
if debug[0]:
|
|
output = self.debug_output[ debug_tag ].format( key )
|
|
print( debug[1] and output or ansi_escape.sub( '', output ) )
|
|
|
|
# Extend list if it exists
|
|
if target_key in self.data.keys():
|
|
self.data[ target_key ].extend( merge_in.data[ key ] )
|
|
else:
|
|
self.data[ target_key ] = merge_in.data[ key ]
|
|
|
|
# Finally apply removal operations to this datastructure
|
|
# If the target removal doesn't exist, ignore silently (show debug message)
|
|
for key in remove_keys:
|
|
# Display key:expression being merged in
|
|
if debug[0]:
|
|
output = merge_in.elem_str( key, True )
|
|
print( debug[1] and output or ansi_escape.sub( '', output ), end="" )
|
|
|
|
# Construct target key
|
|
target_key = key[0] == 'i' and "i:{0}".format( key[3:] ) or ":{0}".format( key[2:] )
|
|
|
|
# Drop right away if target datastructure doesn't have target key
|
|
if target_key not in self.data.keys():
|
|
debug_tag = 'drp'
|
|
|
|
# Debug output
|
|
if debug[0]:
|
|
output = self.debug_output[ debug_tag ].format( key )
|
|
print( debug[1] and output or ansi_escape.sub( '', output ) )
|
|
|
|
continue
|
|
|
|
# Compare expressions to be removed with the current set
|
|
# Use strings to compare
|
|
remove_expressions = [ "{0}".format( expr ) for expr in merge_in.data[ key ] ]
|
|
current_expressions = [ ( "{0}".format( expr ), expr ) for expr in self.data[ target_key ] ]
|
|
for string, expr in current_expressions:
|
|
debug_tag = 'drp'
|
|
|
|
# Check if an expression matches
|
|
if string in remove_expressions:
|
|
debug_tag = 'rem'
|
|
|
|
# Debug output
|
|
if debug[0]:
|
|
output = self.debug_output[ debug_tag ].format( key )
|
|
print( debug[1] and output or ansi_escape.sub( '', output ) )
|
|
|
|
# Remove if found
|
|
if debug_tag == 'rem':
|
|
self.data[ target_key ] = [ value for value in self.data.values() if value != expr ]
|
|
|
|
def reduction( self ):
|
|
'''
|
|
Simplifies datastructure
|
|
|
|
Used to replace all trigger HIDCode(USBCode)s with ScanCodes
|
|
|
|
NOTE: Make sure to create a new MergeContext before calling this as you lose data and prior context
|
|
'''
|
|
scan_code_lookup = {}
|
|
|
|
# Build dictionary of single ScanCodes first
|
|
for key, expr in self.data.items():
|
|
if expr[0].elems()[0] == 1 and expr[0].triggers[0][0][0].type == 'ScanCode':
|
|
scan_code_lookup[ key ] = expr
|
|
|
|
# Using this dictionary, replace all the trigger USB codes
|
|
new_data = copy.copy( scan_code_lookup )
|
|
|
|
# 1) Single USB Codes trigger results will replace the original ScanCode result
|
|
# 2)
|
|
|
|
#TODO
|
|
#print("YAY")
|
|
#print( scan_code_lookup )
|
|
|
|
|
|
class AnimationData( Data ):
|
|
'''
|
|
KLL datastructure for Animation configuration
|
|
|
|
Animation -> modifiers
|
|
'''
|
|
|
|
|
|
class AnimationFrameData( Data ):
|
|
'''
|
|
KLL datastructure for Animation Frame configuration
|
|
|
|
Animation -> Pixel Settings
|
|
'''
|
|
|
|
|
|
class CapabilityData( Data ):
|
|
'''
|
|
KLL datastructure for Capability mapping
|
|
|
|
Capability -> C Function/Identifier
|
|
'''
|
|
|
|
|
|
class DefineData( Data ):
|
|
'''
|
|
KLL datastructure for Define mapping
|
|
|
|
Variable -> C Define/Identifier
|
|
'''
|
|
|
|
|
|
class PixelChannelData( Data ):
|
|
'''
|
|
KLL datastructure for Pixel Channel mapping
|
|
|
|
Pixel -> Channels
|
|
'''
|
|
|
|
|
|
class PixelPositionData( Data ):
|
|
'''
|
|
KLL datastructure for Pixel Position mapping
|
|
|
|
Pixel -> Physical Location
|
|
'''
|
|
|
|
|
|
class ScanCodePositionData( Data ):
|
|
'''
|
|
KLL datastructure for ScanCode Position mapping
|
|
|
|
ScanCode -> Physical Location
|
|
'''
|
|
|
|
|
|
class VariableData( Data ):
|
|
'''
|
|
KLL datastructure for Variables and Arrays
|
|
|
|
Variable -> Data
|
|
Array -> Data
|
|
'''
|
|
|
|
|
|
class Organization:
|
|
'''
|
|
Container class for KLL datastructures
|
|
|
|
The purpose of these datastructures is to symbolically store at first, and slowly solve/deduplicate expressions.
|
|
Since the order in which the merges occurs matters, this involves a number of intermediate steps.
|
|
'''
|
|
|
|
def __init__( self ):
|
|
'''
|
|
Intialize data structure
|
|
'''
|
|
# Setup each of the internal sub-datastructures
|
|
self.animation_data = AnimationData( self )
|
|
self.animation_frame_data = AnimationFrameData( self )
|
|
self.capability_data = CapabilityData( self )
|
|
self.define_data = DefineData( self )
|
|
self.mapping_data = MappingData( self )
|
|
self.pixel_channel_data = PixelChannelData( self )
|
|
self.pixel_position_data = PixelPositionData( self )
|
|
self.scan_code_position_data = ScanCodePositionData( self )
|
|
self.variable_data = VariableData( self )
|
|
|
|
# Expression to Datastructure mapping
|
|
self.data_mapping = {
|
|
'AssignmentExpression' : {
|
|
'Array' : self.variable_data,
|
|
'Variable' : self.variable_data,
|
|
},
|
|
'DataAssociationExpression' : {
|
|
'Animation' : self.animation_data,
|
|
'AnimationFrame' : self.animation_frame_data,
|
|
'PixelPosition' : self.pixel_position_data,
|
|
'ScanCodePosition' : self.scan_code_position_data,
|
|
},
|
|
'MapExpression' : {
|
|
'ScanCode' : self.mapping_data,
|
|
'USBCode' : self.mapping_data,
|
|
'Animation' : self.mapping_data,
|
|
'PixelChannel' : self.pixel_channel_data,
|
|
},
|
|
'NameAssociationExpression' : {
|
|
'Capability' : self.capability_data,
|
|
'Define' : self.define_data,
|
|
},
|
|
}
|
|
|
|
def stores( self ):
|
|
'''
|
|
Returns list of sub-datastructures
|
|
'''
|
|
return [
|
|
self.animation_data,
|
|
self.animation_frame_data,
|
|
self.capability_data,
|
|
self.define_data,
|
|
self.mapping_data,
|
|
self.pixel_channel_data,
|
|
self.pixel_position_data,
|
|
self.scan_code_position_data,
|
|
self.variable_data,
|
|
]
|
|
|
|
def add_expression( self, expression, debug ):
|
|
'''
|
|
Add expression to datastructure
|
|
|
|
Will automatically determine which type of expression and place in the relevant store
|
|
|
|
@param expression: KLL Expression (fully tokenized and parsed)
|
|
@param debug: Enable debug output
|
|
'''
|
|
# Determine type of of Expression
|
|
expression_type = expression.__class__.__name__
|
|
|
|
# Determine Expression Subtype
|
|
expression_subtype = expression.type
|
|
|
|
# Locate datastructure
|
|
data = self.data_mapping[ expression_type ][ expression_subtype ]
|
|
|
|
# Debug output
|
|
if debug[0]:
|
|
output = "\t\033[4m{0}\033[0m".format( data.__class__.__name__ )
|
|
print( debug[1] and output or ansi_escape.sub( '', output ) )
|
|
|
|
# Add expression to determined datastructure
|
|
data.add_expression( expression, debug )
|
|
|
|
def merge( self, merge_in, debug ):
|
|
'''
|
|
Merge in the given organization to this organization
|
|
|
|
This organization serves as the base.
|
|
|
|
@param merge_in: Organization to merge into this one
|
|
@param debug: Enable debug out
|
|
'''
|
|
# Merge each of the sub-datastructures
|
|
for this, that in zip( self.stores(), merge_in.stores() ):
|
|
this.merge( that, debug )
|
|
|
|
def reduction( self ):
|
|
'''
|
|
Simplifies datastructure
|
|
|
|
NOTE: This will remove data, therefore, context is lost
|
|
'''
|
|
for store in self.stores():
|
|
store.reduction()
|
|
|
|
def __repr__( self ):
|
|
return "{0}".format( self.stores() )
|
|
|