Subversion Repositories HelenOS

Rev

Rev 4344 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 4344 Rev 4346
Line 37... Line 37...
37 
 
 37 
 
38 
#include <kbd.h>
 38 
#include <kbd.h>
39 
#include <kbd/kbd.h>
 39 
#include <kbd/kbd.h>
40 
#include <kbd/keycode.h>
 40 
#include <kbd/keycode.h>
41 
#include <kbd_ctl.h>
 41 
#include <kbd_ctl.h>
- 
 
 42 
#include <gsp.h>
- 
 
 43 
#include <stroke.h>
42 
 
 44 
 
43 
static void parse_ds_start(int scancode);
 - 
 
44 
static void parse_ds_e(int scancode);
 - 
 
45 
static void parse_ds_e1(int scancode);
 - 
 
46 
static void parse_ds_e2(int scancode);
 - 
 
47 
static void parse_ds_e2a(int scancode);
 - 
 
48 
static void parse_ds_e2b(int scancode);
 - 
 
49 
 
 - 
 
50 
static void parse_leaf(int scancode, int (*map)[2], size_t map_length);
 - 
 
51 
 
 - 
 
52 
enum dec_state {
 - 
 
53 
    ds_start,
 - 
 
54 
    ds_e,
 - 
 
55 
    ds_e1,
 - 
 
56 
    ds_e2,
 - 
 
57 
    ds_e2a,
 - 
 
58 
    ds_e2b
 - 
 
59 
};
 - 
 
60 
 
 - 
 
