282 lines
8.6 KiB
Python
Executable File
282 lines
8.6 KiB
Python
Executable File
#!/bin/env python3
|
|
|
|
import gzip
|
|
import argparse
|
|
import re
|
|
import sys
|
|
import io
|
|
import os
|
|
from abc import ABC, abstractclassmethod, abstractmethod, abstractstaticmethod
|
|
from typing import List, TextIO
|
|
|
|
|
|
def extract_nerdfont_ranges(font_patcher: TextIO):
|
|
range_re = re.compile(r"'((Src|Sym)(Start|End))':\s*([xXA-Fa-f0-9]+|None)")
|
|
name_re = re.compile(r"'Name':\s+\"(.*?)\"")
|
|
for line in font_patcher:
|
|
results = range_re.findall(line)
|
|
if len(results) != 4:
|
|
continue
|
|
props = {r[0]: int(r[3], base=16) if r[3] != "None" else None for r in results}
|
|
r = (
|
|
props["SrcStart"] or props["SymStart"],
|
|
props["SrcEnd"] or props["SymEnd"],
|
|
)
|
|
if r != (0, 0):
|
|
m = name_re.search(line)
|
|
if not m:
|
|
raise Exception("unable to find name: %s" % line)
|
|
yield r[0], r[1], m[1]
|
|
|
|
|
|
class Scope(ABC):
|
|
comment_override = None
|
|
|
|
def __init__(self, ranges: List[tuple], output: TextIO):
|
|
self.ranges = ranges
|
|
self.length = len(ranges)
|
|
self.output = output
|
|
self.cursor = 0
|
|
self.escape_char = None
|
|
self.re = re.compile(self.pattern())
|
|
|
|
@property
|
|
def empty(self) -> bool:
|
|
return self.cursor >= self.length
|
|
|
|
@property
|
|
def current(self) -> tuple:
|
|
return self.ranges[self.cursor]
|
|
|
|
def pop(self) -> bool:
|
|
if self.empty:
|
|
return False
|
|
ss, se, comment = self.current
|
|
self.write_line(ss, se, self.comment_override or comment)
|
|
self.cursor += 1
|
|
|
|
def read_line(self, line: str) -> bool:
|
|
m = self.re.match(line)
|
|
if not m:
|
|
raise Exception("unkown line: " + line)
|
|
ts = int(m[1], base=16)
|
|
te = int(m[3], base=16) if m[3] else ts
|
|
while not self.empty and self.current[1] < ts:
|
|
self.pop()
|
|
if self.empty:
|
|
return True
|
|
ss, se, _ = self.current
|
|
# output no intersection
|
|
if te < ss:
|
|
return True
|
|
# dont output subset
|
|
if ts >= ss and te <= se:
|
|
return False
|
|
if ss <= te: # clip left intersection
|
|
self.write_line(ts, ss - 1, m[5])
|
|
if se <= te:
|
|
self.pop()
|
|
if ts <= se:
|
|
self.write_line(se + 1, te, m[5])
|
|
if se < ts:
|
|
return True
|
|
return False
|
|
|
|
def write_line(self, start: int = None, end: int = None, comment: str = None) -> None:
|
|
if end < start:
|
|
return
|
|
self.output.write(self.format(start, end, comment) + '\n')
|
|
|
|
@abstractmethod
|
|
def pattern(self) -> str:
|
|
pass
|
|
|
|
@abstractmethod
|
|
def format(self, start: int, end: int, arg: any) -> str:
|
|
pass
|
|
|
|
|
|
class CharmapScope(Scope):
|
|
|
|
def pattern(self) -> str:
|
|
return r'<U([A-Z0-9]+)>(..<U([A-Z0-9]+)>)?\s+(\S+)\s+(.*?)$'
|
|
|
|
def format(self, start: int, end: int, comment: str) -> str:
|
|
return "%s%s %s %s" % (
|
|
"<U%04X>" % start,
|
|
"..<U%04X>" % end if end > start else "",
|
|
"".join(map(lambda x: "%sx%02x" % (self.escape_char, x), chr(start).encode('utf-8'))),
|
|
comment,
|
|
)
|
|
|
|
|
|
class WidthScope(Scope):
|
|
comment_override = '2'
|
|
|
|
def pattern(self) -> str:
|
|
return r'<U([A-Z0-9]+)>(...<U([A-Z0-9]+)>)?(\s+)(\d+)$'
|
|
|
|
def format(self, start: int, end: int, comment: str) -> str:
|
|
return "%s%s\t%s" % (
|
|
"<U%04X>" % start,
|
|
"...<U%04X>" % end if end > start else "",
|
|
comment
|
|
)
|
|
|
|
|
|
def inject_nerdfont_ranges(ranges: List[tuple], textin: TextIO, textout: TextIO):
|
|
comment_char = None
|
|
keyword_re = re.compile(r'<(\w+)>\s+(\S+)\s*')
|
|
charmap_scope = CharmapScope(ranges, textout)
|
|
width_scope = WidthScope(ranges, textout)
|
|
scope = None
|
|
|
|
for line in textin:
|
|
line = line.strip()
|
|
if line.startswith("CHARMAP"):
|
|
scope = charmap_scope
|
|
elif line.startswith("WIDTH"):
|
|
scope = width_scope
|
|
elif line.startswith("END "):
|
|
while not scope.empty:
|
|
scope.pop()
|
|
scope = None
|
|
elif comment_char and line.startswith(comment_char):
|
|
pass
|
|
elif scope and not scope.empty:
|
|
if scope.read_line(line) is False:
|
|
continue
|
|
elif line:
|
|
m = keyword_re.match(line)
|
|
if m:
|
|
if m[1] == "comment_char":
|
|
comment_char = m[2]
|
|
elif m[1] == 'escape_char':
|
|
charmap_scope.escape_char = m[2]
|
|
|
|
textout.write(line + "\n")
|
|
|
|
|
|
def test():
|
|
TARGET = (
|
|
"<comment_char> %\n"
|
|
"<escape_char> /\n\n"
|
|
"CHARMAP\n"
|
|
"<U0000> /x00 no\n"
|
|
"<U0001>..<U0005> /x01 left\n"
|
|
"<U0006> /x06 subset\n"
|
|
"<U0007> /x07 subset\n"
|
|
"<U0008>..<U0009> /x08 right\n"
|
|
"<U4E00>..<U4E99> /xe4/xb8/x80 superset\n"
|
|
"<U5E00> /x00 gap\n"
|
|
"END CHARMAP\n"
|
|
"WIDTH\n"
|
|
"<U0000>...<U0004>\t0\n"
|
|
"<U6F00>...<U7FFF>\t1\n"
|
|
"END WIDTH\n"
|
|
)
|
|
ranges = [
|
|
(4, 8, "test"),
|
|
(0x4e03, 0x4e0a, "test2"),
|
|
(0x4F00, 0x4F00, "test3"),
|
|
(0x6F00, 0x6F00, "tail"),
|
|
]
|
|
EXPECT = (
|
|
"<comment_char> %\n"
|
|
"<escape_char> /\n\n"
|
|
"CHARMAP\n"
|
|
"<U0000> /x00 no\n"
|
|
"<U0001>..<U0003> /x01 left\n"
|
|
"<U0004>..<U0008> /x04 test\n"
|
|
"<U0009> /x09 right\n"
|
|
"<U4E00>..<U4E02> /xe4/xb8/x80 superset\n"
|
|
"<U4E03>..<U4E0A> /xe4/xb8/x83 test2\n"
|
|
"<U4E0B>..<U4E99> /xe4/xb8/x8b superset\n"
|
|
"<U4F00> /xe4/xbc/x80 test3\n"
|
|
"<U5E00> /x00 gap\n"
|
|
"<U6F00> /xe6/xbc/x80 tail\n"
|
|
"END CHARMAP\n"
|
|
"WIDTH\n"
|
|
"<U0000>...<U0003>\t0\n"
|
|
"<U0004>...<U0008>\t2\n"
|
|
"<U4E03>...<U4E0A>\t2\n"
|
|
"<U4F00>\t2\n"
|
|
"<U6F00>\t2\n"
|
|
"<U6F01>...<U7FFF>\t1\n"
|
|
"END WIDTH\n"
|
|
)
|
|
target = io.StringIO(TARGET)
|
|
result = io.StringIO()
|
|
inject_nerdfont_ranges(ranges, target, result)
|
|
if result.getvalue() != EXPECT:
|
|
print("\033[42m origin\033[0m")
|
|
print(TARGET)
|
|
print()
|
|
print("\033[42m inject\033[0m")
|
|
for r in ranges:
|
|
print("%04X %04X %s" % r)
|
|
print()
|
|
print("\033[42m expect \033[0m", len(EXPECT))
|
|
print(EXPECT)
|
|
print()
|
|
print("\033[42m result \033[0m", len(result.getvalue()))
|
|
a = EXPECT.split('\n')
|
|
b = result.getvalue().split('\n')
|
|
for i in range(max(len(a), len(b))):
|
|
print("\033[%dm%s\033[0m" % (32 if a[i] == b[i] else 31, b[i]))
|
|
else:
|
|
print("pass")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
if os.environ.get('DEBUGGING') == '1':
|
|
test()
|
|
else:
|
|
parser = argparse.ArgumentParser(
|
|
description="patch charmap to make NerdFont icons double width"
|
|
)
|
|
parser.add_argument(
|
|
"-i", "--in-charmap",
|
|
dest="in_charmap",
|
|
default="/usr/share/i18n/charmaps/UTF-8.gz",
|
|
help="input charmap file path")
|
|
parser.add_argument(
|
|
"-o", "--out",
|
|
dest="out_charmap",
|
|
default="/usr/share/i18n/charmaps/UTF-8NF.gz",
|
|
help="output charmap file path")
|
|
parser.add_argument(
|
|
"-f", "--font-patcher",
|
|
dest="font_patcher",
|
|
required=True,
|
|
help="file path of font_patcher from NerdFont")
|
|
parser.add_argument(
|
|
"--plainout",
|
|
dest="plainout",
|
|
action="store_true",
|
|
help="write to stdout in plain-text")
|
|
args = parser.parse_args()
|
|
|
|
font_patcher = open(args.font_patcher, 'r',)
|
|
double_width_ranges = extract_nerdfont_ranges(font_patcher)
|
|
|
|
in_charmap = gzip.open(args.in_charmap, 'rt', encoding="ascii")
|
|
if args.plainout:
|
|
out_charmap = sys.stdout
|
|
elif args.out_charmap.endswith('.gz'):
|
|
out_charmap = gzip.open(args.out_charmap, 'wt')
|
|
else:
|
|
out_charmap = open(args.out_charmap, 'wt')
|
|
ranges = sorted(
|
|
filter(lambda x: x[2] in ['Seti-UI + Custom', 'Devicons'], double_width_ranges),
|
|
key=lambda x: x[0]
|
|
)
|
|
for r in ranges:
|
|
print("%04X-%04X %s" % r)
|
|
inject_nerdfont_ranges(ranges, in_charmap, out_charmap)
|
|
|
|
# add `en_US.UTF-8NF UTF-8NF` to `/etc/locale.gen`
|
|
# run `locale-gen`
|
|
# update `/etc/locale.conf` to `LANG=en_US.UTF-8NF`
|
|
# restart
|