From b8fc56ecb49e26ab3fcc37fae7565c279fa43b6b Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Sun, 2 Jan 2022 11:06:09 +0100 Subject: script: add generate-builtin-terminfo.py This script parses a terminfo source file and generates a C header file with a static struct containing terminfo names and their values. The table is sorted on the capability names --- scripts/generate-builtin-terminfo.py | 202 +++++++++++++++++++++++++++++++++++ 1 file changed, 202 insertions(+) create mode 100755 scripts/generate-builtin-terminfo.py (limited to 'scripts') diff --git a/scripts/generate-builtin-terminfo.py b/scripts/generate-builtin-terminfo.py new file mode 100755 index 00000000..dd27913b --- /dev/null +++ b/scripts/generate-builtin-terminfo.py @@ -0,0 +1,202 @@ +#!/usr/bin/env python3 + +import argparse +import re +import sys + +from typing import Dict, Union + + +class Capability: + def __init__(self, name: str, value: Union[bool, int, str]): + self._name = name + self._value = value + + @property + def name(self) -> str: + return self._name + + @property + def value(self) -> Union[bool, int, str]: + return self._value + + def __lt__(self, other): + return self._name < other._name + + def __le__(self, other): + return self._name <= other._name + + def __eq__(self, other): + return self._name == other._name + + def __ne__(self, other): + return self._name != other._name + + def __gt__(self, other): + return self._name > other._name + + def __ge__(self, other): + return self._name >= other._name + + +class BoolCapability(Capability): + def __init__(self, name: str): + super().__init__(name, True) + + +class IntCapability(Capability): + pass + + +class StringCapability(Capability): + pass + + +class Fragment: + def __init__(self, name: str, description: str): + self._name = name + self._description = description + self._caps = {} + + @property + def name(self) -> str: + return self._name + + @property + def description(self) -> str: + return self._description + + @property + def caps(self) -> Dict[str, Capability]: + return self._caps + + def add_capability(self, cap: Capability): + assert cap.name not in self._caps + self._caps[cap.name] = cap + + def del_capability(self, name: str): + del self._caps[name] + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('source_entry_name') + parser.add_argument('source', type=argparse.FileType('r')) + parser.add_argument('target_entry_name') + parser.add_argument('target', type=argparse.FileType('w')) + + opts = parser.parse_args() + source_entry_name = opts.source_entry_name + target_entry_name = opts.target_entry_name + source = opts.source + target = opts.target + + lines = [] + for l in source.readlines(): + l = l.strip() + if l.startswith('#'): + continue + lines.append(l) + + fragments = {} + cur_fragment = None + + for m in re.finditer( + r'(?P(?P[-+\w@]+)\|(?P.+?),)|' + r'(?P(?P\w+),)|' + r'(?P(?P\w+)#(?P(0x)?[0-9a-fA-F]+),)|' + r'(?P(?P\w+)=(?P(.+?)),)', + ''.join(lines)): + + if m.group('name') is not None: + name = m.group('entry_name') + description = m.group('entry_desc') + + assert name not in fragments + fragments[name] = Fragment(name, description) + cur_fragment = fragments[name] + + elif m.group('bool_cap') is not None: + name = m.group('bool_name') + cur_fragment.add_capability(BoolCapability(name)) + + elif m.group('int_cap') is not None: + name = m.group('int_name') + value = int(m.group('int_val'), 0) + cur_fragment.add_capability(IntCapability(name, value)) + + elif m.group('str_cap') is not None: + name = m.group('str_name') + value = m.group('str_val') + cur_fragment.add_capability(StringCapability(name, value)) + + else: + assert False + + # Expand ‘use’ capabilities + for frag in fragments.values(): + for cap in frag.caps.values(): + if cap.name == 'use': + use_frag = fragments[cap.value] + for use_cap in use_frag.caps.values(): + frag.add_capability(use_cap) + + + frag.del_capability(cap.name) + break + + entry = fragments[source_entry_name] + + try: + entry.del_capability('RGB') + except KeyError: + pass + + entry.add_capability(IntCapability('RGB', 8)) # 8 bits per channel + entry.add_capability(StringCapability('TN', target_entry_name)) + + target.write('#pragma once\n') + target.write('\n') + # target.write('enum terminfo_capability_type {\n') + # target.write(' TERMINFO_CAP_BOOL,\n') + # target.write(' TERMINFO_CAP_INT,\n') + # target.write(' TERMINFO_CAP_STRING,\n') + # target.write('};\n') + # target.write('\n') + target.write('struct foot_terminfo_entry {\n') + target.write(' const char *name;\n') + # target.write(' enum terminfo_capability_type type;\n') + target.write(' const char *value;\n') + target.write('};\n') + target.write('\n') + target.write( + 'static const struct foot_terminfo_entry terminfo_capabilities[] = {\n') + + for cap in sorted(entry.caps.values()): + if isinstance(cap, BoolCapability): + continue + + name = cap.name + value = str(cap.value) + + # Expand \E to literal ESC in non-parameterized capabilities + if '%' not in value: + value = re.sub(r'\\E([0-7])', r'\\033" "\1', value) + value = re.sub(r'\\E', r'\\033', value) + else: + # Need to double-escape \E in C string literals + value = value.replace('\\E', '\\\\E') + + # Don’t escape ‘:’ + value = value.replace('\\:', ':') + + # Do escape ‘“‘ + name = name.replace('"', '\"') + value = value.replace('"', '\"') + target.write(f' {{"{name}", "{value}"}},\n') + + target.write('};\n') + + +if __name__ == '__main__': + sys.exit(main()) -- cgit v1.3 From 7feab6092cf20f2b03f16aa0f147020971268e50 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Sun, 2 Jan 2022 20:22:01 +0100 Subject: scripts: generate-builtin-terminfo: add custom capability ‘Co’ MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This is a “special feature”, similar to “TN” and “RGB”: Co for termcap colors (or colors for terminfo colors) --- scripts/generate-builtin-terminfo.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'scripts') diff --git a/scripts/generate-builtin-terminfo.py b/scripts/generate-builtin-terminfo.py index dd27913b..a58b7da3 100755 --- a/scripts/generate-builtin-terminfo.py +++ b/scripts/generate-builtin-terminfo.py @@ -152,8 +152,9 @@ def main(): except KeyError: pass - entry.add_capability(IntCapability('RGB', 8)) # 8 bits per channel + entry.add_capability(IntCapability('Co', 256)) entry.add_capability(StringCapability('TN', target_entry_name)) + entry.add_capability(IntCapability('RGB', 8)) # 8 bits per channel target.write('#pragma once\n') target.write('\n') -- cgit v1.3 From 44aad0941fff3e314ae42c3c578cfa6d61913198 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Tue, 4 Jan 2022 22:01:36 +0100 Subject: dcs: xtgettcap: handle boolean capabilities Reply with DCS 1 + r ST --- dcs.c | 8 ++++++++ scripts/generate-builtin-terminfo.py | 9 +++++---- 2 files changed, 13 insertions(+), 4 deletions(-) (limited to 'scripts') diff --git a/dcs.c b/dcs.c index 6fed8010..07fec5c7 100644 --- a/dcs.c +++ b/dcs.c @@ -99,6 +99,14 @@ xtgettcap_reply(struct terminal *term, const char *hex_cap_name, size_t len) if (entry == NULL) goto err; + if (entry->value == NULL) { + /* Boolean */ + term_to_slave(term, "\033P1+r", 5); + term_to_slave(term, hex_cap_name, len); + term_to_slave(term, "\033\\", 2); + goto out; + } + /* * Reply format: * \EP 1 + r cap=value \E\\ diff --git a/scripts/generate-builtin-terminfo.py b/scripts/generate-builtin-terminfo.py index a58b7da3..9c8807bf 100755 --- a/scripts/generate-builtin-terminfo.py +++ b/scripts/generate-builtin-terminfo.py @@ -174,9 +174,6 @@ def main(): 'static const struct foot_terminfo_entry terminfo_capabilities[] = {\n') for cap in sorted(entry.caps.values()): - if isinstance(cap, BoolCapability): - continue - name = cap.name value = str(cap.value) @@ -194,7 +191,11 @@ def main(): # Do escape ‘“‘ name = name.replace('"', '\"') value = value.replace('"', '\"') - target.write(f' {{"{name}", "{value}"}},\n') + + if isinstance(cap, BoolCapability): + target.write(f' {{"{name}", NULL}},\n') + else: + target.write(f' {{"{name}", "{value}"}},\n') target.write('};\n') -- cgit v1.3 From 5a032c4c6f6517e664ac7b920c3cfae8d5a25b05 Mon Sep 17 00:00:00 2001 From: Daniel Eklöf Date: Thu, 13 Jan 2022 13:37:44 +0100 Subject: xtgettcap: switch from a table based internal structure, to a single char array Having the builtin terminfo DB as a table, with one entry per capability/value pair was ineffective memory-wise - we ended up adding ~20K to the final binary size. This patch changes the internal representation from a table, to a single NULL-separated (and NULL-terminated) char array: cap1-name \0 cap1-value \0 cap2-name \0 cap2-value \0 The capabilities are still sorted; to lookup a capability we need to scan from the beginning until we either find a match, or until the capabilities from the DB sort higher (lexicographically) than the searched-for capability. The terminfo char array is 3.3K - more better than before. --- dcs.c | 64 ++++++++++++++++++++++++++++-------- scripts/generate-builtin-terminfo.py | 57 ++++++++++++++------------------ 2 files changed, 75 insertions(+), 46 deletions(-) (limited to 'scripts') diff --git a/dcs.c b/dcs.c index 07fec5c7..1a388863 100644 --- a/dcs.c +++ b/dcs.c @@ -66,19 +66,52 @@ err: UNITTEST { /* Verify table is sorted */ - for (size_t i = 1; i < ALEN(terminfo_capabilities); i++) { - xassert(strcmp(terminfo_capabilities[i - 1].name, - terminfo_capabilities[i].name ) <= 0); + const char *p = terminfo_capabilities; + size_t left = sizeof(terminfo_capabilities); + + const char *last_cap = NULL; + + while (left > 0) { + const char *cap = p; + const char *val = cap + strlen(cap) + 1; + + size_t size = strlen(cap) + 1 + strlen(val) + 1;; + xassert(size <= left); + p += size; + left -= size; + + if (last_cap != NULL) + xassert(strcmp(last_cap, cap) < 0); + + last_cap = cap; } } -static int -terminfo_entry_compar(const void *_key, const void *_entry) +static bool +lookup_capability(const char *name, const char **value) { - const char *key = _key; - const struct foot_terminfo_entry *entry = _entry; + const char *p = terminfo_capabilities; + size_t left = sizeof(terminfo_capabilities); + + while (left > 0) { + const char *cap = p; + const char *val = cap + strlen(cap) + 1; + + size_t size = strlen(cap) + 1 + strlen(val) + 1;; + xassert(size <= left); + p += size; + left -= size; + + int r = strcmp(cap, name); + if (r == 0) { + *value = val; + return true; + } else if (r > 0) + break; + } - return strcmp(key, entry->name); + *value = NULL; + return false; } static void @@ -88,18 +121,23 @@ xtgettcap_reply(struct terminal *term, const char *hex_cap_name, size_t len) if (name == NULL) goto err; +#if 0 const struct foot_terminfo_entry *entry = bsearch(name, terminfo_capabilities, ALEN(terminfo_capabilities), sizeof(*entry), &terminfo_entry_compar); +#endif + const char *value; + bool valid_capability = lookup_capability(name, &value); + xassert(!valid_capability || value != NULL); LOG_DBG("XTGETTCAP: cap=%s (%.*s), value=%s", name, (int)len, hex_cap_name, - entry != NULL ? entry->value : ""); + valid_capability ? value : ""); - if (entry == NULL) + if (!valid_capability) goto err; - if (entry->value == NULL) { + if (value[0] == '\0') { /* Boolean */ term_to_slave(term, "\033P1+r", 5); term_to_slave(term, hex_cap_name, len); @@ -116,13 +154,13 @@ xtgettcap_reply(struct terminal *term, const char *hex_cap_name, size_t len) 5 + /* DCS 1 + r (\EP1+r) */ len + /* capability name, hex encoded */ 1 + /* ‘=’ */ - strlen(entry->value) * 2 + /* capability value, hex encoded */ + strlen(value) * 2 + /* capability value, hex encoded */ 2 + /* ST (\E\\) */ 1); int idx = sprintf(reply, "\033P1+r%.*s=", (int)len, hex_cap_name); - for (const char *c = entry->value; *c != '\0'; c++) { + for (const char *c = value; *c != '\0'; c++) { uint8_t nib1 = (uint8_t)*c >> 4; uint8_t nib2 = (uint8_t)*c & 0xf; diff --git a/scripts/generate-builtin-terminfo.py b/scripts/generate-builtin-terminfo.py index 9c8807bf..c8d3be4b 100755 --- a/scripts/generate-builtin-terminfo.py +++ b/scripts/generate-builtin-terminfo.py @@ -49,7 +49,19 @@ class IntCapability(Capability): class StringCapability(Capability): - pass + def __init__(self, name: str, value: str): + # Expand \E to literal ESC in non-parameterized capabilities + if '%' not in value: + value = re.sub(r'\\E([0-7])', r'\\033" "\1', value) + value = re.sub(r'\\E', r'\\033', value) + else: + # Need to double-escape \E in C string literals + value = value.replace('\\E', '\\\\E') + + # Don’t escape ‘:’ + value = value.replace('\\:', ':') + + super().__init__(name, value) class Fragment: @@ -156,48 +168,27 @@ def main(): entry.add_capability(StringCapability('TN', target_entry_name)) entry.add_capability(IntCapability('RGB', 8)) # 8 bits per channel - target.write('#pragma once\n') - target.write('\n') - # target.write('enum terminfo_capability_type {\n') - # target.write(' TERMINFO_CAP_BOOL,\n') - # target.write(' TERMINFO_CAP_INT,\n') - # target.write(' TERMINFO_CAP_STRING,\n') - # target.write('};\n') - # target.write('\n') - target.write('struct foot_terminfo_entry {\n') - target.write(' const char *name;\n') - # target.write(' enum terminfo_capability_type type;\n') - target.write(' const char *value;\n') - target.write('};\n') - target.write('\n') - target.write( - 'static const struct foot_terminfo_entry terminfo_capabilities[] = {\n') - + terminfo_parts = [] for cap in sorted(entry.caps.values()): name = cap.name value = str(cap.value) - # Expand \E to literal ESC in non-parameterized capabilities - if '%' not in value: - value = re.sub(r'\\E([0-7])', r'\\033" "\1', value) - value = re.sub(r'\\E', r'\\033', value) - else: - # Need to double-escape \E in C string literals - value = value.replace('\\E', '\\\\E') - - # Don’t escape ‘:’ - value = value.replace('\\:', ':') - - # Do escape ‘“‘ + # Escape ‘“‘ name = name.replace('"', '\"') value = value.replace('"', '\"') + terminfo_parts.append(name) if isinstance(cap, BoolCapability): - target.write(f' {{"{name}", NULL}},\n') + terminfo_parts.append('') else: - target.write(f' {{"{name}", "{value}"}},\n') + terminfo_parts.append(value) + + terminfo = '\\0" "'.join(terminfo_parts) - target.write('};\n') + target.write('#pragma once\n') + target.write('\n') + target.write(f'static const char terminfo_capabilities[] = "{terminfo}";') + target.write('\n') if __name__ == '__main__': -- cgit v1.3