61 
static int map_start[][2] = {
 - 
 
62 
 
 - 
 
63 
    [0x60] = { 0, KC_BACKTICK },
 - 
 
64 
 
 - 
 
65 
    [0x31] = { 0, KC_1 },
 - 
 
66 
    [0x32] = { 0, KC_2 },
 - 
 
67 
    [0x33] = { 0, KC_3 },
 - 
 
68 
    [0x34] = { 0, KC_4 },
 - 
 
69 
    [0x35] = { 0, KC_5 },
 - 
 
70 
    [0x36] = { 0, KC_6 },
 - 
 
71 
    [0x37] = { 0, KC_7 },
 - 
 
72 
    [0x38] = { 0, KC_8 },
 - 
 
73 
    [0x39] = { 0, KC_9 },
 - 
 
74 
    [0x30] = { 0, KC_0 },
 - 
 
75 
 
 - 
 
76 
    [0x2d] = { 0, KC_MINUS },
 - 
 
77 
    [0x3d] = { 0, KC_EQUALS },
 - 
 
78 
    [0x08] = { 0, KC_BACKSPACE },
 - 
 
79 
 
 - 
 
80 
    [0x0f] = { 0, KC_TAB },
 - 
 
81 
 
 - 
 
82 
    [0x71] = { 0, KC_Q },
 - 
 
83 
    [0x77] = { 0, KC_W },
 - 
 
84 
    [0x65] = { 0, KC_E },
 - 
 
85 
    [0x72] = { 0, KC_R },
 - 
 
86 
    [0x74] = { 0, KC_T },
 - 
 
87 
    [0x79] = { 0, KC_Y },
 - 
 
88 
    [0x75] = { 0, KC_U },
 - 
 
89 
    [0x69] = { 0, KC_I },
 - 
 
90 
    [0x6f] = { 0, KC_O },
 - 
 
91 
    [0x70] = { 0, KC_P },
 - 
 
92 
 
 - 
 
93 
    [0x5b] = { 0, KC_LBRACKET },
 - 
 
94 
    [0x5d] = { 0, KC_RBRACKET },
 - 
 
95 
 
 - 
 
96 
    [0x61] = { 0, KC_A },
 - 
 
97 
    [0x73] = { 0, KC_S },
 - 
 
98 
    [0x64] = { 0, KC_D },
 - 
 
99 
    [0x66] = { 0, KC_F },
 - 
 
100 
    [0x67] = { 0, KC_G },
 - 
 
101 
    [0x68] = { 0, KC_H },
 - 
 
102 
    [0x6a] = { 0, KC_J },
 - 
 
103 
    [0x6b] = { 0, KC_K },
 - 
 
104 
    [0x6c] = { 0, KC_L },
 - 
 
105 
 
 - 
 
106 
    [0x3b] = { 0, KC_SEMICOLON },
 - 
 
107 
    [0x27] = { 0, KC_QUOTE },
 - 
 
108 
    [0x5c] = { 0, KC_BACKSLASH },
 - 
 
109 
 
 - 
 
110 
    [0x7a] = { 0, KC_Z },
 - 
 
111 
    [0x78] = { 0, KC_X },
 - 
 
112 
    [0x63] = { 0, KC_C },
 - 
 
113 
    [0x76] = { 0, KC_V },
 - 
 
114 
    [0x62] = { 0, KC_B },
 - 
 
115 
    [0x6e] = { 0, KC_N },
 - 
 
116 
    [0x6d] = { 0, KC_M },
 - 
 
117 
 
 - 
 
118 
    [0x2c] = { 0, KC_COMMA },
 - 
 
119 
    [0x2e] = { 0, KC_PERIOD },
 - 
 
120 
    [0x2f] = { 0, KC_SLASH },
 - 
 
121 
 
 - 
 
122 
    [0x20] = { 0, KC_SPACE },
 - 
 
123 
 
 - 
 
124 
    [0x1b] = { 0, KC_ESCAPE },
 - 
 
125 
 
 - 
 
126 
    [0x0a] = { 0, KC_ENTER },
 - 
 
127 
    [0x0d] = { 0, KC_ENTER },
 - 
 
128 
 
 - 
 
129 
    /* with Shift pressed */
 45 
/** Scancode parser */
130 
 
 - 
 
131 
    [0x7e] = { KM_LSHIFT, KC_BACKTICK },
 - 
 
132 
 
 - 
 
133 
    [0x21] = { KM_LSHIFT, KC_1 },
 - 
 
134 
    [0x40] = { KM_LSHIFT, KC_2 },
 - 
 
135 
    [0x23] = { KM_LSHIFT, KC_3 },
 - 
 
136 
    [0x24] = { KM_LSHIFT, KC_4 },
 - 
 
137 
    [0x25] = { KM_LSHIFT, KC_5 },
 - 
 
138 
    [0x5e] = { KM_LSHIFT, KC_6 },
 - 
 
139 
    [0x26] = { KM_LSHIFT, KC_7 },
 - 
 
140 
    [0x2a] = { KM_LSHIFT, KC_8 },
 - 
 
141 
    [0x28] = { KM_LSHIFT, KC_9 },
 - 
 
142 
    [0x29] = { KM_LSHIFT, KC_0 },
 - 
 
143 
 
 - 
 
144 
    [0x5f] = { KM_LSHIFT, KC_MINUS },
 - 
 
145 
    [0x2b] = { KM_LSHIFT, KC_EQUALS },
 - 
 
146 
 
 - 
 
147 
    [0x51] = { KM_LSHIFT, KC_Q },
 - 
 
148 
    [0x57] = { KM_LSHIFT, KC_W },
 - 
 
149 
    [0x45] = { KM_LSHIFT, KC_E },
 - 
 
150 
    [0x52] = { KM_LSHIFT, KC_R },
 - 
 
151 
    [0x54] = { KM_LSHIFT, KC_T },
 - 
 
152 
    [0x59] = { KM_LSHIFT, KC_Y },
 - 
 
153 
    [0x55] = { KM_LSHIFT, KC_U },
 - 
 
154 
    [0x49] = { KM_LSHIFT, KC_I },
 - 
 
155 
    [0x4f] = { KM_LSHIFT, KC_O },
 - 
 
156 
    [0x50] = { KM_LSHIFT, KC_P },
 - 
 
157 
 
 - 
 
158 
    [0x7b] = { KM_LSHIFT, KC_LBRACKET },
 - 
 
159 
    [0x7d] = { KM_LSHIFT, KC_RBRACKET },
 - 
 
160 
 
 - 
 
161 
    [0x41] = { KM_LSHIFT, KC_A },
 - 
 
162 
    [0x53] = { KM_LSHIFT, KC_S },
 - 
 
163 
    [0x44] = { KM_LSHIFT, KC_D },
 - 
 
164 
    [0x46] = { KM_LSHIFT, KC_F },
 - 
 
165 
    [0x47] = { KM_LSHIFT, KC_G },
 - 
 
166 
    [0x48] = { KM_LSHIFT, KC_H },
 - 
 
167 
    [0x4a] = { KM_LSHIFT, KC_J },
 - 
 
168 
    [0x4b] = { KM_LSHIFT, KC_K },
 - 
 
169 
    [0x4c] = { KM_LSHIFT, KC_L },
 - 
 
170 
 
 - 
 
171 
    [0x3a] = { KM_LSHIFT, KC_SEMICOLON },
 - 
 
172 
    [0x22] = { KM_LSHIFT, KC_QUOTE },
 - 
 
173 
    [0x7c] = { KM_LSHIFT, KC_BACKSLASH },
 - 
 
174 
 
 - 
 
175 
    [0x5a] = { KM_LSHIFT, KC_Z },
 - 
 
176 
    [0x58] = { KM_LSHIFT, KC_X },
 - 
 
177 
    [0x43] = { KM_LSHIFT, KC_C },
 - 
 
178 
    [0x56] = { KM_LSHIFT, KC_V },
 - 
 
179 
    [0x42] = { KM_LSHIFT, KC_B },
 - 
 
180 
    [0x4e] = { KM_LSHIFT, KC_N },
 - 
 
181 
    [0x4d] = { KM_LSHIFT, KC_M },
 - 
 
182 
 
 - 
 
183 
    [0x3c] = { KM_LSHIFT, KC_COMMA },
 - 
 
184 
    [0x3e] = { KM_LSHIFT, KC_PERIOD },
 - 
 
185 
    [0x3f] = { KM_LSHIFT, KC_SLASH }
 - 
 
186 
};
 - 
 
