340 lines
9.6 KiB
Python
Executable File
340 lines
9.6 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
import argparse
|
|
import multiprocessing
|
|
import sys
|
|
import subprocess
|
|
import os
|
|
import xml.etree.ElementTree as ET
|
|
from pathlib import Path
|
|
|
|
|
|
verbose = False
|
|
|
|
DEFAULT_RULES_XML = "@XKB_CONFIG_ROOT@/rules/evdev.xml"
|
|
|
|
# Meson needs to fill this in so we can call the tool in the buildir.
|
|
EXTRA_PATH = "@MESON_BUILD_ROOT@"
|
|
os.environ["PATH"] = ":".join([EXTRA_PATH, os.getenv("PATH")])
|
|
|
|
|
|
def escape(s):
|
|
return s.replace('"', '\\"')
|
|
|
|
|
|
# The function generating the progress bar (if any).
|
|
def create_progress_bar(verbose):
|
|
def noop_progress_bar(x, total, file=None):
|
|
return x
|
|
|
|
progress_bar = noop_progress_bar
|
|
if not verbose and os.isatty(sys.stdout.fileno()):
|
|
try:
|
|
from tqdm import tqdm
|
|
|
|
progress_bar = tqdm
|
|
except ImportError:
|
|
pass
|
|
|
|
return progress_bar
|
|
|
|
|
|
class Invocation:
|
|
def __init__(self, r, m, l, v, o):
|
|
self.command = ""
|
|
self.rules = r
|
|
self.model = m
|
|
self.layout = l
|
|
self.variant = v
|
|
self.option = o
|
|
self.exitstatus = 77 # default to skipped
|
|
self.error = None
|
|
self.keymap = None # The fully compiled keymap
|
|
|
|
@property
|
|
def rmlvo(self):
|
|
return self.rules, self.model, self.layout, self.variant, self.option
|
|
|
|
def __str__(self):
|
|
s = []
|
|
rmlvo = [x or "" for x in self.rmlvo]
|
|
rmlvo = ", ".join([f'"{x}"' for x in rmlvo])
|
|
s.append(f"- rmlvo: [{rmlvo}]")
|
|
s.append(f' cmd: "{escape(self.command)}"')
|
|
s.append(f" status: {self.exitstatus}")
|
|
if self.error:
|
|
s.append(f' error: "{escape(self.error.strip())}"')
|
|
return "\n".join(s)
|
|
|
|
def run(self):
|
|
raise NotImplementedError
|
|
|
|
|
|
class XkbCompInvocation(Invocation):
|
|
def run(self):
|
|
r, m, l, v, o = self.rmlvo
|
|
args = ["setxkbmap", "-print"]
|
|
if r is not None:
|
|
args.append("-rules")
|
|
args.append("{}".format(r))
|
|
if m is not None:
|
|
args.append("-model")
|
|
args.append("{}".format(m))
|
|
if l is not None:
|
|
args.append("-layout")
|
|
args.append("{}".format(l))
|
|
if v is not None:
|
|
args.append("-variant")
|
|
args.append("{}".format(v))
|
|
if o is not None:
|
|
args.append("-option")
|
|
args.append("{}".format(o))
|
|
|
|
xkbcomp_args = ["xkbcomp", "-xkb", "-", "-"]
|
|
|
|
self.command = " ".join(args + ["|"] + xkbcomp_args)
|
|
|
|
setxkbmap = subprocess.Popen(
|
|
args,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
universal_newlines=True,
|
|
)
|
|
stdout, stderr = setxkbmap.communicate()
|
|
if "Cannot open display" in stderr:
|
|
self.error = stderr
|
|
self.exitstatus = 90
|
|
else:
|
|
xkbcomp = subprocess.Popen(
|
|
xkbcomp_args,
|
|
stdin=subprocess.PIPE,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE,
|
|
universal_newlines=True,
|
|
)
|
|
stdout, stderr = xkbcomp.communicate(stdout)
|
|
if xkbcomp.returncode != 0:
|
|
self.error = "failed to compile keymap"
|
|
self.exitstatus = xkbcomp.returncode
|
|
else:
|
|
self.keymap = stdout
|
|
self.exitstatus = 0
|
|
|
|
|
|
class XkbcommonInvocation(Invocation):
|
|
UNRECOGNIZED_KEYSYM_ERROR = "XKB-107"
|
|
|
|
def run(self):
|
|
r, m, l, v, o = self.rmlvo
|
|
args = [
|
|
"xkbcli-compile-keymap", # this is run in the builddir
|
|
"--verbose",
|
|
"--rules",
|
|
r,
|
|
"--model",
|
|
m,
|
|
"--layout",
|
|
l,
|
|
]
|
|
if v is not None:
|
|
args += ["--variant", v]
|
|
if o is not None:
|
|
args += ["--options", o]
|
|
|
|
self.command = " ".join(args)
|
|
try:
|
|
output = subprocess.check_output(
|
|
args, stderr=subprocess.STDOUT, universal_newlines=True
|
|
)
|
|
if self.UNRECOGNIZED_KEYSYM_ERROR in output:
|
|
for line in output.split("\n"):
|
|
if self.UNRECOGNIZED_KEYSYM_ERROR in line:
|
|
self.error = line
|
|
self.exitstatus = 99 # tool doesn't generate this one
|
|
else:
|
|
self.exitstatus = 0
|
|
self.keymap = output
|
|
except subprocess.CalledProcessError as err:
|
|
self.error = "failed to compile keymap"
|
|
self.exitstatus = err.returncode
|
|
|
|
|
|
def xkbcommontool(rmlvo):
|
|
try:
|
|
r = rmlvo.get("r", "evdev")
|
|
m = rmlvo.get("m", "pc105")
|
|
l = rmlvo.get("l", "us")
|
|
v = rmlvo.get("v", None)
|
|
o = rmlvo.get("o", None)
|
|
tool = XkbcommonInvocation(r, m, l, v, o)
|
|
tool.run()
|
|
return tool
|
|
except KeyboardInterrupt:
|
|
pass
|
|
|
|
|
|
def xkbcomp(rmlvo):
|
|
try:
|
|
r = rmlvo.get("r", "evdev")
|
|
m = rmlvo.get("m", "pc105")
|
|
l = rmlvo.get("l", "us")
|
|
v = rmlvo.get("v", None)
|
|
o = rmlvo.get("o", None)
|
|
tool = XkbCompInvocation(r, m, l, v, o)
|
|
tool.run()
|
|
return tool
|
|
except KeyboardInterrupt:
|
|
pass
|
|
|
|
|
|
def parse(path):
|
|
root = ET.fromstring(open(path).read())
|
|
layouts = root.findall("layoutList/layout")
|
|
|
|
options = [e.text for e in root.findall("optionList/group/option/configItem/name")]
|
|
|
|
combos = []
|
|
for l in layouts:
|
|
layout = l.find("configItem/name").text
|
|
combos.append({"l": layout})
|
|
|
|
variants = l.findall("variantList/variant")
|
|
for v in variants:
|
|
variant = v.find("configItem/name").text
|
|
|
|
combos.append({"l": layout, "v": variant})
|
|
for option in options:
|
|
combos.append({"l": layout, "v": variant, "o": option})
|
|
|
|
return combos
|
|
|
|
|
|
def run(combos, tool, njobs, keymap_output_dir):
|
|
if keymap_output_dir:
|
|
keymap_output_dir = Path(keymap_output_dir)
|
|
try:
|
|
keymap_output_dir.mkdir()
|
|
except FileExistsError as e:
|
|
print(e, file=sys.stderr)
|
|
return False
|
|
|
|
keymap_file = None
|
|
keymap_file_fd = None
|
|
|
|
failed = False
|
|
with multiprocessing.Pool(njobs) as p:
|
|
results = p.imap_unordered(tool, combos)
|
|
for invocation in progress_bar(results, total=len(combos), file=sys.stdout):
|
|
if invocation.exitstatus != 0:
|
|
failed = True
|
|
target = sys.stderr
|
|
else:
|
|
target = sys.stdout if verbose else None
|
|
|
|
if target:
|
|
print(invocation, file=target)
|
|
|
|
if keymap_output_dir:
|
|
# we're running through the layouts in a somewhat sorted manner,
|
|
# so let's keep the fd open until we switch layouts
|
|
layout = invocation.layout
|
|
if invocation.variant:
|
|
layout += f"({invocation.variant})"
|
|
fname = keymap_output_dir / layout
|
|
if fname != keymap_file:
|
|
keymap_file = fname
|
|
if keymap_file_fd:
|
|
keymap_file_fd.close()
|
|
keymap_file_fd = open(keymap_file, "a")
|
|
|
|
rmlvo = ", ".join([x or "" for x in invocation.rmlvo])
|
|
print(f"// {rmlvo}", file=keymap_file_fd)
|
|
print(invocation.keymap, file=keymap_file_fd)
|
|
keymap_file_fd.flush()
|
|
|
|
return failed
|
|
|
|
|
|
def main(args):
|
|
global progress_bar
|
|
global verbose
|
|
|
|
tools = {
|
|
"libxkbcommon": xkbcommontool,
|
|
"xkbcomp": xkbcomp,
|
|
}
|
|
|
|
parser = argparse.ArgumentParser(
|
|
description="""
|
|
This tool compiles a keymap for each layout, variant and
|
|
options combination in the given rules XML file. The output
|
|
of this tool is YAML, use your favorite YAML parser to
|
|
extract error messages. Errors are printed to stderr.
|
|
"""
|
|
)
|
|
parser.add_argument(
|
|
"path",
|
|
metavar="/path/to/evdev.xml",
|
|
nargs="?",
|
|
type=str,
|
|
default=DEFAULT_RULES_XML,
|
|
help="Path to xkeyboard-config's evdev.xml",
|
|
)
|
|
parser.add_argument(
|
|
"--tool",
|
|
choices=tools.keys(),
|
|
type=str,
|
|
default="libxkbcommon",
|
|
help="parsing tool to use",
|
|
)
|
|
parser.add_argument(
|
|
"--jobs",
|
|
"-j",
|
|
type=int,
|
|
default=os.cpu_count() * 4,
|
|
help="number of processes to use",
|
|
)
|
|
parser.add_argument("--verbose", "-v", default=False, action="store_true")
|
|
parser.add_argument(
|
|
"--keymap-output-dir",
|
|
default=None,
|
|
type=str,
|
|
help="Directory to print compiled keymaps to",
|
|
)
|
|
parser.add_argument(
|
|
"--layout", default=None, type=str, help="Only test the given layout"
|
|
)
|
|
parser.add_argument(
|
|
"--variant", default=None, type=str, help="Only test the given variant"
|
|
)
|
|
parser.add_argument(
|
|
"--option", default=None, type=str, help="Only test the given option"
|
|
)
|
|
|
|
args = parser.parse_args()
|
|
|
|
verbose = args.verbose
|
|
keymapdir = args.keymap_output_dir
|
|
progress_bar = create_progress_bar(verbose)
|
|
|
|
tool = tools[args.tool]
|
|
|
|
if any([args.layout, args.variant, args.option]):
|
|
combos = [
|
|
{
|
|
"l": args.layout,
|
|
"v": args.variant,
|
|
"o": args.option,
|
|
}
|
|
]
|
|
else:
|
|
combos = parse(args.path)
|
|
failed = run(combos, tool, args.jobs, keymapdir)
|
|
sys.exit(failed)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
main(sys.argv)
|
|
except KeyboardInterrupt:
|
|
print("# Exiting after Ctrl+C")
|