KLL Compiler
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
This repo is archived. You can view files and clone it, but cannot push or open issues/pull-requests.

kiibohdKeymap.h 3.0KB

KLL Compiler Re-Write This was many months of efforts in re-designing how the KLL compiler should work. The major problem with the original compiler was how difficult it was to extend language wise. This lead to many delays in KLL 0.4 and 0.5 being implemented. The new design is a multi-staged compiler, where even tokenization occurs over multiple stages. This allows individual parsing and token regexes to be expressed more simply without affect other expressions. Another area of change is the concept of Contexts. In the original KLL compiler the idea of a cache assigned was "hacked" on when I realized the language was "broken" (after nearly finishing the compiler). Since assignment order is generally considered not to matter for keymappings, I created a "cached" assignment where the whole file is read into a sub-datastructure, then apply to the master datastructure. Unfortunately, this wasn't really all that clear, so it was annoying to work with. To remedy this, I created KLL Contexts, which contain information about a group of expressions. Not only can these groups can be merged with other Contexts, they have historical data about how they were generated allowing for errors very late in processing to be pin-pointed back to the offending kll file. Backends work nearly the same as they did before. However, all call-backs for capability evaluations have been removed. This makes the interface much cleaner as Contexts can only be symbolically merged now. (Previously datastructures did evaluation merges where the ScanCode or Capability was looked up right before passing to the backend, but this required additional information from the backend). Many of the old parsing and tokenization rules have been reused, along with the hid_dict.py code. The new design takes advantage of processor pools to handle multithreading where it makes sense. For example, all specified files are loaded into ram simulatenously rather than sparingly reading from. The reason for this is so that each Context always has all the information it requires at all times. kll - Program entry point (previously kll.py) - Very small now, does some setting up of command-line args - Most command-line args are specified by the corresponding processing stage common/channel.py - Pixel Channel container classes common/context.py - Context container classes - As is usual with other files, blank classes inherit a base class - These blank classes are identified by the class name itself to handle special behaviour - And if/when necessary functions are re-implemented - MergeConext class facilitates merging of contexts while maintaining lineage common/expression.py - Expression container classes * Expression base class * AssignmentExpression * NameAssociationExpression * DataAssociationExpression * MapExpression - These classes are used to store expressions after they have finished parsing and tokenization common/file.py - Container class for files being read by the KLL compiler common/emitter.py - Base class for all KLL emitters - TextEmitter for dealing with text file templates common/hid_dict.py - Slightly modified version of kll_lib/hid_dict.py common/id.py - Identification container classes - Used to indentify different types of elements used within the KLL language common/modifier.py - Container classes for animation and pixel change functions common/organization.py - Data structure merging container classes - Contains all the sub-datastructure classes as well - The Organization class handles the merge orchestration and expression insertion common/parse.py - Parsing rules for funcparserlib - Much of this file was taken from the original kll.py - Many changes to support the multi-stage processing and support KLL 0.5 common/position.py - Container class dealing with physical positions common/schedule.py - Container class dealing with scheduling and timing events common/stage.py - Contains ControlStage and main Stage classes * CompilerConfigurationStage * FileImportStage * PreprocessorStage * OperationClassificationStage * OperationSpecificsStage * OperationOrganizationStage * DataOrganziationStage * DataFinalizationStage * DataAnalysisStage * CodeGenerationStage * ReportGenerationStage - Each of these classes controls the life-cycle of each stage - If multi-threading is desired, it must be handled within the class * The next stage will not start until the current stage is finished - Errors are handled such that as many errors as possible are recorded before forcing an exit * The exit is handled at the end of each stage if necessary - Command-line arguments for each stage can be defined if necessary (they are given their own grouping) - Each stage can pull variables and functions from other stages if necessary using a name lookup * This means you don't have to worry about over-arching datastructures emitters/emitters.py - Container class for KLL emitters - Handles emitter setup and selection emitters/kiibohd/kiibohd.py - kiibohd .h file KLL emitter - Re-uses some backend code from the original KLL compiler funcparserlib/parser.py - Added debug mode control examples/assignment.kll examples/defaultMapExample.kll examples/example.kll examples/hhkbpro2.kll examples/leds.kll examples/mapping.kll examples/simple1.kll examples/simple2.kll examples/simpleExample.kll examples/state_scheduling.kll - Updating/Adding rules for new compiler and KLL 0.4 + KLL 0.5 support
7 년 전
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152
  1. /* Copyright (C) 2014-2016 by Jacob Alexander
  2. *
  3. * This file is free software: you can redistribute it and/or modify
  4. * it under the terms of the GNU General Public License as published by
  5. * the Free Software Foundation, either version 3 of the License, or
  6. * (at your option) any later version.
  7. *
  8. * This file is distributed in the hope that it will be useful,
  9. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. * GNU General Public License for more details.
  12. *
  13. * You should have received a copy of the GNU General Public License
  14. * along with this file. If not, see <http://www.gnu.org/licenses/>.
  15. */
  16. <|Information|>
  17. #pragma once
  18. // ----- Includes -----
  19. // KLL Include
  20. #include <kll.h>
  21. // ----- Capabilities -----
  22. // Capability function declarations
  23. <|CapabilitiesFuncDecl|>
  24. // Indexed Capabilities Table
  25. <|CapabilitiesList|>
  26. // -- Result Macros
  27. // Result Macro Guides
  28. <|ResultMacros|>
  29. // -- Result Macro List
  30. // Indexed Table of Result Macros
  31. <|ResultMacroList|>
  32. // -- Trigger Macro Record
  33. // Keeps a record/state of each result macro
  34. <|ResultMacroRecord|>
  35. // -- Trigger Macros
  36. // Trigger Macro Guides
  37. <|TriggerMacros|>
  38. // -- Trigger Macro List
  39. // Indexed Table of Trigger Macros
  40. <|TriggerMacroList|>
  41. // -- Trigger Macro Record List
  42. // Keeps a record/state of each trigger macro
  43. <|TriggerMacroRecord|>
  44. // ----- Trigger Maps -----
  45. // MaxScanCode
  46. // - This is retrieved from the KLL configuration
  47. // - Should be corollated with the max scan code in the scan module
  48. // - Maximum value is 0x100 (0x0 to 0xFF)
  49. // - Increasing it beyond the keyboard's capabilities is just a waste of ram...
  50. #define MaxScanCode <|MaxScanCode|>
  51. // -- Trigger Lists
  52. //
  53. // Index 0: # of triggers in list
  54. // Index n: pointer to trigger macro - use tm() macro
  55. // - Default Layer -
  56. <|DefaultLayerTriggerList|>
  57. // - Partial Layers -
  58. <|PartialLayerTriggerLists|>
  59. // -- ScanCode Offset Map
  60. // Maps interconnect ids to scancode offsets
  61. //
  62. // Only used for keyboards with an interconnect
  63. <|ScanCodeInterconnectOffsetList|>
  64. // -- ScanCode Indexed Maps
  65. // Maps to a trigger list of macro pointers
  66. // _
  67. // <scan code> -> |T|
  68. // |r| -> <trigger macro pointer 1>
  69. // |i|
  70. // |g| -> <trigger macro pointer 2>
  71. // |g|
  72. // |e| -> <trigger macro pointer 3>
  73. // |r|
  74. // |s| -> <trigger macro pointer n>
  75. // -
  76. // - Default Map for ScanCode Lookup -
  77. <|DefaultLayerScanMap|>
  78. // - Partial Layer ScanCode Lookup Maps -
  79. <|PartialLayerScanMaps|>
  80. // ----- Layer Index -----
  81. // -- Layer Index List
  82. //
  83. // Index 0: Default map
  84. // Index n: Additional layers
  85. <|LayerIndexList|>
  86. // - Layer State
  87. <|LayerState|>
  88. // ----- Key Positions -----
  89. // -- Physical Key Positions
  90. //
  91. // Index 0: Key 1
  92. // Each key has 6 dimensions
  93. // x,y,z and rx,ry,rz (rotation)
  94. // Units are in mm
  95. const Position Key_Position[] = {
  96. PositionEntry( 1,0, 2,0, 3,2, 0,0, 0,0, 0,0 ),
  97. };