187 
 
 - 
 
188 
static int map_e1[][2] =
 46 
static gsp_t sp;
189 
{
 - 
 
190 
    [0x50] = { 0, KC_F1 },
 - 
 
191 
    [0x51] = { 0, KC_F2 },
 - 
 
192 
    [0x52] = { 0, KC_F3 },
 - 
 
193 
    [0x53] = { 0, KC_F4 },
 - 
 
194 
};
 - 
 
195 
 
 - 
 
196 
static int map_e2[][2] =
 - 
 
197 
{
 - 
 
198 
    [0x41] = { 0, KC_UP },
 - 
 
199 
    [0x42] = { 0, KC_DOWN },
 - 
 
200 
    [0x44] = { 0, KC_LEFT },
 - 
 
201 
    [0x43] = { 0, KC_RIGHT },
 - 
 
202 
};
 - 
 
203 
 
 - 
 
204 
static int map_e2a[][2] =
 - 
 
205 
{
 - 
 
206 
    [0x35] = { 0, KC_F5 },
 - 
 
207 
    [0x37] = { 0, KC_F6 },
 - 
 
208 
    [0x38] = { 0, KC_F7 },
 - 
 
209 
    [0x39] = { 0, KC_F8 },
 - 
 
210 
};
 - 
 
211 
 
 47 
 
212 
static int map_e2b[][2] =
 48 
/** Current parser state */
213 
{
 - 
 
214 
    [0x30] = { 0, KC_F9 },
 49 
static int ds;
215 
    [0x31] = { 0, KC_F10 },
 - 
 
216 
    [0x32] = { 0, KC_F11 },
 - 
 
217 
    [0x33] = { 0, KC_F12 },
 - 
 
218 
};
 - 
 
219 
 
 50 
 
- 
 
 51 
#include <stdio.h>
- 
 
 52 
 
