Change default layer names used by modifiers for consistency.

e.g

alt = layer(A) -> alt = layer(alt)

Additionally, left hand modifier names are shorthand
for both associated keycodes as opposed to just
the left one.

e.g:

control = esc

is equivalent to:

leftcontrol = esc
rightcontrol = esc

Author: rvaiya

README.md

@@ -132,12 +132,12 @@ following config:
 
 	[main]
 
-	leftshift = oneshot(S)
-	leftalt = oneshot(A)
-	rightalt = oneshot(G)
-	rightshift = oneshot(A)
-	leftmeta = oneshot(M)
-	rightmeta = oneshot(M)
+	shift = oneshot(shift)
+	meta = oneshot(meta)
+	control = oneshot(control)
+
+	leftalt = oneshot(alt)
+	rightalt = oneshot(altgr)
 
 	capslock = overload(C, esc)
 	insert = S-insert

keyd.1.gz

@@ -135,7 +135,7 @@ for the duration of the corresponding key stroke.
 The *layout* is a special kind of layer from which mappings are drawn if no
 other layers are active. By default all keys are mapped to themselves within a
 layout. Every config has at least one layout called *main*, but additional
-layouts may be defined and subsequently activated using the `layout()` action.  
+layouts may be defined and subsequently activated using the `layout()` action.
 
 Layouts also have the additional property of being affected by the active modifier
 set. That is, unlike layouts, key sequences mapped within them are not
@@ -185,19 +185,30 @@ By default each modifier key is mapped to an eponymously named modifier layer.
 
 Thus the above config can be shortened to:
 
-	[A]
+	[alt]
 
 	1 = C-A-f1
 
-since leftalt and rightalt are already assigned to `layer(A)`.
+since leftalt and rightalt are already assigned to `layer(alt)`.
 
-Additionally, any set of valid modifiers is also a valid layer. For
-example, the layer `M-C` corresponds to a layer which behaves like the
-modifiers meta and control, which means the following:
+Additionally, left hand values which are modifier names are expanded to both
+associated keycodes.
+
+E.G
+	control = esc
+
+is the equivalent of
+
+	rightcontrol = esc
+	leftcontrol = esc
+
+Finally any set of valid modifiers is also a valid layer. For example, the
+layer `M-C` corresponds to a layer which behaves like the modifiers meta and
+control, which means the following:
 
 	capslock = layer(M-A)
 
-will cause capslock to behave as meta and alt when held. 
+will cause capslock to behave as meta and alt when held.
 
 ### Lookup Rules
 
@@ -239,7 +250,7 @@ distinct from `layout()` which should be used for letter layouts.
 
 : Activates the given layer while held and emits the given key sequence when
 tapped. A timeout in milliseconds may optionally be supplied to disambiguate
-a tap and a hold. 
+a tap and a hold.
 
 	If a timeout is present depression of the corresponding key is only interpreted
 as a layer activation in the event that it is sustained for more than
@@ -319,9 +330,6 @@ Invert the behaviour of the shift key without breaking modifier behaviour.
 	*
 
 	[main]
-	leftshift = layer(shift)
-	rightshift = layer(shift)
-
 	1 = !
 	2 = @
 	3 = #
@@ -333,7 +341,7 @@ Invert the behaviour of the shift key without breaking modifier behaviour.
 	9 = (
 	0 = )
 
-	[shift:S]
+	[shift]
 	0 = 0
 	1 = 1
 	2 = 2
@@ -353,10 +361,12 @@ activates it until it is pressed again, and holding it produces expected
 behaviour.
 
 	[main]
+
 	leftcontrol = oneshot(control)
 	rightcontrol = oneshot(control)
 
 	[control:C]
+
 	toggle(control)
 
 # Example 4
@@ -365,14 +375,12 @@ Meta behaves as normal except when \` is pressed, after which the alt_tab layer
 is activated for the duration of the leftmeta keypress. Subsequent actuations
 of \` will thus produce A-tab instead of M-\`.
 
-	[main]
-	leftmeta = layer(meta)
-	rightmeta = layer(meta)
+	[meta]
 
-	[meta:M]
 	` = swap(alt_tab, A-tab)
 
 	[alt_tab:A]
