1 /* Copyright (C) 2007-2008 The Android Open Source Project 2 ** 3 ** This software is licensed under the terms of the GNU General Public 4 ** License version 2, as published by the Free Software Foundation, and 5 ** may be copied, distributed, and modified under those terms. 6 ** 7 ** This program is distributed in the hope that it will be useful, 8 ** but WITHOUT ANY WARRANTY; without even the implied warranty of 9 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 10 ** GNU General Public License for more details. 11 */ 12 #include "qemu-common.h" 13 #include "android/utils/path.h" 14 #include "android/utils/misc.h" 15 #include "android/utils/debug.h" 16 #include "android/charmap.h" 17 18 /* Parses .kcm file producing key characters map. 19 * .kcm file parsed by this module is expected to contain 4 types of 20 * lines: 21 * 1. An empty line (containing no characters, or only space or tab 22 * characters). 23 * 2. A comment line (begins with '#') 24 * 3. A type section line (begins with '[') 25 * 4. Character map line, formatted as such: 26 * Key code value, followed by one or more space or tab characters. 27 * Display value, followed by one or more space or tab characters. 28 * Number value, followed by one or more space or tab characters. 29 * Base value, followed by one or more space or tab characters. 30 * Caps value, followed by one or more space or tab characters. 31 * Fn value, followed by one or more space or tab characters. 32 * Caps_fn value, followed by one or more space or tab characters. 33 * All values, except for the key code value must be either in character 34 * form ('X', where X is the value), or in hexadecimal form (0xXXXX, where 35 * XXXX is hexadecimal representation of the value). Note that if value is 36 * in hexadecimal form, it must not exceed value that can be contained in 37 * variable of 'unsigned short' type. 38 * Bellow are a couple of examples of valid .kcm file lines: 39 * # keycode display number base caps fn caps_fn 40 * A 'A' '2' 'a' 'A' '#' 0x00 41 * PERIOD '.' '.' '.' ':' ':' 0x2026 42 * SPACE 0x20 0x20 0x20 0x20 0xEF01 0xEF01 43 */ 44 45 /* Maximum length of a line expected in .kcm file. */ 46 #define KCM_MAX_LINE_LEN 1024 47 48 /* Maximum length of a token in a key map line. */ 49 #define KCM_MAX_TOKEN_LEN 512 50 51 /* Maps symbol name from .kcm file to a keycode value. */ 52 typedef struct AKeycodeMapEntry { 53 /* Symbol name from .kcm file. */ 54 const char* key_name; 55 56 /* Key code value for the symbol. */ 57 int key_code; 58 } AKeycodeMapEntry; 59 60 /* Result of parsing a line in a .kcm file. */ 61 typedef enum { 62 /* Line format was bad. */ 63 BAD_FORMAT, 64 65 /* Line had been skipped (an empty line, or a comment, etc.). */ 66 SKIP_LINE, 67 68 /* Line represents an entry in the key map. */ 69 KEY_ENTRY, 70 } ParseStatus; 71 72 static const AKeycodeMapEntry keycode_map[] = { 73 /* Symbol Key code */ 74 75 { "A", kKeyCodeA }, 76 { "B", kKeyCodeB }, 77 { "C", kKeyCodeC }, 78 { "D", kKeyCodeD }, 79 { "E", kKeyCodeE }, 80 { "F", kKeyCodeF }, 81 { "G", kKeyCodeG }, 82 { "H", kKeyCodeH }, 83 { "I", kKeyCodeI }, 84 { "J", kKeyCodeJ }, 85 { "K", kKeyCodeK }, 86 { "L", kKeyCodeL }, 87 { "M", kKeyCodeM }, 88 { "N", kKeyCodeN }, 89 { "O", kKeyCodeO }, 90 { "P", kKeyCodeP }, 91 { "Q", kKeyCodeQ }, 92 { "R", kKeyCodeR }, 93 { "S", kKeyCodeS }, 94 { "T", kKeyCodeT }, 95 { "U", kKeyCodeU }, 96 { "V", kKeyCodeV }, 97 { "W", kKeyCodeW }, 98 { "X", kKeyCodeX }, 99 { "Y", kKeyCodeY }, 100 { "Z", kKeyCodeZ }, 101 { "0", kKeyCode0 }, 102 { "1", kKeyCode1 }, 103 { "2", kKeyCode2 }, 104 { "3", kKeyCode3 }, 105 { "4", kKeyCode4 }, 106 { "5", kKeyCode5 }, 107 { "6", kKeyCode6 }, 108 { "7", kKeyCode7 }, 109 { "8", kKeyCode8 }, 110 { "9", kKeyCode9 }, 111 { "COMMA", kKeyCodeComma }, 112 { "PERIOD", kKeyCodePeriod }, 113 { "AT", kKeyCodeAt }, 114 { "SLASH", kKeyCodeSlash }, 115 { "SPACE", kKeyCodeSpace }, 116 { "ENTER", kKeyCodeNewline }, 117 { "TAB", kKeyCodeTab }, 118 { "GRAVE", kKeyCodeGrave }, 119 { "MINUS", kKeyCodeMinus }, 120 { "EQUALS", kKeyCodeEquals }, 121 { "LEFT_BRACKET", kKeyCodeLeftBracket }, 122 { "RIGHT_BRACKET", kKeyCodeRightBracket }, 123 { "BACKSLASH", kKeyCodeBackslash }, 124 { "SEMICOLON", kKeyCodeSemicolon }, 125 { "APOSTROPHE", kKeyCodeApostrophe }, 126 { "STAR", kKeyCodeStar }, 127 { "POUND", kKeyCodePound }, 128 { "PLUS", kKeyCodePlus }, 129 { "DEL", kKeyCodeDel }, 130 }; 131 132 /* the following is automatically generated by the 'gen-charmap.py' script 133 * do not touch. the generation command was: 134 * gen-charmap.py qwerty.kcm qwerty2.kcm 135 */ 136 137 static const AKeyEntry _qwerty_keys[] = 138 { 139 /* keycode base caps fn caps+fn number */ 140 141 { kKeyCodeA , 'a', 'A', '#', 0x00, '#' }, 142 { kKeyCodeB , 'b', 'B', '<', 0x00, '<' }, 143 { kKeyCodeC , 'c', 'C', '9', 0x00E7, '9' }, 144 { kKeyCodeD , 'd', 'D', '5', 0x00, '5' }, 145 { kKeyCodeE , 'e', 'E', '2', 0x0301, '2' }, 146 { kKeyCodeF , 'f', 'F', '6', 0x00A5, '6' }, 147 { kKeyCodeG , 'g', 'G', '-', '_', '-' }, 148 { kKeyCodeH , 'h', 'H', '[', '{', '[' }, 149 { kKeyCodeI , 'i', 'I', '$', 0x0302, '$' }, 150 { kKeyCodeJ , 'j', 'J', ']', '}', ']' }, 151 { kKeyCodeK , 'k', 'K', '"', '~', '"' }, 152 { kKeyCodeL , 'l', 'L', '\'', '`', '\'' }, 153 { kKeyCodeM , 'm', 'M', '!', 0x00, '!' }, 154 { kKeyCodeN , 'n', 'N', '>', 0x0303, '>' }, 155 { kKeyCodeO , 'o', 'O', '(', 0x00, '(' }, 156 { kKeyCodeP , 'p', 'P', ')', 0x00, ')' }, 157 { kKeyCodeQ , 'q', 'Q', '*', 0x0300, '*' }, 158 { kKeyCodeR , 'r', 'R', '3', 0x20AC, '3' }, 159 { kKeyCodeS , 's', 'S', '4', 0x00DF, '4' }, 160 { kKeyCodeT , 't', 'T', '+', 0x00A3, '+' }, 161 { kKeyCodeU , 'u', 'U', '&', 0x0308, '&' }, 162 { kKeyCodeV , 'v', 'V', '=', '^', '=' }, 163 { kKeyCodeW , 'w', 'W', '1', 0x00, '1' }, 164 { kKeyCodeX , 'x', 'X', '8', 0x00, '8' }, 165 { kKeyCodeY , 'y', 'Y', '%', 0x00A1, '%' }, 166 { kKeyCodeZ , 'z', 'Z', '7', 0x00, '7' }, 167 { kKeyCodeComma , ',', ';', ';', '|', ',' }, 168 { kKeyCodePeriod , '.', ':', ':', 0x2026, '.' }, 169 { kKeyCodeAt , '@', '0', '0', 0x2022, '0' }, 170 { kKeyCodeSlash , '/', '?', '?', '\\', '/' }, 171 { kKeyCodeSpace , 0x20, 0x20, 0x9, 0x9, 0x20 }, 172 { kKeyCodeNewline , 0xa, 0xa, 0xa, 0xa, 0xa }, 173 { kKeyCodeTab , 0x9, 0x9, 0x9, 0x9, 0x9 }, 174 { kKeyCode0 , '0', ')', '0', ')', '0' }, 175 { kKeyCode1 , '1', '!', '1', '!', '1' }, 176 { kKeyCode2 , '2', '@', '2', '@', '2' }, 177 { kKeyCode3 , '3', '#', '3', '#', '3' }, 178 { kKeyCode4 , '4', '$', '4', '$', '4' }, 179 { kKeyCode5 , '5', '%', '5', '%', '5' }, 180 { kKeyCode6 , '6', '^', '6', '^', '6' }, 181 { kKeyCode7 , '7', '&', '7', '&', '7' }, 182 { kKeyCode8 , '8', '*', '8', '*', '8' }, 183 { kKeyCode9 , '9', '(', '9', '(', '9' }, 184 { kKeyCodeGrave , '`', '~', '`', '~', '`' }, 185 { kKeyCodeMinus , '-', '_', '-', '_', '-' }, 186 { kKeyCodeEquals , '=', '+', '=', '+', '=' }, 187 { kKeyCodeLeftBracket , '[', '{', '[', '{', '[' }, 188 { kKeyCodeRightBracket , ']', '}', ']', '}', ']' }, 189 { kKeyCodeBackslash , '\\', '|', '\\', '|', '\\' }, 190 { kKeyCodeSemicolon , ';', ':', ';', ':', ';' }, 191 { kKeyCodeApostrophe , '\'', '"', '\'', '"', '\'' }, 192 }; 193 194 static const AKeyCharmap _qwerty_charmap = 195 { 196 _qwerty_keys, 197 51, 198 "qwerty" 199 }; 200 201 static const AKeyEntry _qwerty2_keys[] = 202 { 203 /* keycode base caps fn caps+fn number */ 204 205 { kKeyCodeA , 'a', 'A', 'a', 'A', 'a' }, 206 { kKeyCodeB , 'b', 'B', 'b', 'B', 'b' }, 207 { kKeyCodeC , 'c', 'C', 0x00e7, 0x00E7, 'c' }, 208 { kKeyCodeD , 'd', 'D', '\'', '\'', '\'' }, 209 { kKeyCodeE , 'e', 'E', '"', 0x0301, '"' }, 210 { kKeyCodeF , 'f', 'F', '[', '[', '[' }, 211 { kKeyCodeG , 'g', 'G', ']', ']', ']' }, 212 { kKeyCodeH , 'h', 'H', '<', '<', '<' }, 213 { kKeyCodeI , 'i', 'I', '-', 0x0302, '-' }, 214 { kKeyCodeJ , 'j', 'J', '>', '>', '>' }, 215 { kKeyCodeK , 'k', 'K', ';', '~', ';' }, 216 { kKeyCodeL , 'l', 'L', ':', '`', ':' }, 217 { kKeyCodeM , 'm', 'M', '%', 0x00, '%' }, 218 { kKeyCodeN , 'n', 'N', 0x00, 0x0303, 'n' }, 219 { kKeyCodeO , 'o', 'O', '+', '+', '+' }, 220 { kKeyCodeP , 'p', 'P', '=', 0x00A5, '=' }, 221 { kKeyCodeQ , 'q', 'Q', '|', 0x0300, '|' }, 222 { kKeyCodeR , 'r', 'R', '`', 0x20AC, '`' }, 223 { kKeyCodeS , 's', 'S', '\\', 0x00DF, '\\' }, 224 { kKeyCodeT , 't', 'T', '{', 0x00A3, '}' }, 225 { kKeyCodeU , 'u', 'U', '_', 0x0308, '_' }, 226 { kKeyCodeV , 'v', 'V', 'v', 'V', 'v' }, 227 { kKeyCodeW , 'w', 'W', '~', '~', '~' }, 228 { kKeyCodeX , 'x', 'X', 'x', 'X', 'x' }, 229 { kKeyCodeY , 'y', 'Y', '}', 0x00A1, '}' }, 230 { kKeyCodeZ , 'z', 'Z', 'z', 'Z', 'z' }, 231 { kKeyCodeComma , ',', '<', ',', ',', ',' }, 232 { kKeyCodePeriod , '.', '>', '.', 0x2026, '.' }, 233 { kKeyCodeAt , '@', '@', '@', 0x2022, '@' }, 234 { kKeyCodeSlash , '/', '?', '?', '?', '/' }, 235 { kKeyCodeSpace , 0x20, 0x20, 0x9, 0x9, 0x20 }, 236 { kKeyCodeNewline , 0xa, 0xa, 0xa, 0xa, 0xa }, 237 { kKeyCode0 , '0', ')', ')', ')', '0' }, 238 { kKeyCode1 , '1', '!', '!', '!', '1' }, 239 { kKeyCode2 , '2', '@', '@', '@', '2' }, 240 { kKeyCode3 , '3', '#', '#', '#', '3' }, 241 { kKeyCode4 , '4', '$', '$', '$', '4' }, 242 { kKeyCode5 , '5', '%', '%', '%', '5' }, 243 { kKeyCode6 , '6', '^', '^', '^', '6' }, 244 { kKeyCode7 , '7', '&', '&', '&', '7' }, 245 { kKeyCode8 , '8', '*', '*', '*', '8' }, 246 { kKeyCode9 , '9', '(', '(', '(', '9' }, 247 { kKeyCodeTab , 0x9, 0x9, 0x9, 0x9, 0x9 }, 248 { kKeyCodeGrave , '`', '~', '`', '~', '`' }, 249 { kKeyCodeMinus , '-', '_', '-', '_', '-' }, 250 { kKeyCodeEquals , '=', '+', '=', '+', '=' }, 251 { kKeyCodeLeftBracket , '[', '{', '[', '{', '[' }, 252 { kKeyCodeRightBracket , ']', '}', ']', '}', ']' }, 253 { kKeyCodeBackslash , '\\', '|', '\\', '|', '\\' }, 254 { kKeyCodeSemicolon , ';', ':', ';', ':', ';' }, 255 { kKeyCodeApostrophe , '\'', '"', '\'', '"', '\'' }, 256 }; 257 258 static const AKeyCharmap _qwerty2_charmap = 259 { 260 _qwerty2_keys, 261 51, 262 "qwerty2" 263 }; 264 265 /* Custom character map created with -charmap option. */ 266 static AKeyCharmap android_custom_charmap = { 0 }; 267 268 const AKeyCharmap** android_charmaps = 0; 269 int android_charmap_count = 0; 270 271 /* Checks if a character represents an end of the line. 272 * Returns a non-zero value if ch is an EOL character. Returns 273 * zero value if ch is not an EOL character. 274 */ 275 static int 276 kcm_is_eol(char ch) { 277 // EOLs are 0, \r and \n chars. 278 return ('\0' == ch) || ('\n' == ch) || ('\r' == ch); 279 } 280 281 /* Checks if a character represents a token separator. 282 * Returns a non-zero value if ch is a token separator. 283 * Returns zero value if ch is not a token separator. 284 */ 285 static int 286 kcm_is_token_separator(char ch) { 287 // Spaces and tabs are the only separators allowed 288 // between tokens in .kcm files. 289 return (' ' == ch) || ('\t' == ch); 290 } 291 292 /* Checks if a character represents a path separator. 293 * Returns a non-zero value if ch is a path separator. 294 * Returns zero value if ch is not a path separator. 295 */ 296 static int 297 kcm_is_path_separator(char ch) { 298 #ifdef _WIN32 299 return '/' == ch || '\\' == ch; 300 #else 301 return '/' == ch; 302 #endif // _WIN32 303 } 304 305 /* Skips space separators in a string. 306 * str - string to advance past space separators. 307 * Returns pointer to the first character in the string, that is 308 * not a space separator. Note that this routine may return 309 * pointer to EOL in case if all characters in the string were 310 * space separators. 311 */ 312 static const char* 313 kcm_skip_spaces(const char* str) { 314 while (!kcm_is_eol(*str) && kcm_is_token_separator(*str)) { 315 str++; 316 } 317 return str; 318 } 319 320 /* Advances string to the first space separator character. 321 * str - string to advance. 322 * Returns pointer to the first space separator character in the string. 323 * Note that this routine may return pointer to EOL in case if all 324 * characters in the string were not space separators. 325 */ 326 static const char* 327 kcm_skip_non_spaces(const char* str) { 328 while (!kcm_is_eol(*str) && !kcm_is_token_separator(*str)) { 329 str++; 330 } 331 return str; 332 } 333 334 /* Gets first token from a string. 335 * line - String to get token from. End of the string should be 336 * determined using kcm_is_eol() routine. 337 * token - String where to copy token. Token, copied to this 338 * string will be zero-terminated. Note that buffer for the 339 * token string must be large enough to fit token of any size. 340 * max_token_len - character size of the buffer addressed by 341 * the 'token' parameter. 342 * Returns NULL if there were no tokens found in the string, or 343 * a pointer to the line string, advanced past the found token. 344 */ 345 static const char* 346 kcm_get_token(const char* line, char* token, size_t max_token_len) { 347 // Pass spaces and tabs. 348 const char* token_starts = kcm_skip_spaces(line); 349 // Advance to next space. 350 const char* token_ends = kcm_skip_non_spaces(token_starts); 351 // Calc token length 352 size_t token_len = token_ends - token_starts; 353 if ((0 == token_len) || (token_len >= max_token_len)) { 354 return NULL; 355 } 356 memcpy(token, token_starts, token_len); 357 token[token_len] = '\0'; 358 return token_ends; 359 } 360 361 /* Checks if token represents a comment. 362 * Returns non-zero value if token represents a comment, or zero otherwise. 363 */ 364 static int 365 kcm_is_token_comment(const char* token) { 366 return '#' == *token; 367 } 368 369 /* Converts a key name to a key code as defined by AndroidKeyCode enum. 370 * key_name - Key name to convert. 371 * key_code - Upon success contains key code value for the key_name. 372 * Returns a zero value on success, or -1 if key code was not found 373 * for the given key_name. 374 */ 375 static int 376 kcm_get_key_code(const char* key_name, unsigned short* key_code) { 377 int n; 378 // Iterate through the key code map, matching key names. 379 for (n = 0; n < sizeof(keycode_map) / sizeof(keycode_map[0]); n++) { 380 if (0 == strcmp(key_name, keycode_map[n].key_name)) { 381 *key_code = keycode_map[n].key_code; 382 return 0; 383 } 384 } 385 return -1; 386 } 387 388 /* Gets unsigned short hexadecimal value for a token. 389 * token - Token to get hexadecimal value for. Note that this 390 * routine expects a "clean" (i.e. no "0x" prefix) hex number 391 * represented by the token string. 392 * val - Upon success contains hexadecimal value for the token. 393 * Returns a zero value on success, or -1 on error. 394 */ 395 static int 396 kcm_get_ushort_hex_val(const char* token, unsigned short* val) { 397 int hex_val = hex2int(token, strlen(token)); 398 // Make sure token format was ok and value doesn't exceed unsigned short. 399 if (-1 == hex_val || 0 != (hex_val & ~0xFFFF)) { 400 return -1; 401 } 402 403 *val = (unsigned short)hex_val; 404 405 return 0; 406 } 407 408 /* Gets a character or hexadecimal value represented by a token. 409 * token - Token to get value from. 410 * val - Upon success will contain a character or hexadecimal 411 * value represented by a token. 412 * Returns a zero value on success, or -1 on error. 413 */ 414 static int 415 kcm_get_char_or_hex_val(const char* token, unsigned short* val) { 416 // For chars token must begin with ' followed by character followed by ' 417 if ('\'' == *token) { 418 if ('\0' == token[1] || '\'' != token[2] || '\0' != token[3]) { 419 return 0; 420 } 421 *val = token[1]; 422 return 0; 423 } else { 424 // Make sure that hex token is prefixed with "0x" 425 if (('0' != *token) || ('x' != token[1])) { 426 return -1; 427 } 428 // Past 0x 429 return kcm_get_ushort_hex_val(token + 2, val); 430 } 431 } 432 433 /* Gets first token for the line and calculates its value. 434 * line - Line to get token's value from. 435 * val - Upon success will contain a character or hexadecimal 436 * value represented by the first token in the line. 437 * returns NULL on error, or a pointer to the line string, 438 * advanced past the found token. 439 */ 440 static const char* 441 kcm_get_char_or_hex_token_value(const char* line, unsigned short* val) { 442 char token[KCM_MAX_TOKEN_LEN]; 443 line = kcm_get_token(line, token, KCM_MAX_TOKEN_LEN); 444 if (NULL != line) { 445 // Token must be a char, or a hex number. 446 if (kcm_get_char_or_hex_val(token, val)) { 447 return NULL; 448 } 449 } 450 451 return line; 452 } 453 454 /* Parses a line in .kcm file extracting key information. 455 * line - Line in .kcm file to parse. 456 * line_index - Index of the parsing line in .kcm file. 457 * key_entry - Upon success contains key information extracted from 458 * the line. 459 * kcm_file_path - Path to the charmap file, where paresed line was taken from. 460 * returns BAD_FORMAT if line format was not recognized, SKIP_LINE if line 461 * format was ok, but it didn't contain key information, or KEY_ENTRY 462 * if key information was successfuly extracted from the line. 463 */ 464 static ParseStatus 465 kcm_parse_line(const char* line, 466 int line_index, 467 AKeyEntry* key_entry, 468 const char* kcm_file_path) { 469 char token[KCM_MAX_TOKEN_LEN]; 470 unsigned short disp; 471 472 // Get first token, and see if it's an empty, or a comment line. 473 line = kcm_get_token(line, token, KCM_MAX_TOKEN_LEN); 474 if ((NULL == line) || kcm_is_token_comment(token)) { 475 // Empty line, or a comment. 476 return SKIP_LINE; 477 } 478 479 // Here we expect either [type=XXXX], or a key string. 480 if ('[' == token[0]) { 481 return SKIP_LINE; 482 } 483 484 // It must be a key string. 485 // First token is key code. 486 if (kcm_get_key_code(token, &key_entry->code)) { 487 derror("Invalid format of charmap file %s. Unknown key %s in line %d", 488 kcm_file_path, token, line_index); 489 return BAD_FORMAT; 490 } 491 492 // 2-nd token is display character, which is ignored. 493 line = kcm_get_char_or_hex_token_value(line, &disp); 494 if (NULL == line) { 495 derror("Invalid format of charmap file %s. Invalid display value in line %d", 496 kcm_file_path, line_index); 497 return BAD_FORMAT; 498 } 499 500 // 3-rd token is number. 501 line = kcm_get_char_or_hex_token_value(line, &key_entry->number); 502 if (NULL == line) { 503 derror("Invalid format of charmap file %s. Invalid number value in line %d", 504 kcm_file_path, line_index); 505 return BAD_FORMAT; 506 } 507 508 // 4-th token is base. 509 line = kcm_get_char_or_hex_token_value(line, &key_entry->base); 510 if (NULL == line) { 511 derror("Invalid format of charmap file %s. Invalid base value in line %d", 512 kcm_file_path, line_index); 513 return BAD_FORMAT; 514 } 515 516 // 5-th token is caps. 517 line = kcm_get_char_or_hex_token_value(line, &key_entry->caps); 518 if (NULL == line) { 519 derror("Invalid format of charmap file %s. Invalid caps value in line %d", 520 kcm_file_path, line_index); 521 return BAD_FORMAT; 522 } 523 524 // 6-th token is fn. 525 line = kcm_get_char_or_hex_token_value(line, &key_entry->fn); 526 if (NULL == line) { 527 derror("Invalid format of charmap file %s. Invalid fn value in line %d", 528 kcm_file_path, line_index); 529 return BAD_FORMAT; 530 } 531 532 // 7-th token is caps_fn. 533 line = kcm_get_char_or_hex_token_value(line, &key_entry->caps_fn); 534 if (NULL == line) { 535 derror("Invalid format of charmap file %s. Invalid caps_fn value in line %d", 536 kcm_file_path, line_index); 537 return BAD_FORMAT; 538 } 539 540 // Make sure that line doesn't contain anything else, 541 // except (may be) a comment token. 542 line = kcm_get_token(line, token, KCM_MAX_TOKEN_LEN); 543 if ((NULL == line) || kcm_is_token_comment(token)) { 544 return KEY_ENTRY; 545 } else { 546 derror("Invalid format of charmap file %s in line %d", 547 kcm_file_path, line_index); 548 return BAD_FORMAT; 549 } 550 } 551 552 void 553 kcm_extract_charmap_name(const char* kcm_file_path, 554 char* charmap_name, 555 int max_len) { 556 const char* ext_separator; 557 size_t to_copy; 558 559 // Initialize charmap name with name of .kcm file. 560 // First, get file name from the full path to .kcm file. 561 const char* file_name = kcm_file_path + strlen(kcm_file_path); 562 while (!kcm_is_path_separator(*file_name) && 563 (file_name != kcm_file_path)) { 564 file_name--; 565 } 566 if (kcm_is_path_separator(*file_name)) { 567 file_name++; 568 } 569 570 // Cut off file name extension. 571 ext_separator = strrchr(file_name, '.'); 572 if (NULL == ext_separator) { 573 // "filename" is legal name. 574 ext_separator = file_name + strlen(file_name); 575 } else if (ext_separator == file_name) { 576 // ".filename" is legal name too. In this case we will use 577 // "filename" as our custom charmap name. 578 file_name++; 579 ext_separator = file_name + strlen(file_name); 580 } 581 582 // Copy file name to charmap name. 583 to_copy = ext_separator - file_name; 584 if (to_copy > (max_len - 1)) { 585 to_copy = max_len - 1; 586 } 587 memcpy(charmap_name, file_name, to_copy); 588 charmap_name[to_copy] = '\0'; 589 } 590 591 /* Extracts charmap name from .kcm file name, 592 * and saves it into char_map as its name. 593 */ 594 static void 595 kcm_get_charmap_name(const char* kcm_file_path, AKeyCharmap* char_map) { 596 kcm_extract_charmap_name(kcm_file_path, char_map->name, 597 sizeof(char_map->name)); 598 } 599 600 /* Parses .kcm file producing key characters map. 601 * See comments to this module for .kcm file format information. 602 * This routine checks format only for character map lines. It will not check 603 * format for empty lines, comments, and type section lines. 604 * Note that line length in .kcm file should not exceed 1024 characters, 605 * including newline character. 606 * 607 * Parameters: 608 * kcm_file_path - Full path to the .kcm file to parse. 609 * char_map - Upon success will contain initialized characters map. 610 * Returns a zero value on success, or -1 on failure. 611 */ 612 static int 613 parse_kcm_file(const char* kcm_file_path, AKeyCharmap* char_map) { 614 // A line read from .kcm file. 615 char line[KCM_MAX_LINE_LEN]; 616 // Return code. 617 int err = 0; 618 // Number of the currently parsed line. 619 int cur_line = 1; 620 // Initial size of the charmap's array of keys. 621 int map_size = 52; 622 FILE* kcm_file; 623 624 char_map->num_entries = 0; 625 char_map->entries = 0; 626 627 kcm_file = fopen(kcm_file_path, "r"); 628 if (NULL == kcm_file) { 629 derror("Unable to open charmap file %s : %s", 630 kcm_file_path, strerror(errno)); 631 return -1; 632 } 633 634 // Calculate charmap name. 635 kcm_get_charmap_name(kcm_file_path, char_map); 636 637 // Preallocate map. 638 char_map->num_entries = 0; 639 char_map->entries = qemu_malloc(sizeof(AKeyEntry) * map_size); 640 641 // Line by line parse the file. 642 for (; 0 != fgets(line, sizeof(line), kcm_file); cur_line++) { 643 AKeyEntry key_entry; 644 ParseStatus parse_res = 645 kcm_parse_line(line, cur_line, &key_entry, kcm_file_path); 646 if (BAD_FORMAT == parse_res) { 647 err = -1; 648 break; 649 } else if (KEY_ENTRY == parse_res) { 650 AKeyEntry* entries; 651 // Key information has been extracted. Add it to the map. 652 // Lets see if we need to reallocate map. 653 if (map_size == char_map->num_entries) { 654 void* new_map; 655 map_size += 10; 656 new_map = qemu_malloc(sizeof(AKeyEntry) * map_size); 657 memcpy(new_map, char_map->entries, 658 char_map->num_entries * sizeof(AKeyEntry)); 659 qemu_free((void*)char_map->entries); 660 char_map->entries = new_map; 661 } 662 entries = (AKeyEntry*)char_map->entries; 663 entries[char_map->num_entries] = key_entry; 664 char_map->num_entries++; 665 } 666 } 667 668 if (!err) { 669 // Make sure we exited the loop on EOF condition. Any other 670 // condition is an error. 671 if (0 == feof(kcm_file)) { 672 err = -1; 673 } 674 if (err) { 675 derror("Error reading charmap file %s : %s", 676 kcm_file_path, strerror(errno)); 677 } 678 } 679 680 fclose(kcm_file); 681 682 if (err) { 683 // Cleanup on failure. 684 if (0 != char_map->entries) { 685 qemu_free((void*)char_map->entries); 686 char_map->entries = 0; 687 } 688 char_map->num_entries = 0; 689 } 690 691 return err; 692 } 693 694 int 695 android_charmap_setup(const char* kcm_file_path) { 696 if (NULL != kcm_file_path) { 697 if (!parse_kcm_file(kcm_file_path, &android_custom_charmap)) { 698 // Here we have two default charmaps and the custom one. 699 android_charmap_count = 3; 700 android_charmaps = qemu_malloc(sizeof(AKeyCharmap*) * 701 android_charmap_count); 702 android_charmaps[0] = &android_custom_charmap; 703 android_charmaps[1] = &_qwerty_charmap; 704 android_charmaps[2] = &_qwerty2_charmap; 705 } else { 706 derror("Unable to parse kcm file."); 707 return -1; 708 } 709 } else { 710 // Here we have only two default charmaps. 711 android_charmap_count = 2; 712 android_charmaps = qemu_malloc(sizeof(AKeyCharmap*) * 713 android_charmap_count); 714 android_charmaps[0] = &_qwerty_charmap; 715 android_charmaps[1] = &_qwerty2_charmap; 716 } 717 718 return 0; 719 } 720 721 void 722 android_charmap_done(void) { 723 if (NULL != android_charmaps) { 724 int n; 725 for (n = 0; n < android_charmap_count; n++) { 726 // Entries for qwerty and qwerty2 character maps are 727 // static entries defined in charmap.c 728 if ((_qwerty_charmap.entries != android_charmaps[n]->entries) && 729 (_qwerty2_charmap.entries != android_charmaps[n]->entries)) { 730 qemu_free((void*)android_charmaps[n]->entries); 731 } 732 } 733 qemu_free(android_charmaps); 734 } 735 } 736 737 const AKeyCharmap* 738 android_get_charmap_by_name(const char* name) { 739 int nn; 740 741 if (name != NULL) { 742 // Find charmap by its name in the array of available charmaps. 743 for (nn = 0; nn < android_charmap_count; nn++) { 744 if (!strcmp(android_charmaps[nn]->name, name)) { 745 return android_charmaps[nn]; 746 } 747 } 748 } 749 return NULL; 750 } 751 752 const AKeyCharmap* 753 android_get_charmap_by_index(unsigned int index) { 754 return index < android_charmap_count ? android_charmaps[index] : NULL; 755 } 756 757 int 758 android_charmap_reverse_map_unicode(const AKeyCharmap* cmap, 759 unsigned int unicode, 760 int down, 761 AKeycodeBuffer* keycodes) 762 { 763 int n; 764 765 if (unicode == 0) 766 return 0; 767 768 /* check base keys */ 769 for (n = 0; n < cmap->num_entries; n++) { 770 if (cmap->entries[n].base == unicode) { 771 android_keycodes_add_key_event(keycodes, cmap->entries[n].code, down); 772 return 1; 773 } 774 } 775 776 /* check caps + keys */ 777 for (n = 0; n < cmap->num_entries; n++) { 778 if (cmap->entries[n].caps == unicode) { 779 if (down) { 780 android_keycodes_add_key_event(keycodes, kKeyCodeCapLeft, down); 781 } 782 android_keycodes_add_key_event(keycodes, cmap->entries[n].code, down); 783 if (!down) { 784 android_keycodes_add_key_event(keycodes, kKeyCodeCapLeft, down); 785 } 786 return 2; 787 } 788 } 789 790 /* check fn + keys */ 791 for (n = 0; n < cmap->num_entries; n++) { 792 if (cmap->entries[n].fn == unicode) { 793 if (down) { 794 android_keycodes_add_key_event(keycodes, kKeyCodeAltLeft, down); 795 } 796 android_keycodes_add_key_event(keycodes, cmap->entries[n].code, down); 797 if (!down) { 798 android_keycodes_add_key_event(keycodes, kKeyCodeAltLeft, down); 799 } 800 return 2; 801 } 802 } 803 804 /* check caps + fn + keys */ 805 for (n = 0; n < cmap->num_entries; n++) { 806 if (cmap->entries[n].caps_fn == unicode) { 807 if (down) { 808 android_keycodes_add_key_event(keycodes, kKeyCodeAltLeft, down); 809 android_keycodes_add_key_event(keycodes, kKeyCodeCapLeft, down); 810 } 811 android_keycodes_add_key_event(keycodes, cmap->entries[n].code, down); 812 if (!down) { 813 android_keycodes_add_key_event(keycodes, kKeyCodeCapLeft, down); 814 android_keycodes_add_key_event(keycodes, kKeyCodeAltLeft, down); 815 } 816 return 3; 817 } 818 } 819 820 /* no match */ 821 return 0; 822 } 823