220 
static unsigned int mods_keys[][2] = {
 53 
int seq_defs[] = {
- 
 
 54 
    /* Not shifted */
- 
 
 55 
 
- 
 
 56 
    0,  KC_BACKTICK,    0x60, GSP_END,
- 
 
 57 
 
- 
 
 58 
    0,  KC_1,       0x31, GSP_END,
- 
 
 59 
    0,  KC_2,       0x32, GSP_END,
- 
 
 60 
    0,  KC_3,       0x33, GSP_END,
- 
 
 61 
    0,  KC_4,       0x34, GSP_END,
- 
 
 62 
    0,  KC_5,       0x35, GSP_END,
- 
 
 63 
    0,  KC_6,       0x36, GSP_END,
- 
 
 64 
    0,  KC_7,       0x37, GSP_END,
- 
 
 65 
    0,  KC_8,       0x38, GSP_END,
- 
 
 66 
    0,  KC_9,       0x39, GSP_END,
- 
 
 67 
    0,  KC_0,       0x30, GSP_END,
- 
 
 68 
 
- 
 
 69 
    0,  KC_MINUS,   0x2d, GSP_END,
- 
 
 70 
    0,  KC_EQUALS,  0x3d, GSP_END,
- 
 
 71 
    0,  KC_BACKSPACE,   0x08, GSP_END,
- 
 
 72 
 
- 
 
 73 
    0,  KC_TAB,     0x09, GSP_END,
- 
 
 74 
 
- 
 
 75 
    0,  KC_Q,       0x71, GSP_END,
- 
 
 76 
    0,  KC_W,       0x77, GSP_END,
- 
 
 77 
    0,  KC_E,       0x65, GSP_END,
- 
 
 78 
    0,  KC_R,       0x72, GSP_END,
- 
 
 79 
    0,  KC_T,       0x74, GSP_END,
- 
 
 80 
    0,  KC_Y,       0x79, GSP_END,
- 
 
 81 
    0,  KC_U,       0x75, GSP_END,
- 
 
 82 
    0,  KC_I,       0x69, GSP_END,
- 
 
 83 
    0,  KC_O,       0x6f, GSP_END,
- 
 
 84 
    0,  KC_P,       0x70, GSP_END,
- 
 
 85 
 
- 
 
 86 
    0,  KC_LBRACKET,    0x5b, GSP_END,
- 
 
 87 
    0,  KC_RBRACKET,    0x5d, GSP_END,
- 
 
 88 
 
- 
 
 89 
    0,  KC_A,       0x61, GSP_END,
- 
 
 90 
    0,  KC_S,       0x73, GSP_END,
- 
 
 91 
    0,  KC_D,       0x64, GSP_END,
- 
 
 92 
    0,  KC_F,       0x66, GSP_END,
- 
 
 93 
    0,  KC_G,       0x67, GSP_END,
- 
 
 94 
    0,  KC_H,       0x68, GSP_END,
- 
 
 95 
    0,  KC_J,       0x6a, GSP_END,
- 
 
 96 
    0,  KC_K,       0x6b, GSP_END,
- 
 
 97 
    0,  KC_L,       0x6c, GSP_END,
- 
 
 98 
 
- 
 
 99 
    0,  KC_SEMICOLON,   0x3b, GSP_END,
- 
 
 100 
    0,  KC_QUOTE,   0x27, GSP_END,
- 
 
 101 
    0,  KC_BACKSLASH,   0x5c, GSP_END,
- 
 
 102 
 
- 
 
 103 
    0,  KC_Z,       0x7a, GSP_END,
- 
 
 104 
    0,  KC_X,       0x78, GSP_END,
- 
 
 105 
    0,  KC_C,       0x63, GSP_END,
- 
 
 106 
    0,  KC_V,       0x76, GSP_END,
- 
 
 107 
    0,  KC_B,       0x62, GSP_END,
- 
 
 108 
    0,  KC_N,       0x6e, GSP_END,
- 
 
 109 
    0,  KC_M,       0x6d, GSP_END,
- 
 
 110 
 
- 
 
 111 
    0,  KC_COMMA,   0x2c, GSP_END,
- 
 
 112 
    0,  KC_PERIOD,  0x2e, GSP_END,
- 
 
 113 
    0,  KC_SLASH,   0x2f, GSP_END,
- 
 
 114 
 
- 
 
 115 
    /* Shifted */
- 
 
 116 
 
- 
 
 117 
    KM_SHIFT,   KC_BACKTICK,    0x7e, GSP_END,
- 
 
 118 
 
- 
 
 119 
    KM_SHIFT,   KC_1,       0x21, GSP_END,
- 
 
 120 
    KM_SHIFT,   KC_2,       0x40, GSP_END,
- 
 
 121 
    KM_SHIFT,   KC_3,       0x23, GSP_END,
- 
 
 122 
    KM_SHIFT,   KC_4,       0x24, GSP_END,
- 
 
 123 
    KM_SHIFT,   KC_5,       0x25, GSP_END,
- 
 
 124 
    KM_SHIFT,   KC_6,       0x5e, GSP_END,
- 
 
 125 
    KM_SHIFT,   KC_7,       0x26, GSP_END,
- 
 
 126 
    KM_SHIFT,   KC_8,       0x2a, GSP_END,
- 
 
 127 
    KM_SHIFT,   KC_9,       0x28, GSP_END,
- 
 
 128 
    KM_SHIFT,   KC_0,       0x29, GSP_END,
- 
 
 129 
 
- 
 
 130 
    KM_SHIFT,   KC_MINUS,   0x5f, GSP_END,
- 
 
 131 
    KM_SHIFT,   KC_EQUALS,  0x2b, GSP_END,
- 
 
 132 
 
- 
 
 133 
    KM_SHIFT,   KC_Q,       0x51, GSP_END,
- 
 
 134 
    KM_SHIFT,   KC_W,       0x57, GSP_END,
- 
 
 135 
    KM_SHIFT,   KC_E,       0x45, GSP_END,
- 
 
 136 
    KM_SHIFT,   KC_R,       0x52, GSP_END,
- 
 
 137 
    KM_SHIFT,   KC_T,       0x54, GSP_END,
- 
 
 138 
    KM_SHIFT,   KC_Y,       0x59, GSP_END,
- 
 
 139 
    KM_SHIFT,   KC_U,       0x55, GSP_END,
- 
 
 140 
    KM_SHIFT,   KC_I,       0x49, GSP_END,
- 
 
 141 
    KM_SHIFT,   KC_O,       0x4f, GSP_END,
- 
 
 142 
    KM_SHIFT,   KC_P,       0x50, GSP_END,
- 
 
 143 
 
- 
 
 144 
    KM_SHIFT,   KC_LBRACKET,    0x7b, GSP_END,
- 
 
 145 
    KM_SHIFT,   KC_RBRACKET,    0x7d, GSP_END,
- 
 
 146 
 
- 
 
 147 
    KM_SHIFT,   KC_A,       0x41, GSP_END,
- 
 
 148 
    KM_SHIFT,   KC_S,       0x53, GSP_END,
- 
 
 149 
    KM_SHIFT,   KC_D,       0x44, GSP_END,
- 
 
 150 
    KM_SHIFT,   KC_F,       0x46, GSP_END,
- 
 
 151 
    KM_SHIFT,   KC_G,       0x47, GSP_END,
- 
 
 152 
    KM_SHIFT,   KC_H,       0x48, GSP_END,
- 
 
 153 
    KM_SHIFT,   KC_J,       0x4a, GSP_END,
- 
 
 154 
    KM_SHIFT,   KC_K,       0x4b, GSP_END,
221 
    { KM_LSHIFT, KC_LSHIFT },
 155 
    KM_SHIFT,   KC_L,       0x4c, GSP_END,
- 
 
 156 
 
- 
 
 157 
    KM_SHIFT,   KC_SEMICOLON,   0x3a, GSP_END,
- 
 
 158 
    KM_SHIFT,   KC_QUOTE,   0x22, GSP_END,
- 
 
 159 
    KM_SHIFT,   KC_BACKSLASH,   0x7c, GSP_END,
- 
 
 160 
 
- 
 
 161 
    KM_SHIFT,   KC_Z,       0x5a, GSP_END,
- 
 
 162 
    KM_SHIFT,   KC_X,       0x58, GSP_END,
- 
 
 163 
    KM_SHIFT,   KC_C,       0x43, GSP_END,
- 
 
 164 
    KM_SHIFT,   KC_V,       0x56, GSP_END,
- 
 
 165 
    KM_SHIFT,   KC_B,       0x42, GSP_END,
- 
 
 166 
    KM_SHIFT,   KC_N,       0x4e, GSP_END,
- 
 
 167 
    KM_SHIFT,   KC_M,       0x4d, GSP_END,
- 
 
 168 
 
- 
 
 169 
    KM_SHIFT,   KC_COMMA,   0x3c, GSP_END,
- 
 
 170 
    KM_SHIFT,   KC_PERIOD,  0x3e, GSP_END,
- 
 
 171 
    KM_SHIFT,   KC_SLASH,   0x3f, GSP_END,
- 
 
 172 
 
- 
 
 173 
    /* ... */
- 
 
 174 
 
- 
 
 175 
    0,  KC_SPACE,   0x20, GSP_END,
- 
 
 176 
    0,  KC_ENTER,   0x0a, GSP_END,
- 
 
 177 
    0,  KC_ENTER,   0x0d, GSP_END,
- 
 
 178 
 
- 
 
 179 
    0,  KC_ESCAPE,  0x1b, 0x1b, GSP_END,
- 
 
 180 
 
- 
 
 181 
    0,  KC_F1,      0x1b, 0x4f, 0x50, GSP_END,
- 
 
 182 
    0,  KC_F2,      0x1b, 0x4f, 0x51, GSP_END,
- 
 
 183 
    0,  KC_F3,      0x1b, 0x4f, 0x52, GSP_END,
- 
 
 184 
    0,  KC_F4,      0x1b, 0x4f, 0x53, GSP_END,
- 
 
 185 
    0,  KC_F5,      0x1b, 0x5b, 0x31, 0x35, 0x7e, GSP_END,
- 
 
 186 
    0,  KC_F6,      0x1b, 0x5b, 0x31, 0x37, 0x7e, GSP_END,
- 
 
 187 
    0,  KC_F7,      0x1b, 0x5b, 0x31, 0x38, 0x7e, GSP_END,
- 
 
 188 
    0,  KC_F8,      0x1b, 0x5b, 0x31, 0x39, 0x7e, GSP_END,
- 
 
 189 
    0,  KC_F9,      0x1b, 0x5b, 0x32, 0x30, 0x7e, GSP_END,
- 
 
 190 
    0,  KC_F10,     0x1b, 0x5b, 0x32, 0x31, 0x7e, GSP_END,
- 
 
 191 
    0,  KC_F11,     0x1b, 0x5b, 0x32, 0x33, 0x7e, GSP_END,
- 
 
 192 
    0,  KC_F12,     0x1b, 0x5b, 0x32, 0x34, 0x7e, GSP_END,
- 
 
 193 
 
- 
 
 194 
    0,  KC_INSERT,  0x1b, 0x5b, 0x32, 0x7e, GSP_END,
- 
 
 195 
    0,  KC_HOME,    0x1b, 0x5b, 0x48, GSP_END,
- 
 
 196 
    0,  KC_PAGE_UP, 0x1b, 0x5b, 0x35, 0x7e, GSP_END,
- 
 
 197 
    0,  KC_DELETE,  0x1b, 0x5b, 0x33, 0x7e, GSP_END,
- 
 
 198 
    0,  KC_END,     0x1b, 0x5b, 0x46, GSP_END,
- 
 
 199 
    0,  KC_PAGE_DOWN,   0x1b, 0x5b, 0x36, 0x7e, GSP_END,
- 
 
 200 
 
- 
 
 201 
    0,  KC_UP,      0x1b, 0x5b, 0x41, GSP_END,
- 
 
 202 
    0,  KC_LEFT,    0x1b, 0x5b, 0x44, GSP_END,
- 
 
 203 
    0,  KC_DOWN,    0x1b, 0x5b, 0x42, GSP_END,
- 
 
 204 
    0,  KC_RIGHT,   0x1b, 0x5b, 0x43, GSP_END,
- 
 
 205 
 
222 
    { 0, 0 }
 206 
    0,  0
223 
};
 207 
};
224 
 
 208 
 
