mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-19 14:01:10 +01:00
371 lines
11 KiB
Python
371 lines
11 KiB
Python
#!/usr/bin/env python3
|
|
|
|
import hashlib
|
|
import math
|
|
import os
|
|
import shlex
|
|
import struct
|
|
import sys
|
|
|
|
|
|
HB_FUZZING_EXTENDED_MAGIC = b"HBSUBFZ2"
|
|
|
|
HB_SUBSET_SETS_GLYPH_INDEX = 0
|
|
HB_SUBSET_SETS_UNICODE = 1
|
|
HB_SUBSET_SETS_DROP_TABLE_TAG = 3
|
|
HB_SUBSET_SETS_NAME_ID = 4
|
|
HB_SUBSET_SETS_NAME_LANG_ID = 5
|
|
HB_SUBSET_SETS_LAYOUT_FEATURE_TAG = 6
|
|
HB_SUBSET_SETS_LAYOUT_SCRIPT_TAG = 7
|
|
|
|
HB_FUZZING_OP_SET_FLAGS = 1
|
|
HB_FUZZING_OP_KEEP_EVERYTHING = 2
|
|
HB_FUZZING_OP_SET_CLEAR = 3
|
|
HB_FUZZING_OP_SET_INVERT = 4
|
|
HB_FUZZING_OP_SET_ADD_RANGES = 5
|
|
HB_FUZZING_OP_SET_DEL_RANGES = 6
|
|
HB_FUZZING_OP_TEXT_ADD = 7
|
|
HB_FUZZING_OP_TEXT_DEL = 8
|
|
HB_FUZZING_OP_AXIS_PIN_ALL_TO_DEFAULT = 9
|
|
HB_FUZZING_OP_AXIS_SET = 10
|
|
|
|
HB_FUZZING_AXIS_PIN_TO_DEFAULT = 0
|
|
HB_FUZZING_AXIS_SET_RANGE = 1
|
|
|
|
FLAG_BITS = {
|
|
"--no-hinting": 0x00000001,
|
|
"--retain-gids": 0x00000002,
|
|
"--desubroutinize": 0x00000004,
|
|
"--name-legacy": 0x00000008,
|
|
"--set-overlaps-flag": 0x00000010,
|
|
"--passthrough-tables": 0x00000020,
|
|
"--notdef-outline": 0x00000040,
|
|
"--glyph-names": 0x00000080,
|
|
"--no-prune-unicode-ranges": 0x00000100,
|
|
"--no-layout-closure": 0x00000200,
|
|
"--optimize": 0x00000400,
|
|
"--no-bidi-closure": 0x00000800,
|
|
"--iftb-requirements": 0x00001000,
|
|
"--retain-num-glyphs": 0x00002000,
|
|
"--downgrade-cff2": 0x00004000,
|
|
}
|
|
|
|
|
|
class UserError(Exception):
|
|
pass
|
|
|
|
|
|
def fail(msg: str) -> None:
|
|
raise UserError(msg)
|
|
|
|
|
|
def pack_u32(value: int) -> bytes:
|
|
return struct.pack("<I", value & 0xFFFFFFFF)
|
|
|
|
|
|
def pack_f32(value: float) -> bytes:
|
|
return struct.pack("<f", value)
|
|
|
|
|
|
def emit_set_flags(ops: bytearray, flags: int) -> None:
|
|
ops.append(HB_FUZZING_OP_SET_FLAGS)
|
|
ops += pack_u32(flags)
|
|
|
|
|
|
def emit_keep_everything(ops: bytearray) -> None:
|
|
ops.append(HB_FUZZING_OP_KEEP_EVERYTHING)
|
|
|
|
|
|
def emit_set_clear(ops: bytearray, set_type: int) -> None:
|
|
ops += bytes((HB_FUZZING_OP_SET_CLEAR, set_type))
|
|
|
|
|
|
def emit_set_invert(ops: bytearray, set_type: int) -> None:
|
|
ops += bytes((HB_FUZZING_OP_SET_INVERT, set_type))
|
|
|
|
|
|
def emit_set_ranges(ops: bytearray, opcode: int, set_type: int, ranges: list[tuple[int, int]]) -> None:
|
|
ops += bytes((opcode, set_type))
|
|
ops += pack_u32(len(ranges))
|
|
for start, end in ranges:
|
|
ops += pack_u32(start)
|
|
ops += pack_u32(end)
|
|
|
|
|
|
def emit_text(ops: bytearray, opcode: int, codepoints: list[int]) -> None:
|
|
ops.append(opcode)
|
|
ops += pack_u32(len(codepoints))
|
|
for cp in codepoints:
|
|
ops += pack_u32(cp)
|
|
|
|
|
|
def emit_pin_all_axes_to_default(ops: bytearray) -> None:
|
|
ops.append(HB_FUZZING_OP_AXIS_PIN_ALL_TO_DEFAULT)
|
|
|
|
|
|
def emit_axis_records(ops: bytearray, records: list[tuple[int, int, float, float, float]]) -> None:
|
|
ops.append(HB_FUZZING_OP_AXIS_SET)
|
|
ops += pack_u32(len(records))
|
|
for tag, mode, minimum, middle, maximum in records:
|
|
ops += pack_u32(tag)
|
|
ops.append(mode)
|
|
ops += pack_f32(minimum)
|
|
ops += pack_f32(middle)
|
|
ops += pack_f32(maximum)
|
|
|
|
|
|
def parse_decimal_ranges(value: str) -> list[tuple[int, int]]:
|
|
ranges: list[tuple[int, int]] = []
|
|
for chunk in value.replace(" ", ",").split(","):
|
|
if not chunk:
|
|
continue
|
|
if chunk == "*":
|
|
fail("Internal error: wildcard range should be handled before parsing.")
|
|
if "-" in chunk:
|
|
start_text, end_text = chunk.split("-", 1)
|
|
try:
|
|
start = int(start_text, 10)
|
|
end = int(end_text, 10)
|
|
except ValueError:
|
|
fail(f"Failed parsing decimal range '{chunk}'.")
|
|
else:
|
|
try:
|
|
start = end = int(chunk, 10)
|
|
except ValueError:
|
|
fail(f"Failed parsing decimal value '{chunk}'.")
|
|
if start < 0 or end < start:
|
|
fail(f"Invalid decimal range '{chunk}'.")
|
|
ranges.append((start, end))
|
|
return ranges
|
|
|
|
|
|
def parse_hex_ranges(value: str) -> list[tuple[int, int]]:
|
|
ranges: list[tuple[int, int]] = []
|
|
for chunk in value.replace(" ", ",").split(","):
|
|
if not chunk:
|
|
continue
|
|
if chunk == "*":
|
|
fail("Internal error: wildcard range should be handled before parsing.")
|
|
if "-" in chunk:
|
|
start_text, end_text = chunk.split("-", 1)
|
|
try:
|
|
start = int(start_text, 16)
|
|
end = int(end_text, 16)
|
|
except ValueError:
|
|
fail(f"Failed parsing unicode range '{chunk}'.")
|
|
else:
|
|
try:
|
|
start = end = int(chunk, 16)
|
|
except ValueError:
|
|
fail(f"Failed parsing unicode value '{chunk}'.")
|
|
if start < 0 or end < start or end > 0x10FFFF:
|
|
fail(f"Invalid unicode range '{chunk}'.")
|
|
ranges.append((start, end))
|
|
return ranges
|
|
|
|
|
|
def parse_tags(value: str) -> list[tuple[int, int]]:
|
|
tags: list[tuple[int, int]] = []
|
|
for chunk in value.replace(",", " ").split():
|
|
if chunk == "*":
|
|
fail("Internal error: wildcard tag set should be handled before parsing.")
|
|
if len(chunk) > 4:
|
|
fail(f"Tag '{chunk}' is longer than 4 bytes.")
|
|
try:
|
|
tag_value = int.from_bytes(chunk.ljust(4, " ").encode("ascii"), byteorder="big")
|
|
except UnicodeEncodeError:
|
|
fail(f"Tag '{chunk}' is not ASCII.")
|
|
tags.append((tag_value, tag_value))
|
|
return tags
|
|
|
|
|
|
def parse_text_codepoints(value: str) -> list[int]:
|
|
codepoints = [ord(ch) for ch in value]
|
|
for cp in codepoints:
|
|
if cp < 0 or cp > 0x10FFFF:
|
|
fail(f"Invalid codepoint value {cp}.")
|
|
return codepoints
|
|
|
|
|
|
def parse_tag_value(tag_text: str, kind: str) -> int:
|
|
if len(tag_text) > 4:
|
|
fail(f"{kind} '{tag_text}' is longer than 4 bytes.")
|
|
try:
|
|
return int.from_bytes(tag_text.ljust(4, " ").encode("ascii"), byteorder="big")
|
|
except UnicodeEncodeError:
|
|
fail(f"{kind} '{tag_text}' is not ASCII.")
|
|
|
|
|
|
def parse_axis_number(text: str) -> float:
|
|
try:
|
|
return float(text)
|
|
except ValueError:
|
|
fail(f"Failed parsing axis value '{text}'.")
|
|
|
|
|
|
def parse_axis_range(value: str) -> tuple[int, float, float, float]:
|
|
if value == "drop":
|
|
return HB_FUZZING_AXIS_PIN_TO_DEFAULT, 0.0, 0.0, 0.0
|
|
|
|
parts = value.split(":")
|
|
if len(parts) == 1:
|
|
v = parse_axis_number(parts[0])
|
|
return HB_FUZZING_AXIS_SET_RANGE, v, v, v
|
|
if len(parts) == 2:
|
|
minimum = math.nan if parts[0] == "" else parse_axis_number(parts[0])
|
|
maximum = math.nan if parts[1] == "" else parse_axis_number(parts[1])
|
|
return HB_FUZZING_AXIS_SET_RANGE, minimum, math.nan, maximum
|
|
if len(parts) == 3:
|
|
minimum = math.nan if parts[0] == "" else parse_axis_number(parts[0])
|
|
middle = math.nan if parts[1] == "" else parse_axis_number(parts[1])
|
|
maximum = math.nan if parts[2] == "" else parse_axis_number(parts[2])
|
|
return HB_FUZZING_AXIS_SET_RANGE, minimum, middle, maximum
|
|
fail(f"Failed parsing axis range '{value}'.")
|
|
|
|
|
|
def parse_variations(value: str) -> tuple[bool, list[tuple[int, int, float, float, float]]]:
|
|
pin_all = False
|
|
records: list[tuple[int, int, float, float, float]] = []
|
|
for item in value.replace(" ", ",").split(","):
|
|
if not item:
|
|
continue
|
|
if "=" not in item:
|
|
fail(f"Unsupported variation item '{item}'. Expected tag=value.")
|
|
tag_text, axis_value_text = item.split("=", 1)
|
|
if tag_text == "*":
|
|
if axis_value_text != "drop":
|
|
fail("Only *=drop is supported for wildcard axis pinning.")
|
|
pin_all = True
|
|
continue
|
|
tag = parse_tag_value(tag_text, "Axis tag")
|
|
mode, minimum, middle, maximum = parse_axis_range(axis_value_text)
|
|
records.append((tag, mode, minimum, middle, maximum))
|
|
return pin_all, records
|
|
|
|
|
|
def add_set_option(ops: bytearray, set_type: int, modifier: str, value: str, parser) -> None:
|
|
if modifier == "":
|
|
emit_set_clear(ops, set_type)
|
|
|
|
if value == "*":
|
|
if modifier == "-":
|
|
emit_set_clear(ops, set_type)
|
|
else:
|
|
emit_set_clear(ops, set_type)
|
|
emit_set_invert(ops, set_type)
|
|
return
|
|
|
|
ranges = parser(value)
|
|
if ranges:
|
|
emit_set_ranges(
|
|
ops,
|
|
HB_FUZZING_OP_SET_DEL_RANGES if modifier == "-" else HB_FUZZING_OP_SET_ADD_RANGES,
|
|
set_type,
|
|
ranges,
|
|
)
|
|
|
|
|
|
def parse_output_arg(argv: list[str], usage_text: str) -> tuple[str, list[str]]:
|
|
out = ""
|
|
args = argv[1:]
|
|
|
|
while args:
|
|
arg = args[0]
|
|
if arg == "-o":
|
|
if len(args) < 2:
|
|
print(usage_text, end="", file=sys.stderr)
|
|
raise SystemExit(1)
|
|
out = args[1]
|
|
args = args[2:]
|
|
continue
|
|
if arg in ("-h", "--help"):
|
|
print(usage_text, end="")
|
|
raise SystemExit(0)
|
|
if arg == "--":
|
|
args = args[1:]
|
|
break
|
|
break
|
|
|
|
return out, args
|
|
|
|
|
|
def read_text_file(path: str) -> list[int]:
|
|
with open(path, "r", encoding="utf-8") as fp:
|
|
return parse_text_codepoints(fp.read())
|
|
|
|
|
|
def read_range_file(path: str, parser) -> list[tuple[int, int]]:
|
|
ranges = []
|
|
with open(path, "r", encoding="utf-8") as fp:
|
|
for line in fp:
|
|
line = line.split("#", 1)[0].strip()
|
|
if line:
|
|
ranges.extend(parser(line))
|
|
return ranges
|
|
|
|
|
|
def resolve_seed_output_path(font_path: str, font_bytes: bytes, out_path: str, default_suffix: str) -> tuple[str, str]:
|
|
digest = hashlib.sha1(font_bytes).hexdigest()
|
|
default_name = digest + default_suffix
|
|
default_dir = os.path.join(os.path.dirname(__file__), "fonts")
|
|
|
|
if not out_path:
|
|
display_path = os.path.join(default_dir, default_name)
|
|
return display_path, os.path.abspath(display_path)
|
|
|
|
if out_path.endswith(os.sep):
|
|
display_path = os.path.join(out_path, default_name)
|
|
return display_path, os.path.abspath(display_path)
|
|
|
|
abs_out_path = os.path.abspath(out_path)
|
|
if os.path.isdir(abs_out_path):
|
|
if os.path.isabs(out_path):
|
|
display_path = os.path.join(out_path, default_name)
|
|
else:
|
|
display_path = os.path.join(out_path, default_name)
|
|
return display_path, os.path.join(abs_out_path, default_name)
|
|
|
|
return out_path, abs_out_path
|
|
|
|
def format_leading_comment(argv: list[str]) -> bytes:
|
|
return ("$ " + " ".join(shlex.quote(arg) for arg in argv) + "\n").encode("utf-8")
|
|
|
|
|
|
def write_seed_file(font_file: str,
|
|
out_path: str,
|
|
ops: bytearray,
|
|
default_suffix: str = ".susbset-seed",
|
|
leading_comment: bytes = b"") -> str:
|
|
font_path = os.path.abspath(font_file)
|
|
if not os.path.isfile(font_path):
|
|
fail(f"Font file not found: '{font_path}'.")
|
|
|
|
with open(font_path, "rb") as fp:
|
|
font_bytes = fp.read()
|
|
|
|
display_path, seed_path = resolve_seed_output_path(font_path, font_bytes, out_path, default_suffix)
|
|
parent = os.path.dirname(seed_path)
|
|
if parent:
|
|
os.makedirs(parent, exist_ok=True)
|
|
|
|
with open(seed_path, "wb") as fp:
|
|
fp.write(leading_comment)
|
|
fp.write(font_bytes)
|
|
fp.write(ops)
|
|
fp.write(pack_u32(len(ops)))
|
|
fp.write(HB_FUZZING_EXTENDED_MAGIC)
|
|
|
|
return display_path
|
|
|
|
|
|
def print_recorded_seed_path(seed_path: str) -> None:
|
|
print(seed_path)
|
|
|
|
|
|
def main_with_user_errors(main_fn, argv: list[str]) -> int:
|
|
try:
|
|
return main_fn(argv)
|
|
except UserError as e:
|
|
print(e, file=sys.stderr)
|
|
return 1
|