mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-19 05:51:05 +01:00
340 lines
11 KiB
Python
Executable File
340 lines
11 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
import math
|
|
import os
|
|
import sys
|
|
|
|
from hb_fuzzing_tools import (
|
|
FLAG_BITS,
|
|
HB_FUZZING_AXIS_PIN_TO_DEFAULT,
|
|
HB_FUZZING_AXIS_SET_RANGE,
|
|
HB_FUZZING_OP_SET_ADD_RANGES,
|
|
HB_FUZZING_OP_TEXT_ADD,
|
|
HB_FUZZING_OP_TEXT_DEL,
|
|
HB_SUBSET_SETS_DROP_TABLE_TAG,
|
|
HB_SUBSET_SETS_GLYPH_INDEX,
|
|
HB_SUBSET_SETS_LAYOUT_FEATURE_TAG,
|
|
HB_SUBSET_SETS_LAYOUT_SCRIPT_TAG,
|
|
HB_SUBSET_SETS_NAME_ID,
|
|
HB_SUBSET_SETS_NAME_LANG_ID,
|
|
HB_SUBSET_SETS_UNICODE,
|
|
add_set_option,
|
|
emit_axis_records,
|
|
emit_keep_everything,
|
|
emit_pin_all_axes_to_default,
|
|
emit_set_flags,
|
|
emit_set_ranges,
|
|
emit_text,
|
|
fail,
|
|
format_leading_comment,
|
|
main_with_user_errors,
|
|
parse_decimal_ranges,
|
|
parse_hex_ranges,
|
|
parse_output_arg,
|
|
parse_tag_value,
|
|
parse_tags,
|
|
parse_text_codepoints,
|
|
print_recorded_seed_path,
|
|
read_range_file,
|
|
read_text_file,
|
|
write_seed_file,
|
|
)
|
|
|
|
|
|
KEEP_EVERYTHING_FLAGS = (
|
|
0x00000040 |
|
|
0x00000080 |
|
|
0x00000008 |
|
|
0x00000100 |
|
|
0x00000020
|
|
)
|
|
|
|
SET_OPTION_TYPES = {
|
|
"--gids": HB_SUBSET_SETS_GLYPH_INDEX,
|
|
"--name-IDs": HB_SUBSET_SETS_NAME_ID,
|
|
"--name-languages": HB_SUBSET_SETS_NAME_LANG_ID,
|
|
"--layout-features": HB_SUBSET_SETS_LAYOUT_FEATURE_TAG,
|
|
"--layout-scripts": HB_SUBSET_SETS_LAYOUT_SCRIPT_TAG,
|
|
"--drop-tables": HB_SUBSET_SETS_DROP_TABLE_TAG,
|
|
"--unicodes": HB_SUBSET_SETS_UNICODE,
|
|
}
|
|
|
|
VALUE_OPTIONS_TO_IGNORE = {
|
|
"-o",
|
|
"--output-file",
|
|
"--num-iterations",
|
|
}
|
|
|
|
IGNORED_OPTIONS = {
|
|
"--batch",
|
|
"--preprocess",
|
|
}
|
|
|
|
|
|
def usage(prog: str) -> str:
|
|
return f"""Usage: {prog} [-o OUTPUT_OR_DIR] HB_SUBSET_COMMAND [HB_SUBSET_ARGS...]
|
|
|
|
Generate an hb-subset-fuzzer seed by appending a versioned operation trailer to
|
|
the input font bytes. Existing hb-subset-fuzzer corpus files remain valid; this
|
|
script always emits the newer extended encoding.
|
|
|
|
Supported hb-subset inputs:
|
|
- font file via positional argument or --font-file=FILE
|
|
- boolean subset flags
|
|
- --keep-everything
|
|
- --text / --text-file and additive/subtractive forms
|
|
- --unicodes / --unicodes-file and additive/subtractive forms
|
|
- --gids / --gids-file
|
|
- --name-IDs
|
|
- --name-languages
|
|
- --layout-features
|
|
- --layout-scripts
|
|
- --drop-tables
|
|
- --instance / --variations with fixed values, ranges, and drop/default pins
|
|
|
|
Still unsupported:
|
|
- --glyphs / --glyphs-file
|
|
- --gid-map
|
|
|
|
Options:
|
|
-o OUTPUT_OR_DIR
|
|
Write the seed to this file, or into this directory using
|
|
<sha1(font)>.susbset-seed.
|
|
Default: test/fuzzing/fonts/<sha1(font)>.susbset-seed
|
|
-h, --help Show this help.
|
|
"""
|
|
|
|
|
|
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 parser_for_set_option(base_name: str):
|
|
if base_name == "--unicodes":
|
|
return parse_hex_ranges
|
|
if base_name in ("--layout-features", "--layout-scripts", "--drop-tables"):
|
|
return parse_tags
|
|
return parse_decimal_ranges
|
|
|
|
|
|
def handle_file_backed_set_option(ops: bytearray, name: str, path: str) -> None:
|
|
if name == "--gids-file":
|
|
emit_set_ranges(ops, HB_FUZZING_OP_SET_ADD_RANGES, HB_SUBSET_SETS_GLYPH_INDEX, read_range_file(path, parse_decimal_ranges))
|
|
return
|
|
if name == "--unicodes-file":
|
|
emit_set_ranges(ops, HB_FUZZING_OP_SET_ADD_RANGES, HB_SUBSET_SETS_UNICODE, read_range_file(path, parse_hex_ranges))
|
|
return
|
|
fail(f"Unsupported file-backed option '{name}'.")
|
|
|
|
|
|
def record_subset_main(argv: list[str]) -> int:
|
|
usage_text = usage(argv[0])
|
|
out, args = parse_output_arg(argv, usage_text)
|
|
|
|
if len(args) < 2:
|
|
print(usage_text, end="", file=sys.stderr)
|
|
return 1
|
|
|
|
hb_subset = args[0]
|
|
if "hb-subset" not in os.path.basename(hb_subset):
|
|
fail(f"First argument does not look like hb-subset: '{hb_subset}'.")
|
|
|
|
font_file = None
|
|
flags = 0
|
|
ops = bytearray()
|
|
positionals: list[str] = []
|
|
|
|
i = 1
|
|
while i < len(args):
|
|
arg = args[i]
|
|
|
|
if arg in FLAG_BITS:
|
|
flags |= FLAG_BITS[arg]
|
|
emit_set_flags(ops, flags)
|
|
i += 1
|
|
continue
|
|
|
|
if arg == "--keep-everything":
|
|
emit_keep_everything(ops)
|
|
flags = KEEP_EVERYTHING_FLAGS
|
|
i += 1
|
|
continue
|
|
|
|
if arg in IGNORED_OPTIONS:
|
|
i += 1
|
|
continue
|
|
|
|
ignored_value = False
|
|
for prefix in VALUE_OPTIONS_TO_IGNORE:
|
|
if arg == prefix:
|
|
if i + 1 >= len(args):
|
|
fail(f"Missing value for '{arg}'.")
|
|
i += 2
|
|
ignored_value = True
|
|
break
|
|
if arg.startswith(prefix + "="):
|
|
i += 1
|
|
ignored_value = True
|
|
break
|
|
if ignored_value:
|
|
continue
|
|
|
|
if arg == "--font-file":
|
|
if i + 1 >= len(args):
|
|
fail("Missing value for '--font-file'.")
|
|
font_file = args[i + 1]
|
|
i += 2
|
|
continue
|
|
if arg.startswith("--font-file="):
|
|
font_file = arg.split("=", 1)[1]
|
|
i += 1
|
|
continue
|
|
|
|
if arg in ("--text", "--text+", "--text-"):
|
|
if i + 1 >= len(args):
|
|
fail(f"Missing value for '{arg}'.")
|
|
emit_text(ops, HB_FUZZING_OP_TEXT_DEL if arg.endswith("-") else HB_FUZZING_OP_TEXT_ADD, parse_text_codepoints(args[i + 1]))
|
|
i += 2
|
|
continue
|
|
if arg.startswith("--text=") or arg.startswith("--text+=") or arg.startswith("--text-="):
|
|
name, value = arg.split("=", 1)
|
|
emit_text(ops, HB_FUZZING_OP_TEXT_DEL if name.endswith("-") else HB_FUZZING_OP_TEXT_ADD, parse_text_codepoints(value))
|
|
i += 1
|
|
continue
|
|
if arg == "--text-file":
|
|
if i + 1 >= len(args):
|
|
fail("Missing value for '--text-file'.")
|
|
emit_text(ops, HB_FUZZING_OP_TEXT_ADD, read_text_file(args[i + 1]))
|
|
i += 2
|
|
continue
|
|
if arg.startswith("--text-file="):
|
|
emit_text(ops, HB_FUZZING_OP_TEXT_ADD, read_text_file(arg.split("=", 1)[1]))
|
|
i += 1
|
|
continue
|
|
|
|
handled_set_option = False
|
|
for base_name, set_type in SET_OPTION_TYPES.items():
|
|
for modifier in ("", "+", "-"):
|
|
full_name = base_name + modifier
|
|
if arg == full_name:
|
|
if i + 1 >= len(args):
|
|
fail(f"Missing value for '{arg}'.")
|
|
add_set_option(ops, set_type, modifier, args[i + 1], parser_for_set_option(base_name))
|
|
i += 2
|
|
handled_set_option = True
|
|
break
|
|
if arg.startswith(full_name + "="):
|
|
add_set_option(ops, set_type, modifier, arg.split("=", 1)[1], parser_for_set_option(base_name))
|
|
i += 1
|
|
handled_set_option = True
|
|
break
|
|
if handled_set_option:
|
|
break
|
|
if handled_set_option:
|
|
continue
|
|
|
|
if arg == "--gids-file":
|
|
if i + 1 >= len(args):
|
|
fail("Missing value for '--gids-file'.")
|
|
handle_file_backed_set_option(ops, arg, args[i + 1])
|
|
i += 2
|
|
continue
|
|
if arg == "--unicodes-file":
|
|
if i + 1 >= len(args):
|
|
fail("Missing value for '--unicodes-file'.")
|
|
handle_file_backed_set_option(ops, arg, args[i + 1])
|
|
i += 2
|
|
continue
|
|
if arg.startswith("--gids-file=") or arg.startswith("--unicodes-file="):
|
|
name, value = arg.split("=", 1)
|
|
handle_file_backed_set_option(ops, name, value)
|
|
i += 1
|
|
continue
|
|
|
|
if arg in ("--instance", "--variations"):
|
|
if i + 1 >= len(args):
|
|
fail(f"Missing value for '{arg}'.")
|
|
pin_all, records = parse_variations(args[i + 1])
|
|
if pin_all:
|
|
emit_pin_all_axes_to_default(ops)
|
|
if records:
|
|
emit_axis_records(ops, records)
|
|
i += 2
|
|
continue
|
|
if arg.startswith("--instance=") or arg.startswith("--variations="):
|
|
pin_all, records = parse_variations(arg.split("=", 1)[1])
|
|
if pin_all:
|
|
emit_pin_all_axes_to_default(ops)
|
|
if records:
|
|
emit_axis_records(ops, records)
|
|
i += 1
|
|
continue
|
|
|
|
if arg.startswith("--glyphs") or arg.startswith("--gid-map"):
|
|
fail(f"Unsupported hb-subset option '{arg}'.")
|
|
|
|
if arg.startswith("-"):
|
|
fail(f"Unsupported option '{arg}'.")
|
|
|
|
positionals.append(arg)
|
|
i += 1
|
|
|
|
if font_file is None:
|
|
if not positionals:
|
|
fail("No font file found in hb-subset invocation.")
|
|
font_file = positionals[0]
|
|
positionals = positionals[1:]
|
|
|
|
for text_arg in positionals:
|
|
emit_text(ops, HB_FUZZING_OP_TEXT_ADD, parse_text_codepoints(text_arg))
|
|
|
|
print_recorded_seed_path(write_seed_file(font_file, out, ops, leading_comment=format_leading_comment(args)))
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main_with_user_errors(record_subset_main, sys.argv))
|