225 
static enum dec_state ds;
 - 
 
226 
 
 - 
 
227 
void kbd_ctl_parse_scancode(int scancode)
 209 
int kbd_ctl_init(void)
228 
{
 210 
{
229 
    switch (ds) {
 211 
    ds = 0;
230 
    case ds_start:  parse_ds_start(scancode); break;
 - 
 
231 
    case ds_e:  parse_ds_e(scancode); break;
 - 
 
232 
    case ds_e1: parse_ds_e1(scancode); break;
 - 
 
233 
    case ds_e2: parse_ds_e2(scancode); break;
 - 
 
234 
    case ds_e2a:    parse_ds_e2a(scancode); break;
 - 
 
235 
    case ds_e2b:    parse_ds_e2b(scancode); break;
 - 
 
236 
    }
 - 
 
237 
}
 - 
 
238 
 
 212 
 
239 
static void parse_ds_start(int scancode)
 - 
 
240 
{
 - 
 
241 
    if (scancode == 0x1b) {
 - 
 
242 
        ds = ds_e;
 213 
    gsp_init(&sp);
243 
        return;
 - 
 
244 
    }
 - 
 
245 
 
 - 
 
246 
    parse_leaf(scancode, map_start, sizeof(map_start) / (2 * sizeof(int)));
 214 
    return gsp_insert_defs(&sp, seq_defs);
247 
}
 215 
}
248 
 
 216 
 
