Files
harfbuzz/util/hb-subset-depend.cc
T
Behdad Esfahbod ebf8ad8718 [util] Separate dependency compile and retrieval modes
The quiet option currently exits immediately after compiling the
dependency graph, making it impossible to measure public API retrieval
separately from formatting and output.

Make -q/--quiet retrieve all selected edges without printing them, and
add --compile for construction-only runs.  Avoid creating a font in
quiet mode since glyph names are not needed.

On Noto Nastaliq, compilation takes 362ms and retrieving every edge adds
about 1.4ms, showing that formatting rather than public API retrieval is
the remaining tool-side cost.

Tested with the full Meson test suite (272/272 passed).

Assisted-by: OpenAI Codex <codex@openai.com>
2026-08-20 01:11:59 -06:00

360 lines
11 KiB
C++

/*
* Copyright © 2025 Adobe, Inc.
*
* This is part of HarfBuzz, a text shaping library.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that the
* above copyright notice and the following two paragraphs appear in
* all copies of this software.
*
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
* Adobe Author(s): Skef Iterum
*/
#include "batch.hh"
#include "face-options.hh"
#include <hb-subset.h>
#include <set>
#include <string>
#include <vector>
struct depend_t : option_parser_t, face_options_t
{
gboolean flagged_only = false;
gboolean no_context = false;
gboolean no_glyph_names = false;
gboolean compile_only = false;
gboolean quiet = false;
char *gids_str = nullptr;
void
add_options ()
{
set_summary ("Show glyph dependency graph.");
set_description ("Prints the glyph dependency graph extracted from a font file.\n"
"For each source glyph, lists the glyphs it can produce or depend on\n"
"through GSUB substitutions, composite glyphs, COLR layers, and MATH variants.");
face_options_t::add_options (this);
GOptionEntry depend_entries[] =
{
{"gids", 0, 0, G_OPTION_ARG_STRING, &this->gids_str,
"Filter output to specific glyph IDs (e.g. '1,5,10-20')", "GIDs"},
{"flagged", 0, 0, G_OPTION_ARG_NONE, &this->flagged_only,
"Show only edges with over-approximation flags set (C or N)", nullptr},
{"no-context", 0, 0, G_OPTION_ARG_NONE, &this->no_context,
"Suppress context set output", nullptr},
{"no-glyph-names", 0, 0, G_OPTION_ARG_NONE, &this->no_glyph_names,
"Use numeric glyph IDs instead of names", nullptr},
{"compile", 0, 0, G_OPTION_ARG_NONE, &this->compile_only,
"Build the dependency graph without retrieving it", nullptr},
{"quiet", 'q', 0, G_OPTION_ARG_NONE, &this->quiet,
"Retrieve the dependency graph without printing it", nullptr},
{nullptr}
};
add_group (depend_entries,
"depend",
"Dependency graph options:",
"Options for filtering and formatting the dependency graph output",
this,
false);
GOptionEntry entries[] =
{
{G_OPTION_REMAINING, 0, G_OPTION_FLAG_IN_MAIN,
G_OPTION_ARG_CALLBACK, (gpointer) &collect_rest, nullptr, "[FONT-FILE]"},
{nullptr}
};
add_main_group (entries, this);
option_parser_t::add_options ();
}
static gboolean
collect_rest (const char *name G_GNUC_UNUSED,
const char *arg,
gpointer data,
GError **error)
{
depend_t *thiz = (depend_t *) data;
if (!thiz->font_file)
{
thiz->font_file = g_strdup (arg);
return true;
}
g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED,
"Too many arguments on the command line");
return false;
}
/* Returns the glyph name if font is non-null and the font has a real name
* for this glyph; otherwise returns the glyph ID as a decimal string. */
static std::string
glyph_str (hb_font_t *font, hb_codepoint_t gid)
{
if (font)
{
char buf[128];
if (hb_font_get_glyph_name (font, gid, buf, sizeof (buf)))
return buf;
}
char buf[32];
snprintf (buf, sizeof (buf), "%u", gid);
return buf;
}
/* Parses a comma-separated list of GID ranges (e.g. "1,5,10-20,42"). */
static std::set<unsigned>
parse_gids (const char *str)
{
std::set<unsigned> result;
const char *p = str;
while (*p)
{
char *end;
unsigned long start = strtoul (p, &end, 10);
if (end == p) break;
p = end;
if (*p == '-')
{
p++;
unsigned long stop = strtoul (p, &end, 10);
if (end == p) break;
p = end;
for (unsigned long i = start; i <= stop; i++)
result.insert ((unsigned) i);
}
else
result.insert ((unsigned) start);
if (*p == ',') p++;
}
return result;
}
/* Builds a human-readable string representing the context set at ctx_idx.
* Elements < 0x80000000 are direct GID refs joined with &.
* Elements >= 0x80000000 are indirect set refs (strip high bit for index),
* printed as parenthesized |-separated members. */
static std::string
build_context_str (hb_subset_depend_t *depend, hb_codepoint_t ctx_idx,
hb_font_t *font)
{
hb_set_t *ctx_set = hb_set_create ();
if (!hb_subset_depend_lookup_set (depend, ctx_idx, ctx_set))
{
hb_set_destroy (ctx_set);
return "";
}
std::string result = "(";
bool first = true;
hb_codepoint_t elem = HB_SET_VALUE_INVALID;
while (hb_set_next (ctx_set, &elem))
{
if (!first) result += " & ";
first = false;
if (elem < 0x80000000u)
{
result += glyph_str (font, elem);
}
else
{
hb_codepoint_t set_idx = elem & 0x7FFFFFFFu;
hb_set_t *sub_set = hb_set_create ();
if (hb_subset_depend_lookup_set (depend, set_idx, sub_set))
{
result += "(";
bool sub_first = true;
hb_codepoint_t sub_elem = HB_SET_VALUE_INVALID;
while (hb_set_next (sub_set, &sub_elem))
{
if (!sub_first) result += "|";
sub_first = false;
result += glyph_str (font, sub_elem);
}
result += ")";
}
hb_set_destroy (sub_set);
}
}
result += ")";
hb_set_destroy (ctx_set);
return result;
}
int
operator () (int argc, char **argv)
{
add_options ();
parse (&argc, &argv);
hb_subset_depend_t *depend = hb_subset_depend_from_face_or_fail (face);
if (!depend)
{
fprintf (stderr, "Failed to build dependency graph\n");
return 1;
}
if (compile_only)
{
hb_subset_depend_destroy (depend);
return 0;
}
hb_font_t *font = no_glyph_names || quiet ? nullptr : hb_font_create (face);
std::set<unsigned> gid_filter;
bool filter_gids = gids_str != nullptr;
if (filter_gids)
gid_filter = parse_gids (gids_str);
unsigned num_glyphs = hb_face_get_glyph_count (face);
std::set<hb_codepoint_t> seen_lig_sets;
bool printed_any = false;
for (unsigned gid = 0; gid < num_glyphs; gid++)
{
if (filter_gids && !gid_filter.count (gid))
continue;
unsigned total = hb_subset_depend_lookup_glyph (depend, gid, 0, nullptr, nullptr);
if (total == 0) continue;
/* Collect entries, applying the --flagged filter */
std::vector<hb_subset_depend_entry_t> entries;
for (unsigned i = 0; i < total; i++)
{
hb_subset_depend_entry_t entry;
unsigned count = 1;
hb_subset_depend_lookup_glyph (depend, gid, i, &count, &entry);
if (flagged_only && entry.flags == HB_SUBSET_DEPEND_EDGE_FLAG_NONE)
continue;
entries.push_back (entry);
}
if (entries.empty () || quiet) continue;
if (printed_any) printf ("\n");
printed_any = true;
/* Source GID header: "42 (glyphname):" or "42:" */
{
char name_buf[128];
if (font && hb_font_get_glyph_name (font, gid, name_buf, sizeof (name_buf)))
printf ("%u (%s):\n", gid, name_buf);
else
printf ("%u:\n", gid);
}
for (const auto &entry : entries)
{
std::string line = " ";
/* Table tag, trailing spaces trimmed (e.g. "CFF " -> "CFF") */
char tag_buf[5];
hb_tag_to_string (entry.table_tag, tag_buf);
tag_buf[4] = 0;
int tag_end = 4;
while (tag_end > 0 && tag_buf[tag_end - 1] == ' ') tag_end--;
tag_buf[tag_end] = 0;
line += tag_buf;
/* Feature tag only for GSUB edges */
if (entry.table_tag == HB_OT_TAG_GSUB)
{
char feat_buf[5];
hb_tag_to_string (entry.layout_tag, feat_buf);
feat_buf[4] = 0;
line += " ";
line += feat_buf;
}
line += " -> ";
line += glyph_str (font, entry.dependent);
if (entry.ligature_set_index != HB_CODEPOINT_INVALID)
{
char buf[32];
snprintf (buf, sizeof (buf), " lig[%u]", entry.ligature_set_index);
line += buf;
}
if (entry.flags)
{
line += " flags: ";
if (entry.flags & HB_SUBSET_DEPEND_EDGE_FLAG_FROM_CONTEXT_POSITION) line += "C";
if (entry.flags & HB_SUBSET_DEPEND_EDGE_FLAG_FROM_NESTED_CONTEXT) line += "N";
}
/* Context: append inline if it fits within 80 columns, else wrap */
bool ctx_wraps = false;
std::string ctx_str;
if (!no_context && entry.context_set_index != HB_CODEPOINT_INVALID)
{
ctx_str = build_context_str (depend, entry.context_set_index, font);
if (!ctx_str.empty ())
{
if (line.size () + 2 + ctx_str.size () <= 80)
line += " " + ctx_str;
else
ctx_wraps = true;
}
}
printf ("%s\n", line.c_str ());
if (ctx_wraps)
printf (" ctx: %s\n", ctx_str.c_str ());
/* Ligature set contents: printed once (on first occurrence) */
if (entry.ligature_set_index != HB_CODEPOINT_INVALID &&
!seen_lig_sets.count (entry.ligature_set_index))
{
seen_lig_sets.insert (entry.ligature_set_index);
hb_set_t *lig_set = hb_set_create ();
if (hb_subset_depend_lookup_set (depend, entry.ligature_set_index, lig_set))
{
printf (" lig[%u]:", entry.ligature_set_index);
hb_codepoint_t lig_gid = HB_SET_VALUE_INVALID;
while (hb_set_next (lig_set, &lig_gid))
printf (" %s", glyph_str (font, lig_gid).c_str ());
printf ("\n");
}
hb_set_destroy (lig_set);
}
}
}
if (font) hb_font_destroy (font);
hb_subset_depend_destroy (depend);
return 0;
}
};
int
main (int argc, char **argv)
{
return batch_main<depend_t> (argc, argv);
}