|
|
@@ -0,0 +1,2748 @@
|
|
|
+# Copyright 2013 Google, Inc. All Rights Reserved.
|
|
|
+#
|
|
|
+# Google Author(s): Behdad Esfahbod
|
|
|
+
|
|
|
+# subset.py file from Just van Rossom's fonttools project
|
|
|
+#
|
|
|
+# Copyright 1999-2004
|
|
|
+# by Just van Rossum, Letterror, The Netherlands.
|
|
|
+# The full text of the license is available at https://github.com/behdad/fonttools/blob/master/LICENSE.txt
|
|
|
+
|
|
|
+from __future__ import print_function, division, absolute_import
|
|
|
+from fontTools.misc.py23 import *
|
|
|
+from fontTools import ttLib
|
|
|
+from fontTools.ttLib.tables import otTables
|
|
|
+from fontTools.misc import psCharStrings
|
|
|
+import sys
|
|
|
+import struct
|
|
|
+import time
|
|
|
+import array
|
|
|
+
|
|
|
+__usage__ = "pyftsubset font-file [glyph...] [--option=value]..."
|
|
|
+
|
|
|
+__doc__="""\
|
|
|
+pyftsubset -- OpenType font subsetter and optimizer
|
|
|
+
|
|
|
+ pyftsubset is an OpenType font subsetter and optimizer, based on fontTools.
|
|
|
+ It accepts any TT- or CFF-flavored OpenType (.otf or .ttf) or WOFF (.woff)
|
|
|
+ font file. The subsetted glyph set is based on the specified glyphs
|
|
|
+ or characters, and specified OpenType layout features.
|
|
|
+
|
|
|
+ The tool also performs some size-reducing optimizations, aimed for using
|
|
|
+ subset fonts as webfonts. Individual optimizations can be enabled or
|
|
|
+ disabled, and are enabled by default when they are safe.
|
|
|
+
|
|
|
+Usage:
|
|
|
+ """+__usage__+"""
|
|
|
+
|
|
|
+ At least one glyph or one of --gids, --gids-file, --glyphs, --glyphs-file,
|
|
|
+ --text, --text-file, --unicodes, or --unicodes-file, must be specified.
|
|
|
+
|
|
|
+Arguments:
|
|
|
+ font-file
|
|
|
+ The input font file.
|
|
|
+ glyph
|
|
|
+ Specify one or more glyph identifiers to include in the subset. Must be
|
|
|
+ PS glyph names, or the special string '*' to keep the entire glyph set.
|
|
|
+
|
|
|
+Initial glyph set specification:
|
|
|
+ These options populate the initial glyph set. Same option can appear
|
|
|
+ multiple times, and the results are accummulated.
|
|
|
+ --gids=<NNN>[,<NNN>...]
|
|
|
+ Specify comma/whitespace-separated list of glyph IDs or ranges as
|
|
|
+ decimal numbers. For example, --gids=10-12,14 adds glyphs with
|
|
|
+ numbers 10, 11, 12, and 14.
|
|
|
+ --gids-file=<path>
|
|
|
+ Like --gids but reads from a file. Anything after a '#' on any line
|
|
|
+ is ignored as comments.
|
|
|
+ --glyphs=<glyphname>[,<glyphname>...]
|
|
|
+ Specify comma/whitespace-separated PS glyph names to add to the subset.
|
|
|
+ Note that only PS glyph names are accepted, not gidNNN, U+XXXX, etc
|
|
|
+ that are accepted on the command line. The special string '*' wil keep
|
|
|
+ the entire glyph set.
|
|
|
+ --glyphs-file=<path>
|
|
|
+ Like --glyphs but reads from a file. Anything after a '#' on any line
|
|
|
+ is ignored as comments.
|
|
|
+ --text=<text>
|
|
|
+ Specify characters to include in the subset, as UTF-8 string.
|
|
|
+ --text-file=<path>
|
|
|
+ Like --text but reads from a file. Newline character are not added to
|
|
|
+ the subset.
|
|
|
+ --unicodes=<XXXX>[,<XXXX>...]
|
|
|
+ Specify comma/whitespace-separated list of Unicode codepoints or
|
|
|
+ ranges as hex numbers, optionally prefixed with 'U+', 'u', etc.
|
|
|
+ For example, --unicodes=41-5a,61-7a adds ASCII letters, so does
|
|
|
+ the more verbose --unicodes=U+0041-005A,U+0061-007A.
|
|
|
+ The special strings '*' will choose all Unicode characters mapped
|
|
|
+ by the font.
|
|
|
+ --unicodes-file=<path>
|
|
|
+ Like --unicodes, but reads from a file. Anything after a '#' on any
|
|
|
+ line in the file is ignored as comments.
|
|
|
+ --ignore-missing-glyphs
|
|
|
+ Do not fail if some requested glyphs or gids are not available in
|
|
|
+ the font.
|
|
|
+ --no-ignore-missing-glyphs
|
|
|
+ Stop and fail if some requested glyphs or gids are not available
|
|
|
+ in the font. [default]
|
|
|
+ --ignore-missing-unicodes [default]
|
|
|
+ Do not fail if some requested Unicode characters (including those
|
|
|
+ indirectly specified using --text or --text-file) are not available
|
|
|
+ in the font.
|
|
|
+ --no-ignore-missing-unicodes
|
|
|
+ Stop and fail if some requested Unicode characters are not available
|
|
|
+ in the font.
|
|
|
+ Note the default discrepancy between ignoring missing glyphs versus
|
|
|
+ unicodes. This is for historical reasons and in the future
|
|
|
+ --no-ignore-missing-unicodes might become default.
|
|
|
+
|
|
|
+Other options:
|
|
|
+ For the other options listed below, to see the current value of the option,
|
|
|
+ pass a value of '?' to it, with or without a '='.
|
|
|
+ Examples:
|
|
|
+ $ pyftsubset --glyph-names?
|
|
|
+ Current setting for 'glyph-names' is: False
|
|
|
+ $ ./pyftsubset --name-IDs=?
|
|
|
+ Current setting for 'name-IDs' is: [1, 2]
|
|
|
+ $ ./pyftsubset --hinting? --no-hinting --hinting?
|
|
|
+ Current setting for 'hinting' is: True
|
|
|
+ Current setting for 'hinting' is: False
|
|
|
+
|
|
|
+Output options:
|
|
|
+ --output-file=<path>
|
|
|
+ The output font file. If not specified, the subsetted font
|
|
|
+ will be saved in as font-file.subset.
|
|
|
+ --flavor=<type>
|
|
|
+ Specify flavor of output font file. May be 'woff' or 'woff2'.
|
|
|
+ Note that WOFF2 requires the Brotli Python extension, available
|
|
|
+ at https://github.com/google/brotli
|
|
|
+
|
|
|
+Glyph set expansion:
|
|
|
+ These options control how additional glyphs are added to the subset.
|
|
|
+ --notdef-glyph
|
|
|
+ Add the '.notdef' glyph to the subset (ie, keep it). [default]
|
|
|
+ --no-notdef-glyph
|
|
|
+ Drop the '.notdef' glyph unless specified in the glyph set. This
|
|
|
+ saves a few bytes, but is not possible for Postscript-flavored
|
|
|
+ fonts, as those require '.notdef'. For TrueType-flavored fonts,
|
|
|
+ this works fine as long as no unsupported glyphs are requested
|
|
|
+ from the font.
|
|
|
+ --notdef-outline
|
|
|
+ Keep the outline of '.notdef' glyph. The '.notdef' glyph outline is
|
|
|
+ used when glyphs not supported by the font are to be shown. It is not
|
|
|
+ needed otherwise.
|
|
|
+ --no-notdef-outline
|
|
|
+ When including a '.notdef' glyph, remove its outline. This saves
|
|
|
+ a few bytes. [default]
|
|
|
+ --recommended-glyphs
|
|
|
+ Add glyphs 0, 1, 2, and 3 to the subset, as recommended for
|
|
|
+ TrueType-flavored fonts: '.notdef', 'NULL' or '.null', 'CR', 'space'.
|
|
|
+ Some legacy software might require this, but no modern system does.
|
|
|
+ --no-recommended-glyphs
|
|
|
+ Do not add glyphs 0, 1, 2, and 3 to the subset, unless specified in
|
|
|
+ glyph set. [default]
|
|
|
+ --layout-features[+|-]=<feature>[,<feature>...]
|
|
|
+ Specify (=), add to (+=) or exclude from (-=) the comma-separated
|
|
|
+ set of OpenType layout feature tags that will be preserved.
|
|
|
+ Glyph variants used by the preserved features are added to the
|
|
|
+ specified subset glyph set. By default, 'calt', 'ccmp', 'clig', 'curs',
|
|
|
+ 'kern', 'liga', 'locl', 'mark', 'mkmk', 'rclt', 'rlig' and all features
|
|
|
+ required for script shaping are preserved. To see the full list, try
|
|
|
+ '--layout-features=?'. Use '*' to keep all features.
|
|
|
+ Multiple --layout-features options can be provided if necessary.
|
|
|
+ Examples:
|
|
|
+ --layout-features+=onum,pnum,ss01
|
|
|
+ * Keep the default set of features and 'onum', 'pnum', 'ss01'.
|
|
|
+ --layout-features-='mark','mkmk'
|
|
|
+ * Keep the default set of features but drop 'mark' and 'mkmk'.
|
|
|
+ --layout-features='kern'
|
|
|
+ * Only keep the 'kern' feature, drop all others.
|
|
|
+ --layout-features=''
|
|
|
+ * Drop all features.
|
|
|
+ --layout-features='*'
|
|
|
+ * Keep all features.
|
|
|
+ --layout-features+=aalt --layout-features-=vrt2
|
|
|
+ * Keep default set of features plus 'aalt', but drop 'vrt2'.
|
|
|
+
|
|
|
+Hinting options:
|
|
|
+ --hinting
|
|
|
+ Keep hinting [default]
|
|
|
+ --no-hinting
|
|
|
+ Drop glyph-specific hinting and font-wide hinting tables, as well
|
|
|
+ as remove hinting-related bits and pieces from other tables (eg. GPOS).
|
|
|
+ See --hinting-tables for list of tables that are dropped by default.
|
|
|
+ Instructions and hints are stripped from 'glyf' and 'CFF ' tables
|
|
|
+ respectively. This produces (sometimes up to 30%) smaller fonts that
|
|
|
+ are suitable for extremely high-resolution systems, like high-end
|
|
|
+ mobile devices and retina displays.
|
|
|
+ XXX Note: Currently there is a known bug in 'CFF ' hint stripping that
|
|
|
+ might make the font unusable as a webfont as they will be rejected by
|
|
|
+ OpenType Sanitizer used in common browsers. For more information see:
|
|
|
+ https://github.com/behdad/fonttools/issues/144
|
|
|
+ The --desubroutinize options works around that bug.
|
|
|
+
|
|
|
+Optimization options:
|
|
|
+ --desubroutinize
|
|
|
+ Remove CFF use of subroutinizes. Subroutinization is a way to make CFF
|
|
|
+ fonts smaller. For small subsets however, desubroutinizing might make
|
|
|
+ the font smaller. It has even been reported that desubroutinized CFF
|
|
|
+ fonts compress better (produce smaller output) WOFF and WOFF2 fonts.
|
|
|
+ Also see note under --no-hinting.
|
|
|
+ --no-desubroutinize [default]
|
|
|
+ Leave CFF subroutinizes as is, only throw away unused subroutinizes.
|
|
|
+
|
|
|
+Font table options:
|
|
|
+ --drop-tables[+|-]=<table>[,<table>...]
|
|
|
+ Specify (=), add to (+=) or exclude from (-=) the comma-separated
|
|
|
+ set of tables that will be be dropped.
|
|
|
+ By default, the following tables are dropped:
|
|
|
+ 'BASE', 'JSTF', 'DSIG', 'EBDT', 'EBLC', 'EBSC', 'SVG ', 'PCLT', 'LTSH'
|
|
|
+ and Graphite tables: 'Feat', 'Glat', 'Gloc', 'Silf', 'Sill'
|
|
|
+ and color tables: 'CBLC', 'CBDT', 'sbix', 'COLR', 'CPAL'.
|
|
|
+ The tool will attempt to subset the remaining tables.
|
|
|
+ Examples:
|
|
|
+ --drop-tables-='SVG '
|
|
|
+ * Drop the default set of tables but keep 'SVG '.
|
|
|
+ --drop-tables+=GSUB
|
|
|
+ * Drop the default set of tables and 'GSUB'.
|
|
|
+ --drop-tables=DSIG
|
|
|
+ * Only drop the 'DSIG' table, keep all others.
|
|
|
+ --drop-tables=
|
|
|
+ * Keep all tables.
|
|
|
+ --no-subset-tables+=<table>[,<table>...]
|
|
|
+ Add to the set of tables that will not be subsetted.
|
|
|
+ By default, the following tables are included in this list, as
|
|
|
+ they do not need subsetting (ignore the fact that 'loca' is listed
|
|
|
+ here): 'gasp', 'head', 'hhea', 'maxp', 'vhea', 'OS/2', 'loca',
|
|
|
+ 'name', 'cvt ', 'fpgm', 'prep', 'VMDX', and 'DSIG'. Tables that the tool
|
|
|
+ does not know how to subset and are not specified here will be dropped
|
|
|
+ from the font.
|
|
|
+ Example:
|
|
|
+ --no-subset-tables+=FFTM
|
|
|
+ * Keep 'FFTM' table in the font by preventing subsetting.
|
|
|
+ --hinting-tables[-]=<table>[,<table>...]
|
|
|
+ Specify (=), add to (+=) or exclude from (-=) the list of font-wide
|
|
|
+ hinting tables that will be dropped if --no-hinting is specified,
|
|
|
+ Examples:
|
|
|
+ --hinting-tables-='VDMX'
|
|
|
+ * Drop font-wide hinting tables except 'VDMX'.
|
|
|
+ --hinting-tables=''
|
|
|
+ * Keep all font-wide hinting tables (but strip hints from glyphs).
|
|
|
+ --legacy-kern
|
|
|
+ Keep TrueType 'kern' table even when OpenType 'GPOS' is available.
|
|
|
+ --no-legacy-kern
|
|
|
+ Drop TrueType 'kern' table if OpenType 'GPOS' is available. [default]
|
|
|
+
|
|
|
+Font naming options:
|
|
|
+ These options control what is retained in the 'name' table. For numerical
|
|
|
+ codes, see: http://www.microsoft.com/typography/otspec/name.htm
|
|
|
+ --name-IDs[+|-]=<nameID>[,<nameID>...]
|
|
|
+ Specify (=), add to (+=) or exclude from (-=) the set of 'name' table
|
|
|
+ entry nameIDs that will be preserved. By default only nameID 1 (Family)
|
|
|
+ and nameID 2 (Style) are preserved. Use '*' to keep all entries.
|
|
|
+ Examples:
|
|
|
+ --name-IDs+=0,4,6
|
|
|
+ * Also keep Copyright, Full name and PostScript name entry.
|
|
|
+ --name-IDs=''
|
|
|
+ * Drop all 'name' table entries.
|
|
|
+ --name-IDs='*'
|
|
|
+ * keep all 'name' table entries
|
|
|
+ --name-legacy
|
|
|
+ Keep legacy (non-Unicode) 'name' table entries (0.x, 1.x etc.).
|
|
|
+ XXX Note: This might be needed for some fonts that have no Unicode name
|
|
|
+ entires for English. See: https://github.com/behdad/fonttools/issues/146
|
|
|
+ --no-name-legacy
|
|
|
+ Drop legacy (non-Unicode) 'name' table entries [default]
|
|
|
+ --name-languages[+|-]=<langID>[,<langID>]
|
|
|
+ Specify (=), add to (+=) or exclude from (-=) the set of 'name' table
|
|
|
+ langIDs that will be preserved. By default only records with langID
|
|
|
+ 0x0409 (English) are preserved. Use '*' to keep all langIDs.
|
|
|
+ --obfuscate-names
|
|
|
+ Make the font unusable as a system font by replacing name IDs 1, 2, 3, 4,
|
|
|
+ and 6 with dummy strings (it is still fully functional as webfont).
|
|
|
+
|
|
|
+Glyph naming and encoding options:
|
|
|
+ --glyph-names
|
|
|
+ Keep PS glyph names in TT-flavored fonts. In general glyph names are
|
|
|
+ not needed for correct use of the font. However, some PDF generators
|
|
|
+ and PDF viewers might rely on glyph names to extract Unicode text
|
|
|
+ from PDF documents.
|
|
|
+ --no-glyph-names
|
|
|
+ Drop PS glyph names in TT-flavored fonts, by using 'post' table
|
|
|
+ version 3.0. [default]
|
|
|
+ --legacy-cmap
|
|
|
+ Keep the legacy 'cmap' subtables (0.x, 1.x, 4.x etc.).
|
|
|
+ --no-legacy-cmap
|
|
|
+ Drop the legacy 'cmap' subtables. [default]
|
|
|
+ --symbol-cmap
|
|
|
+ Keep the 3.0 symbol 'cmap'.
|
|
|
+ --no-symbol-cmap
|
|
|
+ Drop the 3.0 symbol 'cmap'. [default]
|
|
|
+
|
|
|
+Other font-specific options:
|
|
|
+ --recalc-bounds
|
|
|
+ Recalculate font bounding boxes.
|
|
|
+ --no-recalc-bounds
|
|
|
+ Keep original font bounding boxes. This is faster and still safe
|
|
|
+ for all practical purposes. [default]
|
|
|
+ --recalc-timestamp
|
|
|
+ Set font 'modified' timestamp to current time.
|
|
|
+ --no-recalc-timestamp
|
|
|
+ Do not modify font 'modified' timestamp. [default]
|
|
|
+ --canonical-order
|
|
|
+ Order tables as recommended in the OpenType standard. This is not
|
|
|
+ required by the standard, nor by any known implementation.
|
|
|
+ --no-canonical-order
|
|
|
+ Keep original order of font tables. This is faster. [default]
|
|
|
+
|
|
|
+Application options:
|
|
|
+ --verbose
|
|
|
+ Display verbose information of the subsetting process.
|
|
|
+ --timing
|
|
|
+ Display detailed timing information of the subsetting process.
|
|
|
+ --xml
|
|
|
+ Display the TTX XML representation of subsetted font.
|
|
|
+
|
|
|
+Example:
|
|
|
+ Produce a subset containing the characters ' !"#$%' without performing
|
|
|
+ size-reducing optimizations:
|
|
|
+
|
|
|
+ $ pyftsubset font.ttf --unicodes="U+0020-0025" \\
|
|
|
+ --layout-features='*' --glyph-names --symbol-cmap --legacy-cmap \\
|
|
|
+ --notdef-glyph --notdef-outline --recommended-glyphs \\
|
|
|
+ --name-IDs='*' --name-legacy --name-languages='*'
|
|
|
+"""
|
|
|
+
|
|
|
+
|
|
|
+def _add_method(*clazzes):
|
|
|
+ """Returns a decorator function that adds a new method to one or
|
|
|
+ more classes."""
|
|
|
+ def wrapper(method):
|
|
|
+ for clazz in clazzes:
|
|
|
+ assert clazz.__name__ != 'DefaultTable', \
|
|
|
+ 'Oops, table class not found.'
|
|
|
+ assert not hasattr(clazz, method.__name__), \
|
|
|
+ "Oops, class '%s' has method '%s'." % (clazz.__name__,
|
|
|
+ method.__name__)
|
|
|
+ setattr(clazz, method.__name__, method)
|
|
|
+ return None
|
|
|
+ return wrapper
|
|
|
+
|
|
|
+def _uniq_sort(l):
|
|
|
+ return sorted(set(l))
|
|
|
+
|
|
|
+def _set_update(s, *others):
|
|
|
+ # Jython's set.update only takes one other argument.
|
|
|
+ # Emulate real set.update...
|
|
|
+ for other in others:
|
|
|
+ s.update(other)
|
|
|
+
|
|
|
+def _dict_subset(d, glyphs):
|
|
|
+ return {g:d[g] for g in glyphs}
|
|
|
+
|
|
|
+
|
|
|
+@_add_method(otTables.Coverage)
|
|
|
+def intersect(self, glyphs):
|
|
|
+ """Returns ascending list of matching coverage values."""
|
|
|
+ return [i for i,g in enumerate(self.glyphs) if g in glyphs]
|
|
|
+
|
|
|
+@_add_method(otTables.Coverage)
|
|
|
+def intersect_glyphs(self, glyphs):
|
|
|
+ """Returns set of intersecting glyphs."""
|
|
|
+ return set(g for g in self.glyphs if g in glyphs)
|
|
|
+
|
|
|
+@_add_method(otTables.Coverage)
|
|
|
+def subset(self, glyphs):
|
|
|
+ """Returns ascending list of remaining coverage values."""
|
|
|
+ indices = self.intersect(glyphs)
|
|
|
+ self.glyphs = [g for g in self.glyphs if g in glyphs]
|
|
|
+ return indices
|
|
|
+
|
|
|
+@_add_method(otTables.Coverage)
|
|
|
+def remap(self, coverage_map):
|
|
|
+ """Remaps coverage."""
|
|
|
+ self.glyphs = [self.glyphs[i] for i in coverage_map]
|
|
|
+
|
|
|
+@_add_method(otTables.ClassDef)
|
|
|
+def intersect(self, glyphs):
|
|
|
+ """Returns ascending list of matching class values."""
|
|
|
+ return _uniq_sort(
|
|
|
+ ([0] if any(g not in self.classDefs for g in glyphs) else []) +
|
|
|
+ [v for g,v in self.classDefs.items() if g in glyphs])
|
|
|
+
|
|
|
+@_add_method(otTables.ClassDef)
|
|
|
+def intersect_class(self, glyphs, klass):
|
|
|
+ """Returns set of glyphs matching class."""
|
|
|
+ if klass == 0:
|
|
|
+ return set(g for g in glyphs if g not in self.classDefs)
|
|
|
+ return set(g for g,v in self.classDefs.items()
|
|
|
+ if v == klass and g in glyphs)
|
|
|
+
|
|
|
+@_add_method(otTables.ClassDef)
|
|
|
+def subset(self, glyphs, remap=False):
|
|
|
+ """Returns ascending list of remaining classes."""
|
|
|
+ self.classDefs = {g:v for g,v in self.classDefs.items() if g in glyphs}
|
|
|
+ # Note: while class 0 has the special meaning of "not matched",
|
|
|
+ # if no glyph will ever /not match/, we can optimize class 0 out too.
|
|
|
+ indices = _uniq_sort(
|
|
|
+ ([0] if any(g not in self.classDefs for g in glyphs) else []) +
|
|
|
+ list(self.classDefs.values()))
|
|
|
+ if remap:
|
|
|
+ self.remap(indices)
|
|
|
+ return indices
|
|
|
+
|
|
|
+@_add_method(otTables.ClassDef)
|
|
|
+def remap(self, class_map):
|
|
|
+ """Remaps classes."""
|
|
|
+ self.classDefs = {g:class_map.index(v) for g,v in self.classDefs.items()}
|
|
|
+
|
|
|
+@_add_method(otTables.SingleSubst)
|
|
|
+def closure_glyphs(self, s, cur_glyphs):
|
|
|
+ s.glyphs.update(v for g,v in self.mapping.items() if g in cur_glyphs)
|
|
|
+
|
|
|
+@_add_method(otTables.SingleSubst)
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ self.mapping = {g:v for g,v in self.mapping.items()
|
|
|
+ if g in s.glyphs and v in s.glyphs}
|
|
|
+ return bool(self.mapping)
|
|
|
+
|
|
|
+@_add_method(otTables.MultipleSubst)
|
|
|
+def closure_glyphs(self, s, cur_glyphs):
|
|
|
+ indices = self.Coverage.intersect(cur_glyphs)
|
|
|
+ _set_update(s.glyphs, *(self.Sequence[i].Substitute for i in indices))
|
|
|
+
|
|
|
+@_add_method(otTables.MultipleSubst)
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ indices = self.Coverage.subset(s.glyphs)
|
|
|
+ self.Sequence = [self.Sequence[i] for i in indices]
|
|
|
+ # Now drop rules generating glyphs we don't want
|
|
|
+ indices = [i for i,seq in enumerate(self.Sequence)
|
|
|
+ if all(sub in s.glyphs for sub in seq.Substitute)]
|
|
|
+ self.Sequence = [self.Sequence[i] for i in indices]
|
|
|
+ self.Coverage.remap(indices)
|
|
|
+ self.SequenceCount = len(self.Sequence)
|
|
|
+ return bool(self.SequenceCount)
|
|
|
+
|
|
|
+@_add_method(otTables.AlternateSubst)
|
|
|
+def closure_glyphs(self, s, cur_glyphs):
|
|
|
+ _set_update(s.glyphs, *(vlist for g,vlist in self.alternates.items()
|
|
|
+ if g in cur_glyphs))
|
|
|
+
|
|
|
+@_add_method(otTables.AlternateSubst)
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ self.alternates = {g:vlist
|
|
|
+ for g,vlist in self.alternates.items()
|
|
|
+ if g in s.glyphs and
|
|
|
+ all(v in s.glyphs for v in vlist)}
|
|
|
+ return bool(self.alternates)
|
|
|
+
|
|
|
+@_add_method(otTables.LigatureSubst)
|
|
|
+def closure_glyphs(self, s, cur_glyphs):
|
|
|
+ _set_update(s.glyphs, *([seq.LigGlyph for seq in seqs
|
|
|
+ if all(c in s.glyphs for c in seq.Component)]
|
|
|
+ for g,seqs in self.ligatures.items()
|
|
|
+ if g in cur_glyphs))
|
|
|
+
|
|
|
+@_add_method(otTables.LigatureSubst)
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ self.ligatures = {g:v for g,v in self.ligatures.items()
|
|
|
+ if g in s.glyphs}
|
|
|
+ self.ligatures = {g:[seq for seq in seqs
|
|
|
+ if seq.LigGlyph in s.glyphs and
|
|
|
+ all(c in s.glyphs for c in seq.Component)]
|
|
|
+ for g,seqs in self.ligatures.items()}
|
|
|
+ self.ligatures = {g:v for g,v in self.ligatures.items() if v}
|
|
|
+ return bool(self.ligatures)
|
|
|
+
|
|
|
+@_add_method(otTables.ReverseChainSingleSubst)
|
|
|
+def closure_glyphs(self, s, cur_glyphs):
|
|
|
+ if self.Format == 1:
|
|
|
+ indices = self.Coverage.intersect(cur_glyphs)
|
|
|
+ if(not indices or
|
|
|
+ not all(c.intersect(s.glyphs)
|
|
|
+ for c in self.LookAheadCoverage + self.BacktrackCoverage)):
|
|
|
+ return
|
|
|
+ s.glyphs.update(self.Substitute[i] for i in indices)
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.ReverseChainSingleSubst)
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ if self.Format == 1:
|
|
|
+ indices = self.Coverage.subset(s.glyphs)
|
|
|
+ self.Substitute = [self.Substitute[i] for i in indices]
|
|
|
+ # Now drop rules generating glyphs we don't want
|
|
|
+ indices = [i for i,sub in enumerate(self.Substitute)
|
|
|
+ if sub in s.glyphs]
|
|
|
+ self.Substitute = [self.Substitute[i] for i in indices]
|
|
|
+ self.Coverage.remap(indices)
|
|
|
+ self.GlyphCount = len(self.Substitute)
|
|
|
+ return bool(self.GlyphCount and
|
|
|
+ all(c.subset(s.glyphs)
|
|
|
+ for c in self.LookAheadCoverage+self.BacktrackCoverage))
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.SinglePos)
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ if self.Format == 1:
|
|
|
+ return len(self.Coverage.subset(s.glyphs))
|
|
|
+ elif self.Format == 2:
|
|
|
+ indices = self.Coverage.subset(s.glyphs)
|
|
|
+ self.Value = [self.Value[i] for i in indices]
|
|
|
+ self.ValueCount = len(self.Value)
|
|
|
+ return bool(self.ValueCount)
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.SinglePos)
|
|
|
+def prune_post_subset(self, options):
|
|
|
+ if not options.hinting:
|
|
|
+ # Drop device tables
|
|
|
+ self.ValueFormat &= ~0x00F0
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(otTables.PairPos)
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ if self.Format == 1:
|
|
|
+ indices = self.Coverage.subset(s.glyphs)
|
|
|
+ self.PairSet = [self.PairSet[i] for i in indices]
|
|
|
+ for p in self.PairSet:
|
|
|
+ p.PairValueRecord = [r for r in p.PairValueRecord
|
|
|
+ if r.SecondGlyph in s.glyphs]
|
|
|
+ p.PairValueCount = len(p.PairValueRecord)
|
|
|
+ # Remove empty pairsets
|
|
|
+ indices = [i for i,p in enumerate(self.PairSet) if p.PairValueCount]
|
|
|
+ self.Coverage.remap(indices)
|
|
|
+ self.PairSet = [self.PairSet[i] for i in indices]
|
|
|
+ self.PairSetCount = len(self.PairSet)
|
|
|
+ return bool(self.PairSetCount)
|
|
|
+ elif self.Format == 2:
|
|
|
+ class1_map = self.ClassDef1.subset(s.glyphs, remap=True)
|
|
|
+ class2_map = self.ClassDef2.subset(s.glyphs, remap=True)
|
|
|
+ self.Class1Record = [self.Class1Record[i] for i in class1_map]
|
|
|
+ for c in self.Class1Record:
|
|
|
+ c.Class2Record = [c.Class2Record[i] for i in class2_map]
|
|
|
+ self.Class1Count = len(class1_map)
|
|
|
+ self.Class2Count = len(class2_map)
|
|
|
+ return bool(self.Class1Count and
|
|
|
+ self.Class2Count and
|
|
|
+ self.Coverage.subset(s.glyphs))
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.PairPos)
|
|
|
+def prune_post_subset(self, options):
|
|
|
+ if not options.hinting:
|
|
|
+ # Drop device tables
|
|
|
+ self.ValueFormat1 &= ~0x00F0
|
|
|
+ self.ValueFormat2 &= ~0x00F0
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(otTables.CursivePos)
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ if self.Format == 1:
|
|
|
+ indices = self.Coverage.subset(s.glyphs)
|
|
|
+ self.EntryExitRecord = [self.EntryExitRecord[i] for i in indices]
|
|
|
+ self.EntryExitCount = len(self.EntryExitRecord)
|
|
|
+ return bool(self.EntryExitCount)
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.Anchor)
|
|
|
+def prune_hints(self):
|
|
|
+ # Drop device tables / contour anchor point
|
|
|
+ self.ensureDecompiled()
|
|
|
+ self.Format = 1
|
|
|
+
|
|
|
+@_add_method(otTables.CursivePos)
|
|
|
+def prune_post_subset(self, options):
|
|
|
+ if not options.hinting:
|
|
|
+ for rec in self.EntryExitRecord:
|
|
|
+ if rec.EntryAnchor: rec.EntryAnchor.prune_hints()
|
|
|
+ if rec.ExitAnchor: rec.ExitAnchor.prune_hints()
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(otTables.MarkBasePos)
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ if self.Format == 1:
|
|
|
+ mark_indices = self.MarkCoverage.subset(s.glyphs)
|
|
|
+ self.MarkArray.MarkRecord = [self.MarkArray.MarkRecord[i]
|
|
|
+ for i in mark_indices]
|
|
|
+ self.MarkArray.MarkCount = len(self.MarkArray.MarkRecord)
|
|
|
+ base_indices = self.BaseCoverage.subset(s.glyphs)
|
|
|
+ self.BaseArray.BaseRecord = [self.BaseArray.BaseRecord[i]
|
|
|
+ for i in base_indices]
|
|
|
+ self.BaseArray.BaseCount = len(self.BaseArray.BaseRecord)
|
|
|
+ # Prune empty classes
|
|
|
+ class_indices = _uniq_sort(v.Class for v in self.MarkArray.MarkRecord)
|
|
|
+ self.ClassCount = len(class_indices)
|
|
|
+ for m in self.MarkArray.MarkRecord:
|
|
|
+ m.Class = class_indices.index(m.Class)
|
|
|
+ for b in self.BaseArray.BaseRecord:
|
|
|
+ b.BaseAnchor = [b.BaseAnchor[i] for i in class_indices]
|
|
|
+ return bool(self.ClassCount and
|
|
|
+ self.MarkArray.MarkCount and
|
|
|
+ self.BaseArray.BaseCount)
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.MarkBasePos)
|
|
|
+def prune_post_subset(self, options):
|
|
|
+ if not options.hinting:
|
|
|
+ for m in self.MarkArray.MarkRecord:
|
|
|
+ if m.MarkAnchor:
|
|
|
+ m.MarkAnchor.prune_hints()
|
|
|
+ for b in self.BaseArray.BaseRecord:
|
|
|
+ for a in b.BaseAnchor:
|
|
|
+ if a:
|
|
|
+ a.prune_hints()
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(otTables.MarkLigPos)
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ if self.Format == 1:
|
|
|
+ mark_indices = self.MarkCoverage.subset(s.glyphs)
|
|
|
+ self.MarkArray.MarkRecord = [self.MarkArray.MarkRecord[i]
|
|
|
+ for i in mark_indices]
|
|
|
+ self.MarkArray.MarkCount = len(self.MarkArray.MarkRecord)
|
|
|
+ ligature_indices = self.LigatureCoverage.subset(s.glyphs)
|
|
|
+ self.LigatureArray.LigatureAttach = [self.LigatureArray.LigatureAttach[i]
|
|
|
+ for i in ligature_indices]
|
|
|
+ self.LigatureArray.LigatureCount = len(self.LigatureArray.LigatureAttach)
|
|
|
+ # Prune empty classes
|
|
|
+ class_indices = _uniq_sort(v.Class for v in self.MarkArray.MarkRecord)
|
|
|
+ self.ClassCount = len(class_indices)
|
|
|
+ for m in self.MarkArray.MarkRecord:
|
|
|
+ m.Class = class_indices.index(m.Class)
|
|
|
+ for l in self.LigatureArray.LigatureAttach:
|
|
|
+ for c in l.ComponentRecord:
|
|
|
+ c.LigatureAnchor = [c.LigatureAnchor[i] for i in class_indices]
|
|
|
+ return bool(self.ClassCount and
|
|
|
+ self.MarkArray.MarkCount and
|
|
|
+ self.LigatureArray.LigatureCount)
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.MarkLigPos)
|
|
|
+def prune_post_subset(self, options):
|
|
|
+ if not options.hinting:
|
|
|
+ for m in self.MarkArray.MarkRecord:
|
|
|
+ if m.MarkAnchor:
|
|
|
+ m.MarkAnchor.prune_hints()
|
|
|
+ for l in self.LigatureArray.LigatureAttach:
|
|
|
+ for c in l.ComponentRecord:
|
|
|
+ for a in c.LigatureAnchor:
|
|
|
+ if a:
|
|
|
+ a.prune_hints()
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(otTables.MarkMarkPos)
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ if self.Format == 1:
|
|
|
+ mark1_indices = self.Mark1Coverage.subset(s.glyphs)
|
|
|
+ self.Mark1Array.MarkRecord = [self.Mark1Array.MarkRecord[i]
|
|
|
+ for i in mark1_indices]
|
|
|
+ self.Mark1Array.MarkCount = len(self.Mark1Array.MarkRecord)
|
|
|
+ mark2_indices = self.Mark2Coverage.subset(s.glyphs)
|
|
|
+ self.Mark2Array.Mark2Record = [self.Mark2Array.Mark2Record[i]
|
|
|
+ for i in mark2_indices]
|
|
|
+ self.Mark2Array.MarkCount = len(self.Mark2Array.Mark2Record)
|
|
|
+ # Prune empty classes
|
|
|
+ class_indices = _uniq_sort(v.Class for v in self.Mark1Array.MarkRecord)
|
|
|
+ self.ClassCount = len(class_indices)
|
|
|
+ for m in self.Mark1Array.MarkRecord:
|
|
|
+ m.Class = class_indices.index(m.Class)
|
|
|
+ for b in self.Mark2Array.Mark2Record:
|
|
|
+ b.Mark2Anchor = [b.Mark2Anchor[i] for i in class_indices]
|
|
|
+ return bool(self.ClassCount and
|
|
|
+ self.Mark1Array.MarkCount and
|
|
|
+ self.Mark2Array.MarkCount)
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.MarkMarkPos)
|
|
|
+def prune_post_subset(self, options):
|
|
|
+ if not options.hinting:
|
|
|
+ # Drop device tables or contour anchor point
|
|
|
+ for m in self.Mark1Array.MarkRecord:
|
|
|
+ if m.MarkAnchor:
|
|
|
+ m.MarkAnchor.prune_hints()
|
|
|
+ for b in self.Mark2Array.Mark2Record:
|
|
|
+ for m in b.Mark2Anchor:
|
|
|
+ if m:
|
|
|
+ m.prune_hints()
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(otTables.SingleSubst,
|
|
|
+ otTables.MultipleSubst,
|
|
|
+ otTables.AlternateSubst,
|
|
|
+ otTables.LigatureSubst,
|
|
|
+ otTables.ReverseChainSingleSubst,
|
|
|
+ otTables.SinglePos,
|
|
|
+ otTables.PairPos,
|
|
|
+ otTables.CursivePos,
|
|
|
+ otTables.MarkBasePos,
|
|
|
+ otTables.MarkLigPos,
|
|
|
+ otTables.MarkMarkPos)
|
|
|
+def subset_lookups(self, lookup_indices):
|
|
|
+ pass
|
|
|
+
|
|
|
+@_add_method(otTables.SingleSubst,
|
|
|
+ otTables.MultipleSubst,
|
|
|
+ otTables.AlternateSubst,
|
|
|
+ otTables.LigatureSubst,
|
|
|
+ otTables.ReverseChainSingleSubst,
|
|
|
+ otTables.SinglePos,
|
|
|
+ otTables.PairPos,
|
|
|
+ otTables.CursivePos,
|
|
|
+ otTables.MarkBasePos,
|
|
|
+ otTables.MarkLigPos,
|
|
|
+ otTables.MarkMarkPos)
|
|
|
+def collect_lookups(self):
|
|
|
+ return []
|
|
|
+
|
|
|
+@_add_method(otTables.SingleSubst,
|
|
|
+ otTables.MultipleSubst,
|
|
|
+ otTables.AlternateSubst,
|
|
|
+ otTables.LigatureSubst,
|
|
|
+ otTables.ReverseChainSingleSubst,
|
|
|
+ otTables.ContextSubst,
|
|
|
+ otTables.ChainContextSubst,
|
|
|
+ otTables.ContextPos,
|
|
|
+ otTables.ChainContextPos)
|
|
|
+def prune_post_subset(self, options):
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(otTables.SingleSubst,
|
|
|
+ otTables.AlternateSubst,
|
|
|
+ otTables.ReverseChainSingleSubst)
|
|
|
+def may_have_non_1to1(self):
|
|
|
+ return False
|
|
|
+
|
|
|
+@_add_method(otTables.MultipleSubst,
|
|
|
+ otTables.LigatureSubst,
|
|
|
+ otTables.ContextSubst,
|
|
|
+ otTables.ChainContextSubst)
|
|
|
+def may_have_non_1to1(self):
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(otTables.ContextSubst,
|
|
|
+ otTables.ChainContextSubst,
|
|
|
+ otTables.ContextPos,
|
|
|
+ otTables.ChainContextPos)
|
|
|
+def __subset_classify_context(self):
|
|
|
+
|
|
|
+ class ContextHelper(object):
|
|
|
+ def __init__(self, klass, Format):
|
|
|
+ if klass.__name__.endswith('Subst'):
|
|
|
+ Typ = 'Sub'
|
|
|
+ Type = 'Subst'
|
|
|
+ else:
|
|
|
+ Typ = 'Pos'
|
|
|
+ Type = 'Pos'
|
|
|
+ if klass.__name__.startswith('Chain'):
|
|
|
+ Chain = 'Chain'
|
|
|
+ else:
|
|
|
+ Chain = ''
|
|
|
+ ChainTyp = Chain+Typ
|
|
|
+
|
|
|
+ self.Typ = Typ
|
|
|
+ self.Type = Type
|
|
|
+ self.Chain = Chain
|
|
|
+ self.ChainTyp = ChainTyp
|
|
|
+
|
|
|
+ self.LookupRecord = Type+'LookupRecord'
|
|
|
+
|
|
|
+ if Format == 1:
|
|
|
+ Coverage = lambda r: r.Coverage
|
|
|
+ ChainCoverage = lambda r: r.Coverage
|
|
|
+ ContextData = lambda r:(None,)
|
|
|
+ ChainContextData = lambda r:(None, None, None)
|
|
|
+ RuleData = lambda r:(r.Input,)
|
|
|
+ ChainRuleData = lambda r:(r.Backtrack, r.Input, r.LookAhead)
|
|
|
+ SetRuleData = None
|
|
|
+ ChainSetRuleData = None
|
|
|
+ elif Format == 2:
|
|
|
+ Coverage = lambda r: r.Coverage
|
|
|
+ ChainCoverage = lambda r: r.Coverage
|
|
|
+ ContextData = lambda r:(r.ClassDef,)
|
|
|
+ ChainContextData = lambda r:(r.BacktrackClassDef,
|
|
|
+ r.InputClassDef,
|
|
|
+ r.LookAheadClassDef)
|
|
|
+ RuleData = lambda r:(r.Class,)
|
|
|
+ ChainRuleData = lambda r:(r.Backtrack, r.Input, r.LookAhead)
|
|
|
+ def SetRuleData(r, d):(r.Class,) = d
|
|
|
+ def ChainSetRuleData(r, d):(r.Backtrack, r.Input, r.LookAhead) = d
|
|
|
+ elif Format == 3:
|
|
|
+ Coverage = lambda r: r.Coverage[0]
|
|
|
+ ChainCoverage = lambda r: r.InputCoverage[0]
|
|
|
+ ContextData = None
|
|
|
+ ChainContextData = None
|
|
|
+ RuleData = lambda r: r.Coverage
|
|
|
+ ChainRuleData = lambda r:(r.BacktrackCoverage +
|
|
|
+ r.InputCoverage +
|
|
|
+ r.LookAheadCoverage)
|
|
|
+ SetRuleData = None
|
|
|
+ ChainSetRuleData = None
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % Format
|
|
|
+
|
|
|
+ if Chain:
|
|
|
+ self.Coverage = ChainCoverage
|
|
|
+ self.ContextData = ChainContextData
|
|
|
+ self.RuleData = ChainRuleData
|
|
|
+ self.SetRuleData = ChainSetRuleData
|
|
|
+ else:
|
|
|
+ self.Coverage = Coverage
|
|
|
+ self.ContextData = ContextData
|
|
|
+ self.RuleData = RuleData
|
|
|
+ self.SetRuleData = SetRuleData
|
|
|
+
|
|
|
+ if Format == 1:
|
|
|
+ self.Rule = ChainTyp+'Rule'
|
|
|
+ self.RuleCount = ChainTyp+'RuleCount'
|
|
|
+ self.RuleSet = ChainTyp+'RuleSet'
|
|
|
+ self.RuleSetCount = ChainTyp+'RuleSetCount'
|
|
|
+ self.Intersect = lambda glyphs, c, r: [r] if r in glyphs else []
|
|
|
+ elif Format == 2:
|
|
|
+ self.Rule = ChainTyp+'ClassRule'
|
|
|
+ self.RuleCount = ChainTyp+'ClassRuleCount'
|
|
|
+ self.RuleSet = ChainTyp+'ClassSet'
|
|
|
+ self.RuleSetCount = ChainTyp+'ClassSetCount'
|
|
|
+ self.Intersect = lambda glyphs, c, r: (c.intersect_class(glyphs, r) if c
|
|
|
+ else (set(glyphs) if r == 0 else set()))
|
|
|
+
|
|
|
+ self.ClassDef = 'InputClassDef' if Chain else 'ClassDef'
|
|
|
+ self.ClassDefIndex = 1 if Chain else 0
|
|
|
+ self.Input = 'Input' if Chain else 'Class'
|
|
|
+
|
|
|
+ if self.Format not in [1, 2, 3]:
|
|
|
+ return None # Don't shoot the messenger; let it go
|
|
|
+ if not hasattr(self.__class__, "__ContextHelpers"):
|
|
|
+ self.__class__.__ContextHelpers = {}
|
|
|
+ if self.Format not in self.__class__.__ContextHelpers:
|
|
|
+ helper = ContextHelper(self.__class__, self.Format)
|
|
|
+ self.__class__.__ContextHelpers[self.Format] = helper
|
|
|
+ return self.__class__.__ContextHelpers[self.Format]
|
|
|
+
|
|
|
+@_add_method(otTables.ContextSubst,
|
|
|
+ otTables.ChainContextSubst)
|
|
|
+def closure_glyphs(self, s, cur_glyphs):
|
|
|
+ c = self.__subset_classify_context()
|
|
|
+
|
|
|
+ indices = c.Coverage(self).intersect(cur_glyphs)
|
|
|
+ if not indices:
|
|
|
+ return []
|
|
|
+ cur_glyphs = c.Coverage(self).intersect_glyphs(cur_glyphs)
|
|
|
+
|
|
|
+ if self.Format == 1:
|
|
|
+ ContextData = c.ContextData(self)
|
|
|
+ rss = getattr(self, c.RuleSet)
|
|
|
+ rssCount = getattr(self, c.RuleSetCount)
|
|
|
+ for i in indices:
|
|
|
+ if i >= rssCount or not rss[i]: continue
|
|
|
+ for r in getattr(rss[i], c.Rule):
|
|
|
+ if not r: continue
|
|
|
+ if not all(all(c.Intersect(s.glyphs, cd, k) for k in klist)
|
|
|
+ for cd,klist in zip(ContextData, c.RuleData(r))):
|
|
|
+ continue
|
|
|
+ chaos = set()
|
|
|
+ for ll in getattr(r, c.LookupRecord):
|
|
|
+ if not ll: continue
|
|
|
+ seqi = ll.SequenceIndex
|
|
|
+ if seqi in chaos:
|
|
|
+ # TODO Can we improve this?
|
|
|
+ pos_glyphs = None
|
|
|
+ else:
|
|
|
+ if seqi == 0:
|
|
|
+ pos_glyphs = frozenset([c.Coverage(self).glyphs[i]])
|
|
|
+ else:
|
|
|
+ pos_glyphs = frozenset([r.Input[seqi - 1]])
|
|
|
+ lookup = s.table.LookupList.Lookup[ll.LookupListIndex]
|
|
|
+ chaos.add(seqi)
|
|
|
+ if lookup.may_have_non_1to1():
|
|
|
+ chaos.update(range(seqi, len(r.Input)+2))
|
|
|
+ lookup.closure_glyphs(s, cur_glyphs=pos_glyphs)
|
|
|
+ elif self.Format == 2:
|
|
|
+ ClassDef = getattr(self, c.ClassDef)
|
|
|
+ indices = ClassDef.intersect(cur_glyphs)
|
|
|
+ ContextData = c.ContextData(self)
|
|
|
+ rss = getattr(self, c.RuleSet)
|
|
|
+ rssCount = getattr(self, c.RuleSetCount)
|
|
|
+ for i in indices:
|
|
|
+ if i >= rssCount or not rss[i]: continue
|
|
|
+ for r in getattr(rss[i], c.Rule):
|
|
|
+ if not r: continue
|
|
|
+ if not all(all(c.Intersect(s.glyphs, cd, k) for k in klist)
|
|
|
+ for cd,klist in zip(ContextData, c.RuleData(r))):
|
|
|
+ continue
|
|
|
+ chaos = set()
|
|
|
+ for ll in getattr(r, c.LookupRecord):
|
|
|
+ if not ll: continue
|
|
|
+ seqi = ll.SequenceIndex
|
|
|
+ if seqi in chaos:
|
|
|
+ # TODO Can we improve this?
|
|
|
+ pos_glyphs = None
|
|
|
+ else:
|
|
|
+ if seqi == 0:
|
|
|
+ pos_glyphs = frozenset(ClassDef.intersect_class(cur_glyphs, i))
|
|
|
+ else:
|
|
|
+ pos_glyphs = frozenset(ClassDef.intersect_class(s.glyphs, getattr(r, c.Input)[seqi - 1]))
|
|
|
+ lookup = s.table.LookupList.Lookup[ll.LookupListIndex]
|
|
|
+ chaos.add(seqi)
|
|
|
+ if lookup.may_have_non_1to1():
|
|
|
+ chaos.update(range(seqi, len(getattr(r, c.Input))+2))
|
|
|
+ lookup.closure_glyphs(s, cur_glyphs=pos_glyphs)
|
|
|
+ elif self.Format == 3:
|
|
|
+ if not all(x.intersect(s.glyphs) for x in c.RuleData(self)):
|
|
|
+ return []
|
|
|
+ r = self
|
|
|
+ chaos = set()
|
|
|
+ for ll in getattr(r, c.LookupRecord):
|
|
|
+ if not ll: continue
|
|
|
+ seqi = ll.SequenceIndex
|
|
|
+ if seqi in chaos:
|
|
|
+ # TODO Can we improve this?
|
|
|
+ pos_glyphs = None
|
|
|
+ else:
|
|
|
+ if seqi == 0:
|
|
|
+ pos_glyphs = frozenset(cur_glyphs)
|
|
|
+ else:
|
|
|
+ pos_glyphs = frozenset(r.InputCoverage[seqi].intersect_glyphs(s.glyphs))
|
|
|
+ lookup = s.table.LookupList.Lookup[ll.LookupListIndex]
|
|
|
+ chaos.add(seqi)
|
|
|
+ if lookup.may_have_non_1to1():
|
|
|
+ chaos.update(range(seqi, len(r.InputCoverage)+1))
|
|
|
+ lookup.closure_glyphs(s, cur_glyphs=pos_glyphs)
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.ContextSubst,
|
|
|
+ otTables.ContextPos,
|
|
|
+ otTables.ChainContextSubst,
|
|
|
+ otTables.ChainContextPos)
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ c = self.__subset_classify_context()
|
|
|
+
|
|
|
+ if self.Format == 1:
|
|
|
+ indices = self.Coverage.subset(s.glyphs)
|
|
|
+ rss = getattr(self, c.RuleSet)
|
|
|
+ rssCount = getattr(self, c.RuleSetCount)
|
|
|
+ rss = [rss[i] for i in indices if i < rssCount]
|
|
|
+ for rs in rss:
|
|
|
+ if not rs: continue
|
|
|
+ ss = getattr(rs, c.Rule)
|
|
|
+ ss = [r for r in ss
|
|
|
+ if r and all(all(g in s.glyphs for g in glist)
|
|
|
+ for glist in c.RuleData(r))]
|
|
|
+ setattr(rs, c.Rule, ss)
|
|
|
+ setattr(rs, c.RuleCount, len(ss))
|
|
|
+ # Prune empty rulesets
|
|
|
+ indices = [i for i,rs in enumerate(rss) if rs and getattr(rs, c.Rule)]
|
|
|
+ self.Coverage.remap(indices)
|
|
|
+ rss = [rss[i] for i in indices]
|
|
|
+ setattr(self, c.RuleSet, rss)
|
|
|
+ setattr(self, c.RuleSetCount, len(rss))
|
|
|
+ return bool(rss)
|
|
|
+ elif self.Format == 2:
|
|
|
+ if not self.Coverage.subset(s.glyphs):
|
|
|
+ return False
|
|
|
+ ContextData = c.ContextData(self)
|
|
|
+ klass_maps = [x.subset(s.glyphs, remap=True) if x else None for x in ContextData]
|
|
|
+
|
|
|
+ # Keep rulesets for class numbers that survived.
|
|
|
+ indices = klass_maps[c.ClassDefIndex]
|
|
|
+ rss = getattr(self, c.RuleSet)
|
|
|
+ rssCount = getattr(self, c.RuleSetCount)
|
|
|
+ rss = [rss[i] for i in indices if i < rssCount]
|
|
|
+ del rssCount
|
|
|
+ # Delete, but not renumber, unreachable rulesets.
|
|
|
+ indices = getattr(self, c.ClassDef).intersect(self.Coverage.glyphs)
|
|
|
+ rss = [rss if i in indices else None for i,rss in enumerate(rss)]
|
|
|
+
|
|
|
+ for rs in rss:
|
|
|
+ if not rs: continue
|
|
|
+ ss = getattr(rs, c.Rule)
|
|
|
+ ss = [r for r in ss
|
|
|
+ if r and all(all(k in klass_map for k in klist)
|
|
|
+ for klass_map,klist in zip(klass_maps, c.RuleData(r)))]
|
|
|
+ setattr(rs, c.Rule, ss)
|
|
|
+ setattr(rs, c.RuleCount, len(ss))
|
|
|
+
|
|
|
+ # Remap rule classes
|
|
|
+ for r in ss:
|
|
|
+ c.SetRuleData(r, [[klass_map.index(k) for k in klist]
|
|
|
+ for klass_map,klist in zip(klass_maps, c.RuleData(r))])
|
|
|
+
|
|
|
+ # Prune empty rulesets
|
|
|
+ rss = [rs if rs and getattr(rs, c.Rule) else None for rs in rss]
|
|
|
+ while rss and rss[-1] is None:
|
|
|
+ del rss[-1]
|
|
|
+ setattr(self, c.RuleSet, rss)
|
|
|
+ setattr(self, c.RuleSetCount, len(rss))
|
|
|
+
|
|
|
+ # TODO: We can do a second round of remapping class values based
|
|
|
+ # on classes that are actually used in at least one rule. Right
|
|
|
+ # now we subset classes to c.glyphs only. Or better, rewrite
|
|
|
+ # the above to do that.
|
|
|
+
|
|
|
+ return bool(rss)
|
|
|
+ elif self.Format == 3:
|
|
|
+ return all(x.subset(s.glyphs) for x in c.RuleData(self))
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.ContextSubst,
|
|
|
+ otTables.ChainContextSubst,
|
|
|
+ otTables.ContextPos,
|
|
|
+ otTables.ChainContextPos)
|
|
|
+def subset_lookups(self, lookup_indices):
|
|
|
+ c = self.__subset_classify_context()
|
|
|
+
|
|
|
+ if self.Format in [1, 2]:
|
|
|
+ for rs in getattr(self, c.RuleSet):
|
|
|
+ if not rs: continue
|
|
|
+ for r in getattr(rs, c.Rule):
|
|
|
+ if not r: continue
|
|
|
+ setattr(r, c.LookupRecord,
|
|
|
+ [ll for ll in getattr(r, c.LookupRecord)
|
|
|
+ if ll and ll.LookupListIndex in lookup_indices])
|
|
|
+ for ll in getattr(r, c.LookupRecord):
|
|
|
+ if not ll: continue
|
|
|
+ ll.LookupListIndex = lookup_indices.index(ll.LookupListIndex)
|
|
|
+ elif self.Format == 3:
|
|
|
+ setattr(self, c.LookupRecord,
|
|
|
+ [ll for ll in getattr(self, c.LookupRecord)
|
|
|
+ if ll and ll.LookupListIndex in lookup_indices])
|
|
|
+ for ll in getattr(self, c.LookupRecord):
|
|
|
+ if not ll: continue
|
|
|
+ ll.LookupListIndex = lookup_indices.index(ll.LookupListIndex)
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.ContextSubst,
|
|
|
+ otTables.ChainContextSubst,
|
|
|
+ otTables.ContextPos,
|
|
|
+ otTables.ChainContextPos)
|
|
|
+def collect_lookups(self):
|
|
|
+ c = self.__subset_classify_context()
|
|
|
+
|
|
|
+ if self.Format in [1, 2]:
|
|
|
+ return [ll.LookupListIndex
|
|
|
+ for rs in getattr(self, c.RuleSet) if rs
|
|
|
+ for r in getattr(rs, c.Rule) if r
|
|
|
+ for ll in getattr(r, c.LookupRecord) if ll]
|
|
|
+ elif self.Format == 3:
|
|
|
+ return [ll.LookupListIndex
|
|
|
+ for ll in getattr(self, c.LookupRecord) if ll]
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.ExtensionSubst)
|
|
|
+def closure_glyphs(self, s, cur_glyphs):
|
|
|
+ if self.Format == 1:
|
|
|
+ self.ExtSubTable.closure_glyphs(s, cur_glyphs)
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.ExtensionSubst)
|
|
|
+def may_have_non_1to1(self):
|
|
|
+ if self.Format == 1:
|
|
|
+ return self.ExtSubTable.may_have_non_1to1()
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.ExtensionSubst,
|
|
|
+ otTables.ExtensionPos)
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ if self.Format == 1:
|
|
|
+ return self.ExtSubTable.subset_glyphs(s)
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.ExtensionSubst,
|
|
|
+ otTables.ExtensionPos)
|
|
|
+def prune_post_subset(self, options):
|
|
|
+ if self.Format == 1:
|
|
|
+ return self.ExtSubTable.prune_post_subset(options)
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.ExtensionSubst,
|
|
|
+ otTables.ExtensionPos)
|
|
|
+def subset_lookups(self, lookup_indices):
|
|
|
+ if self.Format == 1:
|
|
|
+ return self.ExtSubTable.subset_lookups(lookup_indices)
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.ExtensionSubst,
|
|
|
+ otTables.ExtensionPos)
|
|
|
+def collect_lookups(self):
|
|
|
+ if self.Format == 1:
|
|
|
+ return self.ExtSubTable.collect_lookups()
|
|
|
+ else:
|
|
|
+ assert 0, "unknown format: %s" % self.Format
|
|
|
+
|
|
|
+@_add_method(otTables.Lookup)
|
|
|
+def closure_glyphs(self, s, cur_glyphs=None):
|
|
|
+ if cur_glyphs is None:
|
|
|
+ cur_glyphs = frozenset(s.glyphs)
|
|
|
+
|
|
|
+ # Memoize
|
|
|
+ if (id(self), cur_glyphs) in s._doneLookups:
|
|
|
+ return
|
|
|
+ s._doneLookups.add((id(self), cur_glyphs))
|
|
|
+
|
|
|
+ if self in s._activeLookups:
|
|
|
+ raise Exception("Circular loop in lookup recursion")
|
|
|
+ s._activeLookups.append(self)
|
|
|
+ for st in self.SubTable:
|
|
|
+ if not st: continue
|
|
|
+ st.closure_glyphs(s, cur_glyphs)
|
|
|
+ assert(s._activeLookups[-1] == self)
|
|
|
+ del s._activeLookups[-1]
|
|
|
+
|
|
|
+@_add_method(otTables.Lookup)
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ self.SubTable = [st for st in self.SubTable if st and st.subset_glyphs(s)]
|
|
|
+ self.SubTableCount = len(self.SubTable)
|
|
|
+ return bool(self.SubTableCount)
|
|
|
+
|
|
|
+@_add_method(otTables.Lookup)
|
|
|
+def prune_post_subset(self, options):
|
|
|
+ ret = False
|
|
|
+ for st in self.SubTable:
|
|
|
+ if not st: continue
|
|
|
+ if st.prune_post_subset(options): ret = True
|
|
|
+ return ret
|
|
|
+
|
|
|
+@_add_method(otTables.Lookup)
|
|
|
+def subset_lookups(self, lookup_indices):
|
|
|
+ for s in self.SubTable:
|
|
|
+ s.subset_lookups(lookup_indices)
|
|
|
+
|
|
|
+@_add_method(otTables.Lookup)
|
|
|
+def collect_lookups(self):
|
|
|
+ return _uniq_sort(sum((st.collect_lookups() for st in self.SubTable
|
|
|
+ if st), []))
|
|
|
+
|
|
|
+@_add_method(otTables.Lookup)
|
|
|
+def may_have_non_1to1(self):
|
|
|
+ return any(st.may_have_non_1to1() for st in self.SubTable if st)
|
|
|
+
|
|
|
+@_add_method(otTables.LookupList)
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ """Returns the indices of nonempty lookups."""
|
|
|
+ return [i for i,l in enumerate(self.Lookup) if l and l.subset_glyphs(s)]
|
|
|
+
|
|
|
+@_add_method(otTables.LookupList)
|
|
|
+def prune_post_subset(self, options):
|
|
|
+ ret = False
|
|
|
+ for l in self.Lookup:
|
|
|
+ if not l: continue
|
|
|
+ if l.prune_post_subset(options): ret = True
|
|
|
+ return ret
|
|
|
+
|
|
|
+@_add_method(otTables.LookupList)
|
|
|
+def subset_lookups(self, lookup_indices):
|
|
|
+ self.ensureDecompiled()
|
|
|
+ self.Lookup = [self.Lookup[i] for i in lookup_indices
|
|
|
+ if i < self.LookupCount]
|
|
|
+ self.LookupCount = len(self.Lookup)
|
|
|
+ for l in self.Lookup:
|
|
|
+ l.subset_lookups(lookup_indices)
|
|
|
+
|
|
|
+@_add_method(otTables.LookupList)
|
|
|
+def neuter_lookups(self, lookup_indices):
|
|
|
+ """Sets lookups not in lookup_indices to None."""
|
|
|
+ self.ensureDecompiled()
|
|
|
+ self.Lookup = [l if i in lookup_indices else None for i,l in enumerate(self.Lookup)]
|
|
|
+
|
|
|
+@_add_method(otTables.LookupList)
|
|
|
+def closure_lookups(self, lookup_indices):
|
|
|
+ lookup_indices = _uniq_sort(lookup_indices)
|
|
|
+ recurse = lookup_indices
|
|
|
+ while True:
|
|
|
+ recurse_lookups = sum((self.Lookup[i].collect_lookups()
|
|
|
+ for i in recurse if i < self.LookupCount), [])
|
|
|
+ recurse_lookups = [l for l in recurse_lookups
|
|
|
+ if l not in lookup_indices and l < self.LookupCount]
|
|
|
+ if not recurse_lookups:
|
|
|
+ return _uniq_sort(lookup_indices)
|
|
|
+ recurse_lookups = _uniq_sort(recurse_lookups)
|
|
|
+ lookup_indices.extend(recurse_lookups)
|
|
|
+ recurse = recurse_lookups
|
|
|
+
|
|
|
+@_add_method(otTables.Feature)
|
|
|
+def subset_lookups(self, lookup_indices):
|
|
|
+ self.LookupListIndex = [l for l in self.LookupListIndex
|
|
|
+ if l in lookup_indices]
|
|
|
+ # Now map them.
|
|
|
+ self.LookupListIndex = [lookup_indices.index(l)
|
|
|
+ for l in self.LookupListIndex]
|
|
|
+ self.LookupCount = len(self.LookupListIndex)
|
|
|
+ return self.LookupCount or self.FeatureParams
|
|
|
+
|
|
|
+@_add_method(otTables.Feature)
|
|
|
+def collect_lookups(self):
|
|
|
+ return self.LookupListIndex[:]
|
|
|
+
|
|
|
+@_add_method(otTables.FeatureList)
|
|
|
+def subset_lookups(self, lookup_indices):
|
|
|
+ """Returns the indices of nonempty features."""
|
|
|
+ # Note: Never ever drop feature 'pref', even if it's empty.
|
|
|
+ # HarfBuzz chooses shaper for Khmer based on presence of this
|
|
|
+ # feature. See thread at:
|
|
|
+ # http://lists.freedesktop.org/archives/harfbuzz/2012-November/002660.html
|
|
|
+ feature_indices = [i for i,f in enumerate(self.FeatureRecord)
|
|
|
+ if (f.Feature.subset_lookups(lookup_indices) or
|
|
|
+ f.FeatureTag == 'pref')]
|
|
|
+ self.subset_features(feature_indices)
|
|
|
+ return feature_indices
|
|
|
+
|
|
|
+@_add_method(otTables.FeatureList)
|
|
|
+def collect_lookups(self, feature_indices):
|
|
|
+ return _uniq_sort(sum((self.FeatureRecord[i].Feature.collect_lookups()
|
|
|
+ for i in feature_indices
|
|
|
+ if i < self.FeatureCount), []))
|
|
|
+
|
|
|
+@_add_method(otTables.FeatureList)
|
|
|
+def subset_features(self, feature_indices):
|
|
|
+ self.ensureDecompiled()
|
|
|
+ self.FeatureRecord = [self.FeatureRecord[i] for i in feature_indices]
|
|
|
+ self.FeatureCount = len(self.FeatureRecord)
|
|
|
+ return bool(self.FeatureCount)
|
|
|
+
|
|
|
+@_add_method(otTables.DefaultLangSys,
|
|
|
+ otTables.LangSys)
|
|
|
+def subset_features(self, feature_indices):
|
|
|
+ if self.ReqFeatureIndex in feature_indices:
|
|
|
+ self.ReqFeatureIndex = feature_indices.index(self.ReqFeatureIndex)
|
|
|
+ else:
|
|
|
+ self.ReqFeatureIndex = 65535
|
|
|
+ self.FeatureIndex = [f for f in self.FeatureIndex if f in feature_indices]
|
|
|
+ # Now map them.
|
|
|
+ self.FeatureIndex = [feature_indices.index(f) for f in self.FeatureIndex
|
|
|
+ if f in feature_indices]
|
|
|
+ self.FeatureCount = len(self.FeatureIndex)
|
|
|
+ return bool(self.FeatureCount or self.ReqFeatureIndex != 65535)
|
|
|
+
|
|
|
+@_add_method(otTables.DefaultLangSys,
|
|
|
+ otTables.LangSys)
|
|
|
+def collect_features(self):
|
|
|
+ feature_indices = self.FeatureIndex[:]
|
|
|
+ if self.ReqFeatureIndex != 65535:
|
|
|
+ feature_indices.append(self.ReqFeatureIndex)
|
|
|
+ return _uniq_sort(feature_indices)
|
|
|
+
|
|
|
+@_add_method(otTables.Script)
|
|
|
+def subset_features(self, feature_indices):
|
|
|
+ if(self.DefaultLangSys and
|
|
|
+ not self.DefaultLangSys.subset_features(feature_indices)):
|
|
|
+ self.DefaultLangSys = None
|
|
|
+ self.LangSysRecord = [l for l in self.LangSysRecord
|
|
|
+ if l.LangSys.subset_features(feature_indices)]
|
|
|
+ self.LangSysCount = len(self.LangSysRecord)
|
|
|
+ return bool(self.LangSysCount or self.DefaultLangSys)
|
|
|
+
|
|
|
+@_add_method(otTables.Script)
|
|
|
+def collect_features(self):
|
|
|
+ feature_indices = [l.LangSys.collect_features() for l in self.LangSysRecord]
|
|
|
+ if self.DefaultLangSys:
|
|
|
+ feature_indices.append(self.DefaultLangSys.collect_features())
|
|
|
+ return _uniq_sort(sum(feature_indices, []))
|
|
|
+
|
|
|
+@_add_method(otTables.ScriptList)
|
|
|
+def subset_features(self, feature_indices):
|
|
|
+ self.ScriptRecord = [s for s in self.ScriptRecord
|
|
|
+ if s.Script.subset_features(feature_indices)]
|
|
|
+ self.ScriptCount = len(self.ScriptRecord)
|
|
|
+ return bool(self.ScriptCount)
|
|
|
+
|
|
|
+@_add_method(otTables.ScriptList)
|
|
|
+def collect_features(self):
|
|
|
+ return _uniq_sort(sum((s.Script.collect_features()
|
|
|
+ for s in self.ScriptRecord), []))
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('GSUB'))
|
|
|
+def closure_glyphs(self, s):
|
|
|
+ s.table = self.table
|
|
|
+ if self.table.ScriptList:
|
|
|
+ feature_indices = self.table.ScriptList.collect_features()
|
|
|
+ else:
|
|
|
+ feature_indices = []
|
|
|
+ if self.table.FeatureList:
|
|
|
+ lookup_indices = self.table.FeatureList.collect_lookups(feature_indices)
|
|
|
+ else:
|
|
|
+ lookup_indices = []
|
|
|
+ if self.table.LookupList:
|
|
|
+ while True:
|
|
|
+ orig_glyphs = frozenset(s.glyphs)
|
|
|
+ s._activeLookups = []
|
|
|
+ s._doneLookups = set()
|
|
|
+ for i in lookup_indices:
|
|
|
+ if i >= self.table.LookupList.LookupCount: continue
|
|
|
+ if not self.table.LookupList.Lookup[i]: continue
|
|
|
+ self.table.LookupList.Lookup[i].closure_glyphs(s)
|
|
|
+ del s._activeLookups, s._doneLookups
|
|
|
+ if orig_glyphs == s.glyphs:
|
|
|
+ break
|
|
|
+ del s.table
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('GSUB'),
|
|
|
+ ttLib.getTableClass('GPOS'))
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ s.glyphs = s.glyphs_gsubed
|
|
|
+ if self.table.LookupList:
|
|
|
+ lookup_indices = self.table.LookupList.subset_glyphs(s)
|
|
|
+ else:
|
|
|
+ lookup_indices = []
|
|
|
+ self.subset_lookups(lookup_indices)
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('GSUB'),
|
|
|
+ ttLib.getTableClass('GPOS'))
|
|
|
+def subset_lookups(self, lookup_indices):
|
|
|
+ """Retains specified lookups, then removes empty features, language
|
|
|
+ systems, and scripts."""
|
|
|
+ if self.table.LookupList:
|
|
|
+ self.table.LookupList.subset_lookups(lookup_indices)
|
|
|
+ if self.table.FeatureList:
|
|
|
+ feature_indices = self.table.FeatureList.subset_lookups(lookup_indices)
|
|
|
+ else:
|
|
|
+ feature_indices = []
|
|
|
+ if self.table.ScriptList:
|
|
|
+ self.table.ScriptList.subset_features(feature_indices)
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('GSUB'),
|
|
|
+ ttLib.getTableClass('GPOS'))
|
|
|
+def neuter_lookups(self, lookup_indices):
|
|
|
+ """Sets lookups not in lookup_indices to None."""
|
|
|
+ if self.table.LookupList:
|
|
|
+ self.table.LookupList.neuter_lookups(lookup_indices)
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('GSUB'),
|
|
|
+ ttLib.getTableClass('GPOS'))
|
|
|
+def prune_lookups(self, remap=True):
|
|
|
+ """Remove (default) or neuter unreferenced lookups"""
|
|
|
+ if self.table.ScriptList:
|
|
|
+ feature_indices = self.table.ScriptList.collect_features()
|
|
|
+ else:
|
|
|
+ feature_indices = []
|
|
|
+ if self.table.FeatureList:
|
|
|
+ lookup_indices = self.table.FeatureList.collect_lookups(feature_indices)
|
|
|
+ else:
|
|
|
+ lookup_indices = []
|
|
|
+ if self.table.LookupList:
|
|
|
+ lookup_indices = self.table.LookupList.closure_lookups(lookup_indices)
|
|
|
+ else:
|
|
|
+ lookup_indices = []
|
|
|
+ if remap:
|
|
|
+ self.subset_lookups(lookup_indices)
|
|
|
+ else:
|
|
|
+ self.neuter_lookups(lookup_indices)
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('GSUB'),
|
|
|
+ ttLib.getTableClass('GPOS'))
|
|
|
+def subset_feature_tags(self, feature_tags):
|
|
|
+ if self.table.FeatureList:
|
|
|
+ feature_indices = \
|
|
|
+ [i for i,f in enumerate(self.table.FeatureList.FeatureRecord)
|
|
|
+ if f.FeatureTag in feature_tags]
|
|
|
+ self.table.FeatureList.subset_features(feature_indices)
|
|
|
+ else:
|
|
|
+ feature_indices = []
|
|
|
+ if self.table.ScriptList:
|
|
|
+ self.table.ScriptList.subset_features(feature_indices)
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('GSUB'),
|
|
|
+ ttLib.getTableClass('GPOS'))
|
|
|
+def prune_features(self):
|
|
|
+ """Remove unreferenced features"""
|
|
|
+ if self.table.ScriptList:
|
|
|
+ feature_indices = self.table.ScriptList.collect_features()
|
|
|
+ else:
|
|
|
+ feature_indices = []
|
|
|
+ if self.table.FeatureList:
|
|
|
+ self.table.FeatureList.subset_features(feature_indices)
|
|
|
+ if self.table.ScriptList:
|
|
|
+ self.table.ScriptList.subset_features(feature_indices)
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('GSUB'),
|
|
|
+ ttLib.getTableClass('GPOS'))
|
|
|
+def prune_pre_subset(self, options):
|
|
|
+ # Drop undesired features
|
|
|
+ if '*' not in options.layout_features:
|
|
|
+ self.subset_feature_tags(options.layout_features)
|
|
|
+ # Neuter unreferenced lookups
|
|
|
+ self.prune_lookups(remap=False)
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('GSUB'),
|
|
|
+ ttLib.getTableClass('GPOS'))
|
|
|
+def remove_redundant_langsys(self):
|
|
|
+ table = self.table
|
|
|
+ if not table.ScriptList or not table.FeatureList:
|
|
|
+ return
|
|
|
+
|
|
|
+ features = table.FeatureList.FeatureRecord
|
|
|
+
|
|
|
+ for s in table.ScriptList.ScriptRecord:
|
|
|
+ d = s.Script.DefaultLangSys
|
|
|
+ if not d:
|
|
|
+ continue
|
|
|
+ for lr in s.Script.LangSysRecord[:]:
|
|
|
+ l = lr.LangSys
|
|
|
+ # Compare d and l
|
|
|
+ if len(d.FeatureIndex) != len(l.FeatureIndex):
|
|
|
+ continue
|
|
|
+ if (d.ReqFeatureIndex == 65535) != (l.ReqFeatureIndex == 65535):
|
|
|
+ continue
|
|
|
+
|
|
|
+ if d.ReqFeatureIndex != 65535:
|
|
|
+ if features[d.ReqFeatureIndex] != features[l.ReqFeatureIndex]:
|
|
|
+ continue
|
|
|
+
|
|
|
+ for i in range(len(d.FeatureIndex)):
|
|
|
+ if features[d.FeatureIndex[i]] != features[l.FeatureIndex[i]]:
|
|
|
+ break
|
|
|
+ else:
|
|
|
+ # LangSys and default are equal; delete LangSys
|
|
|
+ s.Script.LangSysRecord.remove(lr)
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('GSUB'),
|
|
|
+ ttLib.getTableClass('GPOS'))
|
|
|
+def prune_post_subset(self, options):
|
|
|
+ table = self.table
|
|
|
+
|
|
|
+ self.prune_lookups() # XXX Is this actually needed?!
|
|
|
+
|
|
|
+ if table.LookupList:
|
|
|
+ table.LookupList.prune_post_subset(options)
|
|
|
+ # XXX Next two lines disabled because OTS is stupid and
|
|
|
+ # doesn't like NULL offsets here.
|
|
|
+ #if not table.LookupList.Lookup:
|
|
|
+ # table.LookupList = None
|
|
|
+
|
|
|
+ if not table.LookupList:
|
|
|
+ table.FeatureList = None
|
|
|
+
|
|
|
+ if table.FeatureList:
|
|
|
+ self.remove_redundant_langsys()
|
|
|
+ # Remove unreferenced features
|
|
|
+ self.prune_features()
|
|
|
+
|
|
|
+ # XXX Next two lines disabled because OTS is stupid and
|
|
|
+ # doesn't like NULL offsets here.
|
|
|
+ #if table.FeatureList and not table.FeatureList.FeatureRecord:
|
|
|
+ # table.FeatureList = None
|
|
|
+
|
|
|
+ # Never drop scripts themselves as them just being available
|
|
|
+ # holds semantic significance.
|
|
|
+ # XXX Next two lines disabled because OTS is stupid and
|
|
|
+ # doesn't like NULL offsets here.
|
|
|
+ #if table.ScriptList and not table.ScriptList.ScriptRecord:
|
|
|
+ # table.ScriptList = None
|
|
|
+
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('GDEF'))
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ glyphs = s.glyphs_gsubed
|
|
|
+ table = self.table
|
|
|
+ if table.LigCaretList:
|
|
|
+ indices = table.LigCaretList.Coverage.subset(glyphs)
|
|
|
+ table.LigCaretList.LigGlyph = [table.LigCaretList.LigGlyph[i]
|
|
|
+ for i in indices]
|
|
|
+ table.LigCaretList.LigGlyphCount = len(table.LigCaretList.LigGlyph)
|
|
|
+ if table.MarkAttachClassDef:
|
|
|
+ table.MarkAttachClassDef.classDefs = \
|
|
|
+ {g:v for g,v in table.MarkAttachClassDef.classDefs.items()
|
|
|
+ if g in glyphs}
|
|
|
+ if table.GlyphClassDef:
|
|
|
+ table.GlyphClassDef.classDefs = \
|
|
|
+ {g:v for g,v in table.GlyphClassDef.classDefs.items()
|
|
|
+ if g in glyphs}
|
|
|
+ if table.AttachList:
|
|
|
+ indices = table.AttachList.Coverage.subset(glyphs)
|
|
|
+ GlyphCount = table.AttachList.GlyphCount
|
|
|
+ table.AttachList.AttachPoint = [table.AttachList.AttachPoint[i]
|
|
|
+ for i in indices
|
|
|
+ if i < GlyphCount]
|
|
|
+ table.AttachList.GlyphCount = len(table.AttachList.AttachPoint)
|
|
|
+ if hasattr(table, "MarkGlyphSetsDef") and table.MarkGlyphSetsDef:
|
|
|
+ for coverage in table.MarkGlyphSetsDef.Coverage:
|
|
|
+ coverage.subset(glyphs)
|
|
|
+ # TODO: The following is disabled. If enabling, we need to go fixup all
|
|
|
+ # lookups that use MarkFilteringSet and map their set.
|
|
|
+ # indices = table.MarkGlyphSetsDef.Coverage = \
|
|
|
+ # [c for c in table.MarkGlyphSetsDef.Coverage if c.glyphs]
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('GDEF'))
|
|
|
+def prune_post_subset(self, options):
|
|
|
+ table = self.table
|
|
|
+ # XXX check these against OTS
|
|
|
+ if table.LigCaretList and not table.LigCaretList.LigGlyphCount:
|
|
|
+ table.LigCaretList = None
|
|
|
+ if table.MarkAttachClassDef and not table.MarkAttachClassDef.classDefs:
|
|
|
+ table.MarkAttachClassDef = None
|
|
|
+ if table.GlyphClassDef and not table.GlyphClassDef.classDefs:
|
|
|
+ table.GlyphClassDef = None
|
|
|
+ if table.AttachList and not table.AttachList.GlyphCount:
|
|
|
+ table.AttachList = None
|
|
|
+ if (hasattr(table, "MarkGlyphSetsDef") and
|
|
|
+ table.MarkGlyphSetsDef and
|
|
|
+ not table.MarkGlyphSetsDef.Coverage):
|
|
|
+ table.MarkGlyphSetsDef = None
|
|
|
+ if table.Version == 0x00010002/0x10000:
|
|
|
+ table.Version = 1.0
|
|
|
+ return bool(table.LigCaretList or
|
|
|
+ table.MarkAttachClassDef or
|
|
|
+ table.GlyphClassDef or
|
|
|
+ table.AttachList or
|
|
|
+ (table.Version >= 0x00010002/0x10000 and table.MarkGlyphSetsDef))
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('kern'))
|
|
|
+def prune_pre_subset(self, options):
|
|
|
+ # Prune unknown kern table types
|
|
|
+ self.kernTables = [t for t in self.kernTables if hasattr(t, 'kernTable')]
|
|
|
+ return bool(self.kernTables)
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('kern'))
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ glyphs = s.glyphs_gsubed
|
|
|
+ for t in self.kernTables:
|
|
|
+ t.kernTable = {(a,b):v for (a,b),v in t.kernTable.items()
|
|
|
+ if a in glyphs and b in glyphs}
|
|
|
+ self.kernTables = [t for t in self.kernTables if t.kernTable]
|
|
|
+ return bool(self.kernTables)
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('vmtx'))
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ self.metrics = _dict_subset(self.metrics, s.glyphs)
|
|
|
+ return bool(self.metrics)
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('hmtx'))
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ self.metrics = _dict_subset(self.metrics, s.glyphs)
|
|
|
+ return True # Required table
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('hdmx'))
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ self.hdmx = {sz:_dict_subset(l, s.glyphs) for sz,l in self.hdmx.items()}
|
|
|
+ return bool(self.hdmx)
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('VORG'))
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ self.VOriginRecords = {g:v for g,v in self.VOriginRecords.items()
|
|
|
+ if g in s.glyphs}
|
|
|
+ self.numVertOriginYMetrics = len(self.VOriginRecords)
|
|
|
+ return True # Never drop; has default metrics
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('post'))
|
|
|
+def prune_pre_subset(self, options):
|
|
|
+ if not options.glyph_names:
|
|
|
+ self.formatType = 3.0
|
|
|
+ return True # Required table
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('post'))
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ self.extraNames = [] # This seems to do it
|
|
|
+ return True # Required table
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableModule('glyf').Glyph)
|
|
|
+def remapComponentsFast(self, indices):
|
|
|
+ if not self.data or struct.unpack(">h", self.data[:2])[0] >= 0:
|
|
|
+ return # Not composite
|
|
|
+ data = array.array("B", self.data)
|
|
|
+ i = 10
|
|
|
+ more = 1
|
|
|
+ while more:
|
|
|
+ flags =(data[i] << 8) | data[i+1]
|
|
|
+ glyphID =(data[i+2] << 8) | data[i+3]
|
|
|
+ # Remap
|
|
|
+ glyphID = indices.index(glyphID)
|
|
|
+ data[i+2] = glyphID >> 8
|
|
|
+ data[i+3] = glyphID & 0xFF
|
|
|
+ i += 4
|
|
|
+ flags = int(flags)
|
|
|
+
|
|
|
+ if flags & 0x0001: i += 4 # ARG_1_AND_2_ARE_WORDS
|
|
|
+ else: i += 2
|
|
|
+ if flags & 0x0008: i += 2 # WE_HAVE_A_SCALE
|
|
|
+ elif flags & 0x0040: i += 4 # WE_HAVE_AN_X_AND_Y_SCALE
|
|
|
+ elif flags & 0x0080: i += 8 # WE_HAVE_A_TWO_BY_TWO
|
|
|
+ more = flags & 0x0020 # MORE_COMPONENTS
|
|
|
+
|
|
|
+ self.data = data.tostring()
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('glyf'))
|
|
|
+def closure_glyphs(self, s):
|
|
|
+ decompose = s.glyphs
|
|
|
+ while True:
|
|
|
+ components = set()
|
|
|
+ for g in decompose:
|
|
|
+ if g not in self.glyphs:
|
|
|
+ continue
|
|
|
+ gl = self.glyphs[g]
|
|
|
+ for c in gl.getComponentNames(self):
|
|
|
+ if c not in s.glyphs:
|
|
|
+ components.add(c)
|
|
|
+ components = set(c for c in components if c not in s.glyphs)
|
|
|
+ if not components:
|
|
|
+ break
|
|
|
+ decompose = components
|
|
|
+ s.glyphs.update(components)
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('glyf'))
|
|
|
+def prune_pre_subset(self, options):
|
|
|
+ if options.notdef_glyph and not options.notdef_outline:
|
|
|
+ g = self[self.glyphOrder[0]]
|
|
|
+ # Yay, easy!
|
|
|
+ g.__dict__.clear()
|
|
|
+ g.data = ""
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('glyf'))
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ self.glyphs = _dict_subset(self.glyphs, s.glyphs)
|
|
|
+ indices = [i for i,g in enumerate(self.glyphOrder) if g in s.glyphs]
|
|
|
+ for v in self.glyphs.values():
|
|
|
+ if hasattr(v, "data"):
|
|
|
+ v.remapComponentsFast(indices)
|
|
|
+ else:
|
|
|
+ pass # No need
|
|
|
+ self.glyphOrder = [g for g in self.glyphOrder if g in s.glyphs]
|
|
|
+ # Don't drop empty 'glyf' tables, otherwise 'loca' doesn't get subset.
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('glyf'))
|
|
|
+def prune_post_subset(self, options):
|
|
|
+ remove_hinting = not options.hinting
|
|
|
+ for v in self.glyphs.values():
|
|
|
+ v.trim(remove_hinting=remove_hinting)
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('CFF '))
|
|
|
+def prune_pre_subset(self, options):
|
|
|
+ cff = self.cff
|
|
|
+ # CFF table must have one font only
|
|
|
+ cff.fontNames = cff.fontNames[:1]
|
|
|
+
|
|
|
+ if options.notdef_glyph and not options.notdef_outline:
|
|
|
+ for fontname in cff.keys():
|
|
|
+ font = cff[fontname]
|
|
|
+ c,_ = font.CharStrings.getItemAndSelector('.notdef')
|
|
|
+ # XXX we should preserve the glyph width
|
|
|
+ c.bytecode = '\x0e' # endchar
|
|
|
+ c.program = None
|
|
|
+
|
|
|
+ return True # bool(cff.fontNames)
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('CFF '))
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ cff = self.cff
|
|
|
+ for fontname in cff.keys():
|
|
|
+ font = cff[fontname]
|
|
|
+ cs = font.CharStrings
|
|
|
+
|
|
|
+ # Load all glyphs
|
|
|
+ for g in font.charset:
|
|
|
+ if g not in s.glyphs: continue
|
|
|
+ c,sel = cs.getItemAndSelector(g)
|
|
|
+
|
|
|
+ if cs.charStringsAreIndexed:
|
|
|
+ indices = [i for i,g in enumerate(font.charset) if g in s.glyphs]
|
|
|
+ csi = cs.charStringsIndex
|
|
|
+ csi.items = [csi.items[i] for i in indices]
|
|
|
+ del csi.file, csi.offsets
|
|
|
+ if hasattr(font, "FDSelect"):
|
|
|
+ sel = font.FDSelect
|
|
|
+ # XXX We want to set sel.format to None, such that the
|
|
|
+ # most compact format is selected. However, OTS was
|
|
|
+ # broken and couldn't parse a FDSelect format 0 that
|
|
|
+ # happened before CharStrings. As such, always force
|
|
|
+ # format 3 until we fix cffLib to always generate
|
|
|
+ # FDSelect after CharStrings.
|
|
|
+ # https://github.com/khaledhosny/ots/pull/31
|
|
|
+ #sel.format = None
|
|
|
+ sel.format = 3
|
|
|
+ sel.gidArray = [sel.gidArray[i] for i in indices]
|
|
|
+ cs.charStrings = {g:indices.index(v)
|
|
|
+ for g,v in cs.charStrings.items()
|
|
|
+ if g in s.glyphs}
|
|
|
+ else:
|
|
|
+ cs.charStrings = {g:v
|
|
|
+ for g,v in cs.charStrings.items()
|
|
|
+ if g in s.glyphs}
|
|
|
+ font.charset = [g for g in font.charset if g in s.glyphs]
|
|
|
+ font.numGlyphs = len(font.charset)
|
|
|
+
|
|
|
+ return True # any(cff[fontname].numGlyphs for fontname in cff.keys())
|
|
|
+
|
|
|
+@_add_method(psCharStrings.T2CharString)
|
|
|
+def subset_subroutines(self, subrs, gsubrs):
|
|
|
+ p = self.program
|
|
|
+ assert len(p)
|
|
|
+ for i in range(1, len(p)):
|
|
|
+ if p[i] == 'callsubr':
|
|
|
+ assert isinstance(p[i-1], int)
|
|
|
+ p[i-1] = subrs._used.index(p[i-1] + subrs._old_bias) - subrs._new_bias
|
|
|
+ elif p[i] == 'callgsubr':
|
|
|
+ assert isinstance(p[i-1], int)
|
|
|
+ p[i-1] = gsubrs._used.index(p[i-1] + gsubrs._old_bias) - gsubrs._new_bias
|
|
|
+
|
|
|
+@_add_method(psCharStrings.T2CharString)
|
|
|
+def drop_hints(self):
|
|
|
+ hints = self._hints
|
|
|
+
|
|
|
+ if hints.has_hint:
|
|
|
+ self.program = self.program[hints.last_hint:]
|
|
|
+ if hasattr(self, 'width'):
|
|
|
+ # Insert width back if needed
|
|
|
+ if self.width != self.private.defaultWidthX:
|
|
|
+ self.program.insert(0, self.width - self.private.nominalWidthX)
|
|
|
+
|
|
|
+ if hints.has_hintmask:
|
|
|
+ i = 0
|
|
|
+ p = self.program
|
|
|
+ while i < len(p):
|
|
|
+ if p[i] in ['hintmask', 'cntrmask']:
|
|
|
+ assert i + 1 <= len(p)
|
|
|
+ del p[i:i+2]
|
|
|
+ continue
|
|
|
+ i += 1
|
|
|
+
|
|
|
+ # TODO: we currently don't drop calls to "empty" subroutines.
|
|
|
+
|
|
|
+ assert len(self.program)
|
|
|
+
|
|
|
+ del self._hints
|
|
|
+
|
|
|
+class _MarkingT2Decompiler(psCharStrings.SimpleT2Decompiler):
|
|
|
+
|
|
|
+ def __init__(self, localSubrs, globalSubrs):
|
|
|
+ psCharStrings.SimpleT2Decompiler.__init__(self,
|
|
|
+ localSubrs,
|
|
|
+ globalSubrs)
|
|
|
+ for subrs in [localSubrs, globalSubrs]:
|
|
|
+ if subrs and not hasattr(subrs, "_used"):
|
|
|
+ subrs._used = set()
|
|
|
+
|
|
|
+ def op_callsubr(self, index):
|
|
|
+ self.localSubrs._used.add(self.operandStack[-1]+self.localBias)
|
|
|
+ psCharStrings.SimpleT2Decompiler.op_callsubr(self, index)
|
|
|
+
|
|
|
+ def op_callgsubr(self, index):
|
|
|
+ self.globalSubrs._used.add(self.operandStack[-1]+self.globalBias)
|
|
|
+ psCharStrings.SimpleT2Decompiler.op_callgsubr(self, index)
|
|
|
+
|
|
|
+class _DehintingT2Decompiler(psCharStrings.SimpleT2Decompiler):
|
|
|
+
|
|
|
+ class Hints(object):
|
|
|
+ def __init__(self):
|
|
|
+ # Whether calling this charstring produces any hint stems
|
|
|
+ self.has_hint = False
|
|
|
+ # Index to start at to drop all hints
|
|
|
+ self.last_hint = 0
|
|
|
+ # Index up to which we know more hints are possible.
|
|
|
+ # Only relevant if status is 0 or 1.
|
|
|
+ self.last_checked = 0
|
|
|
+ # The status means:
|
|
|
+ # 0: after dropping hints, this charstring is empty
|
|
|
+ # 1: after dropping hints, there may be more hints
|
|
|
+ # continuing after this
|
|
|
+ # 2: no more hints possible after this charstring
|
|
|
+ self.status = 0
|
|
|
+ # Has hintmask instructions; not recursive
|
|
|
+ self.has_hintmask = False
|
|
|
+ pass
|
|
|
+
|
|
|
+ def __init__(self, css, localSubrs, globalSubrs):
|
|
|
+ self._css = css
|
|
|
+ psCharStrings.SimpleT2Decompiler.__init__(self,
|
|
|
+ localSubrs,
|
|
|
+ globalSubrs)
|
|
|
+
|
|
|
+ def execute(self, charString):
|
|
|
+ old_hints = charString._hints if hasattr(charString, '_hints') else None
|
|
|
+ charString._hints = self.Hints()
|
|
|
+
|
|
|
+ psCharStrings.SimpleT2Decompiler.execute(self, charString)
|
|
|
+
|
|
|
+ hints = charString._hints
|
|
|
+
|
|
|
+ if hints.has_hint or hints.has_hintmask:
|
|
|
+ self._css.add(charString)
|
|
|
+
|
|
|
+ if hints.status != 2:
|
|
|
+ # Check from last_check, make sure we didn't have any operators.
|
|
|
+ for i in range(hints.last_checked, len(charString.program) - 1):
|
|
|
+ if isinstance(charString.program[i], str):
|
|
|
+ hints.status = 2
|
|
|
+ break
|
|
|
+ else:
|
|
|
+ hints.status = 1 # There's *something* here
|
|
|
+ hints.last_checked = len(charString.program)
|
|
|
+
|
|
|
+ if old_hints:
|
|
|
+ assert hints.__dict__ == old_hints.__dict__
|
|
|
+
|
|
|
+ def op_callsubr(self, index):
|
|
|
+ subr = self.localSubrs[self.operandStack[-1]+self.localBias]
|
|
|
+ psCharStrings.SimpleT2Decompiler.op_callsubr(self, index)
|
|
|
+ self.processSubr(index, subr)
|
|
|
+
|
|
|
+ def op_callgsubr(self, index):
|
|
|
+ subr = self.globalSubrs[self.operandStack[-1]+self.globalBias]
|
|
|
+ psCharStrings.SimpleT2Decompiler.op_callgsubr(self, index)
|
|
|
+ self.processSubr(index, subr)
|
|
|
+
|
|
|
+ def op_hstem(self, index):
|
|
|
+ psCharStrings.SimpleT2Decompiler.op_hstem(self, index)
|
|
|
+ self.processHint(index)
|
|
|
+ def op_vstem(self, index):
|
|
|
+ psCharStrings.SimpleT2Decompiler.op_vstem(self, index)
|
|
|
+ self.processHint(index)
|
|
|
+ def op_hstemhm(self, index):
|
|
|
+ psCharStrings.SimpleT2Decompiler.op_hstemhm(self, index)
|
|
|
+ self.processHint(index)
|
|
|
+ def op_vstemhm(self, index):
|
|
|
+ psCharStrings.SimpleT2Decompiler.op_vstemhm(self, index)
|
|
|
+ self.processHint(index)
|
|
|
+ def op_hintmask(self, index):
|
|
|
+ psCharStrings.SimpleT2Decompiler.op_hintmask(self, index)
|
|
|
+ self.processHintmask(index)
|
|
|
+ def op_cntrmask(self, index):
|
|
|
+ psCharStrings.SimpleT2Decompiler.op_cntrmask(self, index)
|
|
|
+ self.processHintmask(index)
|
|
|
+
|
|
|
+ def processHintmask(self, index):
|
|
|
+ cs = self.callingStack[-1]
|
|
|
+ hints = cs._hints
|
|
|
+ hints.has_hintmask = True
|
|
|
+ if hints.status != 2 and hints.has_hint:
|
|
|
+ # Check from last_check, see if we may be an implicit vstem
|
|
|
+ for i in range(hints.last_checked, index - 1):
|
|
|
+ if isinstance(cs.program[i], str):
|
|
|
+ hints.status = 2
|
|
|
+ break
|
|
|
+ if hints.status != 2:
|
|
|
+ # We are an implicit vstem
|
|
|
+ hints.last_hint = index + 1
|
|
|
+ hints.status = 0
|
|
|
+ hints.last_checked = index + 1
|
|
|
+
|
|
|
+ def processHint(self, index):
|
|
|
+ cs = self.callingStack[-1]
|
|
|
+ hints = cs._hints
|
|
|
+ hints.has_hint = True
|
|
|
+ hints.last_hint = index
|
|
|
+ hints.last_checked = index
|
|
|
+
|
|
|
+ def processSubr(self, index, subr):
|
|
|
+ cs = self.callingStack[-1]
|
|
|
+ hints = cs._hints
|
|
|
+ subr_hints = subr._hints
|
|
|
+
|
|
|
+ if subr_hints.has_hint:
|
|
|
+ if hints.status != 2:
|
|
|
+ hints.has_hint = True
|
|
|
+ hints.last_checked = index
|
|
|
+ hints.status = subr_hints.status
|
|
|
+ # Decide where to chop off from
|
|
|
+ if subr_hints.status == 0:
|
|
|
+ hints.last_hint = index
|
|
|
+ else:
|
|
|
+ hints.last_hint = index - 2 # Leave the subr call in
|
|
|
+ else:
|
|
|
+ # In my understanding, this is a font bug.
|
|
|
+ # I.e., it has hint stems *after* path construction.
|
|
|
+ # I've seen this in widespread fonts.
|
|
|
+ # Best to ignore the hints I suppose...
|
|
|
+ pass
|
|
|
+ #assert 0
|
|
|
+ else:
|
|
|
+ hints.status = max(hints.status, subr_hints.status)
|
|
|
+ if hints.status != 2:
|
|
|
+ # Check from last_check, make sure we didn't have
|
|
|
+ # any operators.
|
|
|
+ for i in range(hints.last_checked, index - 1):
|
|
|
+ if isinstance(cs.program[i], str):
|
|
|
+ hints.status = 2
|
|
|
+ break
|
|
|
+ hints.last_checked = index
|
|
|
+ if hints.status != 2:
|
|
|
+ # Decide where to chop off from
|
|
|
+ if subr_hints.status == 0:
|
|
|
+ hints.last_hint = index
|
|
|
+ else:
|
|
|
+ hints.last_hint = index - 2 # Leave the subr call in
|
|
|
+
|
|
|
+class _DesubroutinizingT2Decompiler(psCharStrings.SimpleT2Decompiler):
|
|
|
+
|
|
|
+ def __init__(self, localSubrs, globalSubrs):
|
|
|
+ psCharStrings.SimpleT2Decompiler.__init__(self,
|
|
|
+ localSubrs,
|
|
|
+ globalSubrs)
|
|
|
+
|
|
|
+ def execute(self, charString):
|
|
|
+ # Note: Currently we recompute _desubroutinized each time.
|
|
|
+ # This is more robust in some cases, but in other places we assume
|
|
|
+ # that each subroutine always expands to the same code, so
|
|
|
+ # maybe it doesn't matter. To speed up we can just not
|
|
|
+ # recompute _desubroutinized if it's there. For now I just
|
|
|
+ # double-check that it desubroutinized to the same thing.
|
|
|
+ old_desubroutinized = charString._desubroutinized if hasattr(charString, '_desubroutinized') else None
|
|
|
+
|
|
|
+ charString._patches = []
|
|
|
+ psCharStrings.SimpleT2Decompiler.execute(self, charString)
|
|
|
+ desubroutinized = charString.program[:]
|
|
|
+ for idx,expansion in reversed (charString._patches):
|
|
|
+ assert idx >= 2
|
|
|
+ assert desubroutinized[idx - 1] in ['callsubr', 'callgsubr'], desubroutinized[idx - 1]
|
|
|
+ assert type(desubroutinized[idx - 2]) == int
|
|
|
+ if expansion[-1] == 'return':
|
|
|
+ expansion = expansion[:-1]
|
|
|
+ desubroutinized[idx-2:idx] = expansion
|
|
|
+ if 'endchar' in desubroutinized:
|
|
|
+ # Cut off after first endchar
|
|
|
+ desubroutinized = desubroutinized[:desubroutinized.index('endchar') + 1]
|
|
|
+ else:
|
|
|
+ if not len(desubroutinized) or desubroutinized[-1] != 'return':
|
|
|
+ desubroutinized.append('return')
|
|
|
+
|
|
|
+ charString._desubroutinized = desubroutinized
|
|
|
+ del charString._patches
|
|
|
+
|
|
|
+ if old_desubroutinized:
|
|
|
+ assert desubroutinized == old_desubroutinized
|
|
|
+
|
|
|
+ def op_callsubr(self, index):
|
|
|
+ subr = self.localSubrs[self.operandStack[-1]+self.localBias]
|
|
|
+ psCharStrings.SimpleT2Decompiler.op_callsubr(self, index)
|
|
|
+ self.processSubr(index, subr)
|
|
|
+
|
|
|
+ def op_callgsubr(self, index):
|
|
|
+ subr = self.globalSubrs[self.operandStack[-1]+self.globalBias]
|
|
|
+ psCharStrings.SimpleT2Decompiler.op_callgsubr(self, index)
|
|
|
+ self.processSubr(index, subr)
|
|
|
+
|
|
|
+ def processSubr(self, index, subr):
|
|
|
+ cs = self.callingStack[-1]
|
|
|
+ cs._patches.append((index, subr._desubroutinized))
|
|
|
+
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('CFF '))
|
|
|
+def prune_post_subset(self, options):
|
|
|
+ cff = self.cff
|
|
|
+ for fontname in cff.keys():
|
|
|
+ font = cff[fontname]
|
|
|
+ cs = font.CharStrings
|
|
|
+
|
|
|
+ # Drop unused FontDictionaries
|
|
|
+ if hasattr(font, "FDSelect"):
|
|
|
+ sel = font.FDSelect
|
|
|
+ indices = _uniq_sort(sel.gidArray)
|
|
|
+ sel.gidArray = [indices.index (ss) for ss in sel.gidArray]
|
|
|
+ arr = font.FDArray
|
|
|
+ arr.items = [arr[i] for i in indices]
|
|
|
+ del arr.file, arr.offsets
|
|
|
+
|
|
|
+ # Desubroutinize if asked for
|
|
|
+ if options.desubroutinize:
|
|
|
+ for g in font.charset:
|
|
|
+ c,sel = cs.getItemAndSelector(g)
|
|
|
+ c.decompile()
|
|
|
+ subrs = getattr(c.private, "Subrs", [])
|
|
|
+ decompiler = _DesubroutinizingT2Decompiler(subrs, c.globalSubrs)
|
|
|
+ decompiler.execute(c)
|
|
|
+ c.program = c._desubroutinized
|
|
|
+
|
|
|
+ # Drop hints if not needed
|
|
|
+ if not options.hinting:
|
|
|
+
|
|
|
+ # This can be tricky, but doesn't have to. What we do is:
|
|
|
+ #
|
|
|
+ # - Run all used glyph charstrings and recurse into subroutines,
|
|
|
+ # - For each charstring (including subroutines), if it has any
|
|
|
+ # of the hint stem operators, we mark it as such.
|
|
|
+ # Upon returning, for each charstring we note all the
|
|
|
+ # subroutine calls it makes that (recursively) contain a stem,
|
|
|
+ # - Dropping hinting then consists of the following two ops:
|
|
|
+ # * Drop the piece of the program in each charstring before the
|
|
|
+ # last call to a stem op or a stem-calling subroutine,
|
|
|
+ # * Drop all hintmask operations.
|
|
|
+ # - It's trickier... A hintmask right after hints and a few numbers
|
|
|
+ # will act as an implicit vstemhm. As such, we track whether
|
|
|
+ # we have seen any non-hint operators so far and do the right
|
|
|
+ # thing, recursively... Good luck understanding that :(
|
|
|
+ css = set()
|
|
|
+ for g in font.charset:
|
|
|
+ c,sel = cs.getItemAndSelector(g)
|
|
|
+ c.decompile()
|
|
|
+ subrs = getattr(c.private, "Subrs", [])
|
|
|
+ decompiler = _DehintingT2Decompiler(css, subrs, c.globalSubrs)
|
|
|
+ decompiler.execute(c)
|
|
|
+ for charstring in css:
|
|
|
+ charstring.drop_hints()
|
|
|
+ del css
|
|
|
+
|
|
|
+ # Drop font-wide hinting values
|
|
|
+ all_privs = []
|
|
|
+ if hasattr(font, 'FDSelect'):
|
|
|
+ all_privs.extend(fd.Private for fd in font.FDArray)
|
|
|
+ else:
|
|
|
+ all_privs.append(font.Private)
|
|
|
+ for priv in all_privs:
|
|
|
+ for k in ['BlueValues', 'OtherBlues',
|
|
|
+ 'FamilyBlues', 'FamilyOtherBlues',
|
|
|
+ 'BlueScale', 'BlueShift', 'BlueFuzz',
|
|
|
+ 'StemSnapH', 'StemSnapV', 'StdHW', 'StdVW']:
|
|
|
+ if hasattr(priv, k):
|
|
|
+ setattr(priv, k, None)
|
|
|
+
|
|
|
+ # Renumber subroutines to remove unused ones
|
|
|
+
|
|
|
+ # Mark all used subroutines
|
|
|
+ for g in font.charset:
|
|
|
+ c,sel = cs.getItemAndSelector(g)
|
|
|
+ subrs = getattr(c.private, "Subrs", [])
|
|
|
+ decompiler = _MarkingT2Decompiler(subrs, c.globalSubrs)
|
|
|
+ decompiler.execute(c)
|
|
|
+
|
|
|
+ all_subrs = [font.GlobalSubrs]
|
|
|
+ if hasattr(font, 'FDSelect'):
|
|
|
+ all_subrs.extend(fd.Private.Subrs for fd in font.FDArray if hasattr(fd.Private, 'Subrs') and fd.Private.Subrs)
|
|
|
+ elif hasattr(font.Private, 'Subrs') and font.Private.Subrs:
|
|
|
+ all_subrs.append(font.Private.Subrs)
|
|
|
+
|
|
|
+ subrs = set(subrs) # Remove duplicates
|
|
|
+
|
|
|
+ # Prepare
|
|
|
+ for subrs in all_subrs:
|
|
|
+ if not hasattr(subrs, '_used'):
|
|
|
+ subrs._used = set()
|
|
|
+ subrs._used = _uniq_sort(subrs._used)
|
|
|
+ subrs._old_bias = psCharStrings.calcSubrBias(subrs)
|
|
|
+ subrs._new_bias = psCharStrings.calcSubrBias(subrs._used)
|
|
|
+
|
|
|
+ # Renumber glyph charstrings
|
|
|
+ for g in font.charset:
|
|
|
+ c,sel = cs.getItemAndSelector(g)
|
|
|
+ subrs = getattr(c.private, "Subrs", [])
|
|
|
+ c.subset_subroutines (subrs, font.GlobalSubrs)
|
|
|
+
|
|
|
+ # Renumber subroutines themselves
|
|
|
+ for subrs in all_subrs:
|
|
|
+ if subrs == font.GlobalSubrs:
|
|
|
+ if not hasattr(font, 'FDSelect') and hasattr(font.Private, 'Subrs'):
|
|
|
+ local_subrs = font.Private.Subrs
|
|
|
+ else:
|
|
|
+ local_subrs = []
|
|
|
+ else:
|
|
|
+ local_subrs = subrs
|
|
|
+
|
|
|
+ subrs.items = [subrs.items[i] for i in subrs._used]
|
|
|
+ del subrs.file
|
|
|
+ if hasattr(subrs, 'offsets'):
|
|
|
+ del subrs.offsets
|
|
|
+
|
|
|
+ for subr in subrs.items:
|
|
|
+ subr.subset_subroutines (local_subrs, font.GlobalSubrs)
|
|
|
+
|
|
|
+ # Cleanup
|
|
|
+ for subrs in all_subrs:
|
|
|
+ del subrs._used, subrs._old_bias, subrs._new_bias
|
|
|
+
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('cmap'))
|
|
|
+def closure_glyphs(self, s):
|
|
|
+ tables = [t for t in self.tables if t.isUnicode()]
|
|
|
+
|
|
|
+ # Close glyphs
|
|
|
+ for table in tables:
|
|
|
+ if table.format == 14:
|
|
|
+ for cmap in table.uvsDict.values():
|
|
|
+ glyphs = {g for u,g in cmap if u in s.unicodes_requested}
|
|
|
+ if None in glyphs:
|
|
|
+ glyphs.remove(None)
|
|
|
+ s.glyphs.update(glyphs)
|
|
|
+ else:
|
|
|
+ cmap = table.cmap
|
|
|
+ intersection = s.unicodes_requested.intersection(cmap.keys())
|
|
|
+ s.glyphs.update(cmap[u] for u in intersection)
|
|
|
+
|
|
|
+ # Calculate unicodes_missing
|
|
|
+ s.unicodes_missing = s.unicodes_requested.copy()
|
|
|
+ for table in tables:
|
|
|
+ s.unicodes_missing.difference_update(table.cmap)
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('cmap'))
|
|
|
+def prune_pre_subset(self, options):
|
|
|
+ if not options.legacy_cmap:
|
|
|
+ # Drop non-Unicode / non-Symbol cmaps
|
|
|
+ self.tables = [t for t in self.tables if t.isUnicode() or t.isSymbol()]
|
|
|
+ if not options.symbol_cmap:
|
|
|
+ self.tables = [t for t in self.tables if not t.isSymbol()]
|
|
|
+ # TODO(behdad) Only keep one subtable?
|
|
|
+ # For now, drop format=0 which can't be subset_glyphs easily?
|
|
|
+ self.tables = [t for t in self.tables if t.format != 0]
|
|
|
+ self.numSubTables = len(self.tables)
|
|
|
+ return True # Required table
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('cmap'))
|
|
|
+def subset_glyphs(self, s):
|
|
|
+ s.glyphs = None # We use s.glyphs_requested and s.unicodes_requested only
|
|
|
+ for t in self.tables:
|
|
|
+ if t.format == 14:
|
|
|
+ # TODO(behdad) We drop all the default-UVS mappings
|
|
|
+ # for glyphs_requested. So it's the caller's responsibility to make
|
|
|
+ # sure those are included.
|
|
|
+ t.uvsDict = {v:[(u,g) for u,g in l
|
|
|
+ if g in s.glyphs_requested or u in s.unicodes_requested]
|
|
|
+ for v,l in t.uvsDict.items()}
|
|
|
+ t.uvsDict = {v:l for v,l in t.uvsDict.items() if l}
|
|
|
+ elif t.isUnicode():
|
|
|
+ t.cmap = {u:g for u,g in t.cmap.items()
|
|
|
+ if g in s.glyphs_requested or u in s.unicodes_requested}
|
|
|
+ else:
|
|
|
+ t.cmap = {u:g for u,g in t.cmap.items()
|
|
|
+ if g in s.glyphs_requested}
|
|
|
+ self.tables = [t for t in self.tables
|
|
|
+ if (t.cmap if t.format != 14 else t.uvsDict)]
|
|
|
+ self.numSubTables = len(self.tables)
|
|
|
+ # TODO(behdad) Convert formats when needed.
|
|
|
+ # In particular, if we have a format=12 without non-BMP
|
|
|
+ # characters, either drop format=12 one or convert it
|
|
|
+ # to format=4 if there's not one.
|
|
|
+ return True # Required table
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('DSIG'))
|
|
|
+def prune_pre_subset(self, options):
|
|
|
+ # Drop all signatures since they will be invalid
|
|
|
+ self.usNumSigs = 0
|
|
|
+ self.signatureRecords = []
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('maxp'))
|
|
|
+def prune_pre_subset(self, options):
|
|
|
+ if not options.hinting:
|
|
|
+ if self.tableVersion == 0x00010000:
|
|
|
+ self.maxZones = 1
|
|
|
+ self.maxTwilightPoints = 0
|
|
|
+ self.maxFunctionDefs = 0
|
|
|
+ self.maxInstructionDefs = 0
|
|
|
+ self.maxStackElements = 0
|
|
|
+ self.maxSizeOfInstructions = 0
|
|
|
+ return True
|
|
|
+
|
|
|
+@_add_method(ttLib.getTableClass('name'))
|
|
|
+def prune_pre_subset(self, options):
|
|
|
+ if '*' not in options.name_IDs:
|
|
|
+ self.names = [n for n in self.names if n.nameID in options.name_IDs]
|
|
|
+ if not options.name_legacy:
|
|
|
+ # TODO(behdad) Sometimes (eg Apple Color Emoji) there's only a macroman
|
|
|
+ # entry for Latin and no Unicode names.
|
|
|
+ self.names = [n for n in self.names if n.isUnicode()]
|
|
|
+ # TODO(behdad) Option to keep only one platform's
|
|
|
+ if '*' not in options.name_languages:
|
|
|
+ # TODO(behdad) This is Windows-platform specific!
|
|
|
+ self.names = [n for n in self.names
|
|
|
+ if n.langID in options.name_languages]
|
|
|
+ if options.obfuscate_names:
|
|
|
+ namerecs = []
|
|
|
+ for n in self.names:
|
|
|
+ if n.nameID in [1, 4]:
|
|
|
+ n.string = ".\x7f".encode('utf_16_be') if n.isUnicode() else ".\x7f"
|
|
|
+ elif n.nameID in [2, 6]:
|
|
|
+ n.string = "\x7f".encode('utf_16_be') if n.isUnicode() else "\x7f"
|
|
|
+ elif n.nameID == 3:
|
|
|
+ n.string = ""
|
|
|
+ elif n.nameID in [16, 17, 18]:
|
|
|
+ continue
|
|
|
+ namerecs.append(n)
|
|
|
+ self.names = namerecs
|
|
|
+ return True # Required table
|
|
|
+
|
|
|
+
|
|
|
+# TODO(behdad) OS/2 ulUnicodeRange / ulCodePageRange?
|
|
|
+# TODO(behdad) Drop AAT tables.
|
|
|
+# TODO(behdad) Drop unneeded GSUB/GPOS Script/LangSys entries.
|
|
|
+# TODO(behdad) Drop empty GSUB/GPOS, and GDEF if no GSUB/GPOS left
|
|
|
+# TODO(behdad) Drop GDEF subitems if unused by lookups
|
|
|
+# TODO(behdad) Avoid recursing too much (in GSUB/GPOS and in CFF)
|
|
|
+# TODO(behdad) Text direction considerations.
|
|
|
+# TODO(behdad) Text script / language considerations.
|
|
|
+# TODO(behdad) Optionally drop 'kern' table if GPOS available
|
|
|
+# TODO(behdad) Implement --unicode='*' to choose all cmap'ed
|
|
|
+# TODO(behdad) Drop old-spec Indic scripts
|
|
|
+
|
|
|
+
|
|
|
+class Options(object):
|
|
|
+
|
|
|
+ class OptionError(Exception): pass
|
|
|
+ class UnknownOptionError(OptionError): pass
|
|
|
+
|
|
|
+ _drop_tables_default = ['BASE', 'JSTF', 'DSIG', 'EBDT', 'EBLC',
|
|
|
+ 'EBSC', 'SVG ', 'PCLT', 'LTSH']
|
|
|
+ _drop_tables_default += ['Feat', 'Glat', 'Gloc', 'Silf', 'Sill'] # Graphite
|
|
|
+ _drop_tables_default += ['CBLC', 'CBDT', 'sbix', 'COLR', 'CPAL'] # Color
|
|
|
+ _no_subset_tables_default = ['gasp', 'head', 'hhea', 'maxp',
|
|
|
+ 'vhea', 'OS/2', 'loca', 'name', 'cvt ',
|
|
|
+ 'fpgm', 'prep', 'VDMX', 'DSIG']
|
|
|
+ _hinting_tables_default = ['cvt ', 'fpgm', 'prep', 'hdmx', 'VDMX']
|
|
|
+
|
|
|
+ # Based on HarfBuzz shapers
|
|
|
+ _layout_features_groups = {
|
|
|
+ # Default shaper
|
|
|
+ 'common': ['ccmp', 'liga', 'locl', 'mark', 'mkmk', 'rlig'],
|
|
|
+ 'horizontal': ['calt', 'clig', 'curs', 'kern', 'rclt'],
|
|
|
+ 'vertical': ['valt', 'vert', 'vkrn', 'vpal', 'vrt2'],
|
|
|
+ 'ltr': ['ltra', 'ltrm'],
|
|
|
+ 'rtl': ['rtla', 'rtlm'],
|
|
|
+ # Complex shapers
|
|
|
+ 'arabic': ['init', 'medi', 'fina', 'isol', 'med2', 'fin2', 'fin3',
|
|
|
+ 'cswh', 'mset'],
|
|
|
+ 'hangul': ['ljmo', 'vjmo', 'tjmo'],
|
|
|
+ 'tibetan': ['abvs', 'blws', 'abvm', 'blwm'],
|
|
|
+ 'indic': ['nukt', 'akhn', 'rphf', 'rkrf', 'pref', 'blwf', 'half',
|
|
|
+ 'abvf', 'pstf', 'cfar', 'vatu', 'cjct', 'init', 'pres',
|
|
|
+ 'abvs', 'blws', 'psts', 'haln', 'dist', 'abvm', 'blwm'],
|
|
|
+ }
|
|
|
+ _layout_features_default = _uniq_sort(sum(
|
|
|
+ iter(_layout_features_groups.values()), []))
|
|
|
+
|
|
|
+ drop_tables = _drop_tables_default
|
|
|
+ no_subset_tables = _no_subset_tables_default
|
|
|
+ hinting_tables = _hinting_tables_default
|
|
|
+ legacy_kern = False # drop 'kern' table if GPOS available
|
|
|
+ layout_features = _layout_features_default
|
|
|
+ ignore_missing_glyphs = False
|
|
|
+ ignore_missing_unicodes = True
|
|
|
+ hinting = True
|
|
|
+ glyph_names = False
|
|
|
+ legacy_cmap = False
|
|
|
+ symbol_cmap = False
|
|
|
+ name_IDs = [1, 2] # Family and Style
|
|
|
+ name_legacy = False
|
|
|
+ name_languages = [0x0409] # English
|
|
|
+ obfuscate_names = False # to make webfont unusable as a system font
|
|
|
+ notdef_glyph = True # gid0 for TrueType / .notdef for CFF
|
|
|
+ notdef_outline = False # No need for notdef to have an outline really
|
|
|
+ recommended_glyphs = False # gid1, gid2, gid3 for TrueType
|
|
|
+ recalc_bounds = False # Recalculate font bounding boxes
|
|
|
+ recalc_timestamp = False # Recalculate font modified timestamp
|
|
|
+ canonical_order = False # Order tables as recommended
|
|
|
+ flavor = None # May be 'woff' or 'woff2'
|
|
|
+ desubroutinize = False # Desubroutinize CFF CharStrings
|
|
|
+
|
|
|
+ def __init__(self, **kwargs):
|
|
|
+ self.set(**kwargs)
|
|
|
+
|
|
|
+ def set(self, **kwargs):
|
|
|
+ for k,v in kwargs.items():
|
|
|
+ if not hasattr(self, k):
|
|
|
+ raise self.UnknownOptionError("Unknown option '%s'" % k)
|
|
|
+ setattr(self, k, v)
|
|
|
+
|
|
|
+ def parse_opts(self, argv, ignore_unknown=False):
|
|
|
+ ret = []
|
|
|
+ for a in argv:
|
|
|
+ orig_a = a
|
|
|
+ if not a.startswith('--'):
|
|
|
+ ret.append(a)
|
|
|
+ continue
|
|
|
+ a = a[2:]
|
|
|
+ i = a.find('=')
|
|
|
+ op = '='
|
|
|
+ if i == -1:
|
|
|
+ if a.startswith("no-"):
|
|
|
+ k = a[3:]
|
|
|
+ v = False
|
|
|
+ else:
|
|
|
+ k = a
|
|
|
+ v = True
|
|
|
+ if k.endswith("?"):
|
|
|
+ k = k[:-1]
|
|
|
+ v = '?'
|
|
|
+ else:
|
|
|
+ k = a[:i]
|
|
|
+ if k[-1] in "-+":
|
|
|
+ op = k[-1]+'=' # Op is '-=' or '+=' now.
|
|
|
+ k = k[:-1]
|
|
|
+ v = a[i+1:]
|
|
|
+ ok = k
|
|
|
+ k = k.replace('-', '_')
|
|
|
+ if not hasattr(self, k):
|
|
|
+ if ignore_unknown is True or ok in ignore_unknown:
|
|
|
+ ret.append(orig_a)
|
|
|
+ continue
|
|
|
+ else:
|
|
|
+ raise self.UnknownOptionError("Unknown option '%s'" % a)
|
|
|
+
|
|
|
+ ov = getattr(self, k)
|
|
|
+ if v == '?':
|
|
|
+ print("Current setting for '%s' is: %s" % (ok, ov))
|
|
|
+ continue
|
|
|
+ if isinstance(ov, bool):
|
|
|
+ v = bool(v)
|
|
|
+ elif isinstance(ov, int):
|
|
|
+ v = int(v)
|
|
|
+ elif isinstance(ov, str):
|
|
|
+ v = str(v) # redundant
|
|
|
+ elif isinstance(ov, list):
|
|
|
+ if isinstance(v, bool):
|
|
|
+ raise self.OptionError("Option '%s' requires values to be specified using '='" % a)
|
|
|
+ vv = v.replace(',', ' ').split()
|
|
|
+ if vv == ['']:
|
|
|
+ vv = []
|
|
|
+ vv = [int(x, 0) if len(x) and x[0] in "0123456789" else x for x in vv]
|
|
|
+ if op == '=':
|
|
|
+ v = vv
|
|
|
+ elif op == '+=':
|
|
|
+ v = ov
|
|
|
+ v.extend(vv)
|
|
|
+ elif op == '-=':
|
|
|
+ v = ov
|
|
|
+ for x in vv:
|
|
|
+ if x in v:
|
|
|
+ v.remove(x)
|
|
|
+ else:
|
|
|
+ assert False
|
|
|
+
|
|
|
+ setattr(self, k, v)
|
|
|
+
|
|
|
+ return ret
|
|
|
+
|
|
|
+
|
|
|
+class Subsetter(object):
|
|
|
+
|
|
|
+ class SubsettingError(Exception): pass
|
|
|
+ class MissingGlyphsSubsettingError(SubsettingError): pass
|
|
|
+ class MissingUnicodesSubsettingError(SubsettingError): pass
|
|
|
+
|
|
|
+ def __init__(self, options=None, log=None):
|
|
|
+
|
|
|
+ if not log:
|
|
|
+ log = Logger()
|
|
|
+ if not options:
|
|
|
+ options = Options()
|
|
|
+
|
|
|
+ self.options = options
|
|
|
+ self.log = log
|
|
|
+ self.unicodes_requested = set()
|
|
|
+ self.glyph_names_requested = set()
|
|
|
+ self.glyph_ids_requested = set()
|
|
|
+
|
|
|
+ def populate(self, glyphs=[], gids=[], unicodes=[], text=""):
|
|
|
+ self.unicodes_requested.update(unicodes)
|
|
|
+ if isinstance(text, bytes):
|
|
|
+ text = text.decode("utf_8")
|
|
|
+ for u in text:
|
|
|
+ self.unicodes_requested.add(ord(u))
|
|
|
+ self.glyph_names_requested.update(glyphs)
|
|
|
+ self.glyph_ids_requested.update(gids)
|
|
|
+
|
|
|
+ def _prune_pre_subset(self, font):
|
|
|
+
|
|
|
+ for tag in font.keys():
|
|
|
+ if tag == 'GlyphOrder': continue
|
|
|
+
|
|
|
+ if(tag in self.options.drop_tables or
|
|
|
+ (tag in self.options.hinting_tables and not self.options.hinting) or
|
|
|
+ (tag == 'kern' and (not self.options.legacy_kern and 'GPOS' in font))):
|
|
|
+ self.log(tag, "dropped")
|
|
|
+ del font[tag]
|
|
|
+ continue
|
|
|
+
|
|
|
+ clazz = ttLib.getTableClass(tag)
|
|
|
+
|
|
|
+ if hasattr(clazz, 'prune_pre_subset'):
|
|
|
+ table = font[tag]
|
|
|
+ self.log.lapse("load '%s'" % tag)
|
|
|
+ retain = table.prune_pre_subset(self.options)
|
|
|
+ self.log.lapse("prune '%s'" % tag)
|
|
|
+ if not retain:
|
|
|
+ self.log(tag, "pruned to empty; dropped")
|
|
|
+ del font[tag]
|
|
|
+ continue
|
|
|
+ else:
|
|
|
+ self.log(tag, "pruned")
|
|
|
+
|
|
|
+ def _closure_glyphs(self, font):
|
|
|
+
|
|
|
+ realGlyphs = set(font.getGlyphOrder())
|
|
|
+ glyph_order = font.getGlyphOrder()
|
|
|
+
|
|
|
+ self.glyphs_requested = set()
|
|
|
+ self.glyphs_requested.update(self.glyph_names_requested)
|
|
|
+ self.glyphs_requested.update(glyph_order[i]
|
|
|
+ for i in self.glyph_ids_requested
|
|
|
+ if i < len(glyph_order))
|
|
|
+
|
|
|
+ self.glyphs_missing = set()
|
|
|
+ self.glyphs_missing.update(self.glyphs_requested.difference(realGlyphs))
|
|
|
+ self.glyphs_missing.update(i for i in self.glyph_ids_requested
|
|
|
+ if i >= len(glyph_order))
|
|
|
+ if self.glyphs_missing:
|
|
|
+ self.log("Missing requested glyphs: %s" % self.glyphs_missing)
|
|
|
+ if not self.options.ignore_missing_glyphs:
|
|
|
+ raise self.MissingGlyphsSubsettingError(self.glyphs_missing)
|
|
|
+
|
|
|
+ self.glyphs = self.glyphs_requested.copy()
|
|
|
+
|
|
|
+ self.unicodes_missing = set()
|
|
|
+ if 'cmap' in font:
|
|
|
+ font['cmap'].closure_glyphs(self)
|
|
|
+ self.glyphs.intersection_update(realGlyphs)
|
|
|
+ self.log.lapse("close glyph list over 'cmap'")
|
|
|
+ self.glyphs_cmaped = frozenset(self.glyphs)
|
|
|
+ if self.unicodes_missing:
|
|
|
+ missing = ["U+%04X" % u for u in self.unicodes_missing]
|
|
|
+ self.log("Missing glyphs for requested Unicodes: %s" % missing)
|
|
|
+ if not self.options.ignore_missing_unicodes:
|
|
|
+ raise self.MissingUnicodesSubsettingError(missing)
|
|
|
+ del missing
|
|
|
+
|
|
|
+ if self.options.notdef_glyph:
|
|
|
+ if 'glyf' in font:
|
|
|
+ self.glyphs.add(font.getGlyphName(0))
|
|
|
+ self.log("Added gid0 to subset")
|
|
|
+ else:
|
|
|
+ self.glyphs.add('.notdef')
|
|
|
+ self.log("Added .notdef to subset")
|
|
|
+ if self.options.recommended_glyphs:
|
|
|
+ if 'glyf' in font:
|
|
|
+ for i in range(min(4, len(font.getGlyphOrder()))):
|
|
|
+ self.glyphs.add(font.getGlyphName(i))
|
|
|
+ self.log("Added first four glyphs to subset")
|
|
|
+
|
|
|
+ if 'GSUB' in font:
|
|
|
+ self.log("Closing glyph list over 'GSUB': %d glyphs before" %
|
|
|
+ len(self.glyphs))
|
|
|
+ self.log.glyphs(self.glyphs, font=font)
|
|
|
+ font['GSUB'].closure_glyphs(self)
|
|
|
+ self.glyphs.intersection_update(realGlyphs)
|
|
|
+ self.log("Closed glyph list over 'GSUB': %d glyphs after" %
|
|
|
+ len(self.glyphs))
|
|
|
+ self.log.glyphs(self.glyphs, font=font)
|
|
|
+ self.log.lapse("close glyph list over 'GSUB'")
|
|
|
+ self.glyphs_gsubed = frozenset(self.glyphs)
|
|
|
+
|
|
|
+ if 'glyf' in font:
|
|
|
+ self.log("Closing glyph list over 'glyf': %d glyphs before" %
|
|
|
+ len(self.glyphs))
|
|
|
+ self.log.glyphs(self.glyphs, font=font)
|
|
|
+ font['glyf'].closure_glyphs(self)
|
|
|
+ self.glyphs.intersection_update(realGlyphs)
|
|
|
+ self.log("Closed glyph list over 'glyf': %d glyphs after" %
|
|
|
+ len(self.glyphs))
|
|
|
+ self.log.glyphs(self.glyphs, font=font)
|
|
|
+ self.log.lapse("close glyph list over 'glyf'")
|
|
|
+ self.glyphs_glyfed = frozenset(self.glyphs)
|
|
|
+
|
|
|
+ self.glyphs_all = frozenset(self.glyphs)
|
|
|
+
|
|
|
+ self.log("Retaining %d glyphs: " % len(self.glyphs_all))
|
|
|
+
|
|
|
+ del self.glyphs
|
|
|
+
|
|
|
+ def _subset_glyphs(self, font):
|
|
|
+ for tag in font.keys():
|
|
|
+ if tag == 'GlyphOrder': continue
|
|
|
+ clazz = ttLib.getTableClass(tag)
|
|
|
+
|
|
|
+ if tag in self.options.no_subset_tables:
|
|
|
+ self.log(tag, "subsetting not needed")
|
|
|
+ elif hasattr(clazz, 'subset_glyphs'):
|
|
|
+ table = font[tag]
|
|
|
+ self.glyphs = self.glyphs_all
|
|
|
+ retain = table.subset_glyphs(self)
|
|
|
+ del self.glyphs
|
|
|
+ self.log.lapse("subset '%s'" % tag)
|
|
|
+ if not retain:
|
|
|
+ self.log(tag, "subsetted to empty; dropped")
|
|
|
+ del font[tag]
|
|
|
+ else:
|
|
|
+ self.log(tag, "subsetted")
|
|
|
+ else:
|
|
|
+ self.log(tag, "NOT subset; don't know how to subset; dropped")
|
|
|
+ del font[tag]
|
|
|
+
|
|
|
+ glyphOrder = font.getGlyphOrder()
|
|
|
+ glyphOrder = [g for g in glyphOrder if g in self.glyphs_all]
|
|
|
+ font.setGlyphOrder(glyphOrder)
|
|
|
+ font._buildReverseGlyphOrderDict()
|
|
|
+ self.log.lapse("subset GlyphOrder")
|
|
|
+
|
|
|
+ def _prune_post_subset(self, font):
|
|
|
+ for tag in font.keys():
|
|
|
+ if tag == 'GlyphOrder': continue
|
|
|
+ clazz = ttLib.getTableClass(tag)
|
|
|
+ if hasattr(clazz, 'prune_post_subset'):
|
|
|
+ table = font[tag]
|
|
|
+ retain = table.prune_post_subset(self.options)
|
|
|
+ self.log.lapse("prune '%s'" % tag)
|
|
|
+ if not retain:
|
|
|
+ self.log(tag, "pruned to empty; dropped")
|
|
|
+ del font[tag]
|
|
|
+ else:
|
|
|
+ self.log(tag, "pruned")
|
|
|
+
|
|
|
+ def subset(self, font):
|
|
|
+
|
|
|
+ self._prune_pre_subset(font)
|
|
|
+ self._closure_glyphs(font)
|
|
|
+ self._subset_glyphs(font)
|
|
|
+ self._prune_post_subset(font)
|
|
|
+
|
|
|
+
|
|
|
+class Logger(object):
|
|
|
+
|
|
|
+ def __init__(self, verbose=False, xml=False, timing=False):
|
|
|
+ self.verbose = verbose
|
|
|
+ self.xml = xml
|
|
|
+ self.timing = timing
|
|
|
+ self.last_time = self.start_time = time.time()
|
|
|
+
|
|
|
+ def parse_opts(self, argv):
|
|
|
+ argv = argv[:]
|
|
|
+ for v in ['verbose', 'xml', 'timing']:
|
|
|
+ if "--"+v in argv:
|
|
|
+ setattr(self, v, True)
|
|
|
+ argv.remove("--"+v)
|
|
|
+ return argv
|
|
|
+
|
|
|
+ def __call__(self, *things):
|
|
|
+ if not self.verbose:
|
|
|
+ return
|
|
|
+ print(' '.join(str(x) for x in things))
|
|
|
+
|
|
|
+ def lapse(self, *things):
|
|
|
+ if not self.timing:
|
|
|
+ return
|
|
|
+ new_time = time.time()
|
|
|
+ print("Took %0.3fs to %s" %(new_time - self.last_time,
|
|
|
+ ' '.join(str(x) for x in things)))
|
|
|
+ self.last_time = new_time
|
|
|
+
|
|
|
+ def glyphs(self, glyphs, font=None):
|
|
|
+ if not self.verbose:
|
|
|
+ return
|
|
|
+ self("Glyph names:", sorted(glyphs))
|
|
|
+ if font:
|
|
|
+ reverseGlyphMap = font.getReverseGlyphMap()
|
|
|
+ self("Glyph IDs: ", sorted(reverseGlyphMap[g] for g in glyphs))
|
|
|
+
|
|
|
+ def font(self, font, file=sys.stdout):
|
|
|
+ if not self.xml:
|
|
|
+ return
|
|
|
+ from fontTools.misc import xmlWriter
|
|
|
+ writer = xmlWriter.XMLWriter(file)
|
|
|
+ for tag in font.keys():
|
|
|
+ writer.begintag(tag)
|
|
|
+ writer.newline()
|
|
|
+ font[tag].toXML(writer, font)
|
|
|
+ writer.endtag(tag)
|
|
|
+ writer.newline()
|
|
|
+
|
|
|
+
|
|
|
+def load_font(fontFile,
|
|
|
+ options,
|
|
|
+ allowVID=False,
|
|
|
+ checkChecksums=False,
|
|
|
+ dontLoadGlyphNames=False,
|
|
|
+ lazy=True):
|
|
|
+
|
|
|
+ font = ttLib.TTFont(fontFile,
|
|
|
+ allowVID=allowVID,
|
|
|
+ checkChecksums=checkChecksums,
|
|
|
+ recalcBBoxes=options.recalc_bounds,
|
|
|
+ recalcTimestamp=options.recalc_timestamp,
|
|
|
+ lazy=lazy)
|
|
|
+
|
|
|
+ # Hack:
|
|
|
+ #
|
|
|
+ # If we don't need glyph names, change 'post' class to not try to
|
|
|
+ # load them. It avoid lots of headache with broken fonts as well
|
|
|
+ # as loading time.
|
|
|
+ #
|
|
|
+ # Ideally ttLib should provide a way to ask it to skip loading
|
|
|
+ # glyph names. But it currently doesn't provide such a thing.
|
|
|
+ #
|
|
|
+ if dontLoadGlyphNames:
|
|
|
+ post = ttLib.getTableClass('post')
|
|
|
+ saved = post.decode_format_2_0
|
|
|
+ post.decode_format_2_0 = post.decode_format_3_0
|
|
|
+ f = font['post']
|
|
|
+ if f.formatType == 2.0:
|
|
|
+ f.formatType = 3.0
|
|
|
+ post.decode_format_2_0 = saved
|
|
|
+
|
|
|
+ return font
|
|
|
+
|
|
|
+def save_font(font, outfile, options):
|
|
|
+ if options.flavor and not hasattr(font, 'flavor'):
|
|
|
+ raise Exception("fonttools version does not support flavors.")
|
|
|
+ font.flavor = options.flavor
|
|
|
+ font.save(outfile, reorderTables=options.canonical_order)
|
|
|
+
|
|
|
+def parse_unicodes(s):
|
|
|
+ import re
|
|
|
+ s = re.sub (r"0[xX]", " ", s)
|
|
|
+ s = re.sub (r"[<+>,;&#\\xXuU\n ]", " ", s)
|
|
|
+ l = []
|
|
|
+ for item in s.split():
|
|
|
+ fields = item.split('-')
|
|
|
+ if len(fields) == 1:
|
|
|
+ l.append(int(item, 16))
|
|
|
+ else:
|
|
|
+ start,end = fields
|
|
|
+ l.extend(range(int(start, 16), int(end, 16)+1))
|
|
|
+ return l
|
|
|
+
|
|
|
+def parse_gids(s):
|
|
|
+ l = []
|
|
|
+ for item in s.replace(',', ' ').split():
|
|
|
+ fields = item.split('-')
|
|
|
+ if len(fields) == 1:
|
|
|
+ l.append(int(fields[0]))
|
|
|
+ else:
|
|
|
+ l.extend(range(int(fields[0]), int(fields[1])+1))
|
|
|
+ return l
|
|
|
+
|
|
|
+def parse_glyphs(s):
|
|
|
+ return s.replace(',', ' ').split()
|
|
|
+
|
|
|
+def main(args=None):
|
|
|
+
|
|
|
+ if args is None:
|
|
|
+ args = sys.argv[1:]
|
|
|
+
|
|
|
+ if '--help' in args:
|
|
|
+ print(__doc__)
|
|
|
+ sys.exit(0)
|
|
|
+
|
|
|
+ log = Logger()
|
|
|
+ args = log.parse_opts(args)
|
|
|
+
|
|
|
+ options = Options()
|
|
|
+ args = options.parse_opts(args,
|
|
|
+ ignore_unknown=['gids', 'gids-file',
|
|
|
+ 'glyphs', 'glyphs-file',
|
|
|
+ 'text', 'text-file',
|
|
|
+ 'unicodes', 'unicodes-file',
|
|
|
+ 'output-file'])
|
|
|
+
|
|
|
+ if len(args) < 2:
|
|
|
+ print("usage:", __usage__, file=sys.stderr)
|
|
|
+ print("Try pyftsubset --help for more information.", file=sys.stderr)
|
|
|
+ sys.exit(1)
|
|
|
+
|
|
|
+ fontfile = args[0]
|
|
|
+ args = args[1:]
|
|
|
+
|
|
|
+ subsetter = Subsetter(options=options, log=log)
|
|
|
+ outfile = fontfile + '.subset'
|
|
|
+ glyphs = []
|
|
|
+ gids = []
|
|
|
+ unicodes = []
|
|
|
+ wildcard_glyphs = False
|
|
|
+ wildcard_unicodes = False
|
|
|
+ text = ""
|
|
|
+ for g in args:
|
|
|
+ if g == '*':
|
|
|
+ wildcard_glyphs = True
|
|
|
+ continue
|
|
|
+ if g.startswith('--output-file='):
|
|
|
+ outfile = g[14:]
|
|
|
+ continue
|
|
|
+ if g.startswith('--text='):
|
|
|
+ text += g[7:]
|
|
|
+ continue
|
|
|
+ if g.startswith('--text-file='):
|
|
|
+ text += open(g[12:]).read().replace('\n', '')
|
|
|
+ continue
|
|
|
+ if g.startswith('--unicodes='):
|
|
|
+ if g[11:] == '*':
|
|
|
+ wildcard_unicodes = True
|
|
|
+ else:
|
|
|
+ unicodes.extend(parse_unicodes(g[11:]))
|
|
|
+ continue
|
|
|
+ if g.startswith('--unicodes-file='):
|
|
|
+ for line in open(g[16:]).readlines():
|
|
|
+ unicodes.extend(parse_unicodes(line.split('#')[0]))
|
|
|
+ continue
|
|
|
+ if g.startswith('--gids='):
|
|
|
+ gids.extend(parse_gids(g[7:]))
|
|
|
+ continue
|
|
|
+ if g.startswith('--gids-file='):
|
|
|
+ for line in open(g[12:]).readlines():
|
|
|
+ gids.extend(parse_gids(line.split('#')[0]))
|
|
|
+ continue
|
|
|
+ if g.startswith('--glyphs='):
|
|
|
+ if g[9:] == '*':
|
|
|
+ wildcard_glyphs = True
|
|
|
+ else:
|
|
|
+ glyphs.extend(parse_glyphs(g[9:]))
|
|
|
+ continue
|
|
|
+ if g.startswith('--glyphs-file='):
|
|
|
+ for line in open(g[14:]).readlines():
|
|
|
+ glyphs.extend(parse_glyphs(line.split('#')[0]))
|
|
|
+ continue
|
|
|
+ glyphs.append(g)
|
|
|
+
|
|
|
+ dontLoadGlyphNames = not options.glyph_names and not glyphs
|
|
|
+ font = load_font(fontfile, options, dontLoadGlyphNames=dontLoadGlyphNames)
|
|
|
+ log.lapse("load font")
|
|
|
+ if wildcard_glyphs:
|
|
|
+ glyphs.extend(font.getGlyphOrder())
|
|
|
+ if wildcard_unicodes:
|
|
|
+ for t in font['cmap'].tables:
|
|
|
+ if t.isUnicode():
|
|
|
+ unicodes.extend(t.cmap.keys())
|
|
|
+ assert '' not in glyphs
|
|
|
+
|
|
|
+ log.lapse("compile glyph list")
|
|
|
+ log("Text: '%s'" % text)
|
|
|
+ log("Unicodes:", unicodes)
|
|
|
+ log("Glyphs:", glyphs)
|
|
|
+ log("Gids:", gids)
|
|
|
+
|
|
|
+ subsetter.populate(glyphs=glyphs, gids=gids, unicodes=unicodes, text=text)
|
|
|
+ subsetter.subset(font)
|
|
|
+
|
|
|
+ save_font (font, outfile, options)
|
|
|
+ log.lapse("compile and save font")
|
|
|
+
|
|
|
+ log.last_time = log.start_time
|
|
|
+ log.lapse("make one with everything(TOTAL TIME)")
|
|
|
+
|
|
|
+ if log.verbose:
|
|
|
+ import os
|
|
|
+ log("Input font:% 7d bytes: %s" % (os.path.getsize(fontfile), fontfile))
|
|
|
+ log("Subset font:% 7d bytes: %s" % (os.path.getsize(outfile), outfile))
|
|
|
+
|
|
|
+ log.font(font)
|
|
|
+
|
|
|
+ font.close()
|
|
|
+
|
|
|
+
|
|
|
+__all__ = [
|
|
|
+ 'Options',
|
|
|
+ 'Subsetter',
|
|
|
+ 'Logger',
|
|
|
+ 'load_font',
|
|
|
+ 'save_font',
|
|
|
+ 'parse_gids',
|
|
|
+ 'parse_glyphs',
|
|
|
+ 'parse_unicodes',
|
|
|
+ 'main'
|
|
|
+]
|
|
|
+
|
|
|
+if __name__ == '__main__':
|
|
|
+ main()
|
Chris Simpkins