249 
static void parse_ds_e(int scancode)
 217 
void kbd_ctl_parse_scancode(int scancode)
250 
{
 - 
 
251 
    if (scancode < 0 || scancode >= 0x80) return;
 - 
 
252 
 
 - 
 
253 
    switch (scancode) {
 - 
 
254 
    case 0x4f: ds = ds_e1; return;
 - 
 
255 
    case 0x5b: ds = ds_e2; return;
 - 
 
256 
    case 0x1b: ds = ds_start; break;
 - 
 
257 
    default: ds = ds_start; return;
 - 
 
258 
    }
 - 
 
259 
 
 - 
 
260 
    kbd_push_ev(KE_PRESS, KC_ESCAPE);
 - 
 
261 
}
 - 
 
262 
 
 - 
 
263 
static void parse_ds_e1(int scancode)
 - 
 
264 
{
 - 
 
265 
    parse_leaf(scancode, map_e1, sizeof(map_e1) / (2 * sizeof(int)));
 - 
 
266 
}
 - 
 
267 
 
 - 
 
268 
static void parse_ds_e2(int scancode)
 - 
 
269 
{
 - 
 
270 
    switch (scancode) {
 - 
 
271 
    case 0x31: ds = ds_e2a; break;
 - 
 
272 
    case 0x32: ds = ds_e2b; break;
 - 
 
273 
    default: ds = ds_start; break;
 - 
 
274 
    }
 - 
 
275 
 
 - 
 
276 
    parse_leaf(scancode, map_e2, sizeof(map_e2) / (2 * sizeof(int)));
 - 
 
277 
}
 - 
 
278 
 
 - 
 
279 
static void parse_ds_e2a(int scancode)
 - 
 
280 
{
 - 
 
281 
    parse_leaf(scancode, map_e2a, sizeof(map_e2a) / (2 * sizeof(int)));
 - 
 
282 
}
 - 
 
283 
 
 - 
 
284 
static void parse_ds_e2b(int scancode)
 - 
 
285 
{
 - 
 
286 
    parse_leaf(scancode, map_e2b, sizeof(map_e2b) / (2 * sizeof(int)));
 - 
 
287 
}
 - 
 
288 
 
 - 
 
289 
static void parse_leaf(int scancode, int (*map)[2], size_t map_length)
 - 
 
290 
{
 218 
{
291 
    unsigned int key, mod;
 219 
    unsigned mods, key;
292 
    int i;
 - 
 
293 
 
 - 
 
294 
    ds = ds_start;
 - 
 
295 
 
 - 
 
296 
    if (scancode < 0 || scancode >= map_length)
 - 
 
297 
        return;
 - 
 
298 
 
 - 
 
299 
    mod = map[scancode][0];
 - 
 
300 
    key = map[scancode][1];
 - 
 
301 
 
 - 
 
302 
    /* Simulate modifier pressing. */
 - 
 
303 
    i = 0;
 - 
 
304 
    while (mods_keys[i][0] != 0) {
 - 
 
305 
        if (mod & mods_keys[i][0]) {
 - 
 
306 
            kbd_push_ev(KE_PRESS, mods_keys[i][1]);
 - 
 
307 
        }
 - 
 
308 
        ++i;
 - 
 
309 
    }
 - 
 
310 
 
 220 
 
- 
 
 221 
    ds = gsp_step(&sp, ds, scancode, &mods, &key);
311 
    if (key != 0) {
 222 
    if (key != 0) {
312 
        kbd_push_ev(KE_PRESS, key);
 223 
        stroke_sim(mods, key);
313 
        kbd_push_ev(KE_RELEASE, key);
 - 
 
314 
    }
 - 
 
315 
 
 - 
 
316 
    /* Simulate modifier releasing. */
 - 
 
317 
    i = 0;
 - 
 
318 
    while (mods_keys[i][0] != 0) {
 - 
 
319 
        if (mod & mods_keys[i][0]) {
 - 
 
320 
            kbd_push_ev(KE_RELEASE, mods_keys[i][1]);
 - 
 
321 
        }
 - 
 
322 
        ++i;
 - 
 
323 
    }
 224 
    }
324 
}
 225 
}
325 
 
 226 
 
326 
 
 - 
 
327 
/**
 227 
/**
328 
 * @}
 228 
 * @}
329 
 */
 229 
 */