summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--exec.c364
-rw-r--r--handle.c1348
-rw-r--r--pf.c118
-rw-r--r--swap.km11
-rw-r--r--wq.h143
-rw-r--r--xmodmap.c341
-rw-r--r--xmodmap.h48
-rw-r--r--xmodmap.man302
8 files changed, 2675 insertions, 0 deletions
diff --git a/exec.c b/exec.c
new file mode 100644
index 0000000..612ec85
--- /dev/null
+++ b/exec.c
@@ -0,0 +1,364 @@
+/* $Xorg: exec.c,v 1.4 2001/02/09 02:05:56 xorgcvs Exp $ */
+/*
+
+Copyright 1988, 1998 The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+/*
+ * Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
+ *
+ * All Rights Reserved
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright no-
+ * tice appear in all copies and that both that copyright no-
+ * tice and this permission notice appear in supporting docu-
+ * mentation, and that the name of Sun not be used in
+ * advertising or publicity pertaining to distribution of the
+ * software without specific prior written permission. Sun
+ * makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without any
+ * express or implied warranty.
+ *
+ * SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
+ * NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI-
+ * ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
+ * THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Author: Jim Fulton, MIT X Consortium; derived from parts of the
+ * original xmodmap, written by David Rosenthal, of Sun Microsystems.
+ */
+
+#include <X11/Xos.h>
+#include <X11/Xlib.h>
+#include <stdio.h>
+#include "xmodmap.h"
+#include "wq.h"
+
+static mapping_busy_key (timeout)
+ int timeout;
+{
+ int i;
+ unsigned char keymap[32];
+ static unsigned int masktable[8] = {
+ 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
+
+ XQueryKeymap (dpy, (char *) keymap);
+
+ fprintf (stderr,
+ "%s: please release the following keys within %d seconds:\n",
+ ProgramName, timeout);
+ for (i = 0; i < 256; i++) {
+ if (keymap[i >> 3] & masktable[i & 7]) {
+ KeySym ks = XKeycodeToKeysym (dpy, (KeyCode) i, 0);
+ char *cp = XKeysymToString (ks);
+ fprintf (stderr, " %s (keysym 0x%x, keycode %d)\n",
+ cp ? cp : "UNNAMED", ks, i);
+ }
+ }
+ sleep (timeout);
+ return;
+}
+
+static mapping_busy_pointer (timeout)
+ int timeout;
+{
+ int i;
+ Window root, child; /* dummy variables */
+ int rx, ry, wx, wy; /* dummy variables */
+ unsigned int mask;
+ static unsigned int masks[5] = {
+ Button1Mask, Button2Mask, Button3Mask, Button4Mask, Button5Mask };
+
+ if (!XQueryPointer (dpy, RootWindow(dpy,DefaultScreen(dpy)),
+ &root, &child, &rx, &ry, &wx, &wy, &mask))
+ mask = 0;
+
+ fprintf (stderr,
+ "%s: please release the following buttons within %d seconds:\n",
+ ProgramName, timeout);
+ for (i = 0; i < 5; i++) {
+ if (mask & masks[i])
+ fprintf (stderr, " Button%d\n", i+1);
+ }
+ sleep (timeout);
+ return;
+}
+
+
+/*
+ * UpdateModifierMapping - this sends the modifier map to the server
+ * and deals with retransmissions due to the keyboard being busy.
+ */
+
+int UpdateModifierMapping (map)
+ XModifierKeymap *map;
+{
+ int retries, timeout;
+
+ for (retries = 5, timeout = 2; retries > 0; retries--, timeout *= 2) {
+ int result;
+
+ result = XSetModifierMapping (dpy, map);
+ switch (result) {
+ case MappingSuccess: /* Success */
+ return (0);
+ case MappingBusy: /* Busy */
+ mapping_busy_key (timeout);
+ continue;
+ case MappingFailed:
+ fprintf (stderr, "%s: bad set modifier mapping.\n",
+ ProgramName);
+ return (-1);
+ default:
+ fprintf (stderr, "%s: bad return %d from XSetModifierMapping\n",
+ ProgramName, result);
+ return (-1);
+ }
+ }
+ fprintf (stderr,
+ "%s: unable to set modifier mapping, keyboard problem\n",
+ ProgramName);
+ return (-1);
+}
+
+
+/*
+ * AddModifier - this adds a keycode to the modifier list
+ */
+
+int AddModifier (mapp, keycode, modifier)
+ XModifierKeymap **mapp;
+ KeyCode keycode;
+ int modifier;
+{
+ if (keycode) {
+ *mapp = XInsertModifiermapEntry (*mapp, keycode, modifier);
+ return (0);
+ } else {
+ return (-1);
+ }
+ /*NOTREACHED*/
+}
+
+
+/*
+ * DeleteModifier - this removes a keycode from the modifier list
+ */
+
+int RemoveModifier (mapp, keycode, modifier)
+ XModifierKeymap **mapp;
+ KeyCode keycode;
+ int modifier;
+{
+ if (keycode) {
+ *mapp = XDeleteModifiermapEntry (*mapp, keycode, modifier);
+ return (0);
+ } else {
+ return (-1);
+ }
+ /*NOTREACHED*/
+}
+
+
+/*
+ * ClearModifier - this removes all entries from the modifier list
+ */
+
+int ClearModifier (mapp, modifier)
+ XModifierKeymap **mapp;
+ int modifier;
+{
+ int i;
+ XModifierKeymap *map = *mapp;
+ KeyCode *kcp;
+
+ kcp = &map->modifiermap[modifier * map->max_keypermod];
+ for (i = 0; i < map->max_keypermod; i++) {
+ *kcp++ = (KeyCode) 0;
+ }
+ return (0);
+}
+
+
+/*
+ * print the contents of the map
+ */
+
+PrintModifierMapping (map, fp)
+ XModifierKeymap *map;
+ FILE *fp;
+{
+ int i, k = 0;
+
+ fprintf (fp,
+ "%s: up to %d keys per modifier, (keycodes in parentheses):\n\n",
+ ProgramName, map->max_keypermod);
+ for (i = 0; i < 8; i++) {
+ int j;
+
+ fprintf(fp, "%-10s", modifier_table[i].name);
+ for (j = 0; j < map->max_keypermod; j++) {
+ if (map->modifiermap[k]) {
+ KeySym ks = XKeycodeToKeysym(dpy, map->modifiermap[k], 0);
+ char *nm = XKeysymToString(ks);
+
+ fprintf (fp, "%s %s (0x%0x)", (j > 0 ? "," : ""),
+ (nm ? nm : "BadKey"), map->modifiermap[k]);
+ }
+ k++;
+ }
+ fprintf(fp, "\n");
+ }
+ fprintf (fp, "\n");
+ return;
+}
+
+
+PrintKeyTable (exprs, fp)
+ Bool exprs;
+ FILE *fp;
+{
+ int i;
+ int min_keycode, max_keycode, keysyms_per_keycode;
+ KeySym *keymap, *origkeymap;
+
+ XDisplayKeycodes (dpy, &min_keycode, &max_keycode);
+ origkeymap = XGetKeyboardMapping (dpy, min_keycode,
+ (max_keycode - min_keycode + 1),
+ &keysyms_per_keycode);
+
+ if (!origkeymap) {
+ fprintf (stderr, "%s: unable to get keyboard mapping table.\n",
+ ProgramName);
+ return;
+ }
+ if (!exprs) {
+ fprintf (fp,
+ "There are %d KeySyms per KeyCode; KeyCodes range from %d to %d.\n\n",
+ keysyms_per_keycode, min_keycode, max_keycode);
+ fprintf (fp, " KeyCode\tKeysym (Keysym)\t...\n");
+ fprintf (fp, " Value \tValue (Name) \t...\n\n");
+ }
+ keymap = origkeymap;
+ for (i = min_keycode; i <= max_keycode; i++) {
+ int j, max;
+
+ if (exprs)
+ fprintf(fp, "keycode %3d =", i);
+ else
+ fprintf(fp, " %3d \t", i);
+ max = keysyms_per_keycode - 1;
+ while ((max >= 0) && (keymap[max] == NoSymbol))
+ max--;
+ for (j = 0; j <= max; j++) {
+ register KeySym ks = keymap[j];
+ char *s;
+ if (ks != NoSymbol)
+ s = XKeysymToString (ks);
+ else
+ s = "NoSymbol";
+ if (!exprs)
+ fprintf (fp, "0x%04x (%s)\t", ks, s ? s : "no name");
+ else if (s)
+ fprintf (fp, " %s", s);
+ else
+ fprintf (fp, " 0x%04x", ks);
+ }
+ keymap += keysyms_per_keycode;
+ fprintf (fp, "\n");
+ }
+
+ XFree ((char *) origkeymap);
+ return;
+}
+
+
+PrintPointerMap (fp)
+ FILE *fp;
+{
+ unsigned char pmap[256]; /* there are 8 bits of buttons */
+ int count, i;
+
+ count = XGetPointerMapping (dpy, pmap, 256);
+
+ fprintf (fp, "There are %d pointer buttons defined.\n\n", count);
+ fprintf (fp, " Physical Button\n");
+ fprintf (fp, " Button Code\n");
+/* " ### ###\n" */
+ for (i = 0; i < count; i++) {
+ fprintf (fp, " %3u %3u\n",
+ i+1, (unsigned int) pmap[i]);
+ }
+ fprintf (fp, "\n");
+ return;
+}
+
+
+/*
+ * SetPointerMap - set the pointer map
+ */
+
+int SetPointerMap (map, n)
+ unsigned char *map;
+ int n;
+{
+ unsigned char defmap[MAXBUTTONCODES];
+ int j;
+ int retries, timeout;
+
+ if (n == 0) { /* reset to default */
+ n = XGetPointerMapping (dpy, defmap, MAXBUTTONCODES);
+ for (j = 0; j < n; j++) defmap[j] = (unsigned char) (j + 1);
+ map = defmap;
+ }
+
+ for (retries = 5, timeout = 2; retries > 0; retries--, timeout *= 2) {
+ int result;
+
+ switch (result = XSetPointerMapping (dpy, map, n)) {
+ case MappingSuccess:
+ return 0;
+ case MappingBusy:
+ mapping_busy_pointer (timeout);
+ continue;
+ case MappingFailed:
+ fprintf (stderr, "%s: bad pointer mapping\n", ProgramName);
+ return -1;
+ default:
+ fprintf (stderr, "%s: bad return %d from XSetPointerMapping\n",
+ ProgramName, result);
+ return -1;
+ }
+ }
+ fprintf (stderr, "%s: unable to set pointer mapping\n", ProgramName);
+ return -1;
+}
diff --git a/handle.c b/handle.c
new file mode 100644
index 0000000..df2e82a
--- /dev/null
+++ b/handle.c
@@ -0,0 +1,1348 @@
+/* $Xorg: handle.c,v 1.6 2001/02/09 02:05:56 xorgcvs Exp $ */
+/*
+
+Copyright 1988, 1998 The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+#include <X11/Xos.h>
+#include <X11/Xlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include "xmodmap.h"
+#include "wq.h"
+
+static XModifierKeymap *map = NULL;
+
+
+/*
+ * The routines in this file manipulate a queue of intructions. Instead of
+ * executing each line as it is entered, we build up a list of actions to
+ * take and execute them all at the end. This allows us to find all errors
+ * at once, and to preserve the context in which we are looking up keysyms.
+ */
+
+struct wq work_queue = {NULL, NULL};
+
+
+/*
+ * common utility routines
+ */
+
+KeyCode *KeysymToKeycodes(dpy, keysym, pnum_kcs)
+ Display *dpy;
+ KeySym keysym;
+ int *pnum_kcs;
+{
+ KeyCode *kcs = NULL;
+ int i, j;
+
+ *pnum_kcs = 0;
+ for (i = min_keycode; i <= max_keycode; i++) {
+ for (j = 0; j < 8; j++) {
+ if (XKeycodeToKeysym(dpy, (KeyCode) i, j) == keysym) {
+ if (!kcs)
+ kcs = (KeyCode *)malloc(sizeof(KeyCode));
+ else
+ kcs = (KeyCode *)realloc((char *)kcs,
+ sizeof(KeyCode) * (*pnum_kcs + 1));
+ kcs[*pnum_kcs] = i;
+ *pnum_kcs += 1;
+ break;
+ }
+ }
+ }
+ return kcs;
+}
+
+char *copy_to_scratch (s, len)
+ char *s;
+ int len;
+{
+ static char *buf = NULL;
+ static int buflen = 0;
+
+ if (len > buflen) {
+ if (buf) free (buf);
+ buflen = (len < 40) ? 80 : (len * 2);
+ buf = (char *) malloc (buflen+1);
+ }
+ if (len > 0)
+ strncpy (buf, s, len);
+ else
+ len = 0;
+
+ buf[len] = '\0';
+ return (buf);
+}
+
+static badheader ()
+{
+ fprintf (stderr, "%s: %s:%d: bad ", ProgramName, inputFilename, lineno);
+ parse_errors++;
+}
+
+#define badmsg(what,arg) { badheader(); fprintf (stderr, what, arg); \
+ putc ('\n', stderr); }
+
+#define badmsgn(what,s,len) badmsg (what, copy_to_scratch (s, len))
+
+void initialize_map ()
+{
+ map = XGetModifierMapping (dpy);
+ return;
+}
+
+static void do_keycode(), do_keysym(), finish_keycodes();
+static void do_add(), do_remove(), do_clear(), do_pointer();
+static int get_keysym_list();
+
+int skip_word(), skip_space(), skip_chars();
+
+static struct dt {
+ char *command; /* name of input command */
+ int length; /* length of command */
+ void (*proc)(); /* handler */
+} dispatch_table[] = {
+ { "keycode", 7, do_keycode },
+ { "keysym", 6, do_keysym },
+ { "add", 3, do_add },
+ { "remove", 6, do_remove },
+ { "clear", 5, do_clear },
+ { "pointer", 7, do_pointer },
+ { NULL, 0, NULL }};
+
+/*
+ * handle_line - this routine parses the input line (which has had all leading
+ * and trailing whitespace removed) and builds up the work queue.
+ */
+
+void handle_line (line, len)
+ char *line; /* string to parse */
+ int len; /* length of line */
+{
+ int n;
+ struct dt *dtp;
+
+ n = skip_chars (line, len);
+ if (n < 0) {
+ badmsg ("input line '%s'", line);
+ return;
+ }
+
+ for (dtp = dispatch_table; dtp->command != NULL; dtp++) {
+ if (n == dtp->length &&
+ strncmp (line, dtp->command, dtp->length) == 0) {
+
+ n += skip_space (line+n, len-n);
+ line += n, len -= n;
+
+ (*(dtp->proc)) (line, len);
+ return;
+ }
+ }
+
+ fprintf (stderr, "%s: unknown command on line %s:%d\n",
+ ProgramName, inputFilename, lineno);
+ parse_errors++;
+}
+
+/*
+ * the following routines are useful for parsing
+ */
+
+int skip_word (s, len)
+ register char *s;
+ register int len;
+{
+ register int n;
+
+ n = skip_chars (s, len);
+ return (n + skip_space (s+n, len-n));
+}
+
+int skip_chars (s, len)
+ register char *s;
+ register int len;
+{
+ register int i;
+
+ if (len <= 0 || !s || *s == '\0') return (0);
+
+ for (i = 0; i < len; i++) {
+ if (isspace(s[i])) break;
+ }
+ return (i);
+}
+
+int skip_space (s, len)
+ register char *s;
+ register int len;
+{
+ register int i;
+
+ if (len <= 0 || !s || *s == '\0') return (0);
+
+ for (i = 0; i < len; i++) {
+ if (!s[i] || !isspace(s[i])) break;
+ }
+ return (i);
+}
+
+
+int skip_until_char (s, len, c)
+ register char *s;
+ register int len;
+ register char c;
+{
+ register int i;
+
+ for (i = 0; i < len; i++) {
+ if (s[i] == c) break;
+ }
+ return (i);
+}
+
+int skip_until_chars (s, len, cs, cslen)
+ char *s;
+ int len;
+ register char *cs;
+ register int cslen;
+{
+ int i;
+
+ for (i = 0; i < len; i++) {
+ register int j;
+ register char c = s[i];
+
+ for (j = 0; j < cslen; j++) {
+ if (c == cs[j]) goto done;
+ }
+ }
+ done:
+ return (i);
+}
+
+/*
+ * The action routines.
+ *
+ * This is where the real work gets done. Each routine is responsible for
+ * parsing its input (note that the command keyword has been stripped off)
+ * and adding to the work queue. They are also in charge of outputting
+ * error messages and returning non-zero if there is a problem.
+ *
+ * The following global variables are available:
+ * dpy the display descriptor
+ * work_queue linked list of opcodes
+ * inputFilename name of the file being processed
+ * lineno line number of current line in input file
+ */
+
+add_to_work_queue (p) /* this can become a macro someday */
+ union op *p;
+{
+ if (work_queue.head == NULL) { /* nothing on the list */
+ work_queue.head = work_queue.tail = p; /* head, tail, no prev */
+ } else {
+ work_queue.tail->generic.next = p; /* head okay, prev */
+ work_queue.tail = p; /* tail */
+ }
+ p->generic.next = NULL;
+
+ if (verbose) {
+ print_opcode (p);
+ }
+ return;
+}
+
+char *copystring (s, len)
+ char *s;
+ int len;
+{
+ char *retval;
+
+ retval = (char *) malloc (len+1);
+ if (retval) {
+ strncpy (retval, s, len);
+ retval[len] = '\0';
+ }
+ return (retval);
+}
+
+static Bool parse_number (str, val)
+ char *str;
+ unsigned long *val;
+{
+ char *fmt = "%ld";
+
+ if (*str == '0') {
+ str++;
+ fmt = "%lo";
+ if (*str == '\0') {
+ *val = 0;
+ return 1;
+ }
+ if (*str == 'x' || *str == 'X') {
+ str++;
+ fmt = "%lx";
+ }
+ }
+ return (sscanf (str, fmt, val) == 1);
+}
+
+static Bool parse_keysym (line, n, name, keysym)
+ char *line;
+ int n;
+ char **name;
+ KeySym *keysym;
+{
+ *name = copy_to_scratch (line, n);
+ if (!strcmp(*name, "NoSymbol")) {
+ *keysym = NoSymbol;
+ return (True);
+ }
+ *keysym = XStringToKeysym (*name);
+ if (*keysym == NoSymbol && '0' <= **name && **name <= '9')
+ return parse_number(*name, keysym);
+ return (*keysym != NoSymbol);
+}
+
+/*
+ * do_keycode - parse off lines of the form
+ *
+ * "keycode" number "=" [keysym ...]
+ * ^
+ *
+ * where number is in decimal, hex, or octal. Any number of keysyms may be
+ * listed.
+ */
+
+static void do_keycode (line, len)
+ char *line;
+ int len;
+{
+ int dummy;
+ char *fmt = "%d";
+ KeyCode keycode;
+
+ if (len < 3 || !line || *line == '\0') { /* 5=a minimum */
+ badmsg ("keycode input line", NULL);
+ return;
+ }
+
+ if (!strncmp("any", line, 3)) {
+ keycode = 0;
+ len += 3;
+ } else {
+ if (*line == '0') line++, len--, fmt = "%o";
+ if (*line == 'x' || *line == 'X') line++, len--, fmt = "%x";
+
+ dummy = 0;
+ if (sscanf (line, fmt, &dummy) != 1 || dummy == 0) {
+ badmsg ("keycode value", NULL);
+ return;
+ }
+ keycode = (KeyCode) dummy;
+ if ((int)keycode < min_keycode || (int)keycode > max_keycode) {
+ badmsg ("keycode value (out of range)", NULL);
+ return;
+ }
+ }
+
+ finish_keycodes (line, len, &keycode, 1);
+}
+
+
+/*
+ * do_keysym - parse off lines of the form
+ *
+ * "keysym" keysym "=" [keysym ...]
+ * ^
+ *
+ * The left keysyms has to be checked for validity and evaluated.
+ */
+
+static void do_keysym (line, len)
+ char *line;
+ int len;
+{
+ int n;
+ KeyCode *keycodes;
+ KeySym keysym;
+ char *tmpname;
+
+ if (len < 3 || !line || *line == '\0') { /* a=b minimum */
+ badmsg ("keysym input line", NULL);
+ return;
+ }
+
+ n = skip_chars (line, len);
+ if (n < 1) {
+ badmsg ("target keysym name", NULL);
+ return;
+ }
+ if (!parse_keysym(line, n, &tmpname, &keysym)) {
+ badmsg ("keysym target key symbol '%s'", tmpname);
+ return;
+ }
+
+ keycodes = KeysymToKeycodes (dpy, keysym, &n);
+ if (n == 0) {
+ badmsg ("keysym target keysym '%s', no corresponding keycodes",
+ tmpname);
+ return;
+ }
+ if (verbose) {
+ int i;
+ printf ("! Keysym %s (0x%lx) corresponds to keycode(s)",
+ tmpname, (long) keysym);
+ for (i = 0; i < n; i++)
+ printf (" 0x%x", keycodes[i]);
+ printf("\n");
+ }
+
+ finish_keycodes (line, len, keycodes, n);
+}
+
+static void finish_keycodes (line, len, keycodes, count)
+ char *line;
+ int len;
+ KeyCode *keycodes;
+ int count;
+{
+ int n;
+ KeySym *kslist;
+ union op *uop;
+ struct op_keycode *opk;
+
+ n = skip_until_char (line, len, '=');
+ line += n, len -= n;
+
+ if (len < 1 || *line != '=') { /* = minimum */
+ badmsg ("keycode command (missing keysym list),", NULL);
+ return;
+ }
+ line++, len--; /* skip past the = */
+
+ n = skip_space (line, len);
+ line += n, len -= n;
+
+ /* allow empty list */
+ if (get_keysym_list (line, len, &n, &kslist) < 0)
+ return;
+
+ while (--count >= 0) {
+ uop = AllocStruct (union op);
+ if (!uop) {
+ badmsg ("attempt to allocate a %ld byte keycode opcode",
+ (long) sizeof (struct op_keycode));
+ return;
+ }
+ opk = &uop->keycode;
+
+ opk->type = doKeycode;
+ opk->target_keycode = keycodes[count];
+ opk->count = n;
+ opk->keysyms = kslist;
+
+ add_to_work_queue (uop);
+ }
+
+#ifdef later
+ /* make sure we handle any special keys */
+ check_special_keys (keycode, n, kslist);
+#endif
+}
+
+
+/*
+ * parse_modifier - convert a modifier string name to its index
+ */
+
+struct modtab modifier_table[] = { /* keep in order so it can be index */
+ { "shift", 5, 0 },
+ { "lock", 4, 1 },
+ { "control", 7, 2 },
+ { "mod1", 4, 3 },
+ { "mod2", 4, 4 },
+ { "mod3", 4, 5 },
+ { "mod4", 4, 6 },
+ { "mod5", 4, 7 },
+ { "ctrl", 4, 2 },
+ { NULL, 0, 0 }};
+
+static int parse_modifier (line, n)
+ register char *line;
+ register int n;
+{
+ register int i;
+ struct modtab *mt;
+
+ /* lowercase for comparison against table */
+ for (i = 0; i < n; i++) {
+ if (isupper (line[i])) line[i] = tolower (line[i]);
+ }
+
+ for (mt = modifier_table; mt->name; mt++) {
+ if (n == mt->length && strncmp (line, mt->name, n) == 0)
+ return (mt->value);
+ }
+ return (-1);
+}
+
+
+/*
+ * do_add - parse off lines of the form
+ *
+ * add MODIFIER = keysym ...
+ * ^
+ * where the MODIFIER is one of Shift, Lock, Control, Mod[1-5] where case
+ * is not important. There should also be an alias Ctrl for control.
+ */
+
+static void do_add (line, len)
+ char *line;
+ int len;
+{
+ int n;
+ int modifier;
+ KeySym *kslist;
+ union op *uop;
+ struct op_addmodifier *opam;
+
+ if (len < 6 || !line || *line == '\0') { /* Lock=a minimum */
+ badmsg ("add modifier input line", NULL);
+ return;
+ }
+
+ n = skip_chars (line, len);
+ if (n < 1) {
+ badmsg ("add modifier name %s", line);
+ return;
+ }
+
+ modifier = parse_modifier (line, n);
+ if (modifier < 0) {
+ badmsgn ("add modifier name '%s', not allowed", line, n);
+ return;
+ }
+
+ line += n, len -= n;
+ n = skip_until_char (line, len, '=');
+ if (n < 0) {
+ badmsg ("add modifier = keysym", NULL);
+ return;
+ }
+
+ n++; /* skip = */
+ n += skip_space (line+n, len-n);
+ line += n, len -= n;
+
+ if (get_keysym_list (line, len, &n, &kslist) < 0)
+ return;
+ if (n == 0) {
+ badmsg ("add modifier keysym list (empty)", NULL);
+ return;
+ }
+
+ uop = AllocStruct (union op);
+ if (!uop) {
+ badmsg ("attempt to allocate %ld byte addmodifier opcode",
+ (long) sizeof (struct op_addmodifier));
+ return;
+ }
+ opam = &uop->addmodifier;
+
+ opam->type = doAddModifier;
+ opam->modifier = modifier;
+ opam->count = n;
+ opam->keysyms = kslist;
+
+ add_to_work_queue (uop);
+}
+
+#ifdef AUTO_ADD_REMOVE
+/*
+ * make_add - stick a single add onto the queue
+ */
+static void make_add (modifier, keysym)
+ int modifier;
+ KeySym keysym;
+{
+ union op *uop;
+ struct op_addmodifier *opam;
+
+ uop = AllocStruct (union op);
+ if (!uop) {
+ badmsg ("attempt to allocate %ld byte addmodifier opcode",
+ (long) sizeof (struct op_addmodifier));
+ return;
+ }
+ opam = &uop->addmodifier;
+
+ opam->type = doAddModifier;
+ opam->modifier = modifier;
+ opam->count = 1;
+ opam->keysyms = (KeySym *) malloc (sizeof (KeySym));
+ if (!opam->keysyms) {
+ badmsg ("attempt to allocate %ld byte KeySym", (long) sizeof (KeySym));
+ free ((char *) opam);
+ return;
+ }
+ opam->keysyms[0] = keysym;
+
+ add_to_work_queue (uop);
+ return;
+}
+#endif /* AUTO_ADD_REMOVE */
+
+
+/*
+ * do_remove - parse off lines of the form
+ *
+ * remove MODIFIER = oldkeysym ...
+ * ^
+ * where the MODIFIER is one of Shift, Lock, Control, Mod[1-5] where case
+ * is not important. There should also be an alias Ctrl for control.
+ */
+
+static void do_remove (line, len)
+ char *line;
+ int len;
+{
+ int n;
+ int nc;
+ int i;
+ int tot;
+ int modifier;
+ KeySym *kslist;
+ KeyCode *kclist;
+ union op *uop;
+ struct op_removemodifier *oprm;
+
+ if (len < 6 || !line || *line == '\0') { /* Lock=a minimum */
+ badmsg ("remove modifier input line", NULL);
+ return;
+ }
+
+ n = skip_chars (line, len);
+ if (n < 1) {
+ badmsg ("remove modifier name %s", line);
+ return;
+ }
+
+ modifier = parse_modifier (line, n);
+ if (modifier < 0) {
+ badmsgn ("remove modifier name '%s', not allowed", line, n);
+ return;
+ }
+
+ line += n, len -= n;
+ n = skip_until_char (line, len, '=');
+ if (n < 0) {
+ badmsg ("remove modifier = keysym", NULL);
+ return;
+ }
+
+ n++;
+ n += skip_space (line+n, len-n);
+ line += n, len -= n;
+
+ if (get_keysym_list (line, len, &n, &kslist) < 0)
+ return;
+ if (n == 0) {
+ badmsg ("remove modifier keysym list (empty)", NULL);
+ return;
+ }
+
+ /*
+ * unlike the add command, we have to now evaluate the keysyms
+ */
+
+ kclist = (KeyCode *) malloc (n * sizeof (KeyCode));
+ if (!kclist) {
+ badmsg ("attempt to allocate %ld byte keycode list",
+ (long) (n * sizeof (KeyCode)));
+ free ((char *) kslist);
+ return;
+ }
+
+ tot = n;
+ nc = 0;
+ for (i = 0; i < n; i++) {
+ int num_kcs;
+ KeyCode *kcs;
+ kcs = KeysymToKeycodes (dpy, kslist[i], &num_kcs);
+ if (num_kcs == 0) {
+ char *tmpname = XKeysymToString (kslist[i]);
+ badmsg ("keysym in remove modifier list '%s', no corresponding keycodes",
+ tmpname ? tmpname : "?");
+ continue;
+ }
+ if (verbose) {
+ int j;
+ char *tmpname = XKeysymToString (kslist[i]);
+ printf ("! Keysym %s (0x%lx) corresponds to keycode(s)",
+ tmpname ? tmpname : "?", (long) kslist[i]);
+ for (j = 0; j < num_kcs; j++)
+ printf(" 0x%x", kcs[j]);
+ printf("\n");
+ }
+ if (nc + num_kcs > tot) {
+ tot = nc + num_kcs;
+ kclist = (KeyCode *)realloc((char *)kclist, tot * sizeof(KeyCode));
+ if (!kclist) {
+ badmsg ("attempt to allocate %ld byte keycode list",
+ (long) (tot * sizeof (KeyCode)));
+ free ((char *) kslist);
+ return;
+ }
+ }
+ while (--num_kcs >= 0)
+ kclist[nc++] = *kcs++; /* okay, add it to list */
+ }
+
+ free ((char *) kslist); /* all done with it */
+
+ uop = AllocStruct (union op);
+ if (!uop) {
+ badmsg ("attempt to allocate %ld byte removemodifier opcode",
+ (long) sizeof (struct op_removemodifier));
+ return;
+ }
+ oprm = &uop->removemodifier;
+
+ oprm->type = doRemoveModifier;
+ oprm->modifier = modifier;
+ oprm->count = nc;
+ oprm->keycodes = kclist;
+
+ add_to_work_queue (uop);
+}
+
+#ifdef AUTO_ADD_REMOVE
+/*
+ * make_remove - stick a single remove onto the queue
+ */
+static void make_remove (modifier, keycode)
+ int modifier;
+ KeyCode keycode;
+{
+ union op *uop;
+ struct op_removemodifier *oprm;
+
+ uop = AllocStruct (union op);
+ if (!uop) {
+ badmsg ("attempt to allocate %ld byte removemodifier opcode",
+ (long) sizeof (struct op_removemodifier));
+ return;
+ }
+ oprm = &uop->removemodifier;
+
+ oprm->type = doRemoveModifier;
+ oprm->modifier = modifier;
+ oprm->count = 1;
+ oprm->keycodes = (KeyCode *) malloc (sizeof (KeyCode));
+ if (!oprm->keycodes) {
+ badmsg ("attempt to allocate %ld byte KeyCode",
+ (long) sizeof (KeyCode));
+ free ((char *) oprm);
+ return;
+ }
+ oprm->keycodes[0] = keycode;
+
+ add_to_work_queue (uop);
+ return;
+}
+#endif /* AUTO_ADD_REMOVE */
+
+
+/*
+ * do_clear - parse off lines of the form
+ *
+ * clear MODIFIER
+ * ^
+ */
+
+static void do_clear (line, len)
+ char *line;
+ int len;
+{
+ int n;
+ int modifier;
+ union op *uop;
+ struct op_clearmodifier *opcm;
+
+ if (len < 4 || !line || *line == '\0') { /* Lock minimum */
+ badmsg ("clear modifier input line", NULL);
+ return;
+ }
+
+ n = skip_chars (line, len);
+
+ modifier = parse_modifier (line, n);
+ if (modifier < 0) {
+ badmsgn ("clear modifier name '%s'", line, n);
+ return;
+ }
+ n += skip_space (line+n, len-n);
+ if (n != len) {
+ badmsgn ("extra argument '%s' to clear modifier", line+n, len-n);
+ /* okay to continue */
+ }
+
+ uop = AllocStruct (union op);
+ if (!uop) {
+ badmsg ("attempt to allocate %d byte clearmodifier opcode",
+ (long) sizeof (struct op_clearmodifier));
+ return;
+ }
+ opcm = &uop->clearmodifier;
+
+ opcm->type = doClearModifier;
+ opcm->modifier = modifier;
+
+ add_to_work_queue (uop);
+}
+
+static int strncmp_nocase (a, b, n)
+ char *a, *b;
+ int n;
+{
+ int i;
+ int a1, b1;
+
+ for (i = 0; i < n; i++, a++, b++) {
+ if (!*a) return -1;
+ if (!*b) return 1;
+
+ if (*a != *b) {
+ a1 = (isascii(*a) && isupper(*a)) ? tolower(*a) : *a;
+ b1 = (isascii(*b) && isupper(*b)) ? tolower(*b) : *b;
+ if (a1 != b1) return b1 - a1;
+ }
+ }
+ return 0;
+}
+
+
+/*
+ * do_pointer = get list of numbers of the form
+ *
+ * buttons = NUMBER ...
+ * ^
+ */
+
+static void do_pointer (line, len)
+ char *line;
+ int len;
+{
+ int n;
+ int i;
+ unsigned long val;
+ union op *uop;
+ struct op_pointer *opp;
+ unsigned char buttons[MAXBUTTONCODES];
+ int nbuttons;
+ char *strval;
+ Bool ok;
+
+ if (len < 2 || !line || *line == '\0') { /* =1 minimum */
+ badmsg ("buttons input line", NULL);
+ return;
+ }
+
+ nbuttons = XGetPointerMapping (dpy, buttons, MAXBUTTONCODES);
+
+ n = skip_space (line, len);
+ line += n, len -= n;
+
+ if (line[0] != '=') {
+ badmsg ("buttons pointer code list, missing equal sign", NULL);
+ return;
+ }
+
+ line++, len--; /* skip = */
+ n = skip_space (line, len);
+ line += n, len -= n;
+
+ i = 0;
+ if (len < 7 || strncmp_nocase (line, "default", 7) != 0) {
+ while (len > 0) {
+ n = skip_space (line, len);
+ line += n, len -= n;
+ if (line[0] == '\0') break;
+ n = skip_word (line, len);
+ if (n < 1) {
+ badmsg ("skip of word in buttons line: %s", line);
+ return;
+ }
+ strval = copy_to_scratch(line, n);
+ ok = parse_number (strval, &val);
+ if (!ok || val >= MAXBUTTONCODES) {
+ badmsg ("value %s given for buttons list", strval);
+ return;
+ }
+ buttons[i++] = (unsigned char) val;
+ line += n, len -= n;
+ }
+ }
+
+ if (i > 0 && i != nbuttons) {
+ badheader ();
+ fprintf (stderr, "number of buttons, must have %d instead of %d\n",
+ nbuttons, i);
+ return;
+ }
+
+ uop = AllocStruct (union op);
+ if (!uop) {
+ badmsg ("attempt to allocate a %ld byte pointer opcode",
+ (long) sizeof (struct op_pointer));
+ return;
+ }
+ opp = &uop->pointer;
+
+ opp->type = doPointer;
+ opp->count = i;
+ for (i = 0; i < opp->count; i++) {
+ opp->button_codes[i] = buttons[i];
+ }
+
+ add_to_work_queue (uop);
+}
+
+
+/*
+ * get_keysym_list - parses the rest of the line into a keysyms assumes
+ * that the = sign has been parsed off but there may be leading whitespace
+ *
+ * keysym ...
+ * ^
+ *
+ * this involves getting the word containing the keysym, checking its range,
+ * and adding it to the list.
+ */
+
+static int get_keysym_list (line, len, np, kslistp)
+ char *line;
+ int len;
+ int *np;
+ KeySym **kslistp;
+{
+ int havesofar, maxcanhave;
+ KeySym *keysymlist;
+
+ *np = 0;
+ *kslistp = NULL;
+
+ if (len == 0) return (0); /* empty list */
+
+ havesofar = 0;
+ maxcanhave = 4; /* most lists are small */
+ keysymlist = (KeySym *) malloc (maxcanhave * sizeof (KeySym));
+ if (!keysymlist) {
+ badmsg ("attempt to allocate %ld byte initial keysymlist",
+ (long) (maxcanhave * sizeof (KeySym)));
+ return (-1);
+ }
+
+ while (len > 0) {
+ KeySym keysym;
+ int n;
+ char *tmpname;
+ Bool ok;
+
+ n = skip_space (line, len);
+ line += n, len -= n;
+
+ n = skip_chars (line, len);
+ if (n < 0) {
+ badmsg ("keysym name list", NULL);
+ return (-1);
+ }
+
+ ok = parse_keysym (line, n, &tmpname, &keysym);
+ line += n, len -= n;
+ if (!ok) {
+ badmsg ("keysym name '%s' in keysym list", tmpname);
+ /* do NOT return here, look for others */
+ continue;
+ }
+
+ /*
+ * Do NOT test to see if the keysym translates to a keycode or you
+ * won't be able to assign new ones....
+ */
+
+ /* grow the list bigger if necessary */
+ if (havesofar >= maxcanhave) {
+ maxcanhave *= 2;
+ keysymlist = (KeySym *) realloc (keysymlist,
+ maxcanhave * sizeof (KeySym));
+ if (!keysymlist) {
+ badmsg ("attempt to grow keysym list to %ld bytes",
+ (long) (maxcanhave * sizeof (KeySym)));
+ return (-1);
+ }
+ }
+
+ /* and add it to the list */
+ keysymlist[havesofar++] = keysym;
+ }
+
+ *kslistp = keysymlist;
+ *np = havesofar;
+ return (0);
+}
+
+
+#ifdef later
+/*
+ * check_special_keys - run through list of keysyms and generate "add" or
+ * "remove" commands for for any of the key syms that appear in the modifier
+ * list. this involves running down the modifier map which is an array of
+ * 8 by map->max_keypermod keycodes.
+ */
+
+static void check_special_keys (keycode, n, kslist)
+ KeyCode keycode;
+ int n;
+ KeySym *kslist;
+{
+ int i; /* iterator variable */
+ KeyCode *kcp; /* keycode pointer */
+
+ /*
+ * walk the modifiermap array. since its dimensions are not known at
+ * compile time, we have to walk it by hand instead of indexing. this
+ * is why it is initialized outside the loop, but incremented inside the
+ * second loop.
+ */
+
+ kcp = map->modifiermap; /* start at beginning and iterate */
+ for (i = 0; i < 8; i++) { /* there are 8 modifier keys */
+ int j;
+
+ for (j = 0; j < map->max_keypermod; j++, kcp++) {
+ KeySym keysym;
+ int k;
+
+ if (!*kcp) continue; /* only non-zero entries significant */
+
+ /*
+ * check to see if the target keycode is already a modifier; if so,
+ * then we have to remove it
+ */
+ if (keycode == *kcp) {
+ make_remove (i, keycode);
+ }
+
+ /*
+ * now, check to see if any of the keysyms map to keycodes
+ * that are in the modifier list
+ */
+ for (k = 0; k < n; k++) {
+ KeyCodes kc;
+
+ kc = XKeysymToKeycode (dpy, kslist[k]);
+ if (kc == *kcp) { /* yup, found one */
+ /*
+ * have to generate a remove of the CURRENT keycode
+ * and then an add of the new KEYCODE
+ */
+ make_remove (i, kc); /* modifier, keycode */
+ make_add (i, kslist[k]); /* modifier, keysym */
+ }
+ }
+ }
+ }
+ return;
+}
+#endif
+
+/*
+ * print_work_queue - disassemble the work queue and print it on stdout
+ */
+
+void print_work_queue ()
+{
+ union op *op;
+
+ printf ("! dump of work queue\n");
+ for (op = work_queue.head; op; op = op->generic.next) {
+ print_opcode (op);
+ }
+ return;
+}
+
+void print_opcode (op)
+ union op *op;
+{
+ int i;
+
+ printf (" ");
+ switch (op->generic.type) {
+ case doKeycode:
+ if (op->keycode.target_keycode)
+ printf ("keycode 0x%lx =", (long) op->keycode.target_keycode);
+ else
+ printf ("keycode any =");
+ for (i = 0; i < op->keycode.count; i++) {
+ char *name = XKeysymToString (op->keycode.keysyms[i]);
+
+ printf (" %s", name ? name : "BADKEYSYM");
+ }
+ printf ("\n");
+ break;
+ case doAddModifier:
+ printf ("add %s =", modifier_table[op->addmodifier.modifier].name);
+ for (i = 0; i < op->addmodifier.count; i++) {
+ char *name = XKeysymToString (op->addmodifier.keysyms[i]);
+ printf (" %s", name ? name : "BADKEYSYM");
+ }
+ printf ("\n");
+ break;
+ case doRemoveModifier:
+ printf ("remove %s = ",
+ modifier_table[op->removemodifier.modifier].name);
+ for (i = 0; i < op->removemodifier.count; i++) {
+ printf (" 0x%lx", (long) op->removemodifier.keycodes[i]);
+ }
+ printf ("\n");
+ break;
+ case doClearModifier:
+ printf ("clear %s\n", modifier_table[op->clearmodifier.modifier].name);
+ break;
+ case doPointer:
+ printf ("pointer = ");
+ if (op->pointer.count == 0)
+ printf(" default");
+ else for (i=0; i < op->pointer.count; i++)
+ printf(" %d", op->pointer.button_codes[i]);
+ printf ("\n");
+ break;
+ default:
+ printf ("! unknown opcode %d\n", op->generic.type);
+ break;
+ } /* end switch */
+ return;
+}
+
+/*
+ * execute_work_queue - do the real meat and potatoes now that we know what
+ * we need to do and that all of the input is correct.
+ */
+
+static int exec_keycode(), exec_add(), exec_remove(), exec_clear();
+static int exec_pointer();
+
+int execute_work_queue ()
+{
+ union op *op;
+ int errors;
+ Bool update_map = False;
+ int dosync;
+
+ if (verbose) {
+ printf ("!\n");
+ printf ("! executing work queue\n");
+ printf ("!\n");
+ }
+
+ errors = 0;
+ dosync = 0;
+
+ for (op = work_queue.head; op; op = op->generic.next) {
+ if (verbose) print_opcode (op);
+
+ /* check to see if we have to update the keyboard mapping */
+ if (dosync &&
+ (dosync < 0 ||
+ op->generic.type != doKeycode ||
+ !op->keycode.target_keycode)) {
+ XSync (dpy, 0);
+ while (XEventsQueued (dpy, QueuedAlready) > 0) {
+ XEvent event;
+ XNextEvent (dpy, &event);
+ if (event.type == MappingNotify) {
+ /* read all MappingNotify events */
+ while (XCheckTypedEvent (dpy, MappingNotify, &event)) ;
+ XRefreshKeyboardMapping (&event.xmapping);
+ } else {
+ fprintf (stderr, "%s: unknown event %ld\n",
+ ProgramName, (long) event.type);
+ }
+ }
+ }
+ dosync = 0;
+ switch (op->generic.type) {
+ case doKeycode:
+ if (exec_keycode (op) < 0) errors++;
+ if (op->keycode.target_keycode)
+ dosync = 1;
+ else
+ dosync = -1;
+ break;
+ case doAddModifier:
+ if (exec_add (op) < 0) errors++;
+ else update_map = True;
+ break;
+ case doRemoveModifier:
+ if (exec_remove (op) < 0) errors++;
+ else update_map = True;
+ break;
+ case doClearModifier:
+ if (exec_clear (op) < 0) errors++;
+ else update_map = True;
+ break;
+ case doPointer:
+ if (exec_pointer (op) < 0) errors++;
+ break;
+ default:
+ fprintf (stderr, "%s: unknown opcode %d\n",
+ ProgramName, op->generic.type);
+ break;
+ }
+ }
+
+ if (update_map) {
+ if (UpdateModifierMapping (map) < 0) errors++;
+ }
+
+ return (errors > 0 ? -1 : 0);
+}
+
+static int exec_keycode (opk)
+ struct op_keycode *opk;
+{
+ if (!opk->target_keycode) {
+ int i, j;
+ KeyCode free;
+ if (!opk->count)
+ return (0);
+ free = 0;
+ for (i = min_keycode; i <= max_keycode; i++) {
+ for (j = 0; j < opk->count; j++) {
+ if (XKeycodeToKeysym(dpy, (KeyCode) i, j) != opk->keysyms[j])
+ break;
+ }
+ if (j >= opk->count)
+ return (0);
+ if (free)
+ continue;
+ for (j = 0; j < 8; j++) {
+ if (XKeycodeToKeysym(dpy, (KeyCode) i, j) != None)
+ break;
+ }
+ if (j >= 8)
+ free = i;
+ }
+ if (!free) {
+ fprintf(stderr, "%s: no available keycode for assignment\n",
+ ProgramName);
+ return (-1);
+ }
+ XChangeKeyboardMapping (dpy, free, opk->count, opk->keysyms, 1);
+ } else if (opk->count == 0) {
+ KeySym dummy = NoSymbol;
+ XChangeKeyboardMapping (dpy, opk->target_keycode, 1,
+ &dummy, 1);
+ } else {
+ XChangeKeyboardMapping (dpy, opk->target_keycode, opk->count,
+ opk->keysyms, 1);
+ }
+ return (0);
+}
+
+static int exec_add (opam)
+ struct op_addmodifier *opam;
+{
+ int i;
+ int status;
+
+ status = 0;
+ for (i = 0; i < opam->count; i++) {
+ int num_kcs;
+ KeyCode *kcs;
+
+ kcs = KeysymToKeycodes (dpy, opam->keysyms[i], &num_kcs);
+ if (num_kcs == 0)
+ status = -1;
+ while (--num_kcs >= 0) {
+ if (AddModifier (&map, *kcs++, opam->modifier) < 0)
+ status = -1;
+ }
+ }
+ return (status);
+}
+
+static int exec_remove (oprm)
+ struct op_removemodifier *oprm;
+{
+ int i;
+ int status;
+
+ status = 0;
+ for (i = 0; i < oprm->count; i++) {
+ if (RemoveModifier (&map, oprm->keycodes[i], oprm->modifier) < 0)
+ status = -1;
+ }
+ return (status);
+}
+
+static int exec_clear (opcm)
+ struct op_clearmodifier *opcm;
+{
+ return (ClearModifier (&map, opcm->modifier));
+}
+
+
+static int exec_pointer (opp)
+ struct op_pointer *opp;
+{
+ return (SetPointerMap (opp->button_codes, opp->count));
+}
+
+void print_modifier_map ()
+{
+ PrintModifierMapping (map, stdout);
+ return;
+}
+
+void print_key_table (exprs)
+ Bool exprs;
+{
+ PrintKeyTable (exprs, stdout);
+ return;
+}
+
+void print_pointer_map ()
+{
+ PrintPointerMap (stdout);
+ return;
+}
+
+
diff --git a/pf.c b/pf.c
new file mode 100644
index 0000000..2cacbdc
--- /dev/null
+++ b/pf.c
@@ -0,0 +1,118 @@
+/* $Xorg: pf.c,v 1.4 2001/02/09 02:05:56 xorgcvs Exp $ */
+/*
+
+Copyright 1988, 1998 The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+#include <X11/Xos.h>
+#include <X11/Xlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include "xmodmap.h"
+
+#define NOTINFILEFILENAME "commandline"
+char *inputFilename = NOTINFILEFILENAME;
+int lineno = 0;
+
+void process_file (filename)
+ char *filename; /* NULL means use stdin */
+{
+ FILE *fp;
+ char buffer[BUFSIZ];
+
+ /* open the file, eventually we'll want to pipe through cpp */
+
+ if (!filename) {
+ fp = stdin;
+ inputFilename = "stdin";
+ } else {
+ fp = fopen (filename, "r");
+ if (!fp) {
+ fprintf (stderr, "%s: unable to open file '%s' for reading\n",
+ ProgramName, filename);
+ parse_errors++;
+ return;
+ }
+ inputFilename = filename;
+ }
+
+
+ /* read the input and filter */
+
+ if (verbose) {
+ printf ("! %s:\n", inputFilename);
+ }
+
+ for (lineno = 0; ; lineno++) {
+ buffer[0] = '\0';
+ if (fgets (buffer, BUFSIZ, fp) == NULL)
+ break;
+
+ process_line (buffer);
+ }
+
+ inputFilename = NOTINFILEFILENAME;
+ lineno = 0;
+ (void) fclose (fp);
+}
+
+
+void process_line (buffer)
+ char *buffer;
+{
+ int len;
+ int i;
+ char *cp;
+
+ len = strlen (buffer);
+
+ for (i = 0; i < len; i++) { /* look for blank lines */
+ register char c = buffer[i];
+ if (!(isspace(c) || c == '\n')) break;
+ }
+ if (i == len) return;
+
+ cp = &buffer[i];
+
+ if (*cp == '!') return; /* look for comments */
+ len -= (cp - buffer); /* adjust len by how much we skipped */
+
+ /* pipe through cpp */
+
+ /* strip trailing space */
+ for (i = len-1; i >= 0; i--) {
+ register char c = cp[i];
+ if (!(isspace(c) || c == '\n')) break;
+ }
+ if (i >= 0) cp[len = (i+1)] = '\0'; /* nul terminate */
+
+ if (verbose) {
+ printf ("! %d: %s\n", lineno, cp);
+ }
+
+ /* handle input */
+ handle_line (cp, len);
+}
diff --git a/swap.km b/swap.km
new file mode 100644
index 0000000..64c55e5
--- /dev/null
+++ b/swap.km
@@ -0,0 +1,11 @@
+!
+! Swap Caps_Lock and Control_L
+!
+
+remove Lock = Caps_Lock
+remove Control = Control_L
+keysym Control_L = Caps_Lock
+keysym Caps_Lock = Control_L
+add Lock = Caps_Lock
+add Control = Control_L
+
diff --git a/wq.h b/wq.h
new file mode 100644
index 0000000..e8e4b41
--- /dev/null
+++ b/wq.h
@@ -0,0 +1,143 @@
+/* $Xorg: wq.h,v 1.4 2001/02/09 02:05:56 xorgcvs Exp $ */
+/*
+
+Copyright 1988, 1998 The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+/*
+ * Input is parsed and a work queue is built that is executed later. This
+ * allows us to swap keys as well as ensure that we don't mess up the keyboard
+ * by doing a partial rebind.
+ */
+
+enum opcode { doKeycode, doAddModifier, doRemoveModifier, doClearModifier,
+ doPointer };
+
+struct op_generic {
+ enum opcode type; /* oneof enum opcode */
+ union op *next; /* next element in list or NULL */
+};
+
+
+/*
+ * keycode KEYCODE = KEYSYM
+ * keysym OLDKEYSYM = NEWKEYSYM
+ *
+ * want to eval the OLDKEYSYM before executing the work list so that it isn't
+ * effected by any assignments.
+ */
+
+struct op_keycode {
+ enum opcode type; /* doKeycode */
+ union op *next; /* next element in list or NULL */
+ KeyCode target_keycode; /* key to which we are assigning */
+ int count; /* number of new keysyms */
+ KeySym *keysyms; /* new values to insert */
+};
+
+
+/*
+ * add MODIFIER = KEYSYM ...
+ */
+
+struct op_addmodifier {
+ enum opcode type; /* doAddModifier */
+ union op *next; /* next element in list or NULL */
+ int modifier; /* index into modifier list */
+ int count; /* number of keysyms */
+ KeySym *keysyms; /* new values to insert */
+};
+
+
+/*
+ * remove MODIFIER = OLDKEYSYM ...
+ *
+ * want to eval the OLDKEYSYM before executing the work list so that it isn't
+ * effected by any assignments.
+ */
+
+struct op_removemodifier {
+ enum opcode type; /* doRemoveModifier */
+ union op *next; /* next element in list or NULL */
+ int modifier; /* index into modifier list */
+ int count; /* number of keysyms */
+ KeyCode *keycodes; /* old values to remove */
+};
+
+
+/*
+ * clear MODIFIER
+ */
+
+struct op_clearmodifier {
+ enum opcode type; /* doClearModifier */
+ union op *next; /* next element in list or NULL */
+ int modifier; /* index into modifier list */
+};
+
+/*
+ * pointer = NUMBER ...
+ *
+ * set pointer map to the positive numbers given on the right hand side
+ */
+
+#define MAXBUTTONCODES 256 /* there are eight bits of buttons */
+
+struct op_pointer {
+ enum opcode type; /* doPointer */
+ union op *next; /* next element in list or NULL */
+ int count; /* number of new button codes */
+ unsigned char button_codes[MAXBUTTONCODES];
+};
+
+
+/*
+ * all together now
+ */
+union op {
+ struct op_generic generic;
+ struct op_keycode keycode;
+ struct op_addmodifier addmodifier;
+ struct op_removemodifier removemodifier;
+ struct op_clearmodifier clearmodifier;
+ struct op_pointer pointer;
+};
+
+extern struct wq {
+ union op *head;
+ union op *tail;
+} work_queue;
+
+
+extern struct modtab {
+ char *name;
+ int length;
+ int value;
+} modifier_table[];
+
+#define AllocStruct(s) ((s *) malloc (sizeof (s)))
+
+#define MAXKEYSYMNAMESIZE 80 /* absurdly large */
diff --git a/xmodmap.c b/xmodmap.c
new file mode 100644
index 0000000..b5ffa00
--- /dev/null
+++ b/xmodmap.c
@@ -0,0 +1,341 @@
+/* $Xorg: xmodmap.c,v 1.4 2001/02/09 02:05:56 xorgcvs Exp $ */
+/*
+
+Copyright 1988, 1998 The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+#include <X11/Xos.h>
+#include <X11/Xlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include "xmodmap.h"
+
+char *ProgramName;
+Display *dpy = NULL;
+int min_keycode, max_keycode;
+Bool verbose = False;
+Bool dontExecute = False;
+
+void Exit (status)
+ int status;
+{
+ if (dpy) {
+ XCloseDisplay (dpy);
+ dpy = NULL;
+ }
+ exit (status);
+}
+
+
+static char *help_message[] = {
+"\nwhere options include:",
+" -display host:dpy X server to use",
+" -verbose, -quiet turn logging on or off",
+" -n don't execute changes, just show like make",
+" -e expression execute string",
+" -pm print modifier map",
+" -pk print keymap table",
+" -pke print keymap table as expressions",
+" -pp print pointer map",
+" -grammar print out short help on allowable input",
+" - read standard input",
+"",
+NULL};
+
+
+void usage ()
+{
+ char **cpp;
+
+ fprintf (stderr, "usage: %s [-options ...] [filename]\n", ProgramName);
+ for (cpp = help_message; *cpp; cpp++) {
+ fprintf (stderr, "%s\n", *cpp);
+ }
+ Exit (1);
+}
+
+static char *grammar_message[] = {
+" pointer = default reset pointer buttons to default",
+" pointer = NUMBER ... set pointer button codes",
+" keycode NUMBER = [KEYSYM ...] map keycode to given keysyms",
+" keysym KEYSYM = [KEYSYM ...] look up keysym and do a keycode operation",
+" clear MODIFIER remove all keys for this modifier",
+" add MODIFIER = KEYSYM ... add the keysyms to the modifier",
+" remove MODIFIER = KEYSYM ... remove the keysyms from the modifier",
+"",
+"where NUMBER is a decimal, octal, or hex constant; KEYSYM is a valid",
+"Key Symbol name; and MODIFIER is one of the eight modifier names: Shift,",
+"Lock, Control, Mod1, Mod2, Mod3, Mod4, or Mod5. Lines beginning with",
+"an exclamation mark (!) are taken as comments. Case is significant except",
+"for MODIFIER names.",
+"",
+"Keysyms on the left hand side of the = sign are looked up before any changes",
+"are made; keysyms on the right are looked up after all of those on the left",
+"have been resolved. This makes it possible to swap modifier keys.",
+"",
+NULL };
+
+
+void grammar_usage ()
+{
+ char **cpp;
+
+ fprintf (stderr, "%s accepts the following input expressions:\n\n",
+ ProgramName);
+ for (cpp = grammar_message; *cpp; cpp++) {
+ fprintf (stderr, "%s\n", *cpp);
+ }
+ Exit (0);
+}
+
+int parse_errors = 0;
+
+main (argc, argv)
+ int argc;
+ char **argv;
+{
+ int i;
+ char *displayname = NULL;
+ int status;
+ Bool printMap = False;
+ Bool printKeyTable = False;
+ Bool printKeyTableExprs = False;
+ Bool printPointerMap = False;
+ Bool didAnything = False;
+
+ ProgramName = argv[0];
+
+ /*
+ * scan the arg list once to find out which display to use
+ */
+
+ for (i = 1; i < argc; i++) {
+ if (strncmp (argv[i], "-d", 2) == 0) {
+ if (++i >= argc) usage ();
+ displayname = argv[i];
+ }
+ }
+
+ dpy = XOpenDisplay (displayname);
+ if (!dpy) {
+ fprintf (stderr, "%s: unable to open display '%s'\n",
+ ProgramName, XDisplayName (displayname));
+ Exit (1);
+ }
+
+ XDisplayKeycodes (dpy, &min_keycode, &max_keycode);
+
+ initialize_map ();
+
+ /*
+ * scan the arg list again to do the actual work (since it requires
+ * the display being open.
+ */
+
+ status = 0;
+ for (i = 1; i < argc; i++) {
+ char *arg = argv[i];
+
+ if (arg[0] == '-') {
+ switch (arg[1]) {
+ case 'd': /* -display host:dpy */
+ ++i; /* handled above */
+ continue;
+ case 'v': /* -verbose */
+ verbose = True;
+ continue;
+ case 'q': /* -quiet */
+ verbose = False;
+ continue;
+ case 'n': /* -n (like make) */
+ dontExecute = True;
+ continue;
+ case 'e': /* -e expression */
+ didAnything = True;
+ if (++i >= argc) usage ();
+ process_line (argv[i]);
+ continue;
+ case 'p': /* -p... */
+ switch (arg[2]) {
+ case '\0':
+ case 'm': /* -pm */
+ printMap = True;
+ break;
+ case 'k': /* -pk, -pke */
+ switch (arg[3]) {
+ case '\0':
+ printKeyTable = True;
+ break;
+ case 'e':
+ printKeyTableExprs = True;
+ break;
+ default:
+ usage ();
+ }
+ break;
+ case 'p': /* -pp */
+ printPointerMap = True;
+ break;
+ default:
+ usage ();
+ /* NOTREACHED */
+ }
+ didAnything = True;
+ continue;
+ case 'g': /* -grammar */
+ grammar_usage ();
+ /*NOTREACHED*/
+ case '\0': /* - (use standard input) */
+ didAnything = True;
+ process_file (NULL);
+ continue;
+
+ /*
+ * provide old xmodmap args
+ */
+ case 'S':
+ didAnything = True;
+ process_line ("clear shift");
+ continue;
+ case 'L':
+ didAnything = True;
+ process_line ("clear lock");
+ continue;
+ case 'C':
+ didAnything = True;
+ process_line ("clear control");
+ continue;
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5': {
+ char *cmd = "clear modX";
+ cmd[9] = arg[1];
+ process_line (cmd);
+ continue;
+ }
+ case 's':
+ case 'l':
+ case 'c': {
+ char cmd[80]; /* big enough to hold line */
+ didAnything = True;
+ if (++i >= argc) usage ();
+ (void) sprintf (cmd, "remove %s = %s",
+ ((arg[1] == 's') ? "shift" :
+ ((arg[1] == 'l') ? "lock" :
+ "control")), argv[i]);
+ process_line (cmd);
+ continue;
+ }
+ default:
+ usage ();
+ /*NOTREACHED*/
+ }
+ } else if (arg[0] == '+') { /* old xmodmap args */
+ switch (arg[1]) {
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5': {
+ char cmd[80]; /* big enough to hold line */
+ didAnything = True;
+ if (++i >= argc) usage ();
+
+ (void) sprintf (cmd, "add mod%c = %s", arg[1], argv[i]);
+ process_line (cmd);
+ continue;
+ }
+ case 'S':
+ case 'L':
+ case 'C':
+ arg[1] = tolower (arg[1]);
+ /* fall through to handler below */
+ case 's':
+ case 'l':
+ case 'c': {
+ char cmd[80]; /* big enough to hold line */
+ didAnything = True;
+ if (++i >= argc) usage ();
+ (void) sprintf (cmd, "add %s = %s",
+ ((arg[1] == 's') ? "shift" :
+ ((arg[1] == 'l') ? "lock" :
+ "control")), argv[i]);
+ process_line (cmd);
+ continue;
+ }
+ default:
+ usage ();
+ }
+ } else {
+ didAnything = True;
+ process_file (arg);
+ continue;
+ }
+ } /* end for loop */
+
+ /* for compatibility */
+ if (!didAnything) printMap = True;
+
+ /*
+ * at this point, the work list has been built and we can view it or
+ * execute it
+ */
+
+ if (dontExecute) {
+ print_work_queue ();
+ Exit (0);
+ }
+
+ if (parse_errors != 0) {
+ fprintf (stderr, "%s: %d error%s encountered, aborting.\n",
+ ProgramName, parse_errors,
+ (parse_errors == 1 ? "" : "s"));
+ status = -1; /* return an error condition */
+ } else {
+ status = execute_work_queue ();
+ }
+
+ if (printMap) {
+ print_modifier_map ();
+ }
+
+ if (printKeyTable) {
+ print_key_table (False);
+ }
+
+ if (printKeyTableExprs) {
+ print_key_table (True);
+ }
+
+ if (printPointerMap) {
+ print_pointer_map ();
+ }
+
+ Exit (status < 0 ? 1 : 0);
+}
+
diff --git a/xmodmap.h b/xmodmap.h
new file mode 100644
index 0000000..96b4f66
--- /dev/null
+++ b/xmodmap.h
@@ -0,0 +1,48 @@
+/* $Xorg: xmodmap.h,v 1.4 2001/02/09 02:05:56 xorgcvs Exp $ */
+/*
+
+Copyright 1988, 1998 The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+extern char *ProgramName;
+extern Display *dpy;
+extern int min_keycode, max_keycode;
+extern Bool verbose;
+extern Bool dontExecute;
+extern char *inputFilename;
+extern int lineno;
+extern int parse_errors;
+
+extern void initialize_map ();
+extern void process_file ();
+extern void process_line ();
+extern void handle_line ();
+extern void print_opcode ();
+extern void print_work_queue ();
+extern int execute_work_queue ();
+extern void print_modifier_map ();
+extern void print_key_table ();
+extern void print_pointer_map ();
diff --git a/xmodmap.man b/xmodmap.man
new file mode 100644
index 0000000..d23daca
--- /dev/null
+++ b/xmodmap.man
@@ -0,0 +1,302 @@
+.\" $Xorg: xmodmap.man,v 1.4 2001/02/09 02:05:56 xorgcvs Exp $
+.\" Copyright 1988, 1989, 1990, 1998 The Open Group
+.\" Copyright 1987 Sun Microsystems, Inc.
+.\"
+.\" Permission to use, copy, modify, distribute, and sell this software and its
+.\" documentation for any purpose is hereby granted without fee, provided that
+.\" the above copyright notice appear in all copies and that both that
+.\" copyright notice and this permission notice appear in supporting
+.\" documentation.
+.\"
+.\" The above copyright notice and this permission notice shall be included
+.\" in all copies or substantial portions of the Software.
+.\"
+.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+.\" OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+.\" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+.\" IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+.\" OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+.\" ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+.\" OTHER DEALINGS IN THE SOFTWARE.
+.\"
+.\" Except as contained in this notice, the name of The Open Group shall
+.\" not be used in advertising or otherwise to promote the sale, use or
+.\" other dealings in this Software without prior written authorization
+.\" from The Open Group.
+.de EX \"Begin example
+.ne 5
+.if n .sp 1
+.if t .sp .5
+.nf
+.in +.5i
+..
+.de EE
+.fi
+.in -.5i
+.if n .sp 1
+.if t .sp .5
+..
+.TH XMODMAP 1 "Release 6.4" "X Version 11"
+.SH NAME
+xmodmap - utility for modifying keymaps (and pointer buttons) in X
+.SH SYNOPSIS
+.B xmodmap
+[-options ...] [filename]
+.SH DESCRIPTION
+.PP
+The \fIxmodmap\fP program is used to edit and display the
+keyboard \fImodifier map\fP and \fIkeymap table\fP that are used by client
+applications to convert event keycodes into keysyms. It is usually run from
+the user's session startup script to configure the keyboard according to
+personal tastes.
+.SH OPTIONS
+.PP
+The following options may be used with \fIxmodmap\fP:
+.TP 8
+.B \-display \fIdisplay\fP
+This option specifies the host and display to use.
+.TP 8
+.B \-help
+This option indicates that a brief description of the command line arguments
+should be printed on the standard error channel. This will be done whenever an
+unhandled argument is given to
+.I xmodmap.
+.TP 8
+.B \-grammar
+This option indicates that a help message describing the expression grammar
+used in files and with \-e expressions should be printed on the standard error.
+.TP 8
+.B \-verbose
+This option indicates that
+.I xmodmap
+should print logging information as it parses its input.
+.TP 8
+.B \-quiet
+This option turns off the verbose logging. This is the default.
+.TP 8
+.B \-n
+This option indicates that
+.I xmodmap
+should not change the mappings, but should display what it would do, like
+\fImake(1)\fP does when given this option.
+.TP 8
+.B \-e \fIexpression\fB
+This option specifies an expression to be executed. Any number of expressions
+may be specified from the command line.
+.TP 8
+.B \-pm
+This option indicates that the current modifier map should be printed on the
+standard output.
+.TP 8
+.B \-pk
+This option indicates that the current keymap table should be printed on the
+standard output.
+.TP 8
+.B \-pke
+This option indicates that the current keymap table should be printed on the
+standard output in the form of expressions that can be fed back to
+\fIxmodmap\fP.
+.TP 8
+.B \-pp
+This option indicates that the current pointer map should be printed on the
+standard output.
+.TP 8
+.B \-
+A lone dash means that the standard input should be used as the input file.
+.PP
+The \fIfilename\fP specifies a file containing \fIxmodmap\fP expressions
+to be executed. This file is usually kept in the user's home directory with
+a name like \fI.xmodmaprc\fP.
+.SH EXPRESSION GRAMMAR
+.PP
+The
+.I xmodmap
+program reads a list of expressions and parses them all before attempting
+to execute any of them. This makes it possible to refer to keysyms that are
+being redefined in a natural way without having to worry as much about name
+conflicts.
+.TP 8
+.B keycode \fINUMBER\fP = \fIKEYSYMNAME ...\fP
+The list of keysyms is assigned to the indicated keycode
+(which may be specified in decimal, hex or octal and can be determined by
+running the
+.I xev
+program.
+.TP 8
+.B keycode any = \fIKEYSYMNAME ...\fP
+If no existing key has the specified list of keysyms assigned to it,
+a spare key on the keyboard is selected and the keysyms are assigned to it.
+The list of keysyms may be specified in decimal, hex or octal.
+.TP 8
+.B keysym \fIKEYSYMNAME\fP = \fIKEYSYMNAME ...\fP
+The \fIKEYSYMNAME\fP on the left hand side is translated into matching keycodes
+used to perform the corresponding set of \fBkeycode\fP expressions.
+The list of keysym names may be
+found in the header file \fI<X11/keysymdef.h>\fP (without the \fIXK_\fP prefix)
+or the keysym database \fI<XRoot>/lib/X11/XKeysymDB\fP, where <XRoot> refers
+to the root of the X11 install tree.
+Note that if the same keysym is bound to multiple keys, the expression is
+executed for each matching keycode.
+.TP 8
+.B clear \fIMODIFIERNAME\fP
+This removes all entries in the modifier map for the given modifier, where
+valid name are:
+.BR Shift ,
+.BR Lock ,
+.BR Control ,
+.BR Mod1 ,
+.BR Mod2 ,
+.BR Mod3 ,
+.BR Mod4 ,
+and \fBMod5\fP (case
+does not matter in modifier names, although it does matter for all other
+names). For example, ``clear Lock'' will remove
+all any keys that were bound to the shift lock modifier.
+.TP 8
+.B add \fIMODIFIERNAME\fP = \fIKEYSYMNAME ...\fP
+This adds all keys containing the given keysyms to the indicated modifier map.
+The keysym names
+are evaluated after all input expressions are read to make it easy to write
+expressions to swap keys (see the EXAMPLES section).
+.TP 8
+.B remove \fIMODIFIERNAME\fP = \fIKEYSYMNAME ...\fP
+This removes all keys containing the given keysyms from the indicated
+modifier map. Unlike
+.B add,
+the keysym names are evaluated as the line is read in. This allows you to
+remove keys from a modifier without having to worry about whether or not they
+have been reassigned.
+.TP 8
+.B "pointer = default"
+This sets the pointer map back to its default settings (button 1 generates a
+code of 1, button 2 generates a 2, etc.).
+.TP 8
+.B pointer = \fINUMBER ...\fP
+This sets to pointer map to contain the indicated button codes. The list
+always starts with the first physical button.
+.PP
+Lines that begin with an exclamation point (!) are taken as comments.
+.PP
+If you want to change the binding of a modifier key, you must also remove it
+from the appropriate modifier map.
+.SH EXAMPLES
+.PP
+Many pointers are designed such that the first button is pressed using the
+index finger of the right hand. People who are left-handed frequently find
+that it is more comfortable to reverse the button codes that get generated
+so that the primary button is pressed using the index finger of the left hand.
+This could be done on a 3 button pointer as follows:
+.EX
+% xmodmap -e "pointer = 3 2 1"
+.EE
+.PP
+Many applications support the notion of Meta keys (similar to Control
+keys except that Meta is held down instead of Control). However,
+some servers do not have a Meta keysym in the default keymap table, so one
+needs to be added by hand.
+The following command will attach Meta to the Multi-language key (sometimes
+labeled Compose Character). It also takes advantage of the fact that
+applications that need a Meta key simply need to get the keycode and don't
+require the keysym to be in the first column of the keymap table. This
+means that applications that are looking for a Multi_key (including the
+default modifier map) won't notice any change.
+.EX
+% xmodmap -e "keysym Multi_key = Multi_key Meta_L"
+.EE
+.PP
+Similarly, some keyboards have an Alt key but no Meta key.
+In that case the following may be useful:
+.EX
+% xmodmap -e "keysym Alt_L = Meta_L Alt_L"
+.EE
+.PP
+One of the more simple, yet convenient, uses of \fIxmodmap\fP is to set the
+keyboard's "rubout" key to generate an alternate keysym. This frequently
+involves exchanging Backspace with Delete to be more comfortable to the user.
+If the \fIttyModes\fP resource in \fIxterm\fP is set as well, all terminal
+emulator windows will use the same key for erasing characters:
+.EX
+% xmodmap -e "keysym BackSpace = Delete"
+% echo "XTerm*ttyModes: erase ^?" | xrdb -merge
+.EE
+.PP
+Some keyboards do not automatically generate less than and greater than
+characters when the comma and period keys are shifted. This can be remedied
+with \fIxmodmap\fP by resetting the bindings for the comma and period with
+the following scripts:
+.EX
+!
+! make shift-, be < and shift-. be >
+!
+keysym comma = comma less
+keysym period = period greater
+.EE
+.PP
+One of the more irritating differences between keyboards is the location of the
+Control and Shift Lock keys. A common use of \fIxmodmap\fP is to swap these
+two keys as follows:
+.EX
+!
+! Swap Caps_Lock and Control_L
+!
+remove Lock = Caps_Lock
+remove Control = Control_L
+keysym Control_L = Caps_Lock
+keysym Caps_Lock = Control_L
+add Lock = Caps_Lock
+add Control = Control_L
+.EE
+.PP
+The \fIkeycode\fP command is useful for assigning the same keysym to
+multiple keycodes. Although unportable, it also makes it possible to write
+scripts that can reset the keyboard to a known state. The following script
+sets the backspace key to generate Delete (as shown above), flushes all
+existing caps lock bindings, makes the CapsLock
+key be a control key, make F5 generate Escape, and makes Break/Reset be a
+shift lock.
+.EX
+!
+! On the HP, the following keycodes have key caps as listed:
+!
+! 101 Backspace
+! 55 Caps
+! 14 Ctrl
+! 15 Break/Reset
+! 86 Stop
+! 89 F5
+!
+keycode 101 = Delete
+keycode 55 = Control_R
+clear Lock
+add Control = Control_R
+keycode 89 = Escape
+keycode 15 = Caps_Lock
+add Lock = Caps_Lock
+.EE
+.SH ENVIRONMENT
+.PP
+.TP 8
+.B DISPLAY
+to get default host and display number.
+.SH SEE ALSO
+X(1), xev(1), \fIXlib\fP documentation on key and pointer events
+.SH BUGS
+.PP
+Every time a \fBkeycode\fP expression is evaluated, the server generates
+a \fIMappingNotify\fP event on every client. This can cause some thrashing.
+All of the changes should be batched together and done at once.
+Clients that receive keyboard input and ignore \fIMappingNotify\fP events
+will not notice any changes made to keyboard mappings.
+.PP
+.I Xmodmap
+should generate "add" and "remove" expressions automatically
+whenever a keycode that is already bound to a modifier is changed.
+.PP
+There should be a way to have the
+.I remove
+expression accept keycodes as well as keysyms for those times when you really
+mess up your mappings.
+.SH AUTHOR
+Jim Fulton, MIT X Consortium, rewritten from an earlier version by
+David Rosenthal of Sun Microsystems.
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-21 15:01:12 +0000