+
 	tab = A-S-tab
 	` = A-tab
 

man.md

@@ -50,7 +50,8 @@ static int parse_kvp(char *s, char **key, char **value)
 	char *last_space = NULL;
 	char *c = s;
 
-	if (*c == '=')		//Allow the first character to be = as a special case.
+	/* Allow the first character to be = as a special case. */
+	if (*c == '=')
 		c++;
 
 	while (*c) {
@@ -263,35 +264,60 @@ static void parse_id_section(struct config *config, struct ini_section *section)
 	}
 }
 
+struct config *create_config(const char *name) 
+{
+	size_t i;
+	struct layer *main;
+	struct config *config;
+
+	config = calloc(1, sizeof(struct config));
+	strncpy(config->name, name, sizeof(config->name)-1);
+
+	main = create_layer("main", 0, 1);
+
+	config->nr_layers = 0;
+	config->layers[config->nr_layers++] = main;
+
+	for (i = 0; i < sizeof(modifier_table)/sizeof(modifier_table[0]); i++) {
+		struct modifier_table_ent *m = &modifier_table[i];
+
+		struct layer *layer;
+		struct descriptor d;
+
+		layer = create_layer(m->name, m->mask, 0);
+
+		d.op = OP_LAYER;
+		d.args[0].layer = layer;
+
+		layer_set_descriptor(main, m->code1, &d);
+		layer_set_descriptor(main, m->code2, &d);
+
+		config->layers[config->nr_layers++] = layer;
+	}
+
+	return config;
+}
+
 /*
  * Ownership of the input string is forfeit, it will eventually be freed when
  * the config is destroyed.
  */
 
-static int parse_config(const char *config_name, char *str, struct config *config)
+static int parse_config(struct config *config, char *str)
 {
 	size_t i, j;
 
 	struct ini ini;
 
 	struct ini_section *layer_sections[MAX_LAYERS];
 	struct layer *layers[MAX_LAYERS];
-	size_t nr_layers = 0;
-
+	size_t n = 0;
 
 	if (ini_parse(str, &ini, NULL) < 0) {
-		fprintf(stderr, "ERROR: %s is not a valid config (missing [main]?)\n", config_name);
+		fprintf(stderr, "ERROR: %s is not a valid config\n", config->name);
 		return -1;
 	}
 
-	config->nr_layers = 1;
-	config->nr_device_ids = 0;
-
-	config->layers[0] = create_layer("main", 0, 1);
-
-	assert(strlen(config_name) < MAX_CONFIG_NAME);
-	strcpy(config->name, config_name);
-
 	/*
 	 * First pass, create layers so they are available
 	 * for lookup during descriptor parsing.
@@ -311,42 +337,46 @@ static int parse_config(const char *config_name, char *str, struct config *confi
 		if (parse_header(section->name, name, type) < 0) {
 			fprintf(stderr,
 				"ERROR %s:%zu: Invalid header.\n",
-				config_name,
+				config->name,
 				section->lnum);
 			continue;
 		}
 
 		layer = lookup_layer(name, (void*)config);
 
-		if (!layer) { //If the layer doesn't exist, create it.
-			if (!strcmp(type, "layout")) {
+		if (!layer) { /* If the layer doesn't exist, create it. */
+			if (!strcmp(type, "layout"))
 				layer = create_layer(name, 0, 1);
-			} else if (!parse_modset(type, &mods)) {
+			else if (!parse_modset(type, &mods))
 				layer = create_layer(name, mods, 0);
-			} else if (strcmp(type, "")) {
+			else if (strcmp(type, "")) {
 				fprintf(stderr,
 					"WARNING %s:%zu: \"%s\" is not a valid layer type "
 					" (must be \"layout\" or a valid modifier set).\n",
-					config_name, section->lnum, type);
+					config->name, section->lnum, type);
 				continue;
 			}
 
 			config->layers[config->nr_layers++] = layer;
 		}
 
-		layers[nr_layers] = layer;
-		layer_sections[nr_layers++] = section;
+		layers[n] = layer;
+		layer_sections[n] = section;
+
+		n++;
 	}
 
-	/* Parse each entry section entry and build the layer keymap. */
+	/* Parse each section entry and build the layer keymap. */
 
-	for (i = 0; i < nr_layers; i++) {
+	for (i = 0; i < n; i++) {
 		struct ini_section *section = layer_sections[i];
 		struct layer *layer = layers[i];
 
 		/* Populate the layer described by the section. */
 
 		for (j = 0; j < section->nr_entries; j++) {
+			size_t i;
+			int is_mod;
 			struct ini_entry *ent = &section->entries[j];
 
 			char *k, *v;
@@ -357,97 +387,58 @@ static int parse_config(const char *config_name, char *str, struct config *confi
 			if (parse_kvp(ent->line, &k, &v) < 0) {
 				fprintf(stderr,
 					"ERROR %s:%zu: Invalid key value pair.\n",
-					config_name, ent->lnum);
-				continue;
-			}
-
-			code = lookup_keycode(k);
-
-			if (!code) {
-				fprintf(stderr,
-					"ERROR %s:%zu: %s is not a valid key.\n",
-					config_name, ent->lnum, k);
+					config->name, ent->lnum);
 				continue;
 			}
 
 			if (parse_descriptor(v, &desc, lookup_layer, config) < 0) {
-				fprintf(stderr, "ERROR %s:%zu: %s\n", config_name,
+				fprintf(stderr, "ERROR %s:%zu: %s\n", config->name,
 					ent->lnum, errstr);
 				continue;
 			}
 
-			layer_set_descriptor(layer, code, &desc);
-		}
-	}
-
-	return 0;
-}
+			is_mod = 0;
+			for (i = 0; i < sizeof(modifier_table)/sizeof(modifier_table[0]); i++) {
+				struct modifier_table_ent *m = &modifier_table[i];
 
-static void post_process_config(const struct config *config)
-{
-	size_t i;
-	uint16_t code;
-
-	/*
-	 * Convert all modifier keycodes into their corresponding layer
-	 * counterparts for consistency. This allows us to avoid explicitly
-	 * accounting for modifier layer/modifier keycode overlap within the
-	 * remapping logic and provides the user the ability to remap stock
-	 * modifiers using their eponymous layer names.
-	 */
+				if (!strcmp(m->name, k)) {
+					layer_set_descriptor(layer, m->code1, &desc);
+					layer_set_descriptor(layer, m->code2, &desc);
 
-	for (i = 0; i < config->nr_layers; i++) {
-		struct layer *layer = config->layers[i];
-
-		for (code = 0; code < KEY_MAX; code++) {
-			struct descriptor *d = layer_get_descriptor(layer, code);
-
-			if (d && d->op == OP_KEYSEQ) {
-				uint16_t key = d->args[0].sequence.code;
-				struct layer *modlayer = NULL;
-
-				switch(key) {
-				case KEY_RIGHTSHIFT:
-				case KEY_LEFTSHIFT:
-					modlayer = lookup_layer("S", (void*)config);
-					break;
-				case KEY_RIGHTALT:
-					modlayer = lookup_layer("G", (void*)config);
-					break;
-				case KEY_RIGHTCTRL:
-				case KEY_LEFTCTRL:
-					modlayer = lookup_layer("C", (void*)config);
-					break;
-				case KEY_RIGHTMETA:
-				case KEY_LEFTMETA:
-					modlayer = lookup_layer("M", (void*)config);
-					break;
-				case KEY_LEFTALT:
-					modlayer = lookup_layer("A", (void*)config);
+					is_mod++;
 					break;
 				}
+			}
 
-				if (modlayer) {
-					d->op = OP_LAYER;
-					d->args[0].layer = modlayer;
-				}
+			if (is_mod)
+				continue;
+
+			code = lookup_keycode(k);
+
+			if (!code) {
+				fprintf(stderr,
+					"ERROR %s:%zu: %s is not a valid key.\n",
+					config->name, ent->lnum, k);
+				continue;
 			}
 
+			layer_set_descriptor(layer, code, &desc);
+
 		}
 	}
+
+	return 0;
 }
 
 struct config *add_config(const char *config_name, char *str)
 {
-	struct config *config = malloc(sizeof(struct config));
+	struct config *config = create_config(config_name);
 
-	if (parse_config(config_name, str, config) < 0) {
+	if (parse_config(config, str) < 0) {
 		free(config);
 		return NULL;
 	}
 
-	post_process_config(config);
-
 	config->next = configs;
 	configs = config;