[Haiku-commits] r31195 - haiku/trunk/src/bin/keymap

axeld at BerliOS axeld at mail.berlios.de
Tue Jun 23 11:44:32 CEST 2009 

Author: axeld
Date: 2009-06-23 11:44:31 +0200 (Tue, 23 Jun 2009)
New Revision: 31195
ViewCVS: http://svn.berlios.de/viewcvs/haiku?rev=31195&view=rev

Modified:
   haiku/trunk/src/bin/keymap/Keymap.cpp
   haiku/trunk/src/bin/keymap/Keymap.h
   haiku/trunk/src/bin/keymap/main.cpp
Log:
* More or less rewrote main.cpp to use getopt_long() instead of the self-made
  argument evaluation. Also separated the evaluation from performing the
  options, solving a TODO, and added long versions for the options.
* Changed Keymap methods to work on a path instead of entry_refs - this
  simplifies the code a bit over the place.
* Added new option to load a source keymap directly (-s, --load-source).
* Renamed some methods to make clearer what they do.
* Added a way to directly write a source keymap to a file (by specifying the
  -o option together with -d).
* Coding style cleanup, ordered Keymap methods in the order they are declared.


Modified: haiku/trunk/src/bin/keymap/Keymap.cpp
===================================================================
--- haiku/trunk/src/bin/keymap/Keymap.cpp	2009-06-23 01:39:51 UTC (rev 31194)
+++ haiku/trunk/src/bin/keymap/Keymap.cpp	2009-06-23 09:44:31 UTC (rev 31195)
@@ -1,28 +1,164 @@
 /*
- *	Copyright (c) 2004-2006, Haiku, Inc.
+ * Copyright 2004-2009, Haiku, Inc. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
  *
- *  This software is part of the Haiku distribution and is covered 
- *  by the Haiku license.
- *
- *  Author: Jérôme Duval
+ * Authors:
+ *		Jérôme Duval
+ *		Axel Dörfler, axeld at pinc-software.de.
  */
 
 
 #include "Keymap.h"
 
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
 #include <ByteOrder.h>
 #include <File.h>
 #include <FindDirectory.h>
 #include <Path.h>
 #include <String.h>
 
-#include <stdlib.h>
-#include <string.h>
 
-
 #define CHARS_TABLE_MAXSIZE  10000
 
 
+extern status_t _restore_key_map_();
+
+
+// i couldn't put patterns and pattern bufs on the stack without segfaulting
+// regexp patterns
+const char versionPattern[]
+	= "Version[[:space:]]+=[[:space:]]+\\([[:digit:]]+\\)";
+const char capslockPattern[]
+	= "CapsLock[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
+const char scrolllockPattern[]
+	= "ScrollLock[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
+const char numlockPattern[]
+	= "NumLock[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
+const char lshiftPattern[] = "LShift[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
+const char rshiftPattern[] = "RShift[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
+const char lcommandPattern[]
+	= "LCommand[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
+const char rcommandPattern[]
+	= "RCommand[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
+const char lcontrolPattern[]
+	= "LControl[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
+const char rcontrolPattern[]
+	= "RControl[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
+const char loptionPattern[]
+	= "LOption[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
+const char roptionPattern[]
+	= "ROption[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
+const char menuPattern[] = "Menu[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
+const char locksettingsPattern[]
+	= "LockSettings[[:space:]]+=[[:space:]]+\\([[:alnum:]]*\\)"
+		"[[:space:]]*\\([[:alnum:]]*\\)"
+		"[[:space:]]*\\([[:alnum:]]*\\)[[:space:]]*";
+const char keyPattern[] = "Key[[:space:]]+\\([[:alnum:]]+\\)[[:space:]]+="
+	"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
+	"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
+	"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
+	"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
+	"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
+	"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
+	"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
+	"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
+	"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
+	"[[:space:]]+";
+
+
+const char acutePattern[] = "Acute[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
+	"[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)[[:space:]]+";
+const char gravePattern[] = "Grave[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
+	"[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)[[:space:]]+";
+const char circumflexPattern[] = "Circumflex[[:space:]]+\\([[:alnum:]]"
+	"+\\|'.*'\\)[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)[[:space:]]+";
+const char diaeresisPattern[] = "Diaeresis[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
+	"[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)[[:space:]]+";
+const char tildePattern[] = "Tilde[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
+	"[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)[[:space:]]+";
+const char acutetabPattern[] = "AcuteTab[[:space:]]+="
+	"[[:space:]]+\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)[[:space:]]*" ;
+const char gravetabPattern[] = "GraveTab[[:space:]]+="
+	"[[:space:]]+\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)[[:space:]]*" ;
+const char circumflextabPattern[] = "CircumflexTab[[:space:]]+="
+	"[[:space:]]+\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)[[:space:]]*" ;
+const char diaeresistabPattern[] = "DiaeresisTab[[:space:]]+="
+	"[[:space:]]+\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)[[:space:]]*" ;
+const char tildetabPattern[] = "TildeTab[[:space:]]+="
+	"[[:space:]]+\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)"
+	"[[:space:]]*\\([[:alnum:]-]*\\)[[:space:]]*" ;
+
+
+// re_pattern_buffer buffers
+struct re_pattern_buffer versionBuf;
+struct re_pattern_buffer capslockBuf;
+struct re_pattern_buffer scrolllockBuf;
+struct re_pattern_buffer numlockBuf;
+struct re_pattern_buffer lshiftBuf;
+struct re_pattern_buffer rshiftBuf;
+struct re_pattern_buffer lcommandBuf;
+struct re_pattern_buffer rcommandBuf;
+struct re_pattern_buffer lcontrolBuf;
+struct re_pattern_buffer rcontrolBuf;
+struct re_pattern_buffer loptionBuf;
+struct re_pattern_buffer roptionBuf;
+struct re_pattern_buffer menuBuf;
+struct re_pattern_buffer locksettingsBuf;
+struct re_pattern_buffer keyBuf;
+struct re_pattern_buffer acuteBuf;
+struct re_pattern_buffer graveBuf;
+struct re_pattern_buffer circumflexBuf;
+struct re_pattern_buffer diaeresisBuf;
+struct re_pattern_buffer tildeBuf;
+struct re_pattern_buffer acutetabBuf;
+struct re_pattern_buffer gravetabBuf;
+struct re_pattern_buffer circumflextabBuf;
+struct re_pattern_buffer diaeresistabBuf;
+struct re_pattern_buffer tildetabBuf;
+
+
 void
 dump_map(FILE* file, const char* name, int32* map)
 {
@@ -73,205 +209,11 @@
 }
 
 
-void
-Keymap::GetKey(char *chars, int32 offset, char* string) 
-{
-	int size = chars[offset++];
-	char str[32];
-	memset(str, 0, 32);
-	memset(string, 0, 32);
-
-	switch (size) {
-		case 0:
-			// Not mapped 
-			sprintf(str, "''");
-			break; 
-
-		case 1:
-			// 1-byte UTF-8/ASCII character
-			if ((uint8)chars[offset] < 0x20
-				|| (uint8)chars[offset] > 0x7e)
-				sprintf(str, "0x%02x", (uint8)chars[offset]);
-			else
-				sprintf(str, "'%s%c'", 
-					(chars[offset] == '\\' || chars[offset] == '\'') ? "\\" : "", chars[offset]);
-			break; 
-
-		default:
-			// n-byte UTF-8/ASCII character
-			sprintf(str, "0x");
-			for (int i = 0; i < size; i++) {
-				sprintf(str + 2*(i+1), "%02x", (uint8)chars[offset+i]);
-			}
-			break;
-	}
-
-	strncpy(string, str, strlen(str) < 12 ? strlen(str) : 12);
-		// TODO: Huh?
-}
-
-
-void
-Keymap::Dump()
-{
-	printf("#!/bin/keymap -l\n"
-		"#\n"
-		"#\tRaw key numbering for 101 keyboard...\n"
-		"#                                                                                        [sys]       [brk]\n"
-		"#                                                                                         0x7e        0x7f\n"
-		"# [esc]       [ f1] [ f2] [ f3] [ f4] [ f5] [ f6] [ f7] [ f8] [ f9] [f10] [f11] [f12]    [prn] [scr] [pau]\n"
-		"#  0x01        0x02  0x03  0x04  0x05  0x06  0x07  0x08  0x09  0x0a  0x0b  0x0c  0x0d     0x0e  0x0f  0x10     K E Y P A D   K E Y S\n"
-		"#\n"
-		"# [ ` ] [ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 7 ] [ 8 ] [ 9 ] [ 0 ] [ - ] [ = ] [bck]    [ins] [hme] [pup]    [num] [ / ] [ * ] [ - ]\n"
-		"#  0x11  0x12  0x13  0x14  0x15  0x16  0x17  0x18  0x19  0x1a  0x1b  0x1c  0x1d  0x1e     0x1f  0x20  0x21     0x22  0x23  0x24  0x25\n"
-		"#\n"
-		"# [tab] [ q ] [ w ] [ e ] [ r ] [ t ] [ y ] [ u ] [ i ] [ o ] [ p ] [ [ ] [ ] ] [ \\ ]    [del] [end] [pdn]    [ 7 ] [ 8 ] [ 9 ] [ + ]\n"
-		"#  0x26  0x27  0x28  0x29  0x2a  0x2b  0x2c  0x2d  0x2e  0x2f  0x30  0x31  0x32  0x33     0x34  0x35  0x36     0x37  0x38  0x39  0x3a\n"
-		"#\n"
-		"# [cap] [ a ] [ s ] [ d ] [ f ] [ g ] [ h ] [ j ] [ k ] [ l ] [ ; ] [ ' ] [  enter  ]                         [ 4 ] [ 5 ] [ 6 ]\n"
-		"#  0x3b  0x3c  0x3d  0x3e  0x3f  0x40  0x41  0x42  0x43  0x44  0x45  0x46     0x47                             0x48  0x49  0x4a\n"
-		"#\n"
-		"# [shift]     [ z ] [ x ] [ c ] [ v ] [ b ] [ n ] [ m ] [ , ] [ . ] [ / ]     [shift]          [ up]          [ 1 ] [ 2 ] [ 3 ] [ent]\n"
-		"#   0x4b       0x4c  0x4d  0x4e  0x4f  0x50  0x51  0x52  0x53  0x54  0x55       0x56            0x57           0x58  0x59  0x5a  0x5b\n"
-		"#\n"
-		"# [ctr]             [cmd]             [  space  ]             [cmd]             [ctr]    [lft] [dwn] [rgt]    [ 0 ] [ . ]\n"
-		"#  0x5c              0x5d                 0x5e                 0x5f              0x60     0x61  0x62  0x63     0x64  0x65\n"
-		"#\n"
-		"#\tNOTE: On a Microsoft Natural Keyboard:\n"
-		"#\t\t\tleft option  = 0x66\n"
-		"#\t\t\tright option = 0x67\n"
-		"#\t\t\tmenu key     = 0x68\n"
-		"#\tNOTE: On an Apple Extended Keyboard:\n"
-		"#\t\t\tleft option  = 0x66\n"
-		"#\t\t\tright option = 0x67\n"
-		"#\t\t\tkeypad '='   = 0x6a\n"
-		"#\t\t\tpower key    = 0x6b\n");
-
-	printf("Version = %ld\n", fKeys.version);
-	printf("CapsLock = 0x%02lx\n", fKeys.caps_key);
-	printf("ScrollLock = 0x%02lx\n", fKeys.scroll_key);
-	printf("NumLock = 0x%02lx\n", fKeys.num_key);
-	printf("LShift = 0x%02lx\n", fKeys.left_shift_key);
-	printf("RShift = 0x%02lx\n", fKeys.right_shift_key);
-	printf("LCommand = 0x%02lx\n", fKeys.left_command_key);
-	printf("RCommand = 0x%02lx\n", fKeys.right_command_key);
-	printf("LControl = 0x%02lx\n", fKeys.left_control_key);
-	printf("RControl = 0x%02lx\n", fKeys.right_control_key);
-	printf("LOption = 0x%02lx\n", fKeys.left_option_key);
-	printf("ROption = 0x%02lx\n", fKeys.right_option_key);
-	printf("Menu = 0x%02lx\n", fKeys.menu_key);
-	printf("#\n"
-		"# Lock settings\n"
-		"# To set NumLock, do the following:\n"
-		"#   LockSettings = NumLock\n"
-		"#\n"
-		"# To set everything, do the following:\n"
-		"#   LockSettings = CapsLock NumLock ScrollLock\n"
-		"#\n");
-	printf("LockSettings = ");
-	if (fKeys.lock_settings & B_CAPS_LOCK)
-		printf("CapsLock ");
-	if (fKeys.lock_settings & B_NUM_LOCK)
-		printf("NumLock ");
-	if (fKeys.lock_settings & B_SCROLL_LOCK)
-		printf("ScrollLock ");
-	printf("\n");
-	printf("# Legend:\n"
-		"#   n = Normal\n"
-		"#   s = Shift\n"
-		"#   c = Control\n"
-		"#   C = CapsLock\n"
-		"#   o = Option\n"
-		"# Key      n        s        c        o        os       C        Cs       Co       Cos     \n");
-
-	for (int idx = 0; idx < 128; idx++) {
-		char normalKey[32];
-		char shiftKey[32];
-		char controlKey[32];
-		char optionKey[32];
-		char optionShiftKey[32];
-		char capsKey[32];
-		char capsShiftKey[32];
-		char optionCapsKey[32];
-		char optionCapsShiftKey[32];
-
-		GetKey(fChars, fKeys.normal_map[idx], normalKey);
-		GetKey(fChars, fKeys.shift_map[idx], shiftKey); 
-		GetKey(fChars, fKeys.control_map[idx], controlKey); 
-		GetKey(fChars, fKeys.option_map[idx], optionKey); 
-		GetKey(fChars, fKeys.option_shift_map[idx], optionShiftKey); 
-		GetKey(fChars, fKeys.caps_map[idx], capsKey); 
-		GetKey(fChars, fKeys.caps_shift_map[idx], capsShiftKey); 
-		GetKey(fChars, fKeys.option_caps_map[idx], optionCapsKey); 
-		GetKey(fChars, fKeys.option_caps_shift_map[idx], optionCapsShiftKey);
-
-		printf("Key 0x%02x = %-9s%-9s%-9s%-9s%-9s%-9s%-9s%-9s%-9s\n", idx, normalKey, shiftKey, controlKey,
-			optionKey, optionShiftKey, capsKey, capsShiftKey, optionCapsKey, optionCapsShiftKey); 
-	}
-
-	int32* deadOffsets[] = {
-		fKeys.acute_dead_key,
-		fKeys.grave_dead_key,
-		fKeys.circumflex_dead_key,
-		fKeys.dieresis_dead_key,
-		fKeys.tilde_dead_key
-	};
-
-	char labels[][12] = {
-		"Acute",
-		"Grave",
-		"Circumflex",
-		"Diaeresis",
-		"Tilde"
-	};
-
-	uint32 deadTables[] = {
-		fKeys.acute_tables,
-		fKeys.grave_tables,
-		fKeys.circumflex_tables,
-		fKeys.dieresis_tables,
-		fKeys.tilde_tables
-	};
-
-	for (int i = 0; i<5; i++) {
-		for (int idx = 0; idx < 32; idx++ ) {
-			char deadKey[32];
-			char secondKey[32];
-			GetKey(fChars, deadOffsets[i][idx++], deadKey);
-			GetKey(fChars, deadOffsets[i][idx], secondKey); 
-			printf("%s %-9s = %-9s\n", labels[i], deadKey, secondKey);
-		}
-
-		printf("%sTab = ", labels[i]);
-
-		if (deadTables[i] & B_NORMAL_TABLE)
-			printf("Normal ");
-		if (deadTables[i] & B_SHIFT_TABLE)
-			printf("Shift ");
-		if (deadTables[i] & B_CONTROL_TABLE)
-			printf("Control ");
-		if (deadTables[i] & B_OPTION_TABLE)
-			printf("Option ");
-		if (deadTables[i] & B_OPTION_SHIFT_TABLE)
-			printf("Option-Shift ");
-		if (deadTables[i] & B_CAPS_TABLE)
-			printf("CapsLock ");
-		if (deadTables[i] & B_CAPS_SHIFT_TABLE)
-			printf("CapsLock-Shift ");
-		if (deadTables[i] & B_OPTION_CAPS_TABLE)
-			printf("CapsLock-Option ");
-		if (deadTables[i] & B_OPTION_CAPS_SHIFT_TABLE)
-			printf("CapsLock-Option-Shift ");
-		printf("\n");
-	}
-}
-
-
 status_t
 Keymap::LoadCurrent()
 {
 #if (defined(__BEOS__) || defined(__HAIKU__))
-	key_map *keys = NULL;
+	key_map* keys = NULL;
 	get_key_map(&keys, &fChars);
 	if (!keys)
 		return B_ERROR;
@@ -279,7 +221,6 @@
 	memcpy(&fKeys, keys, sizeof(fKeys));
 	free(keys);
 	return B_OK;
-
 #else	// ! __BEOS__
 	fprintf(stderr, "Unsupported operation on this platform!\n");
 	exit(1);
@@ -287,26 +228,32 @@
 }
 
 
-/*!
-	Load a map from a file.
+/*!	Load a map from a file.
 
 	file format in big endian:
 		struct key_map
 		uint32 size of following charset
-		charset (offsets go into this with size of character followed by character)
+		charset (offsets go into this with size of character followed by
+		  character)
 */
-status_t 
-Keymap::Load(entry_ref &ref)
+status_t
+Keymap::Load(const char* name)
 {
-	status_t err;
+	FILE* file = fopen(name, "r");
+	if (file == NULL)
+		return errno;
 
-	BFile file(&ref, B_READ_ONLY);
-	if ((err = file.InitCheck()) != B_OK)
-		return err;
+	return Load(file);
+}
 
-	if (file.Read(&fKeys, sizeof(fKeys)) < (ssize_t)sizeof(fKeys))
+
+status_t
+Keymap::Load(FILE* file)
+{
+	if (fread(&fKeys, sizeof(fKeys), 1, file) < 1)
 		return B_BAD_VALUE;
 
+	// convert from big-endian
 	for (uint32 i = 0; i < sizeof(fKeys) / 4; i++) {
 		((uint32*)&fKeys)[i] = B_BENDIAN_TO_HOST_INT32(((uint32*)&fKeys)[i]);
 	}
@@ -314,225 +261,59 @@
 	if (fKeys.version != 3)
 		return KEYMAP_ERROR_UNKNOWN_VERSION;
 
-	if (file.Read(&fCharsSize, sizeof(uint32)) < (ssize_t)sizeof(uint32))
+	if (fread(&fCharsSize, sizeof(uint32), 1, file) < 1)
 		return B_BAD_VALUE;
 
 	fCharsSize = B_BENDIAN_TO_HOST_INT32(fCharsSize);
-	if (!fChars)
-		delete[] fChars;
+	if (fCharsSize > 16 * 1024)
+		return B_BAD_DATA;
+
+	delete[] fChars;
 	fChars = new char[fCharsSize];
-	if ((unsigned)file.Read(fChars, fCharsSize) != fCharsSize)
+
+	if (fread(fChars, 1, fCharsSize, file) != fCharsSize)
 		return B_BAD_VALUE;
 
 	return B_OK;
 }
 
 
-void
-Keymap::ComputeChars(const char *buffer, struct re_registers &regs, int i, int &offset)
+status_t
+Keymap::LoadSource(const char* name)
 {
-	char *current = &fChars[offset + 1];
-	char hexChars[12];
-	uint32 length = 0;
-	if (strncmp(buffer + regs.start[i], "''", regs.end[i] - regs.start[i]) == 0)
-		length = 0;
-	else if (sscanf(buffer + regs.start[i], "'%s'", current) > 0) {
-		if (current[0] == '\\')
-			current[0] = current[1];
-		else if (current[0] == '\'')
-			current[0] = ' ';
-		length = 1;
-	} else if (sscanf(buffer + regs.start[i], "0x%s", hexChars) > 0) {
-		length = strlen(hexChars) / 2;
-		for (uint32 j = 0; j < length; j++)
-			sscanf(hexChars + 2*j, "%02hhx", current + j);
-	}
-	fChars[offset] = length;
-	offset += length + 1;
-}
+	FILE* file = fopen(name, "r");
+	if (file == NULL)
+		return errno;
 
+	status_t status = LoadSource(file);
+	fclose(file);
 
-void
-Keymap::ComputeTables(const char *buffer, struct re_registers &regs, uint32 &table)
-{
-	for (int32 i=1; i<=9; i++) {
-		if (regs.end[i] - regs.start[i] <= 0)
-			break;
-		if (strncmp(buffer + regs.start[i], "Normal", regs.end[i] - regs.start[i]) == 0)
-			table |= B_NORMAL_TABLE;
-		else if (strncmp(buffer + regs.start[i], "Shift", regs.end[i] - regs.start[i]) == 0)
-			table |= B_SHIFT_TABLE;
-		else if (strncmp(buffer + regs.start[i], "Control", regs.end[i] - regs.start[i]) == 0)
-			table |= B_CONTROL_TABLE;
-		else if (strncmp(buffer + regs.start[i], "Option", regs.end[i] - regs.start[i]) == 0)
-			table |= B_OPTION_TABLE;
-		else if (strncmp(buffer + regs.start[i], "Option-Shift", regs.end[i] - regs.start[i]) == 0)
-			table |= B_OPTION_SHIFT_TABLE;
-		else if (strncmp(buffer + regs.start[i], "CapsLock", regs.end[i] - regs.start[i]) == 0)
-			table |= B_CAPS_TABLE;
-		else if (strncmp(buffer + regs.start[i], "CapsLock-Shift", regs.end[i] - regs.start[i]) == 0)
-			table |= B_CAPS_SHIFT_TABLE;
-		else if (strncmp(buffer + regs.start[i], "CapsLock-Option", regs.end[i] - regs.start[i]) == 0)
-			table |= B_OPTION_CAPS_TABLE;
-		else if (strncmp(buffer + regs.start[i], "CapsLock-Option-Shift", regs.end[i] - regs.start[i]) == 0)
-			table |= B_OPTION_CAPS_SHIFT_TABLE;
-	}
+	return status;
 }
 
 
-status_t 
-Keymap::LoadSourceFromRef(entry_ref &ref)
+status_t
+Keymap::LoadSource(FILE* file)
 {
-	status_t err;
-	
-	BFile file(&ref, B_READ_ONLY);
-	if ((err = file.InitCheck()) != B_OK)
-		return err;
-	
-	int fd = file.Dup();
-	FILE* f = fdopen(fd, "r");
-	if (f != NULL) {
-		err = LoadSource(f);
-		fclose(f);
-	} else
-		err = B_FILE_ERROR;
+	// Setup regexp parser
 
-	return err;
-}
-
-
-// i couldn't put patterns and pattern bufs on the stack without segfaulting
-// regexp patterns
-const char versionPattern[] = "Version[[:space:]]+=[[:space:]]+\\([[:digit:]]+\\)";
-const char capslockPattern[] = "CapsLock[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
-const char scrolllockPattern[] = "ScrollLock[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
-const char numlockPattern[] = "NumLock[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
-const char lshiftPattern[] = "LShift[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
-const char rshiftPattern[] = "RShift[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
-const char lcommandPattern[] = "LCommand[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
-const char rcommandPattern[] = "RCommand[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
-const char lcontrolPattern[] = "LControl[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
-const char rcontrolPattern[] = "RControl[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
-const char loptionPattern[] = "LOption[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
-const char roptionPattern[] = "ROption[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
-const char menuPattern[] = "Menu[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\)";
-const char locksettingsPattern[] = "LockSettings[[:space:]]+=[[:space:]]+\\([[:alnum:]]*\\)"
-						"[[:space:]]*\\([[:alnum:]]*\\)"
-						"[[:space:]]*\\([[:alnum:]]*\\)[[:space:]]*";
-const char keyPattern[] = "Key[[:space:]]+\\([[:alnum:]]+\\)[[:space:]]+="
-						"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
-						"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
-						"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
-						"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
-						"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
-						"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
-						"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
-						"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
-						"[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)"
-						"[[:space:]]+";
-
-
-const char acutePattern[] = "Acute[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)[[:space:]]+";
-const char gravePattern[] = "Grave[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)[[:space:]]+";
-const char circumflexPattern[] = "Circumflex[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)[[:space:]]+";
-const char diaeresisPattern[] = "Diaeresis[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)[[:space:]]+";
-const char tildePattern[] = "Tilde[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)[[:space:]]+=[[:space:]]+\\([[:alnum:]]+\\|'.*'\\)[[:space:]]+";
-const char acutetabPattern[] = "AcuteTab[[:space:]]+="
-						"[[:space:]]+\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)[[:space:]]*" ;
-const char gravetabPattern[] = "GraveTab[[:space:]]+="
-						"[[:space:]]+\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)[[:space:]]*" ;
-const char circumflextabPattern[] = "CircumflexTab[[:space:]]+="
-						"[[:space:]]+\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)[[:space:]]*" ;
-const char diaeresistabPattern[] = "DiaeresisTab[[:space:]]+="
-						"[[:space:]]+\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)[[:space:]]*" ;
-const char tildetabPattern[] = "TildeTab[[:space:]]+="
-						"[[:space:]]+\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)"
-						"[[:space:]]*\\([[:alnum:]-]*\\)[[:space:]]*" ;
-
-
-// re_pattern_buffer buffers
-struct re_pattern_buffer versionBuf;
-struct re_pattern_buffer capslockBuf;
-struct re_pattern_buffer scrolllockBuf;
-struct re_pattern_buffer numlockBuf;
-struct re_pattern_buffer lshiftBuf;
-struct re_pattern_buffer rshiftBuf;
-struct re_pattern_buffer lcommandBuf;
-struct re_pattern_buffer rcommandBuf;
-struct re_pattern_buffer lcontrolBuf;
-struct re_pattern_buffer rcontrolBuf;
-struct re_pattern_buffer loptionBuf;
-struct re_pattern_buffer roptionBuf;
-struct re_pattern_buffer menuBuf;
-struct re_pattern_buffer locksettingsBuf;
-struct re_pattern_buffer keyBuf;
-struct re_pattern_buffer acuteBuf;
-struct re_pattern_buffer graveBuf;
-struct re_pattern_buffer circumflexBuf;
-struct re_pattern_buffer diaeresisBuf;
-struct re_pattern_buffer tildeBuf;
-struct re_pattern_buffer acutetabBuf;
-struct re_pattern_buffer gravetabBuf;
-struct re_pattern_buffer circumflextabBuf;
-struct re_pattern_buffer diaeresistabBuf;
-struct re_pattern_buffer tildetabBuf;
-	
-status_t
-Keymap::LoadSource(FILE * f)
-{
 	reg_syntax_t syntax = RE_CHAR_CLASSES;
 	re_set_syntax(syntax);
-	
-	const char* error; 
-	error = re_compile_pattern(versionPattern, strlen(versionPattern), &versionBuf);
+
+	const char* error = re_compile_pattern(versionPattern,
+		strlen(versionPattern), &versionBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(capslockPattern, strlen(capslockPattern), &capslockBuf);
+	error = re_compile_pattern(capslockPattern, strlen(capslockPattern),
+		&capslockBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(scrolllockPattern, strlen(scrolllockPattern), &scrolllockBuf);
+	error = re_compile_pattern(scrolllockPattern, strlen(scrolllockPattern),
+		&scrolllockBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(numlockPattern, strlen(numlockPattern), &numlockBuf);
+	error = re_compile_pattern(numlockPattern, strlen(numlockPattern),
+		&numlockBuf);
 	if (error)
 		fprintf(stderr, error);
 	error = re_compile_pattern(lshiftPattern, strlen(lshiftPattern), &lshiftBuf);
@@ -541,28 +322,35 @@
 	error = re_compile_pattern(rshiftPattern, strlen(rshiftPattern), &rshiftBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(lcommandPattern, strlen(lcommandPattern), &lcommandBuf);
+	error = re_compile_pattern(lcommandPattern, strlen(lcommandPattern),
+		&lcommandBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(rcommandPattern, strlen(rcommandPattern), &rcommandBuf);
+	error = re_compile_pattern(rcommandPattern, strlen(rcommandPattern),
+		&rcommandBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(lcontrolPattern, strlen(lcontrolPattern), &lcontrolBuf);
+	error = re_compile_pattern(lcontrolPattern, strlen(lcontrolPattern),
+		&lcontrolBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(rcontrolPattern, strlen(rcontrolPattern), &rcontrolBuf);
+	error = re_compile_pattern(rcontrolPattern, strlen(rcontrolPattern),
+		&rcontrolBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(loptionPattern, strlen(loptionPattern), &loptionBuf);
+	error = re_compile_pattern(loptionPattern, strlen(loptionPattern),
+		&loptionBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(roptionPattern, strlen(roptionPattern), &roptionBuf);
+	error = re_compile_pattern(roptionPattern, strlen(roptionPattern),
+		&roptionBuf);
 	if (error)
 		fprintf(stderr, error);
 	error = re_compile_pattern(menuPattern, strlen(menuPattern), &menuBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(locksettingsPattern, strlen(locksettingsPattern), &locksettingsBuf);
+	error = re_compile_pattern(locksettingsPattern, strlen(locksettingsPattern),
+		&locksettingsBuf);
 	if (error)
 		fprintf(stderr, error);
 	error = re_compile_pattern(keyPattern, strlen(keyPattern), &keyBuf);
@@ -574,32 +362,39 @@
 	error = re_compile_pattern(gravePattern, strlen(gravePattern), &graveBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(circumflexPattern, strlen(circumflexPattern), &circumflexBuf);
+	error = re_compile_pattern(circumflexPattern, strlen(circumflexPattern),
+		&circumflexBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(diaeresisPattern, strlen(diaeresisPattern), &diaeresisBuf);
+	error = re_compile_pattern(diaeresisPattern, strlen(diaeresisPattern),
+		&diaeresisBuf);
 	if (error)
 		fprintf(stderr, error);
 	error = re_compile_pattern(tildePattern, strlen(tildePattern), &tildeBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(acutetabPattern, strlen(acutetabPattern), &acutetabBuf);
+	error = re_compile_pattern(acutetabPattern, strlen(acutetabPattern),
+		&acutetabBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(gravetabPattern, strlen(gravetabPattern), &gravetabBuf);
+	error = re_compile_pattern(gravetabPattern, strlen(gravetabPattern),
+		&gravetabBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(circumflextabPattern, strlen(circumflextabPattern), &circumflextabBuf);
+	error = re_compile_pattern(circumflextabPattern,
+		strlen(circumflextabPattern), &circumflextabBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(diaeresistabPattern, strlen(diaeresistabPattern), &diaeresistabBuf);
+	error = re_compile_pattern(diaeresistabPattern, strlen(diaeresistabPattern),
+		&diaeresistabBuf);
 	if (error)
 		fprintf(stderr, error);
-	error = re_compile_pattern(tildetabPattern, strlen(tildetabPattern), &tildetabBuf);
+	error = re_compile_pattern(tildetabPattern, strlen(tildetabPattern),
+		&tildetabBuf);
 	if (error)
 		fprintf(stderr, error);
 
-	char buffer[1024];
+	// Read file
 
 	delete[] fChars;
 	fChars = new char[CHARS_TABLE_MAXSIZE];
@@ -611,7 +406,7 @@
 	int diaeresisOffset = 0;
 	int tildeOffset = 0;
 
-	int32 *maps[] = {
+	int32* maps[] = {
 		fKeys.normal_map,
 		fKeys.shift_map,
 		fKeys.control_map,
@@ -623,93 +418,118 @@
 		fKeys.option_caps_shift_map
 	};
 
-	while (fgets(buffer, 1024-1, f) != NULL) {
+	char buffer[1024];
+
+	while (fgets(buffer, sizeof(buffer) - 1, file) != NULL) {
 		if (buffer[0] == '#' || buffer[0] == '\n')
 			continue;
 
+		size_t length = strlen(buffer);
+
 		struct re_registers regs;
-		if (re_search(&versionBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		if (re_search(&versionBuf, buffer, length, 0, length, &regs) >= 0) {
 			sscanf(buffer + regs.start[1], "%ld", &fKeys.version);
-		} else if (re_search(&capslockBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&capslockBuf, buffer, length, 0, length, &regs)
+				>= 0) {
 			sscanf(buffer + regs.start[1], "0x%lx", &fKeys.caps_key);
-		} else if (re_search(&scrolllockBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&scrolllockBuf, buffer, length, 0, length, &regs)
+				>= 0) {
 			sscanf(buffer + regs.start[1], "0x%lx", &fKeys.scroll_key);
-		} else if (re_search(&numlockBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&numlockBuf, buffer, length, 0, length, &regs)
+				>= 0) {
 			sscanf(buffer + regs.start[1], "0x%lx", &fKeys.num_key);
-		} else if (re_search(&lshiftBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&lshiftBuf, buffer, length, 0, length, &regs)
+				>= 0) {
 			sscanf(buffer + regs.start[1], "0x%lx", &fKeys.left_shift_key);
-		} else if (re_search(&rshiftBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&rshiftBuf, buffer, length, 0, length, &regs)
+				>= 0) {
 			sscanf(buffer + regs.start[1], "0x%lx", &fKeys.right_shift_key);
-		} else if (re_search(&lcommandBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&lcommandBuf, buffer, length, 0, length, &regs)
+				>= 0) {
 			sscanf(buffer + regs.start[1], "0x%lx", &fKeys.left_command_key);
-		} else if (re_search(&rcommandBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&rcommandBuf, buffer, length, 0, length, &regs)
+				>= 0) {
 			sscanf(buffer + regs.start[1], "0x%lx", &fKeys.right_command_key);
-		} else if (re_search(&lcontrolBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&lcontrolBuf, buffer, length, 0, length, &regs)
+				>= 0) {
 			sscanf(buffer + regs.start[1], "0x%lx", &fKeys.left_control_key);
-		} else if (re_search(&rcontrolBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&rcontrolBuf, buffer, length, 0, length, &regs)
+				>= 0) {
 			sscanf(buffer + regs.start[1], "0x%lx", &fKeys.right_control_key);
-		} else if (re_search(&loptionBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&loptionBuf, buffer, length, 0, length, &regs)
+				>= 0) {
 			sscanf(buffer + regs.start[1], "0x%lx", &fKeys.left_option_key);
-		} else if (re_search(&roptionBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&roptionBuf, buffer, length, 0, length, &regs)
+				>= 0) {
 			sscanf(buffer + regs.start[1], "0x%lx", &fKeys.right_option_key);
-		} else if (re_search(&menuBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&menuBuf, buffer, length, 0, length, &regs) >= 0) {
 			sscanf(buffer + regs.start[1], "0x%lx", &fKeys.menu_key);
-		} else if (re_search(&locksettingsBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&locksettingsBuf, buffer, length, 0, length, &regs)
+				>= 0) {
 			fKeys.lock_settings = 0;
 			for (int32 i = 1; i <= 3; i++) {
-				if (regs.end[i] - regs.start[i] <= 0)
+				const char* start = buffer + regs.start[i];
+				length = regs.end[i] - regs.start[i];
+				if (length == 0)
 					break;
 
-				if (strncmp(buffer + regs.start[i], "CapsLock", regs.end[i] - regs.start[i]) == 0)
+				if (!strncmp(start, "CapsLock", length))
 					fKeys.lock_settings |= B_CAPS_LOCK;
-				else if (strncmp(buffer + regs.start[i], "NumLock", regs.end[i] - regs.start[i]) == 0)
+				else if (!strncmp(start, "NumLock", length))
 					fKeys.lock_settings |= B_NUM_LOCK;
-				else if (strncmp(buffer + regs.start[i], "ScrollLock", regs.end[i] - regs.start[i]) == 0)
+				else if (!strncmp(start, "ScrollLock", length))
 					fKeys.lock_settings |= B_SCROLL_LOCK;
 			}
-		} else if (re_search(&keyBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
-			uint32 keyCode; 
+		} else if (re_search(&keyBuf, buffer, length, 0, length, &regs) >= 0) {
+			uint32 keyCode;
 			if (sscanf(buffer + regs.start[1], "0x%lx", &keyCode) > 0) {
 				for (int i = 2; i <= 10; i++) {
 					maps[i - 2][keyCode] = offset;
-					ComputeChars(buffer, regs, i, offset);
+					_ComputeChars(buffer, regs, i, offset);
 				}
 			}
-		} else if (re_search(&acuteBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&acuteBuf, buffer, length, 0, length, &regs) >= 0) {
 			for (int i = 1; i <= 2; i++) {
-				fKeys.acute_dead_key[acuteOffset++] = offset;		
-				ComputeChars(buffer, regs, i, offset);
+				fKeys.acute_dead_key[acuteOffset++] = offset;
+				_ComputeChars(buffer, regs, i, offset);
 			}
-		} else if (re_search(&graveBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&graveBuf, buffer, length, 0, length, &regs) >= 0) {
 			for (int i = 1; i <= 2; i++) {
-				fKeys.grave_dead_key[graveOffset++] = offset;		
-				ComputeChars(buffer, regs, i, offset);
+				fKeys.grave_dead_key[graveOffset++] = offset;
+				_ComputeChars(buffer, regs, i, offset);
 			}
-		} else if (re_search(&circumflexBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&circumflexBuf, buffer, length, 0, length, &regs)
+				>= 0) {
 			for (int i = 1; i <= 2; i++) {
-				fKeys.circumflex_dead_key[circumflexOffset++] = offset;		
-				ComputeChars(buffer, regs, i, offset);
+				fKeys.circumflex_dead_key[circumflexOffset++] = offset;
+				_ComputeChars(buffer, regs, i, offset);
 			}
-		} else if (re_search(&diaeresisBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&diaeresisBuf, buffer, length, 0, length, &regs)
+				>= 0) {
 			for (int i = 1; i <= 2; i++) {
-				fKeys.dieresis_dead_key[diaeresisOffset++] = offset;		
-				ComputeChars(buffer, regs, i, offset);
+				fKeys.dieresis_dead_key[diaeresisOffset++] = offset;
+				_ComputeChars(buffer, regs, i, offset);
 			}
-		} else if (re_search(&tildeBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
+		} else if (re_search(&tildeBuf, buffer, length, 0, length, &regs) >= 0) {
 			for (int i = 1; i <= 2; i++) {
-				fKeys.tilde_dead_key[tildeOffset++] = offset;		
-				ComputeChars(buffer, regs, i, offset);
+				fKeys.tilde_dead_key[tildeOffset++] = offset;
+				_ComputeChars(buffer, regs, i, offset);
 			}
-		} else if (re_search(&acutetabBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
-			ComputeTables(buffer, regs, fKeys.acute_tables);
-		} else if (re_search(&gravetabBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
-			ComputeTables(buffer, regs, fKeys.grave_tables);
-		} else if (re_search(&circumflextabBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
-			ComputeTables(buffer, regs, fKeys.circumflex_tables);
-		} else if (re_search(&diaeresistabBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
-			ComputeTables(buffer, regs, fKeys.dieresis_tables);
-		} else if (re_search(&tildetabBuf, buffer, strlen(buffer), 0, strlen(buffer), &regs) >= 0) {
-			ComputeTables(buffer, regs, fKeys.tilde_tables);
+		} else if (re_search(&acutetabBuf, buffer, length, 0, length, &regs)
+				>= 0) {
+			_ComputeTables(buffer, regs, fKeys.acute_tables);
+		} else if (re_search(&gravetabBuf, buffer, length, 0, length, &regs)
+				>= 0) {
+			_ComputeTables(buffer, regs, fKeys.grave_tables);
+		} else if (re_search(&circumflextabBuf, buffer, length, 0, length, &regs)
+				>= 0) {
+			_ComputeTables(buffer, regs, fKeys.circumflex_tables);
+		} else if (re_search(&diaeresistabBuf, buffer, length, 0, length, &regs)
+				>= 0) {
+			_ComputeTables(buffer, regs, fKeys.dieresis_tables);
+		} else if (re_search(&tildetabBuf, buffer, length, 0, length, &regs)
+				>= 0) {
+			_ComputeTables(buffer, regs, fKeys.tilde_tables);
 		}
 	}
 
@@ -720,18 +540,42 @@
 
 	return B_OK;
 }
-	
 
-//! we save a map to a file
-status_t 
-Keymap::Save(entry_ref &ref)
+
+status_t
+Keymap::SaveAsCurrent()
 {
-	status_t err;
+#if (defined(__BEOS__) || defined(__HAIKU__))
+	BPath path;
+	status_t status = find_directory(B_USER_SETTINGS_DIRECTORY, &path, true);
+	if (status != B_OK)
+		return status;
 
-	BFile file(&ref, B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE );
-	if ((err = file.InitCheck()) != B_OK)
-		return err;
+	path.Append("Key_map");
 
+	status = Save(path.Path());
+	if (status != B_OK)
+		return status;
+
+	Use();
+	return B_OK;
+#else	// ! __BEOS__
+	fprintf(stderr, "Unsupported operation on this platform!\n");
+	exit(1);
+#endif	// ! __BEOS__
+}
+
+
+//! Save a binary keymap to a file.
+status_t
+Keymap::Save(const char* name)
+{
+	BFile file;
+	status_t status = file.SetTo(name,
+		B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
+	if (status != B_OK)

[... truncated: 1088 lines follow ...]

More information about the Haiku-commits mailing list