OpenType Font utility - Index of

OpenType Font utility
Lars Hellström
2009/09/02–March 13, 2011
Abstract
An obstacle to using OpenType and other sfnt-housed fonts with TEX is
that the information is embedded in a binary file format and thus not easily
accessible for traditional tools such as fontinst. sfntutil aims to extract the
information in a more accessible text format, but leaves the task of making
a “TEX font” from it to other tools.
Contents
I Preparations 2
1 Preliminaries 2
2 Representation formats 3
2.1 TDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3 TEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
II Parsing OpenType (and friends) 14
3 Overall file structure 14
4 Generalities on parsing tables 21
4.1 Binary data parsing . . . . . . . . . . . . . . . . . . . . . . . . . . 27
5 head and OS/2 tables 29
5.1 The fdsc table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
5.2 The FNAM table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
6 hmtx, hhea, and maxp tables 34
6.1 The HFMX table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
7 post tables 38
1

8 name table 41
9 The cmap table 45
10 glyf and loca tables 50
11 kern tables 51
12 CFF tables 56
13 GPOS and GSUB tables 64
III Conversion to other formats 73
14 Generating PostScript CIDFonts 73
15 Conversion to fontinst metrics 83
15.1 Gathering glyph information . . . . . . . . . . . . . . . . . . . . . 83
15.2 Generating metrics . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
15.3 Overall control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
IV Putting it all together 87
16 The program 87
16.1 Generalities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
16.2 Specific commands . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Part I
Preparations
1 Preliminaries
Many 8.5-isms are relied heavily upon in the code below (particularly unsigned
numbers with binary scan), so Tcl 8.5 is a requirement.
1 〈∗pkg〉
2 package require Tcl 8.5
The md5 package (from tcllib) is used for computing XUID values.
3 package require md5 2.0
2

2 Representation formats
2.1 TDL
Parsed data is, as a rule, returned from the parser in an experimental format
tentatively called TDL for Tcl Data Language. This might look as follows:
sfnt-table tag head {
/fontRevision 3
/flags 0000000000000011
/unitsPerEm 1000
/created {Sun Sep 09 01:46:40 GMT 2001}
/modified {Sat Jan 10 13:37:04 GMT 2004}
/bbox 40 -4 922 664
macStyle italic 1
/lowestRecPPEM 6
/fontDirectionHint 2
/indexToLocFormat 0
/glyphDataFormat 0
}
The overall syntax of TDL code is the same as for a Tcl script, except that command
and variable substitutions are unsupported (the interpretation of unquoted
[ and $ characters is unspecified and can generally be expected to vary). “Command
names” generally specify what something is, whereas the data is found in
the arguments.
There is a rather strong correspondence of TDL to XML in that TDL “command
names” which can be names of XML elements—i.e., those that match the
regexp
[[:alpha:]_:][[:alnum:]_:.-]*
—are required to have the syntax
{name} {attribute} {value} ∗ {TDL code} ?
and correspond to an XML element by the same name, with the given explicit
attributes, and with contents of that element the XML which corresponds to the
given {TDL code} (or empty contents if that is omitted). Thus the sfnt-table
element above corresponds to a piece of XML code on the form
〈contents〉
and the macStyle element corresponds to the XML element
This is the primary mechanism in TDL for nesting data containers.
Command names which do not match the above regexp, particularly command
names which begin with ‘/’, need not (and typically will not) adhere to this syntax;
instead they may rely on position in argument sequence for identifying the
3

prettyTDL::theinterp
(slave interp.)
prettyTDL::prettyprint
(proc)
meaning of an argument. This often has the advantage of permitting a more succint
encoding of data than is possible in XML, and it also lends itself better to
the generation of TEX-parsable data, as TEX macros are heavily geared towards
positional syntax. Non-XML command names may still have a correspondence to
some XML element, but this correspondence must be set up separately for each
command.
A particular TDL command of the non-XML variety is ‘/’, which is used for
encoding character data. Its syntax is
/ {string} ∗
and the various {string}s are concatenated in the manner of append, i.e., without
space between them. Several / commands in sequence is equivalent to one with
the combined argument sequences.
Having specified that much, it is possible to define an operation on TDL data,
namely prettyprinting of it.
4 namespace eval prettyTDL {
The idea is that TDL data gets parsed by being evaluated in an empty slave
interpreter.
5 interp create -safe [list [namespace current]::theinterp]
6 theinterp hide namespace
7 theinterp invokehidden namespace delete ::
8 }
The central command point for prettyprinting is the prettyprint procedure,
which has the call syntax
prettyTDL::prettyprint {script} {option} {value} ∗
and returns the prettyprinting of the {script}. The supported {option}s are:
-indent Basic indent string for the code block. Defaults to the empty string.
-step Indent step, as a string to append to the -indent. Defaults to three spaces.
The way the prettyprinting works is that each command appends the prettyprinted
form of itself, preceded by the appropriate indentation and followed by
res (local var.) a newline, to the local variable res in this procedure. The local array O has two
O (local array) entries -indent and -step which contain the current values of these parameters.
9 proc prettyTDL::prettyprint {script args} {
10 set res ""
11 array set O {-indent "" -step { }}
12 array set O $args
13 theinterp eval $script
14 return $res
15 }
4

Since it’s a somewhat esoteric topic, it may be appropriate here to spell out how
the use of a slave interpreter interacts with the call stack: every interpreter has
a separate stack of contexts. Hence a master interpreter procedure that has an
alias in the slave interpreter will have variables of the prettyprint procedure at
upvar 1, if that slave interpeter alias was invoked as part of the prettyinterp\
eval $script. Therefore local prettyprint contexts can nest, even though
prettyinterp stays within the same global context throughout.
prettyTDL::unknown (proc) Via an alias, this procedure serves as the unknown handler in the prettyTDL::theinterp
slave interpreter.
16 prettyTDL::theinterp alias unknown\
[namespace current]::prettyTDL::unknown
Its call syntax is thus
prettyTDL::unknown {name} {argument} ∗
and its main task is to distinguish XML-style commands from the rest, as the
bodies of the former should be given special care when prettyprinting.
17 proc prettyTDL::unknown {name args} {
18 upvar 1 res res O O
19 switch -regexp -- $name {
20 {^[[:alpha:]_:][[:alnum:]_:.-]*$} {
21 if {[llength $args] % 2} then {
22 set body [lindex $args end]
23 set args [lreplace $args end end]
24 } else {
25 set body ""
26 }
27 append res $O(-indent) [linsert $args 0 $name]
28 if {[regexp {\S} $body]} then {
29 append res " \{\n" [
30 prettyprint $body {*}[array get O] -indent\
$O(-indent)$O(-step)
32 ] $O(-indent) \}
33 }
34 append res \n
35 }
36 default {
37 append res $O(-indent) [linsert $args 0 $name] \n
38 }
39 }
40 }
prettyTDL::slash (proc) For the ‘/’ TDL command, it is possible to do slightly better than for an arbitrary
non-XML command, since one can split multiline strings at newlines to preserve
the indentation. The logic is as follows: if an argument contains a newline (and
that argument is not the last being only a newline), then emit one ‘/’ command
for everything up to and including that newline, and process what comes after
5

it anew. The newline itself is expressed as a separate ‘\n’ argument (backslash
substitution).
41 proc prettyTDL::slash {args} {
42 upvar 1 res res O(-indent) indent
43 set L [list /]
44 for {set i 0} {$i < [llength $args]} {incr i} {
45 set n [string first \n [lindex $args $i]]
46 if {$n0} then {
51 lappend L [string range [lindex $args $i] 0 $n-1]
52 }
53 append res $indent $L { \n} \n
54 set L [list /]
55 lset args $i [string replace [lindex $args $i] 0 $n]
56 incr i -1
57 }
58 if {[llength $L] > 1} then {
59 append res $indent $L \n
60 }
61 }
62 prettyTDL::theinterp alias / [namespace current]::prettyTDL::slash
2.2 XML
Another useful operation is that of converting a TDL script to equivalent XML,
which is what the following does—or rather, it converts a TDL script to a list of
tdom data-trees. A data-tree is an encoding (using built-in Tcl data containers) of
general XML elements; technically it is a list on one of the two forms
{element-name} {attribute-dict} {children}
#text {character data}
where the {children} is again a list (possibly empty) of data-trees. The
{attribute-dict} is a dictionary mapping attribute names to their values, neither
of which have any quoting of special characters. Similarly, the {character data}
is text between tags, without any XML-quoting.
For XML-commands and the ‘/’ command, this conversion is obvious, but for
other non-XML commands some kind of XML encoding will have to be invented.
The basic method is to express those as TDL:cmd elements, which must conform
to the DTD fragment
6

TDL:cmd (XML element)
TDL:arg (XML element)
TDLtoXML::theinterp
(slave interp.)
In other words, the command name is made an attribute of the TDL:cmd element,
while the arguments appear in sequence as the character data contents of TDL:arg
elements. It may be observed that this makes the whitespace contents in TDL:arg
elements highly significant.
63 namespace eval TDLtoXML {
The implementation of this converter has very much in common with the TDL
prettyprinter. For example, it uses an empty slave interpreter for parsing TDL
scripts.
64 interp create -safe [list [namespace current]::theinterp]
65 theinterp hide namespace
66 theinterp invokehidden namespace delete ::
67 }
TDLtoXML::main (proc) The central command point for the conversion is the main procedure, which has
the call syntax
res (local var.)
TDLtoXML::main {script}
and returns the list of data-trees to which the {script} corresponds.
The way the conversion works is that each command appends the data-tree
form of itself, as a list element, to the local variable res in this procedure.
68 proc TDLtoXML::main {script} {
69 set res {}
70 theinterp eval $script
71 return $res
72 }
TDLtoXML::unknown (proc) Via an alias, this procedure serves as the unknown handler in the slave interpreter.
73 TDLtoXML::theinterp alias unknown [namespace current]::TDLtoXML::unknown
Its call syntax is thus
prettyTDL::unknown {name} {argument} ∗
and its main task is to distinguish XML-style commands from the rest, as they
convert to XML in rather different ways.
74 proc TDLtoXML::unknown {name args} {
75 switch -regexp -- $name {
76 {^[[:alpha:]_:][[:alnum:]_:.-]*$} {
77 set tree [list $name]
78 if {[llength $args] % 2} then {
79 lappend tree [lreplace $args end end]\
[main [lindex $args end]]
81 } else {
82 lappend tree $args {}
83 }
84 }
85 default {
7

86 set L {}
87 foreach arg $args {
88 lappend L [list TDL:arg {} [list [list \#text $arg]]]
89 }
90 set tree [list TDL:cmd [list name $name] $L]
91 }
92 }
93 uplevel 1 [list ::lappend res $tree]
94 }
TDLtoXML::slash (proc) The ‘/’ TDL command needs special treatment, since it should not be expressed
using TDL:cmd. The implementation here takes the easy route of making each
argument a separate #text item.
TDLtoXML::xml_from_trees
(proc)
95 proc TDLtoXML::slash {args} {
96 upvar 1 res res
97 foreach arg $args {
98 lappend res [list \#text $arg]
99 }
100 }
101 TDLtoXML::theinterp alias / [namespace current]::TDLtoXML::slash
Other commands may of course also have custom conversions to XML; the
above is merely the bare minimum needed to make the system work.
In order to convert data-trees to proper XML, one may use the tdom package, or
(in cases where readability is not an issue) use the following lightweight generator.
This procedure is the toplevel generator of XML code from a list of data-tree. The
call syntax is
TDLtoXML::xml_from_trees {list of trees} {option} {value} ∗
where {list of trees} of course is the list of those trees that should be converted
and the return value is XML code for the corresponding sequence of elements (and
whatever). The supported options are:
-nodesep Basic separator inserted between nodes of the trees; defaults to a newline.
Setting it to empty reduces the output size, but may well have the
effect of making the entire result a single very long line.
-indentstep An indentation step, defaults to being empty. Some repetition (corresponding
to nesting depth) of this string follows the -nodesep.
-charmap A dictionary of character to entity mappings used with string map
to quote problematic characters in XML character data. Defaults to being
empty. The five syntax characters ‘’, ‘&’, ‘’’, and ‘"’ are automatically
inserted into this dictionary if they are not already there.
102 proc TDLtoXML::xml_from_trees {treeL args} {
103 array set Opt {
104 -nodesep \n
8

TDLtoXML:
:xml_from_treenode (proc)
105 -indentstep ""
106 -charmap {}
107 }
108 array set Opt $args
109 if {![dict size $Opt(-charmap)]} then {
110 set Opt(-charmap) {< &lt; > &gt; & &amp; ’ &apos; \" &quot;}
111 } else {
112 foreach char {< > & ’ \"} entity {&lt; &gt; &amp; &apos; &quot;} {
113 if {![dict exists $O(-charmap) $char]} then {
114 dict set $O(-charmap) $char $entity
115 }
116 }
117 }
118 set res ""
119 foreach tree $treeL {
120 append res [
121 xml_from_treenode $tree $Opt(-nodesep) $Opt(-indentstep)\
$Opt(-charmap)
123 ]
124 }
125 return $res
126 }
This is a more internal procedure that generates the XML fragment for a particular
branch of the tree. The call syntax is
xml_from_treenode {branch} {node-sep} {indent-step} {char-map}
Not surprisingly, it relies on recursion to convert the tree as a whole.
127 proc TDLtoXML::xml_from_treenode {tree sep indent map} {
128 switch -- [lindex $tree 0] "#text" - "#cdata" {
129 return [string map $map [lindex $tree 1]]
130 } "#comment" {
131 return ""
132 } "#pi" {
133 return ""
134 } "TDL:arg" {
A special case is added for TDL:arg elements, to preserve the amount of whitespace
there.
135 set sep ""
136 set indent ""
137 }
138 set res ""
9

TDLtoTeX::theinterp
(slave interp.)
145 foreach child [lindex $tree 2] {
146 append res $subsep\
[xml_from_treenode $child $subsep $indent $map]
148 }
149 append res $sep ""
150 } else {
151 append res "/>"
152 }
153 return $res
154 }
2.3 TEX
The model for the TEX-style output format is fontinst’s encoding and metric files,
i.e., elements are either atomic commands (with a fixed number of arguments)
or composite constructions with delimiting beginning-of and end-of commands.
Interesting content should as a rule have special purpose commands—if not for
some other reason, then because TEX is stricter with respect to what characters
are allowed in command names than XML and Tcl—but there are some general
translation mechanisms in force that can be useful for novel or unusual data structures.
155 namespace eval TDLtoTeX {
For the implementation, we need another interpreter.
156 interp create -safe [list [namespace current]::theinterp]
157 theinterp hide namespace
158 theinterp invokehidden namespace delete ::
159 }
An XML-style command {tag} can be converted to a block
\ELEMENT{〈tag〉}{
〈attributes〉
}
〈children〉
\ENDELEMENT{〈tag〉}
where an 〈attribute〉 is a command on the form
\ATTR{〈name〉}{〈value〉}
Likewise, a ‘/’ command can be converted to a sequence of
\TEXT{〈argument〉}
commands. Non-XML commands are on the other hand by default only included
as comments (in TDL form), since their variadic nature make them hard to map
to TEX commands without knowing their meanings.
The above incorporates some changes relative to its first form:
10

TDLtoTeX::quotechars
(proc)
• The 〈attributes〉 appear as an argument of \ELEMENT; they used to just be
a part of the element body. The reason for this change is that the original
approach would have made it rather difficult to write TEX macros that convert
the above back to TDL or XML: the \ELEMENT command would have
to rely on subsequent commands to complete its operation, since it cannot
know how many \ATTR will follow.
• The \ENDELEMENT did not have any argument. While not essential, it can
become easier to implement this command if the 〈tag〉 is supplied explicitly
(consider whether to map to \endsetglyph, \endsetslot, \endvarchar, or
whatever).
The 〈tag〉, 〈name〉, 〈value〉, and 〈argument〉 above are all basically strings, but
since TEX doesn’t have a distinguished strting type, it is necessary to clarify what
this means in terms of octets in a file. The basic rules are:
• Non-ASCII characters are UTF-8 encoded.
• ASCII characters of categories 11 (letter) and 12 (other) represent themselves.
• Spaces are represented as spaces in positions where they are not gobbled by
TEX’s parser, and by the control sequence \space otherwise.
• Control characters are for the moment ignored, in the hope that they won’t
occur where it would mess things up.
• Other characters are expressed using their L ATEX internal character representations,
which means
# becomes \#
$ becomes \$
% becomes \%
& becomes \&
^ becomes \textasciicircum
_ becomes \_
~ becomes \textasciitilde
\ becomes \textbackslash
{ becomes \{
} becomes \}
The use of \$, \_, \{, and \} here is not canonical, but these control sequences
are valid aliases for the characters in question, and should serve to
improve readability.
This procedure takes a string as argument and returns it with all special characters
LICR-quoted, as explained above. The first step is to replace anything sensitive
by its command equivalent. The ‘~’ character is temporarily used as an “end of
control sequence” marker, but will be turned into a proper space later.
160 proc TDLtoTeX::quotechars {str} {
11

161 set qstr [string map {
162 \# {\#} \$ {\$} % {\%} & {\&} ^ {\textasciicircum~} _ {\_}
163 ~ {\textasciitilde~} \\ {\textbackslash~} \{ {\{} \} {\}}
164 " " {\space~}
165 } $str]
The second step is to convert those \space~s that don’t follow a ~ to proper
spaces, since it is safe to do so and it enhances readability.
166 regsub -all {([^~])\\space~} $qstr {\1 } qstr
Next, all remaining ~ not followed by a letter can be dropped.
167 regsub -all {~([^A-Za-z])} $qstr {\1} qstr
Finally, all other ~ must be converted to proper spaces.
168 return [string map {~ { }} $qstr]
169 }
TDLtoTeX::main (proc) The central command point for TDL-to-TEX conversion is the main procedure,
which has the call syntax
TDLtoTeX::main {script} {option} {value} ∗
and returns the TEX counterpart of the {script}. The supported {option}s are:
-indent Basic indent string for the code block. Defaults to the empty string.
-step Indent step, as a string to append to the -indent. Defaults to two spaces.
The way the conversion works is that each command appends its own conversion,
preceded by the appropriate indentation and followed by a newline, to the
res (local var.) local variable res in this procedure. The local array O has two entries -indent
O (local array) and -step which contain the current values of these parameters.
170 proc TDLtoTeX::main {script args} {
171 set res ""
172 array set O {-indent "" -step { }}
173 array set O $args
174 theinterp eval $script
175 return $res
176 }
TDLtoTeX::unknown (proc) Via an alias, this procedure serves as the unknown handler in the TDLtoTeX::theinterp
slave interpreter.
177 TDLtoTeX::theinterp alias unknown [namespace current]::TDLtoTeX::unknown
Its call syntax is thus
TDLtoTeX::unknown {name} {argument} ∗
and its main task is to distinguish XML-style commands from the rest, as former
are converted but the latter are not.
178 proc TDLtoTeX::unknown {name args} {
179 upvar 1 res res O O
12

180 switch -regexp -- $name {
181 {^[[:alpha:]_:][[:alnum:]_:.-]*$} {
182 if {[llength $args] % 2} then {
183 set body [lindex $args end]
184 set args [lreplace $args end end]
185 } else {
186 set body ""
187 }
188 set tag [quotechars $name]
189 append res $O(-indent) "\\ELEMENT\{$tag\}\{"
190 set nextindent $O(-indent)$O(-step)
191 if {[llength $args]} then {append res \n}
192 foreach {key value} $args {
193 append res $nextindent "\\ATTR\{" [quotechars $key] "\}\{"\
[quotechars $value] "\}\n"
195 }
196 if {[llength $args]} then {append res $O(-indent)}
197 append res \}\n
198 append res [main $body {*}[array get O] -indent $nextindent]
199 append res $O(-indent) "\\ENDELEMENT\{$tag\}\n"
200 }
201 default {
202 append res $O(-indent) {% } [
203 string map [list \n "\n$O(-indent)% "]\
[linsert $args 0 $name]
204 ] \n
205 }
206 }
207 }
TDLtoTeX::slash (proc) The ‘/’ TDL command should
208 proc TDLtoTeX::slash {args} {
209 upvar 1 res res O O
210 foreach arg $args {
211 append res $O(-indent) "\\TEXT\{" [quotechars $arg] "\}\n"
212 }
213 }
214 TDLtoTeX::theinterp alias / [namespace current]::TDLtoTeX::slash
Many minor pieces of information scattered throughout the tables are likely to
be turned into fontinst \setint commands, so they are expressed in terms of the
TDL command
/setint {var-name} {number}
where {var-name} is equal to the corresponding fontinst integer variable name,
but {number} need not be an integer, although its value is converted to match
the fontinst counterpart.
13

TDLtoTeX::setint (proc) The main thing that needs to be done when converting a /setint element to a
\setint command is to round the {number}.
/dontsetint (element)
sfnt::parse_file_header
(proc)
215 namespace eval TDLtoTeX {
216 proc setint {varname number} {
217 uplevel 1 {::append res $O(-indent)} [list [
218 format {\setint{%s}{%d}} [quotechars $varname]\
[expr {round($number)}]
220 ] \n]
221 }
222 theinterp alias /setint [namespace current]::setint
223 }
Many other pieces of information are in some sense similar to the /setint
ones, but also highly unlikely to ever be of interest in the TEX context. These
can instead be encoded as /dontsetint commands, where the {var-name} should
usually be chosen equal to the OpenType/TrueType specification name for the
field.
/dontsetint {var-name} {number}
Part II
Parsing OpenType (and friends)
3 Overall file structure
The first problem when reading an OpenType font is to figure out where the
various tables are located. The basic parser returns a TDL representation of the
table directory, using the following elements:
sfnt-font tag {header tag} ? name {font name} ? {tables}
sfnt-table tag {tag} start {filepos} length {length} {contents} ?
The idea is that the sfnt-table elements might later be filled in with the actual
table contents, but one might just as well prefer keep a parsed form of the table
separate from the overall directory. Using a TDL format for this information
has the advantage that it extends nicely to TrueType Collection files (just return
several sfnt-font elements).
The general namespace for OpenType-related data is sfnt.
224 namespace eval sfnt {}
This procedure takes a channel (which must be readable, seekable, and configured
-translation binary) as argument, and returns the TDL form of the corresponding
sfnt-font element. In more detail, the call syntax is
parse_file_header {channel} {position} ? {base} ? {attribute}
{value} ∗ 14

where {position} defaults to 0 and is the position relative to the start of the file
where the sfnt header is expected. The {base} also defaults to 0 and is the base
position for whole-sfnt offsets; it would be nonzero if the file is embedded in a
larger file. Any additional arguments are treated as extra attribute–value pairs to
add to the sfnt-font element.
Calling parse_file_header typically has the side-effect of changing the current
position in {channel}.
The starting point is easy enough: read the initial tag, try to recognise it, and
proceed accordingly. Typically, a known OpenType tag is encountered, and we
can get on with the directory.
225 proc sfnt::parse_file_header {F {pos 0} {base 0} args} {
226 seek $F $pos
227 set tag [read $F 4]
228 switch -- $tag {
229 true {}
230 OTTO {}
231 \x00\x01\x00\x00 {set tag ver:1.0}
232 typ1 {}
It might also be a TrueType Collection file, in which case the component files are
read by recursive calls.
233 ttcf {
234 binary scan [read $F 8] SuH4Iu verMaj verMin numFonts
235 if {$verMaj2} then {
236 return -code error "Unknown TTC major version: $verMaj"
237 }
238 binary scan [read $F [expr {4*$numFonts}]] Iu*] offsetL
239 set dsig_pos [tell $F]
240 set res {}
241 foreach offset $offsetL {
242 append res\
[parse_file_header $F [expr {$base+$offset}] $base]
244 }
245 if {$verMaj==2} then {
246 seek $F $dsig_pos
247 binary scan [read $F 12] a4IuIu dsigTag ofs len
248 if {$dsigTag eq "DSIG"} then {
249 append res [list sfnt-table tag $dsigTag start\
[expr {$base+$ofs}] length $len] \n
251 }
252 }
253 return $res
254 }
The following are headers for AppleSingle and AppleDouble files, respectively. An
OpenType file might be found a few levels further down.
255 \x00\x05\x16\x00 - \x00\x05\x16\x07 {
256 return [parse_applesingle $F $pos]
257 }
15

If it’s not any of the above, then what could it be? Well, it could be a .dfont
file, i.e., a Macintosh Suitcase-in-datafork file. These don’t carry any magic number,
but one can apply some consistency checks on the header information: the
supposed beginnings of resource data or resource map can’t be before position 16
in the file, the supposed resource map and resource data blocks mustn’t overlap,
and they must fit within the file. If all that holds, we dare suppose that the file is
a (data-fork) resource file, and call on parse_resource_map to parse it for us.
258 default {
259 if {$pos==0} then {
260 binary scan $tag[read $F 12] IuIuIuIu resDataOfs resMapOfs\
resDataLen resMapLen
262 seek $F 0 end
263 set endpos [tell $F]
264 if {
265 $resDataOfs=16 &&\
$resDataOfs+$resDataLen

sfnt::parse_resfile_map
(proc)
Mac-resource (element)
293 append res \}\n
294 }
This procedure parses a Macintosh resource map, returning it as a list of tables not
unlike those of an OpenType font, but in the case of sfnt resources it additionally
invokes parse_file_header recursively to obtain the internal table structure. The
call syntax is
parse_resfile_map {channel} {data-start} {map-start} {data-len}
{map-len}
and the return value is a TDL representation of the resource map, in terms of
Mac-resource commands. These have the general element-command syntax, and
sport the following attributes:
type Four-character resource type.
ID Resource ID (16-bit integer).
name Resource string.
start File position of beginning of resource data.
length Length of resource data, in bytes.
295 proc sfnt::parse_resfile_map {F dataOfs mapOfs dataLen mapLen} {
296 seek $F $mapOfs
297 set resMap [read $F $mapLen]
298 binary scan $resMap @24SuSuS refBase nameBase numTypes
299 set refBase
300 set nameBase
301 set numTypes
302 set res ""
303 for {set i 0; set pos 30} {$i

sfnt::parse_applesingle
(proc)
315 if {$nameOfs != 0xFFFF} then {
316 set namePos [expr {$nameBase+$nameOfs}]
317 binary scan $resMap @${namePos}cu len
318 binary scan $resMap @${namePos}cua${len} "" name
319 lappend L name [encoding convertfrom macRoman $name]
320 }
321 if {$type eq "sfnt"} then {
322 set resPos [expr {$dataOfs+$start+4}]
323 append res [parse_file_header $F $resPos $resPos {*}$L]
324 } else {
325 set resPos [expr {$dataOfs+$start}]
326 seek $F $resPos
327 incr resPos 4
328 binary scan [read $F 4] Iu resLen
329 lappend L start $resPos length $resLen
330 append res [linsert $L 0 Mac-resource] \n
331 }
332 }
333 }
334 return $res
335 }
This procedure parses an AppleSingle or AppleDouble file into entities, and calls
parse_resfile_map to parse the resource fork in more detail. This provides
support for reading TrueType fonts stored in Mac OS resource forks that have
first undergone transportation into a single-forked file system.
The call syntax is
parse_applesingle {channel} {start}
AppleSingleEntity and the return value is a TDL script that is a sequence of AppleSingleEntity
(element) commands. These have the general element-command syntax, and sport the following
attributes:
id Name of fork or other information item: data, resource, real name, comment,
etc.
start File position of beginning of resource data.
length Length of resource data, in bytes.
/AppleSingleHomeFS There will also be an /AppleSingleHomeFS command that takes the name of the
(element) “home file system” as its only argument.
336 proc sfnt::parse_applesingle {F pos} {
337 seek $F $pos
338 binary scan [read $F 26] H8H8A16Su magic version filesys count
339 set res "\# Magic number: 0x$magic\n"
340 append res "\# Format version: $version" \n
341 append res [list /AppleSingleHomeFS $filesys] \n
342 binary scan [read $F [expr {12*$count}]] Iu* entityL
18

343 foreach {id offset length} $entityL {
344 append res [list AppleSingleEntity id [
345 if {$id0} {} {incr i -1
372 lappend stack [list $i]
373 }
374 while {[llength $stack]} {
375 set idx [lindex $stack end]
376 set stack [lreplace $stack [set stack end] end]
377 set item [lindex $treeL $idx]
378 switch -glob -- [lindex $item 0] {#*} {} sfnt-table {
379 set tag [dict get [lindex $item 1] tag]
380 set match 0
381 foreach pat $patL {
382 if {[string match $pat $tag]} then {
19

sfnt::combine_tables
(proc)
383 set match 1
384 break
385 }
386 }
387 if {$match} then {
388 seek $F [dict get [lindex $item 1] start]
389 lappend res $tag\
[read $F [dict get [lindex $item 1] length]]
391 }
392 } default {
393 for {set i [llength [lindex $item 2]]} {$i>0} {} {incr i -1
394 lappend stack [linsert $idx end 2 $i]
395 }
396 }
397 }
398 return $res
399 }
This procedure recombines a dictionary of tables within an sfnt wrapper structure.
The call syntax is
combine_tables {table-dict} {sfnt version}
and the return values is a list of bytearrays, the join (without padding) of which
will have a valid sfnt structure. The first element of the list contains the offset
table (i.e., file header) and table directory. Remaining elements contain the individual
tables in the same order as in the {table-dict}, but padded to be multiples
of four bytes long.
If one of the tables is a head table (which ought to be the case, since the result
isn’t a valid OpenType font without it) then the checkSumAdjustment field of
that table is updated as well.
The basic approach is to construct the result table by table, and in parallel
collect data for the first list element. Data which isn’t known from the start will be
corrected later. pos is the “current position” within the “file” being constructed.
dirD maps table tag to dictionaries of the remaining information needed for the
table directory.
400 proc sfnt::combine_tables {tableD sfntver} {
401 set res [list {}]
402 set numTables [dict size $tableD]
403 set pos [expr {12+16*$numTables}]
404 set dirD [dict create]
405 dict for {tag data} $tableD {
406 dict set dirD $tag offset $pos
407 dict set dirD $tag length [string length $data]
408 binary scan $data\0\0\0 Iu* wordL
409 if {$tag eq "head"} then {
410 lset wordL 2 0
411 set headidx [llength $res]
412 }
20

sfnt::〈table〉 (namespace)
413 dict set dirD $tag checkSum\
[expr {[::tcl::mathop::+ {*}$wordL] & 0xFFffFFff}]
415 lappend res [binary format Iu* $wordL]
416 incr pos [expr {4*[llength $wordL]}]
417 }
Now enough is known to construct the initial list element.
418 set entrySelector 0
419 set searchRange 16
420 for {set n $numTables} {$n>1} {set n [expr {$n/2}]} {
421 incr entrySelector
422 incr searchRange $searchRange
423 }
424 set data [binary format a4SuSuSuSu $sfntver $numTables $searchRange\
$entrySelector [expr {16*$numTables-$searchRange}]]
426 foreach tag [lsort [dict keys $dirD]] {
427 append data\
[binary format a4IuIuIu $tag [dict get $dirD $tag checkSum]\
[dict get $dirD $tag offset] [dict get $dirD $tag length]]
430 }
431 lset res 0 $data
Finally compute the overall checksum, if there was a head table.
432 if {[info exists headidx]} then {
433 binary scan $data Iu* wordL
434 set sum [tcl::mathop::+ {*}$wordL]
435 dict for {tag D} $dirD {
436 incr sum [dict get $D checkSum]
437 }
438 lset res $headidx [string replace [lindex $res $headidx] 8 11\
[binary format Iu [expr {(0xB1B0AFBA - $sum) & 0xFFffFFff}]]]
440 }
441 return $res
442 }
4 Generalities on parsing tables
In general, stuff that is useful for parsing 〈table〉 tables are kept in the
sfnt::〈table〉 namespace. In particular, an sfnt::〈table〉::parse procedure (if
it exists) will dump the table contents in TDL format.
A catch is that sometimes data in one table determines the interpretation of
data in another. In order to facilitate sharing of such data, commands that parse
particular tables take a {gdict} (for ‘global dict’) argument, which is a dictionary
where such globally relevant pieces of information can be placed. Some notable
entries are:
funit The length of an “funit” in AFM units (0.001 em).
numGlyphs The number of glyphs in the font.
21

sfnt::〈table〉:
:parse (proc)
The general syntax for a parse procedure is
parse {data} {gdict} {gdict-var} ?
where {data} is the table (a bytearray) to parse, and the return value is its translation
to TDL. The {gdict} is a dictionary of data parsed from other tables, and
the {gdict-var} is (if given) the name of a variable in the calling context which
should be set to a version of the {gdict} which is updated with information from
the {table} table.
Because of such dependencies, a {table} can specify that it should not be parsed
until some other tables have contributed their entries to the gdict. This is done
sfnt::〈table〉:
by defining a parse_after variable, whose value is the list of tables which should
:parse_after (var.) be parsed first.
sfnt::expand:
:interpreter (theinterp)
sfnt::expand:
:unknown res (local (proc) var.)
A useful operation on sfnt-font elements is to fill in their sfnt-tables with what
one gets from parsing them. This is implemented in the sfnt::expand namespace,
whose theinterp command is an empty interpreter set up to do precisely that
when evaluating the return value of e.g. parse_file_header.
443 namespace eval sfnt::expand {
444 interp create -safe [list [namespace current]::theinterp]
445 theinterp hide namespace
446 theinterp invokehidden namespace delete ::
As usual for TDL-to-TDL operations, the implementation of a command in the
slave interpreter is supposed to append the operation result to the res variable in
the master’s calling context. This is often the task of the unknown procedure, for
which the slave’s unknown command is an alias.
In order to permit more context than just the res variable to be available, this
unknown procedure makes an explicit uplevel for the recursion. To facilitate this,
the fully qualified name of theinterp is cached in the alias definition.
447 theinterp alias unknown [namespace current]::unknown\
[namespace current]::theinterp
449 }
The call syntax of this handler procedure is therefore
sfnt::expand::unknown {slave} {name} {argument} ∗
where {slave} is the name of the slave interpreter command to call.
The main task is to recurse over the bodies of XML-style commands, when
present and nonempty.
450 proc sfnt::expand::unknown {slave name args} {
451 upvar 1 res res
452 if {![
453 regexp {^[[:alpha:]_:][[:alnum:]_:.-]*$} $name
454 ] || [llength $args]%2 == 0} then {
455 append res [linsert $args 0 $name] \n
456 } else {
457 set body [lindex $args end]
22

sfnt-table command
sfnt::expand:
:sfnt-table (proc)
458 append res [linsert [lreplace $args end end] 0 $name]
459 if {[regexp {\S} $body]} then {
460 append res " \{\n"
461 uplevel 1 [list $slave eval $body]
462 append res \}
463 }
464 append res \n
465 }
466 }
Prehaps somewhat surprisingly, the expansion of a table is not handled by the
actual sfnt-table command; the reason for this is that the prescribed parsing
order for tables typically will not match the order they are given in. Therefore
it is necessary to rather let the surrounding sfnt-font command control the
parsing, and mostly restrict sfnt-table to storing away its attributes in the
table (local array) calling context. To that end, the table array in that context should have as index
the tag of a table and as value the dictionary of attributes of that table, including
the tag. If adding an entry to this array, the sfnt-table command need not
contribute anything to the res. Conversely, should the sfnt-table command
already have a nonempty body, then going the table route would throw away
information. Therefore the response in that case is to just append the sfnt-table
element as given to res (not processing the body any further).
table1L (local var.) In addition, the tag is appended to the table1L or table0L variable in the
table0L (local var.) calling context, the former of which is the list of tables to expand and the latter of
which is the list of tables to not expand. The purpose of having these lists, rather
than looking into the table array, is to preserve the given order of the tables to
the extent that it is compatible with parsing order.
467 proc sfnt::expand::sfnt-table {args} {
468 upvar 1 table table res res table1L table1L table0L table0L O O
469 if {[llength $args]%2} then {
470 set body [lindex $args end]
471 set args [lreplace $args [set args end] end]
472 } else {
473 set body ""
474 }
475 set tag [dict get $args tag]
476 if {$body eq ""} then {
477 set table($tag) $args
478 } else {
479 append res [list sfnt-table {*}$args $body] \n
480 }
The -which is an option of the main procedure, below.
481 foreach pat $O(-which) {
482 if {[string match $pat $tag]} then {
483 lappend table1L $tag
484 return
485 }
486 }
23

487 lappend table0L $tag
488 }
489 sfnt::expand::theinterp alias sfnt-table\
[namespace which sfnt::expand::sfnt-table]
/datum command A downside of not parsing already-parsed sfnt-tables is that one won’t get their
contributions to the gdict, so some other mechanism for providing that information
/datum (element) must be provided. To that end, the /datum command may be used to embed gdict
entries into the body of an sfnt-font. It has the syntax
gdict (local var.)
/datum {key} {value} ∗
and associates each given {key} with the corresponding {value}. There may be
several /datum commands, in which case their contributions are merged.
What the concrete /datum command does is that it acts on the gdict variable
in the master calling context, lappending the arguments (since that is likely to
be faster than a dict replace when there are several small appends). Also, this
avoids having to create a separate proc as alias target (though at the cost of
slightly weaker error-checking).
491 sfnt::expand::theinterp alias /datum ::lappend gdict
sfnt::expand::main (proc) Before going into the actual expansion of font tables, there is however the matter
of where the data is going to come from. Continuing with the pattern of “calling
thefile (local var.) context res” for returning results, one might declare that the thefile variable
in that context should hold a seekable channel with table data at the positions
specified by start attributes of sfnt-table elements.
Primarily responsible for setting the whole thing up is the main procedure,
which has the call syntax
O (local array)
sfnt-font command
sfnt::expand:
:sfnt-font (proc)
sfnt::expand::main {thefile} {TDL} {option} {value} ∗
and returns the expansion of the {TDL}. All options are dumped into the O array,
where other commands may access them. Currently the only option implemented
is:
-which Takes a list of string match patterns as argument. Only those tables
whose tags match one of these patterns will have been expanded in the
result. The default value is ‘*’, i.e., “expand everything”.
492 proc sfnt::expand::main {thefile TDL args} {
493 set res ""
494 array set O {-which *}
495 array set O $args
496 theinterp eval $TDL
497 return $res
498 }
To recap, the sfnt-font command has the syntax
sfnt-font {attribute} {value} ∗ {body} ?
24

where, for this to be of any use, the {body} should be present and contain several
sfnt-table elements (and possibly some /gdict elements). The {attribute}s are
mostly ignored (since parsing doesn’t depend on them), but should be preserved.
The first step is to process the {body}, thus collecting information about where
in thefile unparsed tables can be found.
499 proc sfnt::expand::sfnt-font {args} {
500 upvar 1 res res thefile thefile O O
501 if {[llength $args] % 2 == 0} then {
502 append res [linsert $args 0 sfnt-font] \n
503 return
504 }
505 append res [linsert [lrange $args 0 end-1] 0 sfnt-font] " \{\n"
506 set table0L {}
507 set table1L {}
Some very old (and probably broken) fonts manufactured by the Type1Enabler [?]
(they are PS type 1 fonts in an sfnt wrapper) lack a head table, but have kerns
that seem consistent with the AFM if the funit is 1, so let’s throw that in as a
default.
508 set gdict [dict create funit 1.0]
509 theinterp eval [lindex $args end]
The next step is to parse the tables. The idea here is that a table is assumed to
have been parsed if it does not have an entry in the table array, so it is safe to
proceed with parsing a table if it doesn’t have a parse_after list, or no item on
that list has an entry in the table array. This implies that table dependencies
are “soft”: if a table is missing from a font, then it never makes it into the table
array and will therefore not block the parsing of anything that depends on it.
Tables that don’t have a parser go into the noparseL list, the elements of which
are attribute dictionaries. Another such list is stack, which handles the nesting
that one table depends on another. By moving items from the table array to
the stack, it is possible to prevent dependency loops from creating infinite loops
here; a table counts as parsed as soon as the requirements for parsing it are being
considered, even though processing it might not happen for quite some time yet.
510 set noparseL {}
511 foreach tag $table1L {
512 if {![info exists table($tag)]} then {continue}
513 set stack [list $table($tag)]
514 unset table($tag)
515 while {[llength $stack]} {
516 set tag [dict get [lindex $stack end] tag]
517 if {[info exists [namespace parent]::${tag}::parse_after]}\
then {
519 set ok 1
520 foreach pretag\
[set [namespace parent]::${tag}::parse_after] {
522 if {[info exists table($pretag)]} then {
523 set ok 0
524 break
25

525 }
526 }
527 if {!$ok} then {
528 lappend stack $table($pretag)
529 unset table($pretag)
530 continue
531 }
532 }
At this point, the tag of a table which we are ready to parse has been determined,
but is there a parser for it?
533 set cmd [namespace which [namespace parent]::${tag}::parse]
534 if {$cmd eq ""} then {
535 lappend noparseL [lindex $stack end]
536 } else {
At this point, a parser has been found, so run it, but be prepared to catch any
errors that might arise when doing so.
537 set D [lindex $stack end]
538 append res [linsert $D 0 sfnt-table]
539 if {[catch {
540 seek $thefile [dict get $D start]
541 $cmd [read $thefile [dict get $D length]] $gdict gdict
542 } result]} then {
543 append res " \{\n" "# Error parsing table:\n# "\
[join [split $::errorInfo \n] "\n# "] \n\}
545 } else {
Having run the parser, it is now necessary to make another check whether to
include the data in the result. It may well happen that a wanted table depended
on one which wasn’t wanted.
546 set ok 0
547 foreach pat $O(-which) {
548 if {[string match $pat $tag]} then {
549 set ok 1; break
550 }
551 }
552 if {$ok} then {
553 append res " \{\n" $result \}
554 }
555 }
556 append res \n
557 }
558 set stack [lreplace $stack [set stack end] end]
559 }
560 }
The third step is to record the gdict entries. Entries whose names begin with #
are not included, so there one can put data which is of a more internal nature.
561 dict for {key value} $gdict {
562 if {[string match #* $key]} then {continue}
26

sfnt::parse_as_hexdump
(proc)
563 append res [list /datum $key $value] \n
564 }
The fourth step is to emit the unparsed tables from table0L. This is similar to
the second step, but much simpler.
565 foreach tag $table0L {
566 if {![info exists table($tag)]} then {continue}
567 append res [linsert $table($tag) 0 sfnt-table] \n
568 }
The final step is to emit the noparseL elements. A comment is placed in front of
these to explain their status.
569 if {[llength $noparseL]} then {
570 append res {# The following tables have no parsers:} \n
571 foreach D $noparseL {
572 append res [linsert $D 0 sfnt-table] \n
573 }
574 }
575 append res \}\n
576 }
577 sfnt::expand::theinterp alias sfnt-font\
[namespace which sfnt::expand::sfnt-font]
4.1 Binary data parsing
For tables without dedicated parsers, a way of at least showing the data can be
to do a hexdump of it. To that end, there is an element
/hexdump {offset} {byte} + {string}
which encodes the fact that the bytes at offset {offset} and forward are the {byte}s
(as far as these suffice). The {string} is an informative decoding of these bytes as
a string of text; that it is informative means one should not expect it to uniquely
determine the {byte}s, and different /hexdata may have used different encodings
for the {string}.
It should be noted that the {offset} is also in hexadecimal, without any ishexadecimal
prefix. This means it can be padded with zeroes to have the same
length as in neighbouring /hexdata lines.
This procedure can be used as a table parser, and generates /hexdump elements.
The call syntax is
sfnt::parse_as_hexdump {options} {data} {gdict} {gdict-var} ?
where the last two arguments are ignored. The {data} argument is the binary data
to parse. The {options} argument is a dictionary which can be used to configure
how the data should be parsed. The recognised entries are:
-bytesperline The number of {byte}s to put in each /hexdump element. Defaults
to 16.
27

sfnt:
:hexdump_char_from_byte
(proc)
-limit The maximal number of bytes to dump; since some tables can be very
large, you don’t want to hex-encode all of them. Defaults to 512 (giving 32
lines of 16 bytes each).
579 proc sfnt::parse_as_hexdump {options data gdict {gdictvar ""}} {
580 array set O {-limit 512 -bytesperline 16}
581 array set O $options
582 set last [expr {min([string length $data],$O(-limit))-1}]
583 set fspec %0[string length [format %03x $last]]x
584 set res ""
585 set byteL {}
586 set str {}
587 for {set pos 0} {$pos= $O(-bytesperline)} then {
596 append res { } [list $str] \n
597 set byteL {}
598 set str {}
599 }
600 }
601 if {[llength $byteL]} then {append res { } [list $str] \n}
602 if {[string length $data] > $pos} then {
603 append res [list /comment [format {%d bytes elided.}\
[expr {[string length $data] - $pos}]]] \n
605 }
606 return $res
607 }
This is a basic procedure which encodes a byte as a “string” character for a
/hexdump. Currently it just replaces anything non-visible-ASCII by ‘.’ (period).
608 proc sfnt::hexdump_char_from_byte {byte} {
609 if {$byte126} then {
610 return .
611 } else {
612 return [format %c $byte]
613 }
614 }
As a demo, here’s how to hexdump ENCO and TYP1 tables:
615 namespace eval sfnt::ENCO {
616 interp alias {} [namespace current]::parse {}\
[namespace parent]::parse_as_hexdump {}
618 }
619 namespace eval sfnt::TYP1 {
28

620 interp alias {} [namespace current]::parse {}\
[namespace parent]::parse_as_hexdump {}
622 }
5 head and OS/2 tables
623 namespace eval sfnt::head {}
sfnt::head::parse (proc) The call syntax of this procedure is
FontRevision (element)
/flag (element)
sfnt::head::parse {data} {gdict} {gdict-var} ?
The {gdict} is a dictionary of global font information, but values in it will be
overridden by what is in the {data}. If a {gdict-var} is specified, then the variable
in the calling context by that name will be set to the updated value of {gdict}.
624 proc sfnt::head::parse {data gdict {gdictvar ""}} {
625 binary scan $data H8H8IuH8B16SuWWS4B16SuSSS tableVersion\
fontRevision checkSumAdjustment magicNumber flags unitsPerEm\
created modified bbox macStyle lowestRecPPEM fontDirectionHint\
indexToLocFormat glyphDataFormat
629 set res ""
630 if {$tableVersion ne "00010000"} then {
631 append res "# Table version: 0x$tableVersion\n"
632 if {![string match 0001* $tableVersion]} then {return $res}
633 }
Font revision numbers are encoded in elements, but a complication is that the
underlying binary value is a Fixed, since the interpretation of this as a version
number . . . varies. Therefore attempts are made at several different interpretations,
and those that make sense are given as attributes.
634 set L [list FontRevision hex $fontRevision]
635 if {[regexp {^([0-9]{3})([0-9])([0-9])([0-9]{3})$} $fontRevision ""\
a b c d]} then {
637 lappend L bcd [string map {| ""} [string trim "$a|$b.$c|$d" 0]]
638 }
639 lappend L num\
[format %.4f [expr {[lindex [scan $fontRevision %x] 0] / 65536.0}]]
641 lappend L shortshort [format %d.%d {*}[scan $fontRevision %4x%4x]]
642 append res $L \n
The encoding of the various flag words is a tricky issue, since on one hand it’s
no good to have many different element names, and on the other it’s no good to
have complicated element syntaxes. The /flag element takes as its only argument
the name of a flag, and its presence signifies that this flag is set to 1, whereas its
absence would mean the flag is 0.
643 foreach bit [split $flags ""] name {
644 15 14 {Optimized for ClearType} {Font converted}
645 {MicroType lossless} {Has Indic-style rearrangement}
646 {Has strong right-to-left} {Has default metamorphosis}
29

647 {requires layout for correct linguistic rendering}
648 6 {Vertical baseline at x=0}
649 {Instructions may alter advance width} {Force ppem to integer}
650 {Instructions may depend on point size}
651 {Left sidebearing point at x=0} {Baseline at y=0}
652 } {
653 if {$bit} then {append res [list /flag $name] \n}
654 }
designunits
The unitsPerEm value is such a DESIGNUNITS, so its get encoding as setting the
designunits integer. Technically, the designunits fontinst variable happens to
(fontinst variable) be a dimen rather than an integer, but it’s only informational anyway.
/when (element)
/FontBBox (element)
655 append res [list /setint designunits $unitsPerEm] \n
656 dict set gdict funit [expr {1e3/$unitsPerEm}]
The /when element has two arguments: (the name for) the event it is a time of,
and the actual time in seconds since the Unix epoch.
657 append res [list /when created [expr {$created-2082844800}]] \n
658 append res [list /when modified [expr {$modified-2082844800}]] \n
The /FontBBox element has four arguments: min-x (left), min-y (bottom), maxx
(right), and max-y (top).
659 set L [list /FontBBox]
660 foreach c $bbox {
661 lappend L [expr {$c*[dict get $gdict funit]}]
662 }
663 append res $L \n
The Mac style is treated as another set of flags.
664 foreach bit [split $macStyle ""] name {
665 15 14 13 12 11 10 9 8 7
666 extended condensed shadow outline underline italic bold
667 } {
668 if {$bit} then {append res [list /flag $name] \n}
669 }
lowestReadablePPEM The lowestReadablePPEM value also gets encoded as a variable value.
(fontinst variable) 670 append res [list /dontsetint lowestRecPPEM $lowestRecPPEM] \n
fontDirectionHint The fontDirectionHint value says something about how much LTR or RTL the
(fontinst variable) font is, but the field is deprecated.
671 append res [list /dontsetint fontDirectionHint $fontDirectionHint] \n
The indexToLocFormat and glyphDataFormat are only of interest when parsing
other tables, so they are included in the output only as comments. indexToLoc-
Format is put in the gdict, however.
672 dict set gdict indexToLocFormat $indexToLocFormat
673 append res "\# indexToLocFormat is $indexToLocFormat.\n"
674 append res "\# glyphDataFormat is $glyphDataFormat.\n"
675 if {$gdictvar ne ""} then {
676 uplevel 1 [list ::set $gdictvar $gdict]
677 }
30

when command
TDLtoTeX::when (proc)
sfnt::OS/2:
:parse_after (var.)
678 return $res
679 }
The /when command can be TEXified as \comments.
680 namespace eval TDLtoTeX {
681 proc when {name time} {
682 uplevel 1 {::append res $O(-indent)} [list [
683 format {\comment{%s %s.}} [string totitle $name]\
[clock format $time -gmt 1]
685 ] \n]
686 }
687 theinterp alias /when [namespace which when]
688 }
Parsing OS/2 tables requires knowing the funit, so it must be done after head.
689 namespace eval sfnt::OS/2 {
690 variable parse_after head
691 }
sfnt::OS/2::parse (proc) The call syntax of this procedure is
linegap (fontinst integer)
sfnt::OS/2::parse {data} {gdict} {gdict-var} ?
The {gdict} is a dictionary of global font information, but values in it will be
overridden by what is in the {data}. If a {gdict-var} is specified, then the variable
in the calling context by that name will be set to the updated value of {gdict}.
692 proc sfnt::OS/2::parse {data gdict {gdictvar ""}} {
693 set numEntries [binary scan $data\
SuSSuSuB16S4S4S2c2cu10B128a4B16SuSuSSSSuSuB64SSSuSuSu Version\
xAvgCharWidth usWeightClass usWidthClass fsType subscriptSizePos\
superscriptSizePos strikeoutSizePos sFamilyClass Panose\
UnicodeCoverage achVendID fsSelection usFirstCharIndex\
usLastCharIndex sTypoAscender sTypoDescender sTypoLineGap\
usWinAscent usWinDescent codePageRange sxHeight sCapHeight\
usDefaultChar usBreakChar usMaxContext]
701 set res "# Version: $Version\n"
702 set funit [dict get $gdict funit]
The linegap value is supposed to produce something like the baselineskip when
added to the ascender and descender, so it would probably be larger than the
\lineskiplimit.
The difference between sub1 and sub2 is that the latter comes into play only
when there is a superscript, so sub1 seems a likelier interpretation of what a “word
processor” would supply. As for the three sup〈n〉 parameters, TEX uses all of them
in the same way, but chooses one depending on the current math style. sup2 is
what would be used for normal \textstyle formulae.
703 set ySubscriptYOffset [lindex $subscriptSizePos 3]
704 set ySuperscriptYOffset [lindex $superscriptSizePos 3]
705 foreach {var int} {
31

scriptsizepos (element)
/Panose (element)
descriptor (element)
706 xAvgCharWidth averagewidth
707 sTypoAscender ascender
708 sTypoDescender descender_neg
709 sTypoLineGap linegap
710 usWinAscent maxheight
711 usWinDescent maxdepth
712 sxHeight xheight
713 sCapHeight capheight
714 ySubscriptYOffset sub1
715 ySuperscriptYOffset sup2
716 } {
717 if {[info exists $var]} then {
718 append res [list /setint $int [expr {$funit*[set $var]}]] \n
719 }
720 }
The /scriptsizepos element has the syntax
/scriptsizepos {type} {x-scale} {y-scale} {x-ofs} {y-ofs}
where {type} is one of super and sub. The {x-scale} and {y-scale} are interpreted
as by \xscalefont and \yscalefont respectively. The {y-ofs} is negative for
subscripts.
721 lset subscriptSizePos 3 [expr {-[lindex $subscriptSizePos 3]}]
722 foreach L [list $subscriptSizePos $superscriptSizePos] type\
{sub super} {
724 set L2 [list /scriptsizepos $type]
725 foreach val $L {lappend L2 [expr {$funit*$val}]}
726 append res $L2 \n
727 }
The /Panose element has the syntax
/Panose {family type} {serif style} {weight} {proportion} {contrast}
{stroke variation} {arm style} {letterform} {midline} {xheight}
The arguments are the raw numbers, not their interpretations.
728 append res [list /Panose {*}$Panose] \n
729 if {$gdictvar ne ""} then {
730 uplevel 1 [list ::set $gdictvar $gdict]
731 }
732 return $res
733 }
5.1 The fdsc table
Slightly duplicating the /Panose information is the Apple-defined [?] fdsc (font
descriptors) table. This is basically a dictionary, but since the tags could in
principle contain arbitrary characters, it seems unwise to use them as attribute
names. Hence the table is encoded as a sequence of element, which carry tag and
value attributes.
32

sfnt::fdsc::parse (proc) The call syntax of this procedure is
FNAM (table)
sfnt::fdsc::parse {data} {gdict} {gdict-var} ?
The {gdict} and {gdict-var} arguments are currently ignored.
734 namespace eval sfnt::fdsc {
735 proc parse {data gdict {gdictvar ""}} {
736 binary scan $data H8Iu tableVersion count
737 set res ""
738 if {$tableVersion ne "00010000"} then {
739 append res "# Table version: 0x$tableVersion\n"
740 if {![string match 0001* $tableVersion]} then {return $res}
741 }
742 set pos 8
743 for {} {$count>=1} {incr count -1} {
744 binary scan $data @${pos}a4I tag value
745 incr pos 8
746 switch -- $tag "nalf" {
747 set name [lindex {Alphabetic Dingbats {Pi characters}\
Fleurons {Decorative borders} {International symbols}\
{Math symbols}} $value]
750 if {$name eq ""} then {set name $value}
751 append res [list descriptor tag $tag value $name] \n
752 } default {
753 append res\
[list descriptor tag $tag value [expr {$value/65536.0}]]\
\n
755 }
756 }
757 return $res
758 }
759 }
5.2 The FNAM table
Before OpenType, there was an older (but rather obscure) format of wrapping
PS fonts in sfnt containers, and these fonts had a set of tables which deviate
considerably from what the TrueType and OpenType standards prescribe. The
FNAM table purpose-wise overlap a bit with the OS/2 table, in that it specifies font
style.
sfnt::FNAM::parse (proc) The call syntax of this procedure is
sfnt::FNAM::parse {data} {gdict} {gdict-var} ?
The {gdict} and {gdict-var} arguments are currently ignored.
760 namespace eval sfnt::FNAM {}
761 proc sfnt::FNAM::parse {data gdict {gdictvar ""}} {
762 binary scan $data H8Su tableVersion encSets
33

FOND-association (tag)
763 set res ""
764 if {$tableVersion ne "00010000"} then {
765 append res "# Table version: 0x$tableVersion\n"
766 if {![string match 0001* $tableVersion]} then {return $res}
767 }
The following data is conceptually an array of offsets of the starts of selector
subtables, with an extra offset afterwards marking the end to the table, but since
each new offset also marks the end of the previous subtable it is convenient to
rather parse it as a position of the first subtable and a list of ends of subtables.
768 binary scan $data @6SuSu${encSets} pos offsets
769 set sel 0
770 foreach end $offsets {
771 while {$pos < $end} {
The FOND-association tag effectively describes an entry this font would have
in the user interface list of fonts. The name attribute gives the font (family)
name, whereas the style attribute is a list of QuickDraw styles applied to it.
The selector attribute specifies (in reference to the cmap or ENCO table) the font
subset that this UI font would expose. [?, Sec. 9]
772 set L [list FOND-association]
773 binary scan $data @${pos}cucu style len
774 incr pos 2
775 binary scan $data @${pos}a${len} name
776 incr pos $len
777 lappend L name [encoding convertfrom macRoman $name]
778 set L2 {}
779 foreach flag {
780 bold italic underline outline shadow condensed extended
781 } {
782 if {$style & 1} then {lappend L2 $flag}
783 set style [expr {$style >> 1}]
784 }
785 lappend L style $L2 selector $sel
786 append res $L \n
787 }
788 incr sel
789 set pos $end
790 }
791 return $res
792 }
6 hmtx, hhea, and maxp tables
An obviously interesting table is hmtx, since this is where the glyph advance widths
are to be found. Unfortunately, the format of this table is rather bizarre; it is
concerned more with specifying left sidebearing points than with widths (you can
default widths, but need to give a sidebearing for each glyph). Also, the table
34

consists of two arrays, the sizes of which are not stored in this table, but in the
hhea and maxp tables instead.
sfnt::maxp::parse (proc) The only generally useful information in the maxp table is numGlyphs, which is
exported to the gdict. Then there are a bunch of fields which essentially only
say how much resources of various types that the TrueType renderer would need;
these are just dumped as comments.
793 namespace eval sfnt::maxp {
794 proc parse {data gdict {gdictvar ""}} {
795 binary scan $data H8Su version numGlyphs
796 set res "# ’maxp’ version 0x$version\n"
797 if {$version in {00005000 00010000}} then {
798 dict set gdict numGlyphs $numGlyphs
799 append res [list /numGlyphs $numGlyphs] \n
800 }
801 if {$version eq "00010000"} then {
802 binary scan $data @6Su* L
803 foreach val $L name {
804 maxPoints maxContours maxCompositePoints
805 maxCompositeContours maxZones maxTwilightPoints maxStorage
806 maxFunctionDefs maxInstructionDefs maxStackElements
807 maxSizeOfInstructions maxComponentElements
808 maxComponentDepth
809 } {
810 append res "# $name $val\n"
811 }
812 }
813 if {$gdictvar ne ""} then {
814 uplevel 1 [list ::set $gdictvar $gdict]
815 }
816 return $res
817 }
818 }
sfnt::hhea::parse (proc) The hhea table contains some typographically interesting entries, but those are
duplicated in the OS/2 table, so again this is mostly needed to parse the hmtx
table. Still, there’s little harm in exporting what can be found.
819 namespace eval sfnt::hhea {
820 variable parse_after head
821 proc parse {data gdict {gdictvar ""}} {
822 binary scan $data H8SSSSuSSSSSSx8SSu version Ascender Descender\
LineGap advanceWidthMax minLeftSideBearing minRightSideBearing\
xMaxExtent caretSlopeRise caretSlopeRun caretOffset\
metricDataFormat numberOfHMetrics
827 set res "# ’hhea’ version 0x$version\n"
828 if {$version ne "00010000"} then {return $res}
829 set funit [dict get $gdict funit]
The “ascender” and “descender” values here are probably closer to being maximal
height and depth than height and depth of actual ascenders. There is no fontinst
35

sfnt::hmtx::parse (proc)
/glyphwidth (element)
name for “line gap” (though TEX’s \lineskip is pretty close), but the line gap
value suggests a baselineskip value.
830 append res [list /setint maxheight [expr {$Ascender*$funit}]] \n
831 append res [list /setint maxdepth_neg [expr {$Descender*$funit}]]\
\n
832 append res [list /setint baselineskip\
[expr {($Ascender-$Descender+$LineGap)*$funit}]] \n
834 foreach var {advanceWidthMax minLeftSideBearing\
minRightSideBearing xMaxExtent} {
836 append res [list /dontsetint $var [expr {$funit*[set $var]}]]\
\n
838 }
The caret slope information isn’t likely to be used with TEX either, but can do
with being collected under a custom heading. Hence
/caretSlope {rise} {run} {offset}
specifies the slant (like italicslant) as run/rise and {offset} as a horizontal
offset to add to the position of the caret. (Adobe technote #5180 contains an
illustration of these parameters, which suggests the offset should actually be subtracted
from the x-position.)
839 append res [list /caretSlope $caretSlopeRise $caretSlopeRun\
[expr {$funit*$caretOffset}]] \n
The metricDataFormat and numberOfHMetrics entries are logically headers for
the hmtx table, so they are simply stored into the gdict.
841 dict set gdict metricDataFormat $metricDataFormat
842 dict set gdict numberOfHMetrics $numberOfHMetrics
843 if {$gdictvar ne ""} then {
844 uplevel 1 [list ::set $gdictvar $gdict]
845 }
846 return $res
847 }
848 }
849 namespace eval sfnt::hmtx {
850 variable parse_after {head maxp hhea}
851 proc parse {data gdict {var ""}} {
852 if {$var ne ""} then {uplevel 1 [list ::set $var $gdict]}
853 binary scan $data [
854 format S%dS%d [expr {2*[dict get $gdict numberOfHMetrics]}]\
[expr {[dict get $gdict numGlyphs] -\
[dict get $gdict numberOfHMetrics]}]
857 ] wsL sL
Glyph width data is encoded using /glyphwidth elements, which have the syntax
/glyphwidth {GID} {width} {lsb} ?
36

sfnt::HFMX:
:parse_after (var.)
where the optional {lsb} is the left sidebearing and defaults to 0 (since this is the
only possible value for a CFF font).
858 set res ""
859 set funit [dict get $gdict funit]
860 set n -1; foreach {w lsb} $wsL {incr n
861 set L [list /glyphwidth $n [expr {$w*$funit}]]
862 if {$lsb != 0} then {lappend L [expr {$lsb*$funit}]}
863 append res $L \n
864 }
865 foreach lsb $sL {incr n
866 set L [list /glyphwidth $n [expr {$w*$funit}]]
867 if {$lsb != 0} then {lappend L [expr {$lsb*$funit}]}
868 append res $L \n
869 }
870 return $res
871 }
872 }
6.1 The HFMX table
Another variant table that might be found in pre-OpenType sfnt-wrapped PS
fonts is HFMX, which overlaps with the hhea table.
Parsing HFMX tables requires knowing the funit, so it must be done after head.
873 namespace eval sfnt::HFMX {
874 variable parse_after head
875 }
sfnt::HFMX::parse (proc) The call syntax of this procedure is
sfnt::HFMX::parse {data} {gdict} {gdict-var} ?
The {gdict} is a dictionary of global font information, but values in it will be
overridden by what is in the {data}. A {gdict-var} will be ignored.
876 proc sfnt::HFMX::parse {data gdict {gdictvar ""}} {
877 binary scan $data H8SSSSSS tableVersion ascent descent lineGap\
caretSlopeRise caretSlopeRun caretOffset
879 set res ""
880 if {$tableVersion ne "00010000"} then {
881 append res "# Table version: 0x$tableVersion\n"
882 if {![string match 0001* $tableVersion]} then {return $res}
883 }
884 set funit [dict get $gdict funit]
885 append res [list /setint maxheight [expr {$ascent*$funit}]] \n
886 append res [list /setint maxdepth_neg [expr {$descent*$funit}]] \n
887 append res [list /setint baselineskip\
[expr {($ascent-$descent+$lineGap)*$funit}]] \n
889 append res [list /caretSlope $caretSlopeRise $caretSlopeRun\
[expr {$funit*$caretOffset}]] \n
37

sfnt::post:
:base_258_glyphs (var.)
891 return $res
892 }
7 post tables
The post table is one source of glyph name information, and as such interesting
for fontinst use. The TDL command for associating a glyph ID with a name is
simply
/glyphname {GID} {name}
Most other data in the post table is encoded as /setint elements.
Versions 1.0 and 2.0 of the post table start out with a list of 258 standard glyph
names, which do not get encoded into the font. Hence a copy of this list must be
part of this program instead.
893 namespace eval sfnt::post {
894 variable base_258_glyphs {
895 .notdef .null nonmarkingreturn space exclam quotedbl numbersign
896 dollar percent ampersand quotesingle parenleft parenright
897 asterisk plus comma hyphen period slash zero one two three four
898 five six seven eight nine colon semicolon less equal greater
899 question at A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
900 bracketleft backslash bracketright asciicircum underscore grave
901 a b c d e f g h i j k l m n o p q r s t u v w x y z braceleft
902 bar braceright asciitilde Adieresis Aring Ccedilla Eacute Ntilde
903 Odieresis Udieresis aacute agrave acircumflex adieresis atilde
904 aring ccedilla eacute egrave ecircumflex edieresis iacute igrave
905 icircumflex idieresis ntilde oacute ograve ocircumflex odieresis
906 otilde uacute ugrave ucircumflex udieresis dagger degree cent
907 sterling section bullet paragraph germandbls registered
908 copyright trademark acute dieresis notequal AE Oslash infinity
909 plusminus lessequal greaterequal yen mu partialdiff summation
910 product pi integral ordfeminine ordmasculine Omega ae oslash
911 questiondown exclamdown logicalnot radical florin approxequal
912 Delta guillemotleft guillemotright ellipsis nonbreakingspace
913 Agrave Atilde Otilde OE oe endash emdash quotedblleft
914 quotedblright quoteleft quoteright divide lozenge ydieresis
915 Ydieresis fraction currency guilsinglleft guilsinglright fi fl
916 daggerdbl periodcentered quotesinglbase quotedblbase perthousand
917 Acircumflex Ecircumflex Aacute Edieresis Egrave Iacute
918 Icircumflex Idieresis Igrave Oacute Ocircumflex apple Ograve
919 Uacute Ucircumflex Ugrave dotlessi circumflex tilde macron breve
920 dotaccent ring cedilla hungarumlaut ogonek caron Lslash lslash
921 Scaron scaron Zcaron zcaron brokenbar Eth eth Yacute yacute
922 Thorn thorn minus multiply onesuperior twosuperior threesuperior
923 onehalf onequarter threequarters franc Gbreve gbreve Idotaccent
924 Scedilla scedilla Cacute cacute Ccaron ccaron dcroat
925 }
38

926 variable parse_after head
927 }
sfnt::post::parse (proc) Being a parse procedure, this returns the TDL counterpart of a post table. Its
call syntax is
sfnt::post::parse {binary data} {global dict}
and the interesting piece of information in the {global dict} is the unitsPerEm
value, which is needed to interpret FWord values.
928 proc sfnt::post::parse {data gdict {gdictvar ""}} {
929 binary scan $data H8ISSIuIu4 version italicAngle underlinePosition\
underlineThickness isFixedPitch minMaxMem
932 set funit [dict get $gdict funit]
933 set res "# ’post’ version 0x$version\n"
934 append res [list /setint italicslant\
[expr {-1000*tan($italicAngle*2.663161090079238e-7)}]] \n
2.663161090079238 · 10−7 ≈ π/180/216 .
underlinetop
The underlinetop quantity appears to be new to fontinst. It is defined to be
(fontinst variable) the y-position of the top edge of the underlining stroke (i.e., the same as in the
post table, which is different from what would be in an AFM file)
/minMaxPSMem (element)
936 append res\
[list /setint underlinetop [expr {$underlinePosition*$funit}]] \n
938 append res [list /setint underlinethickness\
[expr {$underlineThickness*$funit}]] \n
940 if {$isFixedPitch} then {
941 append res [list /setint monowidth $isFixedPitch] \n
942 }
943 if {$minMaxMem ne "0 0 0 0"} then {
944 append res [linsert $minMaxMem 0 /minMaxPSMem] \n
945 }
The /minMaxPSMem element encodes information about how much memory the
font requires when downloaded into a PS interpreter; it is probably not so interesting
these days, with growing RAM sizes also in printers. The Type 42 values
correspond to memory requirements when downloading what is actually in the
sfnt font, whereas the Type 1 values correspond to memory requirements when
downloading an equivalent Type 1 font (which would usually be taken from a
separate external file rather than autoconverted from the TrueType, I think).
/minMaxPSMem {Type 42 minimum} {Type 42 maximum} {Type 1
minimum} {Type 1 maximum}
After these preliminaries comes the more interesting collection of glyph names.
Version 1.0 is just a fixed list of 258 glyphs.
946 variable base_258_glyphs
947 switch -- $version 00010000 {
948 set n -1; foreach name $base_258_glyphs {incr n
949 append res [list /glyphname $n $name] \n
39

glyphccode (element)
950 }
951 } 00020000 {
Version 2.0 is the main form of the table. The code below reads a name string in
the same step as the length of the next string, because it is easy to have binary do
that. A consequence is that the last binary probably won’t update len because
the byte where this value is expected is after the end of data, but then this len
value wouldn’t be used either.
952 binary scan $data @32Su numberOfGlyphs
953 binary scan $data @34S$numberOfGlyphs indexL
954 set pos [expr {34+2*$numberOfGlyphs}]
955 binary scan $data @${pos}cu len
956 incr pos
957 set nameL $base_258_glyphs
958 set n -1; foreach index $indexL {incr n
959 while {$index >= [llength $nameL]} {
960 set npos [expr {$pos+$len+1}]
961 binary scan $data @${pos}a${len}cu name len
962 set pos $npos
963 lappend nameL $name
964 }
965 append res [list /glyphname $n [lindex $nameL $index]] \n
966 }
967 } 00025000 {
Version 2.5 has been deprecated, but is in principle a possibility. I haven’t been
able to test it, though.
968 append res {# WARNING: Parsing of table version 2.5 is untested.}\
\n
969 binary scan $data @32Su numberOfGlyphs
970 binary scan $data @34c${numberOfGlyphs} offsetL
971 set n -1; foreach ofs $offsetL {incr n
972 append res [list /glyphname $n\
[lindex $base_258_glyphs [expr {($n+$ofs)%258}]]] \n
974 }
975 } 00040000 {
post table version 3.0 says nothing about the glyph names. For a version 4.0
table, the glyph names should be of the form a〈hex〉, but these are kind of fake;
rather than be looked up in a table, they are supposed to be parsed to extract
the four 〈hex〉 digits. Hence they are not encoded as /glyphname commands, but
rather as /glyphccode elements, which have the syntax
/glyphccode {GID} {code}
where the {code} is four hex digits. ToDo: Research how these {code}s are used on
the PS side. A plausible guess is that they are looked up as 16-bit character codes
(in some two-byte encoding CMap). I’ve seen comments that they are related to
OpenType cmaps, but fail to specify exactly which one if there are several.
976 binary scan $data @32Su numberOfGlyphs
40

nameid (element)
code (attribute)
description (attribute)
sfnt::name:
:description (var.)
977 binary scan $data @34Su${numberOfGlyphs} codeL
978 set n -1; foreach code $codeL {incr n
979 append res [list /glyphccode $n [format %04X $code]] \n
980 }
981 }
982 return $res
983 }
8 name table
The name table is primarily a list of strings, the interpretations of which are
determined by their “name id”, but it additionally has the feature that a string
may have variant forms depending on platform, encoding, and language. Therefore
there is a container element nameid which collects all strings with a particular id,
and various item elements which hold the particular string data. The nameid
element have a required attribute code which holds the numeric string id, and an
optional attribute description which gives a textual interpretation of the code
(there doesn’t seem to be any symbolic names defined for the strings).
The description variable is a list of descriptions for the standard name strings.
Empty string means no description.
984 namespace eval sfnt::name {
985 variable description {
986 {Copyright notice}
987 {Font Family name}
988 {Font Subfamily name}
989 {Unique font identifier}
990 {Full font name}
991 {Version string}
992 {Postscript name}
993 Trademark
994 Manufacturer
995 Designer
996 Description
997 {Vendor URL}
998 {Designer URL}
999 {License Description}
1000 {License Info URL}
1001 {}
1002 {Preferred Family}
1003 {Preferred Subfamily}
1004 {Compatible Full name}
1005 {Sample text}
1006 {PostScript CID findfont name}
1007 {WWS family name}
1008 {WWS subfamily name}
1009 }
1010 }
41

namestr (element)
sfnt::name:
:PELdict (proc)
sfnt::name::tclenc
(array)
The normal item element is /namestr, which has the syntax
/namestr {string} {platform-encoding-language} +
where {string} is the actual string being encoded. The {platform-encoding-language}s
are dictionaries specifying these properties of the underlying name record; multiple
name records that produce the same {string} will be combined. Keys that
may occur in a platform-encoding-language dictionary are
-platform May take a numeric value or one of the strings Unicode, Macintosh,
ISO, Windows, and Custom.
-enc The numeric encoding id.
-lang The numeric language id.
-language A textual language tag or name; the decoded equivalent of the -lang.
This procedure constructs a platform-encoding-language dictionary for given ids.
The call syntax is
PELdict {platform} {encoding} {language} {language-tag-list}
where the fourth argument is the list of strings that the language tag records
encode.
1011 proc sfnt::name::PELdict {plat enc lang ltL} {
1012 if {$plat=0x8000} then {
1022 incr lang -0x8000
1023 if {[lindex $ltL $lang] ne ""} then {
1024 dict set res -language [lindex $ltL $lang]
1025 }
1026 }
1027 return $res
1028 }
1029 namespace eval sfnt::name {
1030 namespace export PELdict
1031 }
The tclenc array maps combinations of numeric platform and encoding ids to Tcl
encoding names. Indices that are lists of length two have the form
{platform} {encoding}
42

namebytearray (element)
sfnt::name:
:encoding_convertfrom
(proc)
and should be checked first. Indices that are lists of length one are just the platform
id and should be used for all encodings on that platform which do not have a more
specific match.
1032 array set [namespace current]::sfnt::name::tclenc {
1033 0 UTF-16BE
1034 {1 0} macRoman
1035 {1 1} macJapan
1036 {1 6} macGreek
1037 {1 7} macCyrillic
1038 {1 21} macThai
1039 {1 29} macCentEuro
1040 {2 0} ascii
1041 {2 1} UTF-16BE
1042 {2 2} iso8859-1
1043 {3 1} UTF-16BE
1044 {3 2} shiftjis
1045 {3 4} big5
1046 {3 10} UTF-16BE
1047 }
Warning: Many of these entires are little more than guesses; the specification is
not very clear, and I haven’t had any examples to test the unusual combinations
on. It is however quite possible that the unclarity of the specification reflects an
uncertainty among its authors about what was being specified.
For items where the encoding is unknown, the string cannot be decoded, so
these will instead have to be represented by the /namebytearray element, which
has the syntax
/namebytearray {binary data} {platform-encoding-language} +
This is a replacement for encoding convertfrom to handle the platform dependence
of the built-in unicode encoding. The call syntax is
encoding_convertfrom {encoding} {bytearray}
and this defaults to calling encoding convertfrom, unless {encoding} is UTF-16BE,
in which case converting from unicode may require byte-swapping.
1048 namespace eval sfnt::name {
1049 proc encoding_convertfrom {enc str} {
1050 if {$enc eq "UTF-16BE"} then {
1051 set enc unicode
1052 if {$::tcl_platform(byteOrder) eq "littleEndian"} then {
1053 binary scan $str Su* words
1054 set str [binary format su* $words]
1055 }
1056 }
1057 encoding convertfrom $enc $str
1058 }
1059 namespace export encoding_convertfrom
1060 }
43

sfnt::name::parse PSBaseName (proc) The parse procedure may augment the gdict with two items, namely PSBaseName
PSType0Name (string 6) and PSType0Name (string 20). These should only occur in one form, but
if there are several then it is random which will be picked.
1061 proc sfnt::name::parse {data gdict {gdictvar ""}} {
1062 variable description
1063 variable tclenc
1064 set res ""
1065 set D [rawnestdict $data]
1066 binary scan $data SuSuSu format ncount base
1067 set lTagL {}
1068 if {$format==1} then {
1069 set pos [expr {6+12*$ncount}]
1070 binary scan $data @${pos}Su lcount
1071 incr pos 2
1072 binary scan $data @${pos}Su[expr {2*$lcount}] lRecL
1073 foreach {length offset} $lRecL {
1074 binary scan $data @${base}x${offset}a${length} tag
1075 lappend lTagL [encoding_convertfrom UTF-16BE $tag]
1076 }
1077 }
1078 foreach nameid [lsort -integer [dict keys $D]] {
1079 append res [list nameid code $nameid]
1080 if {[lindex $description $nameid] ne ""} then {
1081 append res " " [list description [lindex $description $nameid]]
1082 }
1083 append res " \{\n"
1084 set strD [dict create]
1085 set rawD {}
1086 dict for {plat D2} [dict get $D $nameid] {
1087 dict for {enc D3} $D2 {
1088 set enckey [list $plat $enc]
1089 if {![info exists tclenc($enckey)]} then\
{set enckey [list $plat]}
1091 dict for {lang raw} $D3 {
1092 set pel [PELdict $plat $enc $lang $lTagL]
1093 if {[info exists tclenc($enckey)]} then {
1094 dict lappend strD\
[encoding_convertfrom $tclenc($enckey) $raw] $pel
1096 } else {
1097 dict lappend rawD $raw $pel
1098 }
1099 }
1100 }
1101 }
1102 dict for {str L} $strD {
1103 append res [linsert $L 0 /namestr $str] \n
1104 if {$nameid == 6} then {
1105 dict set gdict PSBaseName $str
1106 } elseif {$nameid == 20} then {
44

sfnt::name:
:rawnestdict (proc)
/charmap (element)
1107 dict set gdict PSType0Name $str
1108 }
1109 }
1110 dict for {raw L} $rawD {
1111 append res [linsert $L 0 /namebytearray $raw] \n
1112 }
1113 append res "\}\n"
1114 }
1115 if {$gdictvar ne ""} then {
1116 uplevel 1 [list ::set $gdictvar $gdict]
1117 }
1118 return $res
1119 }
This procedure returns a four levels nested dictionary with the raw (undecoded)
strings in the name table. The keys are, in sequence, the numeric nameID,
platformID, encodingID, and languageID. The call syntax is
sfnt::name::rawnestdict {bytearray}
1120 proc sfnt::name::rawnestdict {data} {
1121 set res [dict create]
1122 binary scan $data SuSuSu format count base
1123 for {set rpos 6; set n 0} {$n

charmap command The {string}s of a /charmap can contain pretty arbitrary characters, and in particular
control character can be troublesome in output (even though Tcl handles
them correctly internally). Therefore it is useful to have a prettyprinting of this
command which converts these to suitable escape sequences.
1131 proc prettyTDL::/charmap {hex gid args} {
1132 upvar 1 res res O(-indent) indent
1133 append res $indent [list /charmap $hex $gid]
1134 foreach str $args {
By using list on a string which is unbalanced with respect to braces, it is possible
to get something which works as a bareword in a list; this makes sure syntax
characters are properly quoted, and will have rewritten newline, tab, etc. as their
usual letter-escapes. Hence remaining control characters can be expressed using
octal escapes.
1135 set arg [string range [list "$str \{"] 0 end-4]
1136 append res " " [string map {
1137 \0 {\000} \1 {\001} \2 {\002} \3 {\003} \4 {\004} \5 {\005}
1138 \6 {\006} \7 {\007} \10 {\010} \11 {\011} \12 {\012}
1139 \13 {\013} \14 {\014} \15 {\015} \16 {\016} \17 {\017}
1140 \20 {\020} \21 {\021} \22 {\022} \23 {\023} \24 {\024}
1141 \25 {\025} \26 {\026} \27 {\027} \30 {\030} \31 {\031}
1142 \32 {\032} \33 {\033} \34 {\034} \35 {\035} \36 {\036}
1143 \37 {\037}
1144 } $arg]
1145 }
1146 append res \n
1147 }
1148 prettyTDL::theinterp alias /charmap\
[namespace which prettyTDL::/charmap]
cmap (element) There is also a cmap element which surrounds each cmap subtable. Notable
format (attribute) attributes of this element are format, which details the subtable format, and
offset (attribute) offset, which details the offset of the subtable from the beginning of the table.
plat-enc-lang (element) cmap elements also contain plat-enc-lang elements, with attributes platform,
platform (attribute) enc, lang, and language as in a platform–encoding–language dictionary. These
enc (attribute) elements have no contents, but rather encode that the subtable that the surround-
lang (attribute) ing cmap element encodes was mapped to by this combination of values.
language (attribute) 1149 namespace eval sfnt::cmap {
1150 namespace import [namespace parent]::name::PELdict
1151
1152 }
namespace import [namespace parent]::name::encoding_convertfrom
sfnt::cmap::parse (proc) The top-level parse procedure handles subtables and the plat-enc-lang tagging
of these. Parsing of subtable format n is handled by the parse_format_n procedure,
although to add a subformat parser it is necessary to add it to the final
switch over formats.
1153 proc sfnt::cmap::parse {data gdict {gdictvar ""}} {
1154 upvar #0 [namespace parent]::name::tclenc Tclenc
46

1155 binary scan $data SuSu version count
1156 set res "# Table version $version.\n"
1157 if {$version != 0} then {return $res}
All references to a particular subtable are collected in the Subtable array, whose
entries are lists of the form
{platform} {encoding} ∗
1158 set pos 4
1159 for {} {$count >= 1} {incr count -1} {
1160 binary scan $data @${pos}SuSuIu plat enc offset
1161 incr pos 8
1162 lappend Subtable($offset) $plat $enc
1163 }
Then each subtable is decoded once.
1164 foreach offset [lsort -integer [array names Subtable]] {
1165 set L [list cmap offset $offset]
1166 binary scan $data @${offset}Su format
1167 lappend L format $format
1168 append res $L " \{\n"
The language field is the third (if one counts as Apple does) in all subtable formats,
but since it is not the same length in formats 8–12 as it is in formats 0–6, it is
necessary to have a preliminary switch just for the purpose of reading it. And
while we’re at that, we might as well take note of the length field too.
1169 switch -- $format 0 - 2 - 4 - 6 {
1170 binary scan $data @${offset}x2SuSu length language
1171 } 8 - 10 - 12 {
1172 binary scan $data @${offset}x2SuIuIu subformat length language
1174 if {$subformat != 0} then {
1175 append res "# Subformat $subformat.\n"
1176 }
1177 }
1178 if {[info exists length]} then {
1179 append res "# Subtable length $length bytes.\n"
1180 unset length
1181 }
1182 set tclencL {}
1183 foreach {plat enc} $Subtable($offset) {
1184 set L [list plat-enc-lang]
1185 dict for {key val} [PELdict $plat $enc $language {}] {
1186 lappend L [string trimleft $key -] $val
1187 }
1188 append res $L \n
1189 if {[info exists Tclenc([list $plat $enc])]} then {
1190 lappend tclencL $Tclenc([list $plat $enc])
1191 } elseif {[info exists Tclenc([list $plat])]} then {
1192 lappend tclencL $Tclenc([list $plat])
1193 }
1194 }
47

sfnt::cmap:
:parse_format_0 (proc)
sfnt::cmap:
:parse_format_2 (proc)
Here is where one must modify the procedure to add parsing of more subtable
formats.
1195 switch -- $format 0 - 2 {
1196 append res [parse_format_$format $data $offset $tclencL]
1197 }
1198 append res \}\n
1199 }
1200 return $res
1201 }
This procedure parses cmap subtables in format 0. It has the call syntax
parse_format_0 {table} {position} {tclenc-list}
and returns the parsed data as TDL code. The {table} is the entire cmap table and
the {position} is where in that table the subtable to parse begins. The {tclenc-list}
is a list of Tcl encodings which should be tried for decoding the character code
being mapped.
Subtable format 0 is just an array of 256 GIDs in bytes.
1202 proc sfnt::cmap::parse_format_0 {data pos encL} {
1203 binary scan $data @${pos}x6cu256 L
1204 set res ""
1205 set code -1; foreach gid $L {incr code
1206 if {$gid == 0} then {continue}
1207 append res [list /charmap [format %02X $code] $gid]
1208 foreach enc $encL {
1209 append res { }\
[list [encoding_convertfrom $enc [binary format cu $code]]]
1211 }
1212 append res \n
1213 }
1214 return $res
1215 }
This procedure parses cmap subtables in format 2. It has the call syntax
parse_format_2 {table} {position} {tclenc-list}
and returns the parsed data as TDL code. The {table} is the entire cmap table and
the {position} is where in that table the subtable to parse begins. The {tclenc-list}
is a list of Tcl encodings which should be tried for decoding the character code
being mapped.
Subtable format 2 supports two-byte encodings and mixed one/two-byte encodings.
It has a three level structure where the first and second levels hold byte
offsets to selected the second and third respectively level entries. Actual glyph
indices are computed by adding numbers in the second and third levels.
The fixed length part is the first level (256 words), so the procedure is organised
as an outer loop over the first level and an inner loop over the second level.
1216 proc sfnt::cmap::parse_format_2 {data pos encL} {
48

1217 binary scan $data @${pos}x6Su256 L
1218 set res ""
1219 set hi -1; foreach key $L {incr hi
1220 set pos2 [expr {$pos+518+$key}]
1221 binary scan $data @${pos2}SuSuSSu firstCode entryCount idDelta\
idRangeOffset
If the key is 0 then the hi byte is the only byte, and it is used also as index for a
GID datum.
1223 if {$key == 0} then {
1224 if {$hi < $firstCode || $hi >= $firstCode+$entryCount} then\
{continue}
1226 binary scan $data\
@[expr {$pos2 + 8 + $idRangeOffset + $hi-$firstCode}]S gid
1229 if {!$gid} then {continue}
1230 set mapL [list [format %02X $hi] $gid]
1231 } else {
Otherwise there is an entire range of GID data, and each of them contributes one
/charmap entry.
1232 binary scan $data @${pos2}x8x${idRangeOffset}S${entryCount}\
gidL
1234 set mapL {}
1235 foreach gid $gidL {
1236 if {$gid} then {
1237 lappend mapL [format %02X%02X $hi $firstCode] $gid
1238 }
1239 incr firstCode
1240 }
1241 }
Manufacturing actual /charmap entries is common in the two cases, since for
example the idDelta aspect still remains to be handled. The mapL list is used as
intermediate storage for data.
1242 foreach {hex gid} $mapL {
1243 set L [list /charmap $hex]
1244 lappend L [expr {($gid+$idDelta) & 65535}]
1245 set bytes [binary format H* $hex]
1246 foreach enc $encL {
1247 append L [encoding_convertfrom $enc $bytes]
1248 }
1249 append res $L \n
1250 }
1251 }
1252 return $res
1253 }
Note: This is currently untested, since I haven’t yet found any font with a format
2 cmap table.
49

glyphbbox (element)
sfnt::glyf:
:parse_bboxes (proc)
sfnt::glyf:
:parse_loca (proc)
10 glyf and loca tables
OpenType doesn’t provide glyph-wise bounding box inforation separately from
the glyph outlines, but there is an explicit bounding box in each glyph header.
This information is encoded using /glyphbbox elements, which have the syntax
/glyphbbox {GID} {left} {bottom} {right} {top}
This is different from the fontinst \setglyphbb command only in that it specified
the glyph by number rather than by name.
1254 namespace eval sfnt::glyf {}
Since this doesn’t parse the whole of the glyf table, it shouldn’t be the general
sfnt::glyf::parse procedure, but on the other hand this allows us to diverge
from the standard table-parse syntax and instead use
sfnt::glyf::parse_bboxes {loca} {glyf } {gdict}
since the loca table is all about keeping track of where in the glyf table the glyph
headers are located.
1255 proc sfnt::glyf::parse_bboxes {loca glyf gdict} {
1256 set posL [parse_loca $loca $gdict]
1257 set res ""
1258 for {set n 0} {$n < [dict get $gdict numGlyphs]} {incr n} {
1259 if {[lindex $posL $n] != [lindex $posL $n+1]} then {
1260 binary scan $glyf @[lindex $posL $n]SS4 numberOfContours bbox
1261 set L [list /glyphbbox $n]
1262 foreach b $bbox {
1263 lappend L [expr {$b*[dict get $gdict funit]}]
1264 }
1265 append res $L \n
1266 }
1267 }
1268 return $res
1269 }
The parsing of the loca table is slightly unintuitive, so it is handled by a separate
procedure. The call syntax is
parse_loca {loca} {gdict}
but the return value is the list of offsets rather than some TDL-encoding of the
same.
1270 proc sfnt::glyf::parse_loca {loca gdict} {
1271 if {[dict get $gdict indexToLocFormat]} then {
1272 binary scan $loca Iu* posL
1273 } else {
1274 binary scan $loca Su* L
1275 set posL {}
50

1276 foreach c $L {lappend posL [expr {2*$c}]}
1277 }
1278 return $posL
1279 }
sfnt::glyf::parse (proc) Still, in want of a more thorough glyf parser, parse_bboxes is a decent substitute.
#loca (gdict entry)
1280 proc sfnt::glyf::parse {glyf gdict {var ""}} {
1281 if {$var ne ""} then {uplevel 1 [list ::set $var $gdict]}
1282 return "# Outline data elided.\n[
1283 parse_bboxes [dict get $gdict #loca] $glyf $gdict
1284 ]"
1285 }
The above assumes the gdict contains a #loca entry with the raw contents of the
loca table.
sfnt::glyf:
Even that parser requires several tables to have been parsed before.
:parse_after (var.) 1286 namespace eval sfnt::glyf {
1287 variable parse_after {head maxp loca}
1288 }
sfnt::loca:
:parse_after (var.)
Proper parsing of the loca table requires knowing the indexToLocFormat from
the head table, but the “just copy to gdict” parsing done below could in principle
do without that.
1289 namespace eval sfnt::loca {variable parse_after head}
sfnt::loca::parse (proc) Besides copying the raw data to the gdict,
sfnt::kern:
:parse_after (var.)
1290 proc sfnt::loca::parse {data gdict {var ""}} {
1291 dict set gdict #loca $data
1292 if {$var ne ""} then {uplevel 1 [list ::set $var $gdict]}
1293 return "# Indices into ’glyf’ table elided.\n"
1294 }
11 kern tables
Parsing kern tables requires knowing the funit, and must hence come after the
head table.
1295 namespace eval sfnt::kern {
1296 variable parse_after head
1297 }
sfnt::kern::parse (proc) The main parse procedure mostly iterates over the subtables, using parse_subtable
to parse these.
1298 proc sfnt::kern::parse {data gdict {var ""}} {
1299 if {$var ne ""} then {uplevel 1 [list ::set $var $gdict]}
1300 binary scan $data SuSu version numsub
1301 if {$version == 0} then {
1302 set pos 4
51

sfnt::kern:
:parse_subtable (proc)
kern-table (element)
/kernpair (element)
1303 set res ""
1304 for {} {$numsub>0} {incr numsub -1} {
1305 append res [parse_subtable $data pos [dict get $gdict funit]]
1306 }
1307 return $res
1308 } elseif {$version == 1} then {
Although not mentioned in the OFF spec, there is also a version 1 of the table
which is used by Apple. It is quite similar to version 0, but some fields are 32 bit
wide rather than 16 bit wide.
1309 binary scan $data H8Iu version numsub
1310 set res "# ’kern’ table version 0x$version.\n"
1311 set pos 8
1312 for {} {$numsub>0} {incr numsub -1} {
1313 append res\
[parse_long_subtable $data pos [dict get $gdict funit]]
1314 }
1315 return $res
1316 } else {
1317 return "# Could not parse ’kern’ table version $version.\n"
1318 }
1319 }
This procedure parses a kern subtable. It has the call syntax
parse_subtable {data} {start-var} {funit}
where {data} is binary data and {start-var} is the name of a variable in the calling
context that contains the index into the {data} of the beginning of the subtable
to parse. The procedure returns TDL code for the subtable and increments the
{start-var} to point at the first byte after the table.
Each subtable is parsed as a kern-table element, which may have the at-
tributes horizontal, minimum, cross-stream, and override, corresponding to
bits in the coverage field of the subtable header. If an attribute is present, the
value of the corresponding bit is 1, whereas it is 0 if omitted.
Individual kern pairs are expressed using /kernpair elements, which have the
syntax
/kernpair {left} {right} {amount}
where {left} and {right} are lists of GIDs, and {amount} is in AFM units. It
means this amount should be added between all pairs of one {left} glyph and one
{right} glyph.
1320 proc sfnt::kern::parse_subtable {data startvar funit} {
1321 upvar 1 $startvar start
1322 binary scan $data @${start}SuSucub8 version length format coverage
1323 if {$version != 0} then {
1324 incr start $length
1325 return "# Could not parse version $version subtable ($length\
bytes).\n"
52

sfnt::kern:
:parse_format_0 (proc)
sfnt::kern:
:parse_format_2 (proc)
1327 }
1328 set res [list kern-table]
1329 foreach bit [split $coverage ""] attr {
1330 horizontal minimum cross-stream override bit4 bit5 bit6 bit7
1331 } {if {$bit} then {lappend res $attr 1}}
1332 append res " \{\n"
1333 switch -- $format 0 {
1334 parse_format_0 res $data [expr {$start+6}] $funit
1335 } 2 {
1336 parse_format_2 res $data $start $funit
1337 } default {
1338 append res "# Unknown subtable format: $format\n"
1339 }
1340 incr start $length
1341 append res \}\n
1342 }
This procedure parses a format 0 kern subtable. It has the call syntax
parse_format_0 {res-var} {data} {pos} {funit}
where {res-var} is a variable in the calling context to which the TDL interpretation
of the table should be appended, {data} is binary data containing the subtable to
parse with the first byte after the subtable header at position {pos}, and {funit}
is the font unit. There is no particular return value.
1343 proc sfnt::kern::parse_format_0 {resvar data pos funit} {
1344 upvar 1 $resvar res
1345 binary scan $data @${pos}Su npairs
1346 binary scan $data @${pos}x8Su[expr {3*$npairs}] L
1347 foreach {left right value} $L {
1348 append res [list /kernpair [list $left] [list $right]\
[expr {$funit*(($value^0x8000)-0x8000)}]] \n
1350 }
1351 }
This procedure parses a format 2 kern subtable. It has the call syntax
parse_format_2 {res-var} {data} {start} {funit}
where {res-var} is a variable in the calling context to which the TDL interpretation
of the table should be appended, {data} is binary data containing the subtable
to parse beginning (with header, assumed to be 8 bytes long) at position {start},
and {funit} is the font unit. There is no particular return value.
1352 proc sfnt::kern::parse_format_2 {resvar data start funit} {
1353 upvar 1 $resvar res
1354 binary scan $data @${start}x8SuSuSuSu width leftOfs rightOfs arrayOfs
1356 binary scan @${start}x${leftOfs}SuSu gid num
1357 binary scan @${start}x${leftOfs}x4Su${num} L
1358 foreach class $L {
1359 lappend lA($class) $gid
53

sfnt::kern:
:parse_long_subtable
(proc)
kern-table (element)
1360 incr gid
1361 }
1362 binary scan @${start}x${rightOfs}SuSu gid num
1363 binary scan @${start}x${leftOfs}x4Su${num} L
1364 foreach class $L {
1365 lappend rA($class) $gid
1366 incr gid
1367 }
1368 incr start $arrayOfs
1369 foreach lc [array names lA] {
1370 foreach rc [array names rA] {
1371 binary scan @${start}x${lc}x${rc}S value
1372 if {$value != 0} then {
1373 append res\
[list /kernpair $lA($lc) $rA($rc) [expr {$value*$funit}]]\
\n
1375 }
1376 }
1377 }
1378 }
This procedure parses a subtable in the long (32-bit; version 1) kind of kern table.
It has the call syntax
parse_long_subtable {data} {start-var} {funit}
where {data} is binary data and {start-var} is the name of a variable in the calling
context that contains the index into the {data} of the beginning of the subtable
to parse. The procedure returns TDL code for the subtable and increments the
{start-var} to point at the first byte after the table.
Each subtable is parsed as a kern-table element, which may have the at-
tributes horizontal and cross-stream, corresponding to bits in the coverage
field of the subtable header. If one of these attributes is present, its value must be
boolean true, with boolean false being the default. (For compatibility with table
version 0, the horizontal mode is 1 even though the corresponding binary bit will
in fact be 0 in this case.) There may also be a variation attribute, whose value
is the tuple index for the font that this subtable applies to; this has to do with
variation fonts (whatever those are).
1379 proc sfnt::kern::parse_long_subtable {data startvar funit} {
1380 upvar 1 $startvar start
1381 binary scan $data @${start}IuB8cuSu length coverage format tuple
1382 set res [list kern-table]
1383 if {![string index $coverage 0]} then {lappend res horizontal 1}
1384 if {[string index $coverage 1]} then {lappend res cross-stream 1}
1385 if {[string index $coverage 2]} then {
1386 lappend res variation $tuple
1387 }
1388 append res " \{\n"
1389 switch -- $format 0 {
54

sfnt::kern:
:parse_format_3 (proc)
1390 parse_format_0 res $data [expr {$start+8}] $funit
1391 } 1 {
1392 append res "# Sorry, no parser for format 1 (automaton) ’kern’\
subtables.\n"
1394 } 2 {
1395 parse_format_2 res $data $start $funit
1396 } 3 {
1397 parse_format_3 res $data [expr {$start+8}] $funit
1398 } default {
1399 append res "# Unknown subtable format: $format\n"
1400 }
1401 incr start $length
1402 append res \}\n
1403 }
This procedure parses a format 3 kern subtable. It has the call syntax
parse_format_3 {res-var} {data} {pos} {funit}
where {res-var} is a variable in the calling context to which the TDL interpretation
of the table should be appended, {data} is binary data containing the subtable to
parse with the first byte after the subtable header at position {pos}, and {funit}
is the font unit. There is no particular return value.
1404 proc sfnt::kern::parse_format_3 {resvar data pos funit} {
1405 upvar 1 $resvar res
1406 binary scan $data @${pos}Sucucucucu glyphs kvals lclass rclass\
reserved
1408 incr pos 6
1409 binary scan $data\
@${pos}S${kvals}cu${glyphs}cu${glyphs}cu[expr {$lclass*$rclass}]\
kernValL lClassL rClassL kernIndexL
1412 set n -1; foreach lc $lClassL rc $rClassL {incr n
1413 lappend LA($lc) $n
1414 lappend RA($rc) $n
1415 }
1416 set lc 0; set rc 0
1417 foreach item $kernIndexL {
1418 if {[lindex $kernValL $item] != 0} then {
1419 append res [
1420 list /kernpair [lappend LA($lc)] [lappend RA($rc)]\
[expr {$funit*[lindex $kernValL $item]}]
1422 ] \n
1423 }
1424 if {[incr rc]>=$rclass} then {set rc 0; incr lc}
1425 }
1426 }
55

sfnt::CFF::parse_index
(proc)
sfnt::CFF:
:standard_strings (var.)
12 CFF tables
The main namespace for CFF-related things is CFF rather than CFF as the general
parser format would require, since the extra space would make command names
somewhat awkward to write. If need for a general format parser arises, then that
can be an alias in the CFF namespace.
1427 namespace eval sfnt::CFF {}
This procedure parses an Index data structure and returns the data as a list with
unparsed elements. The call syntax is
parse_index {data} {position} {after-var} ?
where {data} is binary data containing the Index and {position} is the position
in {data} where the Index begins. The {after-var}, if provided, is the name of a
variable in the calling context which will be set to the position of the first byte in
{data} after the Index.
1428 proc sfnt::CFF::parse_index {data pos {aftervar ""}} {
1429 binary scan $data @${pos}Suc count offsize
1430 if {!$count} then {
1431 incr pos 2
1432 if {$aftervar ne ""} then {
1433 uplevel 1 [list ::set $aftervar $pos]
1434 }
1435 return {}
1436 }
1437 incr pos 3
1438 binary scan $data @${pos}H[expr {2*$offsize*($count+1)}] offsets
1439 regsub -all [format {.{%d}} [expr {2*$offsize}]] $offsets {0x& } ofsL
1440 incr pos [expr {$offsize*($count+1)-1}]
1441 set res {}
1442 for {set n 0} {$n

1457 N O P Q R S T U V W X Y Z bracketleft backslash bracketright
1458 asciicircum underscore quoteleft a b c d e f g h i j k l m n o p q
1459 r s t u v w x y z braceleft bar braceright asciitilde exclamdown
1460 cent sterling fraction yen florin section currency quotesingle
1461 quotedblleft guillemotleft guilsinglleft guilsinglright fi fl
1462 endash dagger daggerdbl periodcentered paragraph bullet
1463 quotesinglbase quotedblbase quotedblright guillemotright ellipsis
1464 perthousand questiondown grave acute circumflex tilde macron breve
1465 dotaccent dieresis ring cedilla hungarumlaut ogonek caron emdash AE
1466 ordfeminine Lslash Oslash OE ordmasculine ae dotlessi lslash oslash
1467 oe germandbls onesuperior logicalnot mu trademark Eth onehalf
1468 plusminus Thorn onequarter divide brokenbar degree thorn
1469 threequarters twosuperior registered minus eth multiply
1470 threesuperior copyright Aacute Acircumflex Adieresis Agrave Aring
1471 Atilde Ccedilla Eacute Ecircumflex Edieresis Egrave Iacute
1472 Icircumflex Idieresis Igrave Ntilde Oacute Ocircumflex Odieresis
1473 Ograve Otilde Scaron Uacute Ucircumflex Udieresis Ugrave Yacute
1474 Ydieresis Zcaron aacute acircumflex adieresis agrave aring atilde
1475 ccedilla eacute ecircumflex edieresis egrave iacute icircumflex
1476 idieresis igrave ntilde oacute ocircumflex odieresis ograve otilde
1477 scaron uacute ucircumflex udieresis ugrave yacute ydieresis zcaron
1478 exclamsmall Hungarumlautsmall dollaroldstyle dollarsuperior
1479 ampersandsmall Acutesmall parenleftsuperior parenrightsuperior
1480 twodotenleader onedotenleader zerooldstyle oneoldstyle twooldstyle
1481 threeoldstyle fouroldstyle fiveoldstyle sixoldstyle sevenoldstyle
1482 eightoldstyle nineoldstyle commasuperior threequartersemdash
1483 periodsuperior questionsmall asuperior bsuperior centsuperior
1484 dsuperior esuperior isuperior lsuperior msuperior nsuperior
1485 osuperior rsuperior ssuperior tsuperior ff ffi ffl
1486 parenleftinferior parenrightinferior Circumflexsmall hyphensuperior
1487 Gravesmall Asmall Bsmall Csmall Dsmall Esmall Fsmall Gsmall Hsmall
1488 Ismall Jsmall Ksmall Lsmall Msmall Nsmall Osmall Psmall Qsmall
1489 Rsmall Ssmall Tsmall Usmall Vsmall Wsmall Xsmall Ysmall Zsmall
1490 colonmonetary onefitted rupiah Tildesmall exclamdownsmall
1491 centoldstyle Lslashsmall Scaronsmall Zcaronsmall Dieresissmall
1492 Brevesmall Caronsmall Dotaccentsmall Macronsmall figuredash
1493 hypheninferior Ogoneksmall Ringsmall Cedillasmall questiondownsmall
1494 oneeighth threeeighths fiveeighths seveneighths onethird twothirds
1495 zerosuperior foursuperior fivesuperior sixsuperior sevensuperior
1496 eightsuperior ninesuperior zeroinferior oneinferior twoinferior
1497 threeinferior fourinferior fiveinferior sixinferior seveninferior
1498 eightinferior nineinferior centinferior dollarinferior
1499 periodinferior commainferior Agravesmall Aacutesmall
1500 Acircumflexsmall Atildesmall Adieresissmall Aringsmall AEsmall
1501 Ccedillasmall Egravesmall Eacutesmall Ecircumflexsmall
1502 Edieresissmall Igravesmall Iacutesmall Icircumflexsmall
1503 Idieresissmall Ethsmall Ntildesmall Ogravesmall Oacutesmall
1504 Ocircumflexsmall Otildesmall Odieresissmall OEsmall Oslashsmall
1505 Ugravesmall Uacutesmall Ucircumflexsmall Udieresissmall Yacutesmall
1506 Thornsmall Ydieresissmall 001.000 001.001 001.002 001.003 Black
57

sfnt::CFF::parse_dict
(proc)
1507 Bold Book Light Medium Regular Roman Semibold
1508 }
This procedure parses CFF dictionary bytecode and returns it as a list of TDL
elements. The call syntax is
parse_dict {data} {self-pos} {string-list}
where {data} is precisely the bytes to interpret as a dictionary. The {self-pos} is
the nominal position of the {data}; this is used when interpreting relative pointers
to other data structures. The {string-list} is the SID-indexed list of known strings.
The idea for this parser is to first use a regexp to cut the bytecode up into a
list of tokens, then process these with tools appropriate for each type.
1509 proc sfnt::CFF::parse_dict {data pos stringL} {
1510 set tokenL [regexp -all -inline {(?x)
1511 [\040-\366] | # One-byte number, -107..107
1512 [\367-\376]. | # Two-byte number, -1131..1131
1513 \034.. | # Three-byte number, -32768..32767
1514 \035.... | # Five-byte number; 32-bit 2’s-complement
1515 \036
1516 [^\x0F\x1F\x2F\x3F\x4F\x5F\x6F\x7F\x8F\x9F\xAF\xBF\xCF\xDF\xEF\xFF]*
1517 [\x0F\x1F\x2F\x3F\x4F\x5F\x6F\x7F\x8F\x9F\xAF\xBF\xCF\xDF\xEF\xFF]
1518 # Real number (BCD-coded)
1519 | [\000-\013\015-025] # One-byte operators
1520 | \014. # Two-byte operators
1521 } $data]
Operand tokens push items on the stack, operator tokens empty it.
1522 set stack {}
1523 set res {}
1524 foreach token $tokenL {
1525 binary scan $token cucu b0 b1
1526 if {$b0>=28} then {
1527 if {$b0==28} then {
1528 binary scan $token x1S num
1529 lappend stack $num
1530 } elseif {$b0==29} then {
1531 binary scan $token x1I num
1532 lappend stack $num
1533 } elseif {$b0==30} then {
1534 binary scan $token x1H* num
1535 lappend stack [string map {a . b E c E- d {} e - f {}} $num]
1536 } elseif {$b0

The bytecode is first translated to a symbolic name, then that name is used to
decide how to interpret the operands.
1544 if {$b0!=12} then {
1545 set name [lindex {
1546 version Notice FullName FamilyName Weight FontBBox
1547 BlueValues OtherBlues FamilyBlues FamilyOtherBlues
1548 StdHW StdVW escape UniqueID XUID charset Encoding
1549 CharStrings Private Subrs defaultWidthX nominalWidthX
1550 } $b0]
1551 } else {
1552 set name [lindex {
1553 Copyright isFixedPitch ItalicAngle UnderlinePosition
1554 UnderlineThickness PaintType CharstringType FontMatrix
1555 StrokeWidth BlueScale BlueShift BlueFuzz StemSnapH
1556 StemSnapV ForceBold -Reserved- -Reserved- LanguageGroup
1557 ExpansionFactor initialRandomSeed SyntheticBase
1558 PostScript BaseFontName BaseFontBlend -Reserved-
1559 -Reserved- -Reserved- -Reserved- -Reserved- -Reserved-
1560 ROS CIDFontVersion CIDFontRevision CIDFontType CIDCount
1561 UIDBase FDArray FDSelect FontName
1562 } $b1]
1563 }
1564 switch -- $name {
The following operators have one SID operand. The corresponding string becomes
the only argument of the command, which is thus positional. The syntaxes are:
/version {string}
/Notice {string}
/FullName {string}
/FamilyName {string}
/Weight {string}
/PostScript {string}
/BaseFontName {string}
/FontName {string}
1565 version - Notice - FullName - FamilyName - Weight -
1566 PostScript - BaseFontName - FontName {
1567 lappend res\
[list /$name [lindex $stringL [lindex $stack 0]]]
1569 }
The following operators have a delta-encoded array of operands. The decoded
array becomes the args (again positional) of the command. Thus syntaxes are:
/BlueValues {value} ∗
/OtherBlues {value} ∗
/FamilyBlues {value} ∗
/FamilyOtherBlues {value} ∗
/StemSnapH {value} ∗
59

StemSnapV {value} ∗
/BaseFontBlend {value} ∗
1570 BlueValues - OtherBlues - FamilyBlues - FamilyOtherBlues -
1571 StemSnapH - StemSnapV - BaseFontBlend {
1572 set sum 0
1573 set cmd [list /$name]
1574 foreach num $stack {
1575 set sum [expr {$sum+$num}]
1576 lappend cmd $sum
1577 }
1578 lappend res $cmd
1579 }
The following operators point to a separate data structure, and the interpretation
of that should become the TDL body of the corresponding element, but for now
the location of that data structure is encoded in the start attribute.
1580 charset - Encoding - CharStrings - FDArray - FDSelect {
1581 lappend res [list $name start [lindex $stack 0]]
1582 }
The Private operator is similar, but since it points directly to a dict, it is necessary
to also encode the length of the pointed-to data structure.
1583 Private {
1584 lappend res [list $name start [lindex $stack 1] length\
[lindex $stack 0]]
1586 }
The Subrs operator has a self-relative offset, but is otherwise similar to e.g. charset.
1587 Subrs {
1588 lappend res\
[list $name start [expr {$pos+[lindex $stack 0]}]]
1590 }
The ROS operator has the most complex operand structure, with two SIDs and a
number. Its syntax is
/ROS {registry} {ordering} {supplement}
1591 ROS {
1592 set cmd [list /$name]
1593 lappend cmd [lindex $stringL [lindex $stack 0]]
1594 lappend cmd [lindex $stringL [lindex $stack 1]]
1595 lappend cmd [lindex $stack 2]
1596 lappend res $cmd
1597 }
For all other operators, the contents of the stack are directly made the positional
arguments of the TDL command. This covers all argument structures described
as number, array, or boolean. ToDo: Document their syntaxes.
1598 default {
1599 lappend res [linsert $stack 0 /$name]
60

sfnt::CFF::parse_charset
(proc)
1600 }
1601 }
1602 set stack {}
1603 }
1604 }
1605 return $res
1606 }
This procedure parses the charset data from a CFF font and returns the corresponding
TDL script, typically a long sequence of /glyphname commands. The
call syntax is
parse_charset {CFF } {start} {numglyphs} {is CID?} {string-list}
{end-pos-var} ?
where {CFF } is the entire CFF table and {start} is the position within this table
where the charset data to parse begins; this is necessary since the length of this
data is not explicit in the data structure. Instead it is supposed to go on until all
glyphs are covered, which is why {numglyphs} provides this information. Finally,
if an {end-pos-var} is specified then the variable by that name in the calling
context will be set to the first position after the charset data.
Glyph names are encoded as SIDs, so the {string-list} must also be provided.
However, in a CIDFont (which is signalled by passing boolean true as {is CID?})
the SIDs are rather CIDs, so in that case the generated commands are rather
/glyphCID {GID} {CID}
The first byte determines the data format.
1607 proc sfnt::CFF::parse_charset\
{data pos nglyphs isCID stringL {endvar ""}} {
1609 binary scan $data @${pos}cu format
1610 incr pos
1611 set res "/glyphname 0 .notdef\n"
1612 if {$isCID} then {
1613 set mkcmd [list apply {{gid sid} {
1614 list /glyphCID $gid $sid
1615 }}]
1616 } else {
1617 set mkcmd [list apply {{strL gid sid} {
1618 list /glyphname $gid [lindex $strL $sid]
1619 }} $stringL]
1620 }
1621 switch -- $format 0 {
1622 append res "# Format 0 data:\n"
1623 binary scan $data @${pos}Su[expr {$nglyphs-1}] sidL
1624 set n 0; foreach sid $sidL {incr n
1625 append res [{*}$mkcmd $n $sid] \n
1626 }
1627 incr pos [expr {2*($nglyphs-1)}]
61

1628 } 1 {
1629 append res "# Format 1 data:\n"
1630 for {set n 1} {$n=0} {incr count -1} {
1634 append res [{*}$mkcmd $n $sid] \n
1635 incr n; incr sid
1636 }
1637 }
1638 } 2 {
1639 append res "# Format 2 data:\n"
1640 for {set n 1} {$n=0} {incr count -1} {
1645 append res [{*}$mkcmd $n $sid] \n
1646 incr n; incr sid
1647 }
1648 }
1649 } default {
1650 error "Unknown charset format: $format"
1651 }
1652 if {$endvar ne ""} then {
1653 uplevel 1 [list ::set $endvar $pos]
1654 }
1655 return $res
1656 }
sfnt::CFF::parse (proc) This procedure is the top-level parser for CFF tables. As such, it has the call
syntax
sfnt::CFF::parse {data} {gdict} {gdict-var}
and returns a TDL representation of the CFF table contents, but it might more
often be called as sfnt::CFF ::parse.
1657 namespace eval sfnt {
1658 interp alias {} [namespace current]::CFF\ ::parse {}\
[namespace current]::CFF::parse
1660 }
The CFF table is mostly independent of the rest of the tables, so there is
nothing strict that it can contribute to the gdict. It may however have something
similar internally.
1661 proc sfnt::CFF::parse {data gdict {var ""}} {
1662 if {$var ne ""} then {uplevel 1 [list ::set $var $gdict]}
The first thing to parse is as always the header.
1663 binary scan $data cucucucu major minor pos offSize
62

1664 set res "# Format version $major.$minor\n"
1665 if {$major != 1} then {return $res}
1666 append res [list /CFF-offSize $offSize] \n
Then comes the four global indices (name, top dict, string, and global subr).
1667 set nameL [parse_index $data $pos pos]
1668 append res "# [llength $nameL] fonts\n"
1669 set topdictL [parse_index $data $pos pos]
1670 variable standard_strings
1671 set stringL [list {*}$standard_strings {*}[
1672 parse_index $data $pos pos
1673 ]]
1674 append res "# [llength $stringL] strings (including\
[llength $standard_strings] standard)\n"
1676 set gsubrL [parse_index $data $pos pos]
With the list of strings known, the top dicts can be parsed. The following is rather
preliminary.
1677 foreach name $nameL td $topdictL {
1678 append res [list CFF-font name $name] " \{\n"
1679 set pass2L {}
1680 set isCIDFont 0
1681 foreach element [parse_dict $td 0 $stringL] {
1682 switch -- [lindex $element 0] "charset" {
1683 lappend pass2L $element
1684 continue
1685 } "CharStrings" {
1686 set charstrL [parse_index $data [lindex $element 2]]
1687 } "/ROS" {
1688 set isCIDFont 1
1689 } "Private" {
1690 set D [lrange $element 1 end]
1691 append res $element " \{\n"
1692 binary scan $data @[dict get $D start]a[dict get $D length]\
subdata
1694 foreach element [
1695 parse_dict $subdata [dict get $D start] $stringL
1696 ] {
1697 append res $element \n
1698 }
1699 append res \}\n
1700 continue
1701 }
1702 append res $element \n
1703 }
1704 foreach element $pass2L {
1705 switch -- [lindex $element 0] "charset" {
1706 append res $element " \{\n" [
1707 parse_charset $data [lindex $element 2]\
[llength $charstrL] $isCIDFont $stringL
1709 ] \}\n
63

sfnt::GPOS:
:scriptlist_by_feature
(proc)
ScriptRecord (element)
LangSysRecord (element)
1710 }
1711 }
1712 append res \}\n
1713 }
1714 return $res
1715 }
13 GPOS and GSUB tables
The GPOS and GSUB tables are organised as Directed Acyclic Graphs in three major
levels: scriptlist, feature list, and lookup list. The way they are supposed to be
used is that the client first determines what features (entries in the feature list)
should be active, by looking up the current combination of script and language in
the scriptlist. Then whenever something (forming a ligature, placing an accent,
kerning, etc.) might need to be done, the client should examine what the active
features (that employ the operation in question) wants to do, by looking up the
current situation in the referenced lookup tables, and only then get some hard
data. Experience has furthermore shown that in particular the language to feature
mapping can be very many to one, and the lookup tables can be huge. Hence it
is not feasible to simply expand the DAG into a tree, which would have been the
most straightforward way of decoding the given information.
With older metrics formats in mind, the most practical way of organising
the decoded information instead seems to be to make the lookup tables the outermost
elements, and reverse the arrows from feature to lookup and script to
feature. This means a lookuptable element typically contains one or several
FeatureRecord elements, which in turn contains ScriptRecord elements, which
contain LangSysRecord elements. These FeatureRecord elements can be viewed
as declarations of the purpose of the data in the lookuptable, and conversion
procedures would typically look at it to determine whether to (a) use the data in
this table or (b) ignore it.
The construction of such FeatureRecord elements is shared between the table
types. Because of alphabetical order, these shared things live in the GPOS
namespace.
1716 namespace eval sfnt::GPOS {
1717 variable parse_after head
1718 }
This procedure parses a scriptlist table. The call syntax is
scriptlist_by_feature {data} {position}
where the {position} is the point within the bytearray {data} where the scriptlist
table begins. The return value is a dictionary that maps feature-list indices to a
TDL encoding of the subset of the scriptlist which employs the given feature.
The outermost element type is the ScriptRecord, which carries a manda-
tory tag attribute and has a body containing LangSysRecord elements. The
LangSysRecord element also carries a tag attribute, but it is not mandatory; the
64

sfnt::GPOS:
:featurelist_by_lookup
(proc)
default LangSysRecord (if any) for a script does not carry a tag. A LangSysRecord
may also carry a required attribute, which if present must have a boolean
true value; this means the feature is marked as required for this language. A
LangSysRecord is currently always empty.
To avoid trivial elements in the dictionary, the TDL fragments are constructed
in a bottom-up manner, with an intermediate dictionary being constructed for
each script record in the table.
1719 proc sfnt::GPOS::scriptlist_by_feature {data pos} {
1720 binary scan $data @${pos}Su scount
1721 set res [dict create]
1722 for {set spos [expr {$pos+2}]} {$scount>0}\
{incr scount -1; incr spos 6} {
1724 binary scan $data @${spos}a4Su stag lofs
1725 set lpos [expr {$pos+$lofs}]
1726 binary scan $data @${lpos}SuSu defaultOfs lcount
1727 set recordL {}
1728 if {$defaultOfs} then {lappend recordL "" $defaultOfs}
1729 for {set rpos [expr {$lpos+4}]} {$lcount>0}\
{incr lcount -1; incr rpos 6} {
1731 binary scan $data @${rpos}a4Su tag ofs
1732 lappend recordL $tag $ofs
1733 }
1734 set D [dict create]
1735 foreach {tag ofs} $recordL {
1736 incr ofs $lpos
1737 set L [list LangSysRecord]
1738 if {$tag ne ""} then {lappend L tag $tag}
1739 binary scan $data @${ofs}SuSuSu LookupOrder ReqFeatureIndex\
fcount
1741 if {$ReqFeatureIndex != 0xFFFF} then {
1742 dict append D $ReqFeatureIndex $L { required yes} \n
1743 }
1744 binary scan $data @${ofs}x6Su${fcount} indexL
1745 foreach feature $indexL {
1746 dict append D $feature $L \n
1747 }
1748 }
1749 dict for {feature body} $D {
1750 dict append res $feature [list ScriptRecord tag $stag] " \{\n"\
$body "\}\n"
1752 }
1753 }
1754 return $res
1755 }
This procedure parses a featurelist as a table of features per lookup. The call
syntax is
featurelist_by_lookup {data} {pos} {body-dict}
65

Feature (element)
sfnt::GPOS:
:parse_feature (proc)
FeatureRecord (element)
where {pos} is the position in the {data} at which the featurelist starts. The
{body-dict} is indexed by feature index and contains material to be placed in the
body of the corresponding Feature element.
A Feature element marks a surrounding lookuptable as being used for this
feature. It carries a tag attribute that is the feature tag (kern, liga, etc.).
1756 proc sfnt::GPOS::featurelist_by_lookup {data pos bodyD} {
1757 binary scan $data @${pos}Su fcount
1758 set res [dict create]
1759 for {set index 0} {$index < $fcount} {incr index} {
1760 binary scan $data @[expr {6*$index+2+$pos}]a4Su tag ofs
1761 set code [list Feature tag $tag]
1762 incr ofs $pos
1763 binary scan $data @${ofs}SuSu params count
1764 if {$params} then {
1765 append code " " paramOfs [expr {$params+$pos}]]
1766 }
1767 if {[dict exists $bodyD $index]} then {
1768 append code " \{\n" [dict get $bodyD $index] "\}"
1769 }
1770 append code \n
1771 binary scan $data @${ofs}x4Su${count} iL
1772 foreach i $iL {dict append res $i $code}
1773 }
1774 return $res
1775 }
This procedure parses one feature table from a feature list, returning a TDL
encoding of the information, namely a FeatureRecord element. The call syntax
is
parse_feature {data} {prefix} {index} {required?}
where {data} is the binary representation of the feature list and {index} is the
index of the feature to parse. The {prefix} is a command prefix with the call
syntax
〈prefix〉 {lookup-index}
that is supposed to return the TDL encoding of the lookup record.
The return value consists of a single FeatureRecord element, the body of which
is produced by the {prefix} callback. A FeatureRecord element always carries a
tag attribute which identifies it further. It may also carry a required attribute
if parse_feature was called with {required?} being true, and an index feature
specifying the {index}. Finally, it will carry a FeatureParams attribute if that
field of the record is nonzero; the value of that attribute is then the position within
the {data} where the feature parameters data structure is expected to begin. No
interpretation of that data structure is given, since it depends on the tag (and
most features don’t use it).
1776 proc sfnt::GPOS::parse_feature {data prefix index required} {
66

sfnt::GPOS:
:parse_lookuplist (proc)
lookuptable (element)
1777 binary scan $data Su count
1778 if {$index >= $count} then {
1779 return "\# Asked for feature $index, but only $count in table.\n"
1780 }
1781 binary scan $data @[expr {6*$index+2}]a4Su tag ofs
1782 binary scan $data @${ofs}SuSu params count
1783 set res [list FeatureRecord tag $tag index $index]
1784 if {$required} then {append res " " [list required $required]}
1785 if {$params} then {
1786 append res " " [list FeatureParams [expr {$params+$ofs}]]
1787 }
1788 append res " \{\n"
1789 binary scan $data @${ofs}x4Su${count} iL
1790 foreach i $iL {append res [{*}$prefix $i]}
1791 append res "\}\n"
1792 return $res
1793 }
This procedure parses a lookup list, using a callback for parsing subtables. The
call syntax is
parse_lookuplist {data} {start} {prefix-list} {description-list}
{header-dict}
and the return value is the parsed data, in TDL format. The {data} is binary
data (typically the whole GPOS or GSUB table) in which the lookuplist can be found
starting at position {start}.
The {prefix-list} is a list indexed by lookup type (hence the first element is not
used) whose elements, if nonempty, are command prefixes used to parse subtables
of that type; they have the call syntax
〈prefix〉 {data} {st-start}
where {data} is as for parse_lookuplist and {st-start} is the position of the
beginning of the subtable to parse. The return value is the parsed data, in TDL
format.
The {description-list} is a list similarly indexed by lookup type, whose elements
(if nonempty) are single line descriptions of the types. These are included as
comments in the output.
The {header-dict} is a dictionary indexed by lookup index. If a lookup has an
entry in this dictionary, then the value of that entry is included in the result, just
below the description comment. It is typically used to include Feature data.
Each lookup table parsed is wrapped up in a lookuptable element, whose
body contains the component subtables. Important attributes are:
index The index of the table, as used by a /lookup element when referencing it.
type The numeric type of the table.
RightToLeft Bit 0 of LookupFlag word. If present, the value of this flag is a
boolean true.
67

IgnoreBaseGlyphs Bit 1 of LookupFlag word. If present, the value of this flag is
a boolean true.
IgnoreLigatures Bit 2 of LookupFlag word. If present, the value of this flag is
a boolean true.
IgnoreMarks Bit 3 of LookupFlag word. If present, the value of this flag is a
boolean true.
MarkFilteringSet If present, the value is an index into a GDEF table mark glyph
set structure, and mark glyphs not in the set should be ignored by the layout
engine.
MarkAttachmentType If present (i.e., nonzero), marks of attachment type different
from this should be ignored by the layout engine.
1794 proc sfnt::GPOS::parse_lookuplist\
{data start prefixL descriptionL headerD} {
1796 binary scan $data @${start}Su numLookups
1797 binary scan $data @${start}x2Su${numLookups} lookupOfsL
1798 set res ""
1799 set index 0
1800 foreach ofs $lookupOfsL {
1801 incr ofs $start
1802 binary scan $data @${ofs}Sucub8Su type MarkAttachmentType\
bitfield count
1804 set D [dict create index $index type $type]
1805 foreach bit [split $bitfield ""] name {
1806 RightToLeft IgnoreBaseGlyphs IgnoreLigatures IgnoreMarks\
MarkFilteringSet bit5 bit6 bit7
1808 } {
1809 if {$bit} then {dict set D $name 1}
1810 }
1811 if {$MarkAttachmentType} then {
1812 dict set D MarkAttachmentType $MarkAttachmentType
1813 }
1814 binary scan $data @${ofs}x6Su${count}Su subOfsL MarkFilteringSet
1815 if {[dict exists $D MarkFilteringSet]} then {
1816 dict set D MarkFilteringSet $MarkFilteringSet
1817 }
1818 append res [linsert $D 0 lookuptable] " \{\n"
1819 if {[lindex $descriptionL $type] ne ""} then {
1820 append res "# [lindex $descriptionL $type]\n"
1821 }
1822 if {[dict exists $headerD $index]} then {
1823 append res [dict get $headerD $index]
1824 }
1825 set prefix [lindex $prefixL $type]
1826 if {[llength $prefix]} then {
1827 foreach sofs $subOfsL {
68

sfnt::GPOS:
:coverage (proc)
adjust-table (element)
/adjustpair (element)
sfnt::GPOS:
:valueformat (proc)
1828 append res [{*}$prefix $data [expr {$ofs+$sofs}]]
1829 }
1830 } else {
1831 append res "# $count subtables, but no parser.\n"
1832 }
1833 append res \}\n
1834 incr index
1835 }
1836 return $res
1837 }
This procedure parses a coverage table, returning a list of GIDs. The call syntax
is
coverage {data} {start}
where {data} is binary data containing the coverage table, and {start} is the
position in {data} at which the table begins.
1838 proc sfnt::GPOS::coverage {data start} {
1839 binary scan $data @${start}SuSu format count
1840 set res {}
1841 if {$format == 1} then {
1842 binary scan $data @${start}x4Su${count} res
1843 } elseif {$format == 2} then {
1844 binary scan $data @${start}x4Su[expr {3*$count}] L
1845 foreach {first last idx} $L {
1846 for {} {$first

sfnt::GPOS:
:classtable (proc)
XPlacement x-axis adjustment of glyph position
YPlacement y-axis adjustment of glyph position
XAdvance x-axis adjustment of glyph advance width
YAdvance y-axis adjustment of glyph advance width
XPlaDevice Offset to device table
YPlaDevice Offset to device table
XAdvDevice Offset to device table
YAdvDevice Offset to device table
A {suffix} of 2 is common for data related to the second glyph in a pair.
1851 proc sfnt::GPOS::valueformat {num {suffix ""}} {
1852 set res {}
1853 set mask 1
1854 foreach field {
1855 XPlacement YPlacement XAdvance YAdvance
1856 XPlaDevice YPlaDevice XAdvDevice YAdvDevice
1857 reserved8 reserved9 reserved10 reserved11 reserved12 reserved13
1858 reserved14 reserved15
1859 } {
1860 if {$num & $mask} then {
1861 lappend res $field$suffix
1862 }
1863 set mask [expr {$mask

sfnt::GPOS:
:parse_pairpos (proc)
1882 }
1883 }
1884 set res {}
1885 while {[array size A]} {
1886 set n [llength $res]
1887 lappend res [lappend A($n)]
1888 unset A($n)
1889 }
1890 return $res
1891 }
This procedure parses a GPOS lookup type 2 subtable, returning the data as TDL.
The call syntax is
parse_pairpos {unit} {data} {start}
where {start} is the start position in {data} of the subtable to parse, and {unit}
is the font design unit (funit).
1892 proc sfnt::GPOS::parse_pairpos {funit data start} {
1893 binary scan $data @${start}SuSuSuSu format covOfs vf1 vf2
1894 if {$format < 1 || $format > 2} then {
1895 return "# Unknwon PairPos format $format.\n"
1896 }
1897 set leftL [coverage $data [expr {$start+$covOfs}]]
1898 set valueL [concat [valueformat $vf1] [valueformat $vf2 2]]
1899 set res [list adjust-table values $valueL]
1900 append res " \{\n# Format $format subtable.\n"
1901 if {$format == 1} then {
1902 binary scan $data @${start}x8Su numPairSet
1903 binary scan $data @${start}x10Su${numPairSet} ofsL
1904 foreach ofs $ofsL left $leftL {
1905 if {[catch {incr ofs $start}]} then {break}
1906 binary scan $data @${ofs}Su count
1907 binary scan $data\
@${ofs}x2S[expr {$count*(1+[llength $valueL])}] L
1909 foreach [concat right $valueL] $L {
1910 set cmd [list /adjustpair [list $left]\
[list [expr {$right & 0xFFFF}]]]
1912 foreach var $valueL {
1913 switch -glob -- $var *Device* {
1914 lappend cmd *
1915 } default {
1916 lappend cmd [expr {$funit*[set $var]}]
1917 }
1918 }
1919 append res $cmd \n
1920 }
1921 }
1922 } else {
1923 binary scan $data @${start}x8SuSuSuSu lOfs rOfs rows cols
71

1924 set leftCL [classtable $data [expr {$start+$lOfs}]]
1925 set rightCL [classtable $data [expr {$start+$rOfs}]]
1926 binary scan $data\
@${start}x16S[expr {$rows*$cols*[llength $valueL]}] L
1928 set pos 0
1929 for {set lc 0} {$lc < $rows} {incr lc} {
1930 for {set rc 0} {$rc < $cols} {incr rc} {
1931 set cmd [list /adjustpair [lindex $leftCL $lc]\
[lindex $rightCL $rc]]
1933 set nonzero 0
1934 foreach var $valueL {
1935 switch -glob -- $var *Device* {
1936 lappend cmd *
1937 set nonzero 1
1938 } default {
1939 lappend cmd [expr {$funit*[lindex $L $pos]}]
1940 if {[lindex $L $pos]} then {set nonzero 1}
1941 }
1942 incr pos
1943 }
1944 if {$nonzero} then {append res $cmd \n}
1945 }
1946 }
1947 }
1948 append res \}\n
1949 }
sfnt::GPOS::parse (proc) ToDo: Correct description
1950 proc sfnt::GPOS::parse {data gdict {var ""}} {
1951 if {$var ne ""} then {uplevel 1 [list ::set $var $gdict]}
1952 binary scan $data H8SuSuSu version scriptOfs featureOfs lookupOfs
1953 set res ""
1954 if {$version ne "00010000"} then {
1955 append res "# Version: $version" \n
1956 if {![string match 0001* $version]} then {return $res}
1957 }
1958 set scriptD [scriptlist_by_feature $data $scriptOfs]
1959 set featureD [featurelist_by_lookup $data $featureOfs $scriptD]
1960 append res [
1961 parse_lookuplist $data $lookupOfs [
1962 list "" {} [list parse_pairpos [dict get $gdict funit]]
1963 ] {
1964 ""
1965 "Single adjustment"
1966 "Pair adjustment"
1967 "Cursive attachment"
1968 "MarkToBase attachment"
1969 "MarkToLigature attachment"
1970 "MarkToMark attachment"
1971 "Context positioning"
72

1972 "Chained Context positioning"
1973 "Extension positioning"
1974 } $featureD
1975 ]
1976 }
sfnt::GSUB::parse (proc) The same procedure can also be used for the GSUB table.
1977 namespace eval sfnt::GSUB {
1978 namespace path [list [namespace parent]::GPOS]
1979 }
1980 proc sfnt::GSUB::parse {data gdict {var ""}} {
1981 if {$var ne ""} then {uplevel 1 [list ::set $var $gdict]}
1982 binary scan $data H8SuSuSu version scriptOfs featureOfs lookupOfs
1983 set res ""
1984 if {$version ne "00010000"} then {
1985 append res "# Version: $version" \n
1986 if {![string match 0001* $version]} then {return $res}
1987 }
1988 set scriptD [scriptlist_by_feature $data $scriptOfs]
1989 set featureD [featurelist_by_lookup $data $featureOfs $scriptD]
1990 append res [
1991 parse_lookuplist $data $lookupOfs {} {
1992 ""
1993 "Single"
1994 "Multiple"
1995 "Alternate"
1996 "Ligature"
1997 "Context"
1998 "Chaining Context"
1999 "Extension Substitution"
2000 "Reverse chaining context single"
2001 } $featureD
2002 ]
2003 }
Part III
Conversion to other formats
14 Generating PostScript CIDFonts
This section deals with the issues of defining a CIDFont in a PS interpreter.
2004 namespace eval sfnt::postscript\
{namespace path [list [namespace parent]]}
The TrueType-flavoured type of CIDFont (type 2) is the easiest to generate,
as CFF fonts have the CIDFont-or-Font status encoded in the binary data; for
73

sfnt::postscript:
:write_truetype (proc)
TrueType it is rather the PS wrapper that determines what kind of resource is
being defined.
This procedure creates a new file with the PS code to set up a TrueType font as
a type 2 CIDFont. The call syntax is
sfnt::postscript::write_truetype {filename} {table-dict} {extra-dict}
where the {filename} is the name of the file to write to and {table-dict} is a
dictionary with the tables (binary data) to put in the font. This should contain
the head, hhea, hmtx, maxp, loca, prep, fpgm, glyf, and cvt tables.
The {extra-dict} is a dictionary of additional information that might get put
in the generated file. The necessary entries are:
FontName The PS name given to the CIDFont (not including slash for literate
name).
Additional entries considered are:
FontInfo PS code for putting a dictionary (which is used as FontInfo dictionary)
on the operand stack.
2005 proc sfnt::postscript::write_truetype {fname tdict xdict} {
2006 set F [open $fname w]
2007 puts $F "%!PS-Adobe-3.0 Resource-CIDFont"
The CIDInit procset does not appear to be needed to define the CIDFont as such,
but it is needed to define the CMaps.
2008 puts $F {%%DocumentNeededResources: procset CIDInit}
2009 puts $F {%%IncludeResource: procset CIDInit}
2010 puts $F "%%BeginResource: CIDFont [dict get $xdict FontName]"
2011 binary scan [dict get $tdict head] @4SuSu version revision
2012 puts $F [format {%%Version: %d %d} $version $revision]
Now for the actual font dictionary. It begins with some rather basic entries.
2013 puts $F {20 dict begin}
2014 puts $F {/CIDFontType 2 def}
2015 puts $F {/FontType 42 def}
2016 set fontname [dict get $xdict FontName]
2017 puts $F "/CIDFontName /$fontname def"
2018 if {[dict exists $xdict FontInfo]} then {
2019 puts $F "/FontInfo [dict get $xdict FontInfo] def"
2020 }
Next comes the FontMatrix and FontBBox. For the latter, it is necessary to parse
and convert some entries from the head table.
2021 puts $F {/FontMatrix [1 0 0 1 0 0] def}
2022 binary scan [dict get $tdict head] @18Sux16S4 unitsPerEm bbox
2023 set bbox2 {}
2024 foreach c $bbox {lappend bbox2 [expr {double($c)/$unitsPerEm}]}
2025 puts $F [format {/FontBBox [%g %g %g %g] def} {*}$bbox2]
74

sfnt::postscript:
:write_composefonts
(proc)
After that comes some entries that have to do with the correspondence between
CIDs and GIDs. This information is not provided at the PS level, so the two are
simply set to be equal, but one might in production want to have some fallback
code for the CIDMap entry in order to support PS interpreters older than version
3011.
2026 binary scan [dict get $tdict maxp] @4Su numGlyphs
2027 puts $F "/CIDCount $numGlyphs def"
2028 puts $F {/GDBytes 2 def}
2029 puts $F {/CIDMap 0 def}
2030 puts $F {/CIDSystemInfo > def}
Next comes the big entry: the actual TrueType data. This is also used to compute
values for the XUID array.
2032 set blocks [sfnt::combine_tables $tdict \0\1\0\0]
2033 puts -nonewline $F "/sfnts "
2034 write_sfnts $F $blocks [linsert [dict keys $tdict] 0 {}] 1
2035 puts $F " def"
2036 set md5tok [::md5::MD5Init]
2037 foreach block $blocks {::md5::MD5Update $md5tok $block}
2038 binary scan [::md5::MD5Final $md5tok] I4 XUID
2039 puts $F "/XUID \[42 $XUID\] def"
Finally some degenerate but sometimes required entries are added, before the
resource is defined.
2040 puts $F {/Encoding StandardEncoding def}
2041 puts $F {/CharStrings > def}
2042 puts $F {/PaintType 0 def}
2043 puts $F {CIDFontName currentdict end /CIDFont defineresource pop}
2044 puts $F {%%EndResource}
But this is not the end of the story. Having a CIDFont is nice, but it is better to
also have some composite fonts defined on top of it.
2045 write_composefonts $F $fontname
After that, we’re quite done.
2046 puts $F {%%EOF}
2047 close $F
2048 }
This procedure writes PS code defining two composite fonts on top of a CIDFont.
The call syntax is
write_composefont {channel} {name}
and there is no particular return value; the code is written to the {channel}.
More concretely, the PS code written presumes a CIDFont named {name} (no
initial slash) has been defined, and will define the following five resources:
75

sfnt::postscript:
:write_identity_cmap
(proc)
CMap Identity-H
Font (Type 0) 〈name〉-Identity-H
CIDFont 〈name〉-rlap
CMap Shifted201C
Font (Type 0) 〈name〉-rlap-Shifted201C
—though the CMaps are only defined if they don’t already exist.
2049 proc sfnt::postscript::write_composefonts {F fontname} {
Technical complication: Some PS interpreters appear to have composefont in the
CIDInit procset rather than in the system dictionary. For that reason, this procset
is left on the dictionary stack throughout the definition of composite fonts.
2050 puts $F {/CIDInit /ProcSet findresource begin}
2051 write_identity_cmap $F
2052 puts $F "%%BeginResource: font $fontname-Identity-H"
2053 puts $F [format {/%s-Identity-H /Identity-H [/%s] composefont pop}\
$fontname $fontname]
2055 puts $F {%%EndResource}
The following is a classical method of modifying a PS font: find its font dictionary,
copy everything except the FID entry from it into a new dictionary, make changes
there, and finally define the new font. Though some operators accept (or even
require) the dictionary instead of the font name, it is still necessary to define the
thing under some name in order to make it a proper font or CIDFont.
2056 puts $F "%%BeginResource: CIDFont $fontname-rlap"
2057 puts $F "/$fontname /CIDFont findresource"
2058 puts $F {dup length 1 add dict begin}
2059 puts $F {{ 1 index /FID ne {def} {pop pop} ifelse } forall}
2060 puts $F {/CDevProc {pop 10 8 roll pop pop 0 0 10 2 roll} def}
2061 puts $F "/$fontname-rlap currentdict end /CIDFont defineresource pop"
2063 puts $F {%%EndResource}
2064 write_shifted_cmap $F 201C
2065 puts $F "%%BeginResource: font $fontname-rlap-Shifted201C"
2066 puts $F [format\
{/%s-rlap-Shifted201C /Shifted201C [/%s-rlap] composefont pop}\
$fontname $fontname]
2069 puts $F {%%EndResource}
2070 puts $F {end}
2071 }
This procedure writes PS code defining the Identity-H CMap to a channel. The
call syntax is simply
write_identity_cmap {channel}
and there is no particular return value.
The code written takes care to check whether the CMap in question already
exists, and avoids redefining it in that case. It presumes that the CIDInit procset
is present on the dictionary stack.
2072 proc sfnt::postscript::write_identity_cmap {F} {
76

sfnt::postscript:
:write_shifted_cmap
(proc)
2073 puts $F {%%BeginResource: CMap Identity-H}
2074 puts $F "/Identity-H /CMap resourcestatus {pop pop} \{"
2075 puts $F {5 dict begin begincmap}
2076 puts $F {/CMapType 1 def}
2077 puts $F {/CMapName /Identity-H def}
2078 puts $F {/CIDSystemInfo > def}
2080 puts $F {1 begincodespacerange endcodespacerange}
2081 puts $F {0 usefont}
2082 puts $F {1 begincidrange 0 endcidrange}
2083 puts $F {endcmap CMapName currentdict end}
2084 puts $F {/CMap defineresource pop}
2085 puts $F "\} ifelse"
2086 puts $F {%%EndResource}
2087 }
This procedure writes PS code defining the CMap Shifted〈hex〉 to a channel. The
call syntax is
write_shifted_cmap {channel} {hex}
where {hex} is the (typically four digit) hexadecimal number which should become
the character code of glyph 0. There is no particular return value.
The code written takes care to check whether the CMap in question already
exists, and avoids redefining it in that case. It presumes that the CIDInit procset
is present on the dictionary stack.
2088 proc sfnt::postscript::write_shifted_cmap {F hex} {
2089 scan $hex %x num
2090 set name "Shifted$hex"
2091 puts $F "%%BeginResource: CMap $name"
2092 puts $F "/$name /CMap resourcestatus {pop pop} \{"
2093 puts $F {5 dict begin begincmap}
2094 puts $F {/CMapType 1 def}
2095 puts $F "/CMapName /$name def"
2096 puts $F {/CIDSystemInfo > def}
2098 puts $F {1 begincodespacerange endcodespacerange}
2099 puts $F {0 usefont}
2100 puts $F {2 begincidrange}
2101 puts $F\
[format { %d} [expr {$num-1}] [expr {0x10000-$num}]]
2103 puts $F [format { 0} $num]
2104 puts $F {endcidrange}
2105 puts $F {endcmap CMapName currentdict end}
2106 puts $F {/CMap defineresource pop}
2107 puts $F "\} ifelse"
2108 puts $F {%%EndResource}
2109 }
77

sfnt::postscript:
:write_sfnts (proc)
This procedure writes PS code for an sfnts array of strings that together contain
a TrueType font. The call syntax is
write_sfnts {channel} {blocks} {legend} {comment?}
where {channel} is the channel to write to, {blocks} are the blocks of binary data
(one for the file header, and one for each table) to write, and {legend} is a list
of tags (the file header should be represented by an empty string) identifying the
contents of each block. The {legend} is needed to know where to split the glyf
table (if necessary).
The {comment?} is a boolean signalling whether to put in comments between
the blocks, specifying what each new block contains. These might disrupt functionality
if the font is to be made resident in the printer, but should not present
any problem if the font is embedded in a document.
The list of blocks is processed twice. On the first run, the size constraints are
enforced and the legends are turned into full comments. On the second run, the
material is written out.
2110 proc sfnt::postscript::write_sfnts {F blocks legend commentQ} {
2111 set bL {}
2112 set cL {}
2113 foreach block $blocks tag $legend {
2114 if {[string length $block]

multiple of 2 bytes long.
2128 set startPos 0; set startGlyph 0
2129 while {[string length $block] - $startPos > 65534} {
To protect against the remote possibility of someone creating a TrueType glyph
too long to fit in a PS string (or, more likely, corrupted data), there is first a check
that the beginning of the next glyph is not too far away.
2130 if {[lindex $locaL $startGlyph+1] - $startPos > 65534} {
2131 lappend bL\
[string range $block $startPos $startPos+65533]
2133 lappend cL\
[format {Freaky! Glyph %d is longer than 65534 bytes}\
$startGlyph]
2135 incr startPos 65534
2136 continue
2137 }
The binary search proceeds with upper pointing at a glyph boundary too far away
and lower pointing at one which is close enough.
2138 set lower $startGlyph; set upper $numGlyphs
2139 while {$upper-$lower>1} {
2140 set middle [expr {($lower+$upper)/2}]
2141 if {[lindex $locaL $middle]-$startPos > 65534} then {
2142 set upper $middle
2143 } else {
2144 set lower $middle
2145 }
2146 }
2147 lappend bL\
[string range $block $startPos [lindex $locaL $lower]-1]
2149 lappend cL [format {’glyf’ table, glyphs %d..%d}\
$startGlyph [expr {$lower-1}]]
2151 set startPos [lindex $locaL $lower]
2152 set startGlyph $lower
2153 }
2154 lappend bL [string range $block $startPos end]
2155 lappend cL [format {’glyf’ table, glyphs %d..%d} $startGlyph\
[expr {$numGlyphs-1}]]
2157 } else {
If some table other than glyf has become too long, it is simply split in blocks of
65532 bytes.
2158 for {set startPos 0} {$startPos

sfnt::postscript:
:togid (slave)
sfnt::postscript:
:tdl_togid (proc)
With that over, writing the data out isn’t so difficult.
2166 puts -nonewline $F "\[ "
2167 foreach block $bL cmt $cL {
2168 if {$commentQ && $cmt ne ""} then {
2169 puts -nonewline $F "% $cmt:\n

-progress A command prefix, which is called to report progress (on a per-target
basis). Its call syntax is merely
〈value〉 {message}
and there is no particular return value.
The return value of tdl_togid is the list of those {target list} elements that were
not matched to any sfnt-font. This makes it possible (at least in principle) to
chain TDL calls.
2189 proc sfnt::postscript::tdl_togid {targetL thefile script args} {
2190 set Opt(-names) {}
2191 array set Opt $args
2192 set nexttarget 0
2193 togid eval $script
2194 lrange $targetL $nexttarget end
2195 }
targetL (local var.)
As usual, the underlying operations are expected to access certain local variables
of tdl_togid using upvar. The targetL variable holds the list of targets, and the
nexttarget (local var.) nexttarget variable holds the index into targetL of the next target. The thefile
thefile (local var.) variable holds source file channel. Finally, the Opt array holds the options that
Opt (local array) were passed; one should therefore inspect the Opt(-names) and Opt(-progress)
entries (the latter of which need not be defined).
sfnt::postscript:
:psgid_unknown (proc)
sfnt::postscript:
:psgid_sfnt-font (proc)
As usual, the unknown handler recurses over the bodies of XML-style commands,
when present. Its call syntax is
sfnt::postscript::psgid_unknown {slave} {name} {argument} ∗
where {slave} is the name of the slave interpreter command to call.
2196 namespace eval sfnt::postscript {
2197 proc psgid_unknown {slave name args} {
2198 if {[
2199 regexp {^[[:alpha:]_:][[:alnum:]_:.-]*$} $name
2200 ] && [llength $args]%2 == 1} then {
2201 uplevel 1 [list $slave eval [lindex $args end]]
tailcall would fit nicely here, but it’s not worth bumping the Tcl version requirement
over.
2202 }
2203 }
2204 togid alias unknown [namespace which psgid_unknown]\
[namespace which togid]
2206 }
Output is generated (and a target is consumed) when a sfnt-font element is
encountered.
2207 proc sfnt::postscript::psgid_sfnt-font {args} {
2208 upvar 1 targetL targetL nexttarget nexttarget thefile F Opt Opt
81

2209 if {[llength $args]%2} then {
2210 set tableL [TDLtoXML::main [lindex $args end]]
2211 set args [lreplace $args end end]
2212 } else {
2213 set tableL {}
2214 }
2215 set tableD [fetch_tables $F $tableL\
{head hhea hmtx maxp loca prep fpgm glyf {cvt } name}]
2217 set target [lindex $targetL $nexttarget]
2218 if {[llength $Opt(-names)] > $nexttarget} then {
2219 set psfontname [lindex $Opt(-names) $nexttarget]
2220 } else {
A somewhat tricky issue is what to name the PS font (when the -names option
is not used as an override). The following sources are considered, in order of
increasing priority:
1. The target file name (tail minus suffix).
2. The sfnt-font attribute name.
3. Item 6 (Postscript name) in the name table.
Regardless of source, any forbidden characters are washed out of the name before
it is used.
2221 set psfontname [file rootname [file tail $target]]
2222 if {[dict exists $args name]} then {
2223 set psfontname [dict get $args name]
2224 }
2225 if {[dict exists $tableD name]} then {
2226 foreach item\
[TDLtoXML::main [name::parse [dict get $tableD name] {}]] {
2228 if {[lindex $item 0] ne "nameid"} then {continue}
2229 if {[dict get [lindex $item 1] code] != 6} then {continue}
2230 foreach item [lindex $item 2] {
2231 if {[lindex $item 0] eq "TDL:cmd" &&\
[dict get [lindex $item 1] name] eq "/namestr"} then {
2234 set psfontname [lindex $item 2 0 2 0 1]
That somewhat opaque lindex reflects the actual structure of the data after conversion
to an XML-tree. The sought string is character data, so it is element 1 of
a #text list. This character data is the only child of a TDL:arg element, so that
prefixes 2 0. The TDL:arg element is itself the first child of the TDL:cmd element
currently in item, so this prefixes another 2 0.
2235 break
2236 }
2237 }
2238 break
2239 }
2240 }
2241 }
82

2242 set extraD [dict create FontName [join [
2243 regexp -all -inline {[!-$&’*-.0-;=?-Z\\^-z|~]+} $psfontname
2244 ] ""]]
2245 dict unset tableD name
2246 if {$target eq ""} then {
2247 set msg "No target specified for /[dict get $extraD FontName]."
2248 } elseif {[dict exists $tableD glyf]} then {
2249 write_truetype $target $tableD $extraD
2250 set msg "Wrote /[dict get $extraD FontName] to $target."
2251 } else {
2252 set msg "No TrueType outlines to write to $target."
2253 }
2254 if {[info exists Opt(-progress)]} then {
2255 {*}$Opt(-progress) $msg
2256 }
2257 incr nexttarget
2258 }
2259 namespace eval sfnt::postscript {
2260 togid alias sfnt-font [namespace which psgid_sfnt-font]
2261 }
15 Conversion to fontinst metrics
The large-scale structure of the fontinstification operation is similar to that of the
psgid operation: the TOC of the input file is processed, a list of output names
must be supplied, and it is the encounter of an sfnt-font element that triggers
the generation proper.
sfnt::make_mtx (proc) The main controller is the make_mtx procedure. It has the call syntax
15.1 Gathering glyph information
Many pieces of information which occur together in fontinst metric files are spread
out over several sfnt tables, so before anything can be written, it is necessary
to collect these pieces. In particular one must determine the glyph names, since
these are what will be used as identifiers. The basic idea is (as usual) to evaluate
the body of an sfnt-font element in a separate interpreter, and define the
commands there to store away what useful information they may hold in a huge
nested dictionary, which will then be the gathering of font information.
sfnt::gather (proc) The command to call to produce a gathering is sfnt::gather, which has the call
syntax
gathering (local var.)
sfnt::gather {script}
and returns the gathering dictionary produced from the {script}.
This dictionary is stored in the gathering local variable in the context from
83

sfnt::gather:
:unknown (proc)
which the script is evaluated in the helper interpreter.
2262 proc sfnt::gather {script} {
2263 set gathering [dict create]
2264 gather::theinterp eval $script
2265 return $gathering
2266 }
Most things related to the implementation of gather resides in the sfnt::gather
namespace.
2267 namespace eval sfnt::gather {}
The unknown handler follows the pattern of sfnt::postscript::psgid_unknown,
by having the slave interpreter command name as an extra argument.
2268 proc sfnt::gather::unknown {slave name args} {
2269 if {[
2270 regexp {^[[:alpha:]_:][[:alnum:]_:.-]*$} $name
2271 ] && [llength $args]%2 == 1} then {
2272 uplevel 1 [list $slave eval [lindex $args end]]
2273 }
2274 }
sfnt::gather::theinterp The gathering interpreter, as already referenced above, is called theinterp.
(slave interp.) 2275 namespace eval sfnt::gather {
2276 interp create -safe [list [namespace current]::theinterp]
2277 theinterp hide namespace
2278 theinterp invokehidden namespace delete ::
2279
2281 }
theinterp alias unknown [namespace which unknown]\
[namespace which theinterp]
fontinst (gathering entry)
Dictionary entries whose names are GIDs (sensible interpretation: whose
names consist entirely of digits) are themselves dictionaries with information about
that particular glyph. Notable entries are:
bbox Bounding box (a four-element list {left} {bottom} {right} {top}).
ccode Hex digits of Unicode code point. Version 4.0 post tables provide these
instead of names.
CID CID value from CFF font. Would produce a distinct glyph name if combined
with registry and ordering (from /ROS element).
name PS-style glyph name.
width Advance width.
Fontinst integers are put in the fontinst sub-dictionary under their usual names.
84

setint command
/dontsetint command
sfnt::gather:
:glyphdatum (proc)
/glyphname command
/glyphccode command
/glyphCID command
/glyphbbox command
sfnt::gather:
:glyphbbox (proc)
/glyphwidth command
sfnt::gather:
:glyphwidth (proc)
/ROS command
sfnt::gather::ROS ROS (gathering (proc) entry)
Recording a /setint (or /dontsetint) can be a direct alias for dict set. (This
implies last definition wins semantics rather than the \setint first definition wins
semantics, but this difference is not expected to be relevant here.)
2282 sfnt::gather::theinterp alias /setint dict set gathering fontinst
2283 sfnt::gather::theinterp alias /dontsetint dict set gathering fontinst
The /glyphname command, on the other hand, does not quite have the arguments
in the order dict set would require. (Sometimes one misses features that TEX’s
macros provide.) Hence it is useful to define a generic glyphdatum command with
the syntax
glyphdatum {key} {GID} {datum}
that sets the {key} entry in {GID}’s subdictionary of the gathering to {datum}.
2284 namespace eval sfnt::gather {
2285 proc glyphdatum {key gid datum} {
2286 uplevel 1 [list ::dict set gathering $gid $key $datum]
2287 }
2288 theinterp alias /glyphname [namespace which glyphdatum] name
The same principle can be used for /glyphccode and /glyphCID, which may be
other sources of glyph names.
2289 theinterp alias /glyphccode [namespace which glyphdatum] ccode
2290 theinterp alias /glyphCID [namespace which glyphdatum] CID
2291 }
The same glyphdatum proc cannot be used for the /glyphbbox command, as it
needs to combine four arguments into a list.
2292 namespace eval sfnt::gather {
2293 proc glyphbbox {gid left bottom right top} {
2294 uplevel 1 [list ::dict set gathering $gid bbox\
[list $left $bottom $right $top]]
2296 }
2297 theinterp alias /glyphbbox [namespace which glyphbbox]
2298 }
Similarly the /glyphwidth command needs a separate helper proc, since it may
come with an left sidebearing x-coordinate. That optional argument is (as usual)
ignored.
2299 namespace eval sfnt::gather {
2300 proc glyphwidth {gid width {lsx 0}} {
2301 uplevel 1 [list ::dict set gathering $gid width $width]
2302 }
2303 theinterp alias /glyphwidth [namespace which glyphwidth]
2304 }
In order to make sense of a CID, it is necessary to know the registry and ordering.
The /ROS data are stored as a three element list in the ROS gathering entry.
85

FontBBox command
/Panose command
/BlueValues command
/OtherBlues command
/FamilyBlues command
/FamilyOtherBlues
command
/StemSnapH command
/StemSnapV command
2305 namespace eval sfnt::gather {
2306 proc ROS {registry ordering supplement} {
2307 uplevel 1 [list ::dict set gathering ROS\
[list $registry $ordering $supplement]]
2309 }
2310 theinterp alias /ROS [namespace which ROS]
2311 }
Another class of element command syntaxes is those where one wants the gathering
element to be the list of the element arguments. It turns out dict lappend works
well as “helper” for this.
2312 apply {args {
2313 foreach name $args {
2314 theinterp alias /$name dict lappend gathering $name
2315 }
2316 } sfnt::gather} FontBBox Panose \
Two elements which can be handled this way are FontBBox and Panose, although
this implies that one must take care to only use the first four and ten respectively
elements in these entries, as duplicates of these commands could produce longer
entries.
The vertical alignment line positions (“blue values”) elements BlueValues,
OtherBlues, FamilyBlues, and FamilyOtherBlues more naturally fit into the
lappend pattern.
2317 BlueValues OtherBlues FamilyBlues FamilyOtherBlues \
As do StemSnapH, StemSnapV, and BaseFontBlend.
2318 StemSnapH StemSnapV BaseFontBlend
/BaseFontBlend command
/FontName command Speking of BaseFont: it, FontName, and FullName are three strings which can
/FullName command usably be saved away in separate entries.
/BaseFont command
2319 namespace eval sfnt::gather {
2320 theinterp alias /FontName dict set gathering FontName
2321 theinterp alias /FullName dict set gathering FullName
2322 theinterp alias /BaseFont dict set gathering BaseFont
2323 }
15.2 Generating metrics
With the basic information gathered
86

15.3 Overall control
Part IV
Putting it all together
16 The program
16.1 Generalities
sfntutil (ensemble) The command-line program sfntutil maps directly to an ensemble of the same
name. Something is a subcommand of the program if and only if it is a subcommand
of this ensemble.
eval subcommand
source subcommand
2324 namespace eval sfntutil {
2325 namespace ensemble create
The traditional rule that things beginning with lower case letters are public and
everything else private is applied. Hence you can add a subcommand to the
program merely by defining it in the sfntutil namespace.
2326 namespace export {[a-z]*}
To provide hackability, there are two subcommands
sfntutil eval {script} {subcommand} ? {arg} ∗
sfntutil source {file} {subcommand} ? {arg} ∗
that eval and source a script and file respectively, after which they recursively
call sfntutil to interpret the rest of the arguments as another subcommand.
2327 proc eval {script args} {
2328 uplevel #0 $script
2329 if {[llength $args]} then {[namespace current] {*}$args}
2330 }
2331 proc source {fname args} {
2332 uplevel #0 [list ::source $fname]
2333 if {[llength $args]} then {[namespace current] {*}$args}
2334 }
2335 }
Note that defining commands with these names mean Tcl’s core eval and source
command cannot be called from within this namespace without qualification. For
that reason, one might want to put the actual implementation of a command in
some other namespace, and only place an alias to it here.
eval subcommand Another basic subcommand is the help command. This is mostly another ensemble,
but since ensembles cannot do something sensible when the subcommand
name is missing, a small wrapper proc is needed to handle that situation.
2336 proc sfntutil::help {{topic ""} args} {
2337 if {$topic ne ""} then {
87

2338 Help $topic {*}$args
2339 } else {
2340 puts stderr {Write: sfntutil help TOPIC; for example}
2341 puts stderr\
{ sfntutil help commands -- to get a list of commands}
2343 puts stderr\
{ sfntutil help topics -- to get a list of help topics}
2345 puts stderr\
{ sfntutil help COMMAND -- to get help for COMMAND}
2347 }
2348 }
sfntutil::Help (ensemble) One important point for the Help ensemble is that it should have an -unknown
handler. Another point is that the namespace is in all lower case.
2349 namespace eval sfntutil::help {
2350 namespace ensemble create -command [namespace parent]::Help -unknown\
[list ::apply {{cmdns helpns helpcmd topic args} {
The -unknown handler is implemented as an anonymous procedure executing in
the :: namespace, just to avoid bugs due to core commands unexpectedly having
namesakes in the sfntutil::help namespace. This means it is convenient to
embed the fully qualified names of the sfntutil and sfntutil::help namespaces
as arguments in the handler prefix (see also below).
The first thing the handler should do is admit it doesn’t have any help.
2352 puts stderr "No help for $topic."
Then it’s best to check whether the specified topic happens to be a command.
2353 if {[string match *::* $topic] ||\
[namespace which ${cmdns}::${topic}] eq ""} then {return list}
2356 set match 0
2357 foreach pattern [namespace inscope $cmdns {namespace export}] {
2359 if {[string match $pattern $topic]} then {set match 1}
2360 }
2361 if {!$match} then {return {list}}
2362 puts stderr "It is a command, though."
If it is a proc, then we might even be able to produce a guess at what its syntax
is, by looking at its argument specifiers.
2363 if {![llength [info procs\
${cmdns}::[string map {* {\*} ? {\?} \[ {\[}} $topic]]]} then\
{return {list}}
2366 set syntax [list sfntutil $topic]
2367 foreach arg [info args ${cmdns}::${topic}] {
2368 if {[info default ${cmdns}::${topic} $arg default]} then {
2369 lappend syntax ?$arg?
2370 } else {
2371 lappend syntax $arg
2372 }
2373 }
2374 if {[lindex $syntax end] eq "args"} then {
88

sfntutil::help:
:commands (proc)
sfntutil::help:
:description (array)
2375 lset syntax end "?arg"
2376 lappend syntax "...?"
2377 }
2378 puts stderr "Surface syntax is: $syntax"
Either way, the default handler must return a command prefix that does effectively
nothing, so list comes in handy.
2379 return {list}
2380 } ::} [namespace parent] [namespace current]]
2381 namespace export {[a-z]*}
2382 }
OK, it was promised above that the commands help topic would return a list of
all commands, so we’d better define sfntutil::help::commands as something
which does precisely that.
However, the above sort-of hints that the commands list should contain short descriptions
of the various commands, and that information must be stored somewhere.
A simple implementation is to keep an array in the sfntutil::help
namespace which is indexed by command name and whose entries contains the
strings.
2383 namespace eval sfntutil::help {
2384 variable description
2385 set description(help) "Get help at the command line"
2386 set description(eval) "Evaluate arg as Tcl script, then execute\
another sfntutil command"
2388 set description(source) "Source a Tcl script, then execute another\
sfntutil command"
2390 }
The commands procedure itself first builds the list of commands, and then
formats the table. It is not assumed that the namespace export patterns will
stay the same; someone might need to add specific commands not beginning with
a lower case letter.
2391 proc sfntutil::help::commands {} {
2392 set ns [namespace parent]
2393 set cmdL {}
2394 foreach pat [namespace eval $ns {namespace export}] {
2395 foreach cmd [info commands ${ns}::${pat}] {
2396 lappend cmdL [namespace tail $cmd]
2397 }
2398 }
2399 set cmdL [lsort -unique $cmdL]
2400 set width 0
2401 foreach cmd $cmdL {
2402 if {[string length $cmd] > $width} then {
2403 set width [string length $cmd]
2404 }
2405 }
89

sfntutil::help:
:topics (proc)
sfntutil::stuff:
:openfont (proc)
2406 puts stderr "Available sfntutil subcommands:"
2407 variable description
2408 foreach cmd $cmdL {
2409 puts stderr [format { %-*s -- %s} $width $cmd [expr {
2410 [info exists description($cmd)] ? $description($cmd)
2411 : "no description"
2412 }]]
2413 }
2414 }
The topics command is pretty much the same idea, but it looks in the help namespace
instead. Also, it is simpler since it doesn’t bother with tabular formatting or
descriptions.
2415 proc sfntutil::help::topics {} {
2416 set ns [namespace current]
2417 set cmdL {}
2418 foreach pat [namespace eval $ns {namespace export}] {
2419 foreach cmd [info commands ${ns}::${pat}] {
2420 lappend cmdL [namespace tail $cmd]
2421 }
2422 }
2423 puts stderr "Available help topics:\
[join [lsort -unique $cmdL] {, }]"
2424 }
2425 namespace eval sfntutil::stuff {}
This procedure opens a font file and reads its table of contents, returning that and
the open channel handle to the caller. If the file could not be interpreted, then a
check is made of whether the data might be in the resource-fork, and advice on
the matter is written to stderr.
The call syntax is
openfont {filename}
and the return value is a list
{channel} {TDL}
where the {TDL} is the contents in TDL format.
2426 proc sfntutil::stuff::openfont {fname} {
2427 set F [open $fname rb]
2428 if {![catch {
2429 sfnt::parse_file_header $F
2430 } res]} then {
2431 return [list $F $res]
2432 }
2433 set attrD [file attributes $fname]
2434 if {[dict exists $attrD -rsrclength] &&\
[dict get $attrD -rsrclength] > 0} then {
90

sfntutil::stuff:
:stdout (proc)
sfntutil::stuff:
:alloptions (proc)
2436 puts stderr "Could not find font data in file $fname."
2437 puts stderr "It has a resource fork though, which I cannot open\
directly;"
2439 puts stderr "the font data might be in there. To make it\
accessible, do as follows:\n"
2441 puts stderr " 1. Mount a writable single-fork file system.\n"
2442 puts stderr " If you don’t have any physical single-fork file\
system at hand"
2444 puts stderr " (or can’t tell, because you’re not sure what it\
means), then"
2446 puts stderr " a writable disk image will do the trick. Use the\
Disk Utility"
2448 puts stderr " to create one, selecting MS-DOS or Unix as file\
system.\n"
2450 puts stderr " 2. In the Finder, drag $fname unto the other\
filesystem.\n"
2452 puts stderr " 3. Try the sfntutil command again, on the newly\
created file"
2454 puts stderr " ._[file tail $fname] in the other filesystem.\n"
2455 }
2456 return [list $F [list /error $res]]
2457 }
This procedure is used for sending data to stdout. It handles reconfiguring the
channel to use UTF-8. It also only writes something in the 〈cmdline〉 setting,
but always returns its argument as given. This is easier on the eyes when calling
sfntutil as a Tcl command.
The call syntax is
sfntutil::stuff::stdout {data}
2458 proc sfntutil::stuff::stdout {data} {
2459 〈∗cmdline〉
2460 fconfigure stdout -encoding utf-8
2461 puts stdout $data
2462 〈/cmdline〉
2463 return $data
2464 }
This is Yet Another option parser, since the option syntax of the one in tcllib (i.e.,
cmdline) wasn’t quite what I wanted. . . With this, options are entered on the form
-- ? 〈name〉(=〈value〉) ?
and they are returned in an array indexed by 〈name〉. A missing 〈value〉 (which
would typically happen for boolean switches) is treated as the empty string. Note
that each option is precisely one word.
The two “empty” options ‘-’ and ‘--’ have special interpretation. ‘-’ quotes the
following argument from being interpreted as an option. ‘--’ quotes all subsequent
arguments from being interpreted as options.
91

sfntutil::help:
:options (alias)
The command which does this has the syntax
stuff::alloptions {target-array} {args-var} {optlist}
where {target-array} is the name of the array into which the parsed option values
should be stored, {args-var} is the name of the variable (which will be modified)
holding the list of arguments to parse out all options from, and {optlist} is the
list of allowed option 〈name〉s (i.e., without dashes).
2465 proc sfntutil::stuff::alloptions {arrname argsname optlist} {
2466 upvar 1 $arrname Opt $argsname argv
2467 set newL {}
2468 set quoted 0
2469 set pos 0; foreach arg $argv {
2470 if {$quoted} then {
2471 lappend newL $arg
2472 incr quoted -1
2473 } else {
2474 switch -glob -- $arg "-" {
2475 set quoted 1
2476 } "--" {
2477 set quoted -1
2478 } "-*" {
2479 regexp {^--?([^=]*)=?(.*)$} $arg "" name value
2480 if {$name ni $optlist} then {
2481 puts stderr "Unknown option -$name ignored."
2482 } else {
2483 set Opt($name) $value
2484 }
2485 } default {
2486 lappend newL $arg
2487 }
2488 }
2489 }
2490 set argv $newL
2491 }
Since the above is going to be the standard option processor in sfntutil, it warrants
a help topic.
2492 interp alias {} sfntutil::help::options {} puts stderr {
2493 Options of sfntutil subcommands usually come at the end,
2494 i.e., after the subcommand and its direct argument.
2495 Each subcommand has its own set of options.
2496 Unknown options are warned about but ignored.
2497
2498 Every option is precisely one command word.
2499 An option has one of the following forms:
2500 -NAME
2501 --NAME
2502 -NAME=VALUE
92

2503 --NAME=VALUE
2504 The forms with one dash are equivalent to those with two dashes.
2505 Every option can take a VALUE, but those that are boolean switches
2506 will ignore it.
2507
2508 The two forms - and -- can be used to quote subsequent words
2509 from being interpreted as options.
2510 A single dash quotes one following word.
2511 A double dash quotes all following words.
2512 }
16.2 Specific commands
sfntutil::dump (proc) This procedure implements the dump command. It has the call syntax
dump {font file} {option} ∗
2513 set sfntutil::help::description(dump) "Dump sfnt-housed data in text\
form"
2515 proc sfntutil::dump {fontfile args} {
2516 array set Opt {format TDL detail metrics}
2517 stuff::alloptions Opt args {format detail only}
2518 lassign [stuff::openfont $fontfile] F data
2519 if {[string tolower $Opt(detail)] ne "toc"} then {
2520 if {[info exists Opt(only)]} then {
2521 set which [split $Opt(only) ,]
2522 } else {
2523 set which *
2524 }
2525 set data [sfnt::expand::main $F $data -which $which]
2526 }
2527 close $F
2528 switch -- [string toupper $Opt(format)] "TDL" {
2529 set data [prettyTDL::prettyprint $data]
2530 } "XML" {
2531 set data [TDLtoXML::main $data]
2532 } "TEX" {
2533 set data [TDLtoTeX::main $data]
2534 }
2535 stuff::stdout $data
2536 }
And now the help text.
2537 interp alias {} sfntutil::help::dump {} puts stderr {
2538 sfntutil dump - Dump contents of sfnt file as text to standard out
2539 Syntax:
2540 sfntutil dump FILENAME ?OPTION ...?
2541
2542 Recognised options:
2543 -format: The output format. One of (case ignored):
93

2544 TDL (default) - Tcl Data Language: the internal format of\
sfntutil.
2545 XML - Translation to XML of the TDL data.
2546 TeX - Translation to TeX of the TDL data.
2547 raw - Like TDL, but not prettyprinted. Contains some extra\
comments
2548 giving more details of how data was encoded in the file,
2549 so can be useful for debugging.
2550 -detail: The detail in the file contents are given. One of (case
2551 ignored):
2552 toc - Only give a "table of contents" of the file, listing the
2553 individual sfnt tables but none of their contents.
2554 metrics (default) -
2555 Parse tables that might be relevant for metrics, but
2556 don’t bother about outlines or rendering.
2557 -only: If not taking -detail=toc, then this selects which tables
2558 to parse. The value is a comma-separated list of
2559 [string match] (i.e., glob-style) patterns, and tables are
2560 parsed if their tag matches some element in this list.
2561 Example:
2562 -only=h*,OS/2
2563 Parse tables beginning with h (head, hhea, hmtx, etc.), and
2564 also the OS/2 table.
2565 }
sfntutil::psgid (proc) This procedure is the top-level implementation of the psgid command, which
generates PS file(s) defining the font(s) as CIDFonts with the GID as CID. The
call syntax is
sfntutil psgid {source font file} {target file/option} ∗
Output is written to the {target file}s.
2566 set sfntutil::help::description(psgid) "Convert to PS CID-font(s)"
2568 proc sfntutil::psgid {fontfile args} {
2569 stuff::alloptions Opt args {names}
If a target name does not have a suffix, then a .psfont suffix is appended.
2570 set nameL {}
2571 foreach name $args {
2572 if {[file extension $name] eq ""} then {
2573 lappend nameL $name.psfont
2574 } else {
2575 lappend nameL $name
2576 }
2577 }
2578 lassign [stuff::openfont $fontfile] F script
2579 foreach name [
2580 sfnt::postscript::tdl_togid $nameL $F $script {*}[
2581 if {[info exists Opt(names)]} then {
2582 list -names [split [string trim $Opt(names) /] /]
94

2583 }
2584 ] -progress {puts stdout}
2585 ] {
2586 puts stdout "Ignoring unused target $name."
2587 }
2588 }
And now the help text.
2589 interp alias {} sfntutil::help::psgid {} puts stderr {
2590 sfntutil psgid - Use outline data to generate Postscript CIDFont(s)
2591 having CID=GID.
2592 Syntax:
2593 sfntutil psgid SOURCE ?OPTION-or-TARGET ...?
2594
2595 For each font within the SOURCE, PS code defining that font as
2596 a CIDFont is written to one of the TARGET files (overwriting previous
2597 content without asking). If there are more fonts than TARGETs, or
2598 more TARGETs than fonts, then nothing is done for the superfluous
2599 items. A .psfont suffix is appended to TARGETs without extension.
2600
2601 The only recognised option is -names, which takes as value
2602 a slash-separated list of PS names. If provided, then names in this
2603 list will override names found in the SOURCE. Extra slashes at the
2604 beginning or end of the value are ignored, so you may also supply
2605 the concatenation of the font names written with initial slashes.
2606
2607 One output line is generated for each font in the SOURCE. psgid without
2608 TARGETs can be used to produce a listing of fonts in the SOURCE.
2609 }
2610 〈/pkg〉
2611 〈∗cmdline〉
2612 if {![llength $argv]} then {set argv help}
2613 sfntutil {*}$argv
2614 〈/cmdline〉
References
[1] mpsuzuki et al.: plan to support sfnt-wrapped CID-keyed font. Thread on
freetype-devel@nongnu.org mailing list, 2008-08-29 ff. http://lists.nongnu.
org/archive/html/freetype-devel/2008-08/msg00038.html
Index
Numbers written in italic refer to the page where the corresponding entry is described;
numbers underlined refer to the code line of the definition; numbers in
roman refer to the code lines where the entry is used.
Symbols
/AppleSingleHomeFS (element) . . . . 18
95

BaseFont (element), sfnt::gather:
:theinterp interpreter . . . . . 86
/BaseFontBlend (element) . . . . . . . . 60
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 86
/BaseFontName (element) . . . . . . . . 59
/BlueValues (element) . . . . . . . . . . 59
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 86
/FamilyBlues (element) . . . . . . . . . 59
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 86
/FamilyName (element) . . . . . . . . . . 59
/FamilyOtherBlues (element) . . . . . 59
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 86
/FontBBox (element) . . . . . . . . . . . . 30
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 86
/FontName (element) . . . . . . . . . . . . 59
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 86
/FullName (element) . . . . . . . . . . . . 59
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 86
/Notice (element) . . . . . . . . . . . . . . 59
/OtherBlues (element) . . . . . . . . . . 59
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 86
/Panose (element) . . . . . . . . . . . . . . 32
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 86
/PostScript (element) . . . . . . . . . . 59
/ROS (element) . . . . . . . . . . . . . . . . 60
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 85
/StemSnapH (element) . . . . . . . . . . . 59
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 86
/StemSnapV (element) . . . . . . . . . . . 60
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 86
/Weight (element) . . . . . . . . . . . . . . 59
/adjustpair (element) . . . . . . . . . . 69
/caretSlope (element) . . . . . . . . . . 36
/charmap (element) . . . . . . . . . . . . . 45
prettyTDL::theinterp interpreter 46
/datum (element) . . . . . . . . . . . . . . 24
sfnt::expand::theinterp
interpreter . . . . . . . . . . . . . . 24
96
/dontsetint (element) . . . . . . . . . . 14
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 85
/flag (element) . . . . . . . . . . . . . . . 29
/glyphCID (element) . . . . . . . . . . . . 61
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 85
/glyphbbox (element) . . . . . . . . . . . 50
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 85
/glyphccode (element) . . . . . . . . . . 40
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 85
/glyphname (element) . . . . . . . . . . . 38
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 85
/glyphwidth (element) . . . . . . . . . . 36
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 85
/hexdump (element) . . . . . . . . . . . . . 27
/kernpair (element) . . . . . . . . . . . . 52
/minMaxPSMem (element) . . . . . . . . . 39
/namebytearray (element) . . . . . . . . 43
/namestr (element) . . . . . . . . . . . . . 42
/scriptsizepos (element) . . . . . . . . 32
/setint (element) . . . . . . . . . . . . . . 13
sfnt::gather::theinterp
interpreter . . . . . . . . . . . . . . 85
/version (element) . . . . . . . . . . . . . 59
/when (element) . . . . . . . . . . . . . . . 30
TDLtoTeX::theinterp interpreter 31
#loca (gdict entry) . . . . . . . . . . . . . 51
A
adjust-table (element) . . . . . . . . . 69
alloptions (proc), sfntutil::stuff
namespace . . . . . . . . . . . . . . 91
AppleSingleEntity (element) . . . . . 18
ascender (fontinst integer) . . . . . . . 31
B
base_258_glyphs (var.), sfnt::post
namespace . . . . . . . . . . . . . . 38
BaseFont (gathering entry) . . . . . . . 86
BaseFontBlend (gathering entry) . . . 86
baselineskip (fontinst integer) . . . . 31
BlueValues (gathering entry) . . . . . 86
C
classtable (proc), sfnt::GPOS namespace
. . . . . . . . . . . . . . . . . . 70

cmap (element) . . . . . . . . . . . . . . . . 46
code (attribute) . . . . . . . . . . . . . . . 41
combine_tables (proc), sfnt namespace
. . . . . . . . . . . . . . . . . . 20
commands (proc), sfntutil::help
namespace . . . . . . . . . . . . . . 89
coverage (proc), sfnt::GPOS namespace
. . . . . . . . . . . . . . . . . . 69
D
descender (fontinst integer) . . . . . . 31
description (array), sfntutil::help
namespace . . . . . . . . . . . . . . 89
description (attribute) . . . . . . . . . 41
description (var.), sfnt::name namespace
. . . . . . . . . . . . . . . . . . 41
descriptor (element) . . . . . . . . . . . 32
designunits (fontinst variable) . . . . 30
dump (proc), sfntutil namespace . . 93
E
enc (attribute) . . . . . . . . . . . . . . . . 46
encoding_convertfrom (proc), sfnt:
:name namespace . . . . . . . . . 43
F
FamilyBlues (gathering entry) . . . . . 86
FamilyOtherBlues (gathering entry) 86
Feature (element) . . . . . . . . . . . . . . 66
featurelist_by_lookup (proc), sfnt:
:GPOS namespace . . . . . . . . . 65
FeatureRecord (element) . . . . . . . . 66
fetch_tables (proc), sfnt namespace 19
FNAM (table) . . . . . . . . . . . . . . . . . . 33
FOND-association (tag) . . . . . . . . . 34
FontBBox (gathering entry) . . . . . . . 86
fontDirectionHint (fontinst variable) 30
fontinst (gathering entry) . . . . . . . 84
FontName (gathering entry) . . . . . . . 86
FontRevision (element) . . . . . . . . . 29
format (attribute) . . . . . . . . . . . . . 46
FullName (gathering entry) . . . . . . . 86
funit (gdict entry) . . . . . . . . . . . . . 21
G
gather (proc), sfnt namespace . . . . 83
gathering (local var.) . . . . . . . . . . . 83
gdict (local var.) . . . . . . . . . . . . . . 24
glyphbbox (proc), sfnt::gather
namespace . . . . . . . . . . . . . . 85
97
glyphdatum (proc), sfnt::gather
namespace . . . . . . . . . . . . . . 85
glyphwidth (proc), sfnt::gather
namespace . . . . . . . . . . . . . . 85
H
Help (ensemble), sfntutil namespace 88
hexdump_char_from_byte (proc), sfnt
namespace . . . . . . . . . . . . . . 28
I
interpreter (theinterp), sfnt:
:expand namespace . . . . . . . 22
K
kern-table (element) . . . . . . . . 52, 54
L
lang (attribute) . . . . . . . . . . . . . . . 46
LangSysRecord (element) . . . . . . . . 64
language (attribute) . . . . . . . . . . . . 46
linegap (fontinst integer) . . . . . . . . 31
lookuptable (element) . . . . . . . . . . 67
lowestReadablePPEM (fontinst variable)
. . . . . . . . . . . . . . . . . . 30
M
Mac-resource (element) . . . . . . . . . 17
main (proc)
sfnt::expand namespace . . . . . . 24
TDLtoTeX namespace . . . . . . . . . 12
TDLtoXML namespace . . . . . . . . . . 7
make_mtx (proc), sfnt namespace . . 83
N
nameid (element) . . . . . . . . . . . . . . 41
nexttarget (local var.) . . . . . . . . . . 81
numGlyphs (gdict entry) . . . . . . . . . 21
O
O (local array) . . . . . . . . . . . . . 4, 12, 24
offset (attribute) . . . . . . . . . . . . . 46
openfont (proc), sfntutil::stuff
namespace . . . . . . . . . . . . . . 90
Opt (local array) . . . . . . . . . . . . . . . 81
options (alias), sfntutil::help
namespace . . . . . . . . . . . . . . 92
OtherBlues (gathering entry) . . . . . 86
P
Panose (gathering entry) . . . . . . . . . 86
parse (proc)
sfnt::GSUB namespace . . . . . . . 73

sfnt::hhea namespace . . . . . . . 35
sfnt::hmtx namespace . . . . . . . 36
sfnt::maxp namespace . . . . . . . 35
sfnt::〈table〉 namespace . . . . . . 22
sfnt::CFF namespace . . . . . . . . 62
sfnt::cmap namespace . . . . . . . 46
sfnt::fdsc namespace . . . . . . . 33
sfnt::FNAM namespace . . . . . . . 33
sfnt::glyf namespace . . . . . . . 51
sfnt::GPOS namespace . . . . . . . 72
sfnt::head namespace . . . . . . . 29
sfnt::HFMX namespace . . . . . . . 37
sfnt::kern namespace . . . . . . . 51
sfnt::loca namespace . . . . . . . 51
sfnt::name namespace . . . . . . . 44
sfnt::OS/2 namespace . . . . . . . 31
sfnt::post namespace . . . . . . . 39
parse_after (var.)
sfnt::〈table〉 namespace . . . . . . 22
sfnt::glyf namespace . . . . . . . 51
sfnt::HFMX namespace . . . . . . . 37
sfnt::kern namespace . . . . . . . 51
sfnt::loca namespace . . . . . . . 51
sfnt::OS/2 namespace . . . . . . . 31
parse_applesingle (proc), sfnt
namespace . . . . . . . . . . . . . . 18
parse_as_hexdump (proc), sfnt namespace
. . . . . . . . . . . . . . . . . . 27
parse_bboxes (proc), sfnt::glyf
namespace . . . . . . . . . . . . . . 50
parse_charset (proc), sfnt::CFF
namespace . . . . . . . . . . . . . . 61
parse_dict (proc), sfnt::CFF namespace
. . . . . . . . . . . . . . . . . . 58
parse_feature (proc), sfnt::GPOS
namespace . . . . . . . . . . . . . . 66
parse_file_header (proc), sfnt
namespace . . . . . . . . . . . . . . 14
parse_format_0 (proc)
sfnt::cmap namespace . . . . . . . 48
sfnt::kern namespace . . . . . . . 53
parse_format_2 (proc)
sfnt::cmap namespace . . . . . . . 48
sfnt::kern namespace . . . . . . . 53
parse_format_3 (proc), sfnt::kern
namespace . . . . . . . . . . . . . . 55
parse_index (proc), sfnt::CFF namespace
. . . . . . . . . . . . . . . . . . 56
parse_loca (proc), sfnt::glyf namespace
. . . . . . . . . . . . . . . . . . 50
98
parse_long_subtable (proc), sfnt:
:kern namespace . . . . . . . . . 54
parse_lookuplist (proc), sfnt::GPOS
namespace . . . . . . . . . . . . . . 67
parse_pairpos (proc), sfnt::GPOS
namespace . . . . . . . . . . . . . . 71
parse_resfile_map (proc), sfnt
namespace . . . . . . . . . . . . . . 17
parse_subtable (proc), sfnt::kern
namespace . . . . . . . . . . . . . . 52
PELdict (proc), sfnt::name namespace
. . . . . . . . . . . . . . . . . . 42
plat-enc-lang (element) . . . . . . . . 46
platform (attribute) . . . . . . . . . . . . 46
post (table) . . . . . . . . . . . . . . . . . . 38
prettyprint (proc), prettyTDL namespace
. . . . . . . . . . . . . . . . . . . 4
PSBaseName . . . . . . . . . . . . . . . . . . 44
psgid (proc), sfntutil namespace . 94
psgid_sfnt-font (proc), sfnt:
:postscript namespace . . . . 81
psgid_unknown (proc), sfnt:
:postscript namespace . . . . 81
PSType0Name . . . . . . . . . . . . . . . . . . 44
Q
quotechars (proc), TDLtoTeX namespace
. . . . . . . . . . . . . . . . . . 11
R
rawnestdict (proc), sfnt::name
namespace . . . . . . . . . . . . . . 45
res (local var.) . . . . . . . . . . 4, 7, 12, 22
ROS (gathering entry) . . . . . . . . . . . 85
ROS (proc), sfnt::gather namespace 85
S
scriptlist_by_feature (proc), sfnt:
:GPOS namespace . . . . . . . . . 64
ScriptRecord (element) . . . . . . . . . 64
setint (proc), TDLtoTeX namespace . 14
sfnt-font (element) . . . . . . . . . . . . 14
sfnt::expand::theinterp
interpreter . . . . . . . . . . . . . . 24
sfnt-font (proc), sfnt::expand
namespace . . . . . . . . . . . . . . 24
sfnt-table (element) . . . . . . . . . . . 14
sfnt::expand::theinterp
interpreter . . . . . . . . . . . . . . 23

sfnt-table (proc), sfnt::expand
namespace . . . . . . . . . . . . . . 23
sfnt::〈table〉 (namespace) . . . . . . . 21
sfntutil (ensemble), global namespace
. . . . . . . . . . . . . . . . . . 87
eval subcommand . . . . . . . . . 87
source subcommand . . . . . . . 87
slash (proc)
prettyTDL namespace . . . . . . . . . 5
TDLtoTeX namespace . . . . . . . . . 13
TDLtoXML namespace . . . . . . . . . . 8
standard_strings (var.), sfnt::CFF
namespace . . . . . . . . . . . . . . 56
stdout (proc), sfntutil::stuff
namespace . . . . . . . . . . . . . . 91
StemSnapH (gathering entry) . . . . . . 86
StemSnapV (gathering entry) . . . . . . 86
sub1 (fontinst integer) . . . . . . . . . . . 31
sub2 (fontinst integer) . . . . . . . . . . . 31
sup2 (fontinst integer) . . . . . . . . . . . 31
T
table (local array) . . . . . . . . . . . . . 23
table0L (local var.) . . . . . . . . . . . . 23
table1L (local var.) . . . . . . . . . . . . 23
targetL (local var.) . . . . . . . . . . . . 81
tclenc (array), sfnt::name namespace
. . . . . . . . . . . . . . . . . . 42
TDL:arg (XML element) . . . . . . . . . . 7
TDL:cmd (XML element) . . . . . . . . . . 7
tdl_togid (proc), sfnt::postscript
namespace . . . . . . . . . . . . . . 80
thefile (local var.) . . . . . . . . . 24, 81
theinterp (slave interp.)
prettyTDL namespace . . . . . . . . . 4
sfnt::gather namespace . . . . . . 84
TDLtoTeX namespace . . . . . . . . . 10
99
TDLtoXML namespace . . . . . . . . . . 7
togid (slave), sfnt::postscript
namespace . . . . . . . . . . . . . . 80
topics (proc), sfntutil::help namespace
. . . . . . . . . . . . . . . . . . 90
U
underlinetop (fontinst variable) . . . 39
unknown (proc)
prettyTDL namespace . . . . . . . . . 5
sfnt::expand namespace . . . . . . 22
sfnt::gather namespace . . . . . . 84
TDLtoTeX namespace . . . . . . . . . 12
TDLtoXML namespace . . . . . . . . . . 7
V
valueformat (proc), sfnt::GPOS
namespace . . . . . . . . . . . . . . 69
W
when (proc), TDLtoTeX namespace . . 31
write_composefonts (proc), sfnt:
:postscript namespace . . . . 75
write_identity_cmap (proc), sfnt:
:postscript namespace . . . . 76
write_sfnts (proc), sfnt:
:postscript namespace . . . . 78
write_shifted_cmap (proc), sfnt:
:postscript namespace . . . . 77
write_truetype (proc), sfnt:
:postscript namespace . . . . 74
X
xml_from_treenode (proc), TDLtoXML
namespace . . . . . . . . . . . . . . . 9
xml_from_trees (proc), TDLtoXML
namespace . . . . . . . . . . . . . . . 8