more logic for reading tables with rather peculiar dependencies

Sigrid Solveig Haflínudóttir committed 2 years ago

Commit f152a7f1 parent 0ce46015 files · +1188 −526Browse files

Unified · Split

5 files

gen.rkt +97 −50
otf.c +818 −349
otf.h +171 −84
otf.rkt +101 −42
test.c +1 −1

 (require (for-syntax racket/format))
 (require (for-syntax syntax/parse))
 (require (for-syntax racket/contract))
+(require (for-syntax racket/string))
 (require racket/contract)
 (require racket/generic)
   (-> string? boolean?)
   (string-prefix? s "typedef"))
+(define/contract (extra-context-ref? ref)
+  (-> symbol? boolean?)
+  (string-prefix? (symbol->string ref) "o->"))
 (define/contract (format f)
   (-> procedure? string?)
   (define-values (a b) (partition c-typedef? (flatten (map f cmplxs))))
   (if (= (length lst) 1) (list* stmt lst) (list (string-append stmt "{") lst "}")))
 (define (wrap-cond-c cond lst)
+  (define (fmt-ref ref)
+    (if (extra-context-ref? ref) ref (~a "v->" ref)))
   (match cond
     [#f lst]
     [(list op ref n ...)
-     (block (~a "if(" (string-join (map (λ (n) (~a "v->" ref " " op " " n)) n) " || ") ")")
+     (block (~a "if(" (string-join (map (λ (n) (~a (fmt-ref ref) " " op " " n)) n) " || ") ")")
             (indent lst))]))
 (define (invert-c op)
          [#f
           (if (or declared (not (field-unused? f)))
               (if index
-                  (~a (if declared (~a (name (field-type f)) " ") "")
+                  (list (~a (if declared (~a (name (field-type f)) " ") "")
-                      ref
+                            ref
-                      " = "
+                            " = "
-                      ((type-parse (field-type f)) b index)
+                            ((type-parse (field-type f)) b index)
-                      ";")
+                            ";")
+                        (if (field-context? f) (~a "o->" (field-name f) " = " ref ";") empty))
                   (list
                    (if declared
                        (~a (name (field-type f)) " " ref ";")
   (define v (assoc 'cond (field-attrs f)))
   (and v (rest v)))
+(define (field-context? f)
+  (field-attr f '->o))
 (define/contract (field-count f)
   (-> field? (or/c false/c number? string?))
   (define (fmt-expr e)
       [(number? e) e]
       [(list? e)
        (match e
-         [(list op x y) (~a (fmt-expr x) op (fmt-expr y))])]
+         [(list op x y) (~a "(" (fmt-expr x) op (fmt-expr y) ")")])]
+      [(and (symbol? e) (extra-context-ref? e)) (~a e)]
       [(symbol? e) (~a "v->" e)]))
   (define e (field-attr f 'count))
   (and e (fmt-expr e)))
                 (~a (if is-ptr "\t" "")
                     "print_"
                     (cmplx-name t)
-                    "(f, indent+indentΔ, "
+                    "(f, indent+indentΔ, o, "
                     (if is-ptr "" "&")
                     "v->"
                     (field-name f)
 (define (filter-extra extra key)
   (flatten (filter-map (λ (e) (and (eq? (car e) key) (cdr e))) extra)))
-(define-struct cmplx (name fields tag extra)
+(define-struct cmplx (name fields tag extra after)
   #:transparent
   #:methods gen:code
   [(define/generic super-gen-h gen-h)
    (define/generic super-gen-c gen-c)
    (define (gen-h c)
-     (flatten
+     (flatten (append (list (~a "typedef struct " (cmplx-name c) " " (cmplx-name c) ";")
-      (append
+                            (~a "")
-       (list (~a "typedef struct " (cmplx-name c) " " (cmplx-name c) ";")
+                            (~a "struct " (cmplx-name c) " {"))
-             (~a "")
+                      (indent (map super-gen-h (cmplx-fields c)))
-             (~a "struct " (cmplx-name c) " {"))
+                      (indent (filter-extra (cmplx-extra c) 'field))
-       (indent (map super-gen-h (cmplx-fields c)))
+                      (list (~a "};")
-       (indent (filter-extra (cmplx-extra c) 'field))
+                            (~a "")
-       (list (~a "};")
+                            (~a "int read_" (cmplx-name c) "(Otf *o, " (cmplx-name c) " *v);")
-             (~a "")
+                            (~a "void print_"
-             (~a "int read_" (cmplx-name c) "(Otf *o, " (cmplx-name c) " *v);")
+                                (cmplx-name c)
-             (~a "void print_" (cmplx-name c) "(Biobuf *f, int indent, " (cmplx-name c) " *v);")))))
+                                "(Biobuf *f, int indent, Otf *o, "
+                                (cmplx-name c)
+                                " *v);")))))
    (define (gen-c c b index)
      (define (no-vla? f)
        (define cnt (field-count f))
                                                     (parse-group fields)))])
                           lst))))
      (flatten
-      (append (list (~a "")
+      (append
-                    (~a "int")
+       (list (~a "")
-                    (~a "read_" (cmplx-name c) "(Otf *o, " (cmplx-name c) " *v)")
+             (~a "int")
-                    (~a "{")
+             (~a "read_" (cmplx-name c) "(Otf *o, " (cmplx-name c) " *v)")
-                    (~a "\tu8int *b;"))
+             (~a "{")
-              (indent (map gen-group-c (group-fields (cmplx-fields c))))
+             (~a "\tu8int *b;"))
-              (indent (filter-extra (cmplx-extra c) 'read))
+       (indent (map gen-group-c (group-fields (cmplx-fields c))))
-              (list (~a "\treturn 0;")
+       (indent (filter-extra (cmplx-extra c) 'read))
-                    (~a "err:")
+       (list (~a "\treturn 0;")
-                    (~a "\twerrstr(\"%s: %r\", \"" (cmplx-name c) "\");")
+             (~a "err:")
-                    (~a "\treturn -1;")
+             (~a "\twerrstr(\"%s: %r\", \"" (cmplx-name c) "\");")
-                    (~a "}"))
+             (~a "\treturn -1;")
-              (list (~a "")
+             (~a "}"))
-                    (~a "void")
+       (list (~a "")
-                    (~a "print_" (cmplx-name c) "(Biobuf *f, int indent, " (cmplx-name c) " *v)")
+             (~a "void")
-                    (~a "{")
+             (~a "print_" (cmplx-name c) "(Biobuf *f, int indent, Otf *o, " (cmplx-name c) " *v)")
-                    (indent (map field-print-c (cmplx-fields c)))
+             (~a "{")
-                    (indent (filter-extra (cmplx-extra c) 'print))
+             (indent (map field-print-c (cmplx-fields c)))
-                    (~a "}")))))
+             (indent (filter-extra (cmplx-extra c) 'print))
+             (~a "\tUSED(o);")
+             (~a "}")))))
    (define (c-type c)
      (cmplx-name c))])
 (define-syntax (mkcmplx stx)
   (syntax-parse stx
-    [(_ typ:id fields:expr ...+ (~optional (~seq #:tag tag)) (~optional (~seq #:extra extra:expr)))
+    [(_ typ:id
+        fields:expr ...+
+        (~optional (~seq #:tag tag))
+        (~optional (~seq #:extra extra:expr))
+        (~optional (~seq #:after after)))
      #:declare tag (expr/c #'tag/c #:name "table tag")
      (begin
        (set! typenames (cons (syntax-e #`typ) typenames))
        #'(begin
            (define tag- (~? (~@ tag.c) #f))
-           (define typ (make-cmplx `typ (mkfields [~@ fields] ...) tag- (~? (~@ extra) empty)))
+           (define typ
+             (make-cmplx `typ
+                         (mkfields [~@ fields] ...)
+                         tag-
+                         (~? (~@ extra) empty)
+                         (~? (~@ after) empty)))
            (set! cmplxs (append cmplxs (list typ)))
            (when tag-
              (set! tagged (append tagged (list typ))))))]))
     (pattern op:id
       #:when (member (syntax-e #'op) '(+ - / *))))
+  (define-syntax-class oref
+    #:description "extra context field reference"
+    (pattern oref:id
+      #:when (string-prefix? (symbol->string (syntax-e #'oref)) "o->")))
   (define-syntax-class ref
     #:description "field reference"
     (pattern ref:id
       #:with type (cadr (assoc (syntax-e #'ref) fields))))
   (syntax-parse stx
-    [(_ _ ({~literal at} ref:ref))
+    [(_ type name {~literal ->o}) #''(->o #t)]
+    [(_ _ _ ({~literal at} ref:ref))
      #:fail-when (not (type-offset? (syntax-e #'ref.type))) "can't be used as an offset"
      #''(at ref)]
-    [(_ type {~literal hex})
+    [(_ type _ {~literal hex})
      #:fail-when (not (type-number? (syntax-e #'type))) "not a number type"
      #''(verb "%#ux")]
-    [(_ type (p:compop vs:number ...+))
+    [(_ type _ (p:compop vs:number ...+))
      #:fail-when (not (type-comparable? (syntax-e #'type))) "type can't be used in a comparison"
      #''(test p vs ...)]
-    [(_ _ (p:compop ref:ref vs:number ...+))
+    [(_ _ _ (p:compop oref:oref vs:number ...+))
+     #''(cond
+          p
+          oref
+          vs ...)]
+    [(_ _ _ (p:compop ref:ref vs:number ...+))
      #''(cond
           p
           ref
           vs ...)]
-    [(_ _ {~literal unused}) #''(unused #t)]
+    [(_ _ _ {~literal unused}) #''(unused #t)]
-    [(_ _ (ref:ref))
+    [(_ _ _ (ref:ref))
      #:fail-when (not (type-index? (syntax-e #'ref.type))) "can't be used as index to an array"
      #''(count ref)]
-    [(_ _ (n:number)) #''(count n)]
+    [(_ _ _ (n:number)) #''(count n)]
-    [(_ _ (p:arithop e:expr ...+)) #''(count (p e ...))])) ; FIXME - check fields and ops/numbers
+    [(_ _ _ (p:arithop e:expr ...+)) #''(count (p e ...))])) ; FIXME - check fields and ops/numbers
 (define-syntax (mkfield stx)
   (define-syntax-class name
        (set! fields (cons (syntax->datum #'(name type)) fields))
        #'(field type
                 `name
-                (list (mkattr type [~@ attrs]) ...)))]))
+                (list (mkattr type `name [~@ attrs]) ...)))]))
 (define-syntax (mkfields stx)
   (syntax-parse stx
 EOF
                )))
+(define (extra-context-fields c)
+  (if (cmplx? c)
+      (filter-map (λ (f) (and (field-context? f) (indent (gen-h f)))) (cmplx-fields c))
+      empty))
 (out "otf.c"
      (λ ()
        (printf #<<EOF
 	u8int *buf;
 	int bufsz;
 	int off;
+	/* extra fields to simplify parsing */
+EOF
+               )
+       (printf (format extra-context-fields))
+       (printf #<<EOF
 };
 struct Range {

otf.c+818−349

 	u8int *buf;
 	int bufsz;
 	int off;
+	/* extra fields to simplify parsing */
+	s16int indexToLocFormat;
+	u16int numberOfHMetrics;
+	u16int numGlyphs;
+	u16int firstGlyphIndex;
+	u16int lastGlyphIndex;
 };
 struct Range {
 }
 void
-print_SubHeader(Biobuf *f, int indent, SubHeader *v)
+print_SubHeader(Biobuf *f, int indent, Otf *o, SubHeader *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "firstCode", v->firstCode);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "entryCode", v->entryCode);
 	Bprint(f, "%*s%s: %d\n", indent, "", "idDelta", v->idDelta);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "idRangeOffset", v->idRangeOffset);
+	USED(o);
 }
 int
 }
 void
-print_MapGroup(Biobuf *f, int indent, MapGroup *v)
+print_MapGroup(Biobuf *f, int indent, Otf *o, MapGroup *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "startCharCode", v->startCharCode);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "endCharCode", v->endCharCode);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "startGlyphID", v->startGlyphID);
+	USED(o);
 }
 int
 }
 void
-print_SubtableCmap0(Biobuf *f, int indent, SubtableCmap0 *v)
+print_SubtableCmap0(Biobuf *f, int indent, Otf *o, SubtableCmap0 *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "length", v->length);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "language", v->language);
 	for(int i = 0; i < 256; i++)
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "glyphIdArray", i, v->glyphIdArray[i]);
+	USED(o);
 }
 int
 }
 void
-print_SubtableCmap2(Biobuf *f, int indent, SubtableCmap2 *v)
+print_SubtableCmap2(Biobuf *f, int indent, Otf *o, SubtableCmap2 *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "length", v->length);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "language", v->language);
 	for(int i = 0; i < 256; i++)
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "subHeaderKeys", i, v->subHeaderKeys[i]);
+	USED(o);
 }
 int
 	v->searchRange = b[6]<<8 | b[7];
 	v->entrySelector = b[8]<<8 | b[9];
 	v->rangeShift = b[10]<<8 | b[11];
-	if((b = otfreadn(o, v->segCountX2/2*2)) == nil)
+	if((b = otfreadn(o, (v->segCountX2/2)*2)) == nil)
 		goto err;
-	v->endCode = malloc(v->segCountX2/2*sizeof(*v->endCode));
+	v->endCode = malloc((v->segCountX2/2)*sizeof(*v->endCode));
-	for(int i = 0; i < v->segCountX2/2; i++)
+	for(int i = 0; i < (v->segCountX2/2); i++)
 		v->endCode[i] = b[0+i*2]<<8 | b[1+i*2];
 	if((b = otfreadn(o, 2)) == nil)
 		goto err;
 	USED(b);
-	if((b = otfreadn(o, v->segCountX2/2*2)) == nil)
+	if((b = otfreadn(o, (v->segCountX2/2)*2)) == nil)
 		goto err;
-	v->startCode = malloc(v->segCountX2/2*sizeof(*v->startCode));
+	v->startCode = malloc((v->segCountX2/2)*sizeof(*v->startCode));
-	for(int i = 0; i < v->segCountX2/2; i++)
+	for(int i = 0; i < (v->segCountX2/2); i++)
 		v->startCode[i] = b[0+i*2]<<8 | b[1+i*2];
-	if((b = otfreadn(o, v->segCountX2/2*2)) == nil)
+	if((b = otfreadn(o, (v->segCountX2/2)*2)) == nil)
 		goto err;
-	v->idDelta = malloc(v->segCountX2/2*sizeof(*v->idDelta));
+	v->idDelta = malloc((v->segCountX2/2)*sizeof(*v->idDelta));
-	for(int i = 0; i < v->segCountX2/2; i++)
+	for(int i = 0; i < (v->segCountX2/2); i++)
 		v->idDelta[i] = b[0+i*2]<<8 | b[1+i*2];
-	if((b = otfreadn(o, v->segCountX2/2*2)) == nil)
+	if((b = otfreadn(o, (v->segCountX2/2)*2)) == nil)
 		goto err;
-	v->idRangeOffset = malloc(v->segCountX2/2*sizeof(*v->idRangeOffset));
+	v->idRangeOffset = malloc((v->segCountX2/2)*sizeof(*v->idRangeOffset));
-	for(int i = 0; i < v->segCountX2/2; i++)
+	for(int i = 0; i < (v->segCountX2/2); i++)
 		v->idRangeOffset[i] = b[0+i*2]<<8 | b[1+i*2];
 	return 0;
 err:
 }
 void
-print_SubtableCmap4(Biobuf *f, int indent, SubtableCmap4 *v)
+print_SubtableCmap4(Biobuf *f, int indent, Otf *o, SubtableCmap4 *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "length", v->length);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "language", v->language);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "searchRange", v->searchRange);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "entrySelector", v->entrySelector);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "rangeShift", v->rangeShift);
-	for(int i = 0; i < v->segCountX2/2; i++)
+	for(int i = 0; i < (v->segCountX2/2); i++)
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "endCode", i, v->endCode[i]);
-	for(int i = 0; i < v->segCountX2/2; i++)
+	for(int i = 0; i < (v->segCountX2/2); i++)
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "startCode", i, v->startCode[i]);
-	for(int i = 0; i < v->segCountX2/2; i++)
+	for(int i = 0; i < (v->segCountX2/2); i++)
 		Bprint(f, "%*s%s[%d]: %d\n", indent, "", "idDelta", i, v->idDelta[i]);
-	for(int i = 0; i < v->segCountX2/2; i++)
+	for(int i = 0; i < (v->segCountX2/2); i++)
 		Bprint(f, "%*s%s[%d]: %d\n", indent, "", "idRangeOffset", i, v->idRangeOffset[i]);
+	USED(o);
 }
 int
 }
 void
-print_SubtableCmap6(Biobuf *f, int indent, SubtableCmap6 *v)
+print_SubtableCmap6(Biobuf *f, int indent, Otf *o, SubtableCmap6 *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "length", v->length);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "language", v->language);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "entryCount", v->entryCount);
 	for(int i = 0; i < v->entryCount; i++)
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "glyphIdArray", i, v->glyphIdArray[i]);
+	USED(o);
 }
 int
 }
 void
-print_SubtableCmap8(Biobuf *f, int indent, SubtableCmap8 *v)
+print_SubtableCmap8(Biobuf *f, int indent, Otf *o, SubtableCmap8 *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "length", v->length);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "language", v->language);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "numGroups", v->numGroups);
 	for(int i = 0; i < v->numGroups; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "groups", i);
-		print_MapGroup(f, indent+indentΔ, &v->groups[i]);
+		print_MapGroup(f, indent+indentΔ, o, &v->groups[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_SubtableCmap10(Biobuf *f, int indent, SubtableCmap10 *v)
+print_SubtableCmap10(Biobuf *f, int indent, Otf *o, SubtableCmap10 *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "reserved", v->reserved);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "length", v->length);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "language", v->language);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "startCharCode", v->startCharCode);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "numChars", v->numChars);
+	USED(o);
 }
 int
 }
 void
-print_SubtableCmap12or13(Biobuf *f, int indent, SubtableCmap12or13 *v)
+print_SubtableCmap12or13(Biobuf *f, int indent, Otf *o, SubtableCmap12or13 *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "reserved", v->reserved);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "length", v->length);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "numGroups", v->numGroups);
 	for(int i = 0; i < v->numGroups; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "groups", i);
-		print_MapGroup(f, indent+indentΔ, &v->groups[i]);
+		print_MapGroup(f, indent+indentΔ, o, &v->groups[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_UnicodeRange(Biobuf *f, int indent, UnicodeRange *v)
+print_UnicodeRange(Biobuf *f, int indent, Otf *o, UnicodeRange *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "startUnicodeValue", v->startUnicodeValue);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "additionalCount", v->additionalCount);
+	USED(o);
 }
 int
 }
 void
-print_DefaultUVS(Biobuf *f, int indent, DefaultUVS *v)
+print_DefaultUVS(Biobuf *f, int indent, Otf *o, DefaultUVS *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "numUnicodeValueRanges", v->numUnicodeValueRanges);
 	for(int i = 0; i < v->numUnicodeValueRanges; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "ranges", i);
-		print_UnicodeRange(f, indent+indentΔ, &v->ranges[i]);
+		print_UnicodeRange(f, indent+indentΔ, o, &v->ranges[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_UVSMapping(Biobuf *f, int indent, UVSMapping *v)
+print_UVSMapping(Biobuf *f, int indent, Otf *o, UVSMapping *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "unicodeValue", v->unicodeValue);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "glyphID", v->glyphID);
+	USED(o);
 }
 int
 }
 void
-print_NonDefaultUVS(Biobuf *f, int indent, NonDefaultUVS *v)
+print_NonDefaultUVS(Biobuf *f, int indent, Otf *o, NonDefaultUVS *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "numUVSMappings", v->numUVSMappings);
 	for(int i = 0; i < v->numUVSMappings; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "uvsMappings", i);
-		print_UVSMapping(f, indent+indentΔ, &v->uvsMappings[i]);
+		print_UVSMapping(f, indent+indentΔ, o, &v->uvsMappings[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_VariationSelector(Biobuf *f, int indent, VariationSelector *v)
+print_VariationSelector(Biobuf *f, int indent, Otf *o, VariationSelector *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "varSelector", v->varSelector);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "defaultUVSOffset", v->defaultUVSOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "nonDefaultUVSOffset", v->nonDefaultUVSOffset);
 	Bprint(f, "%*s%s:\n", indent, "", "defaultUVS");
 	if(v->defaultUVS != nil)
-		print_DefaultUVS(f, indent+indentΔ, v->defaultUVS);
+		print_DefaultUVS(f, indent+indentΔ, o, v->defaultUVS);
 	Bprint(f, "%*s%s:\n", indent, "", "nonDefaultUVS");
 	if(v->nonDefaultUVS != nil)
-		print_NonDefaultUVS(f, indent+indentΔ, v->nonDefaultUVS);
+		print_NonDefaultUVS(f, indent+indentΔ, o, v->nonDefaultUVS);
+	USED(o);
 }
 int
 }
 void
-print_SubtableCmap14(Biobuf *f, int indent, SubtableCmap14 *v)
+print_SubtableCmap14(Biobuf *f, int indent, Otf *o, SubtableCmap14 *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "length", v->length);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "numVarSelectorRecords", v->numVarSelectorRecords);
 	for(int i = 0; i < v->numVarSelectorRecords; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "varSelector", i);
-		print_VariationSelector(f, indent+indentΔ, &v->varSelector[i]);
+		print_VariationSelector(f, indent+indentΔ, o, &v->varSelector[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_SubtableCmap(Biobuf *f, int indent, SubtableCmap *v)
+print_SubtableCmap(Biobuf *f, int indent, Otf *o, SubtableCmap *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "format", v->format);
 	if(v->format == 0){
 		Bprint(f, "%*s%s:\n", indent, "", "sub0");
-		print_SubtableCmap0(f, indent+indentΔ, &v->sub0);
+		print_SubtableCmap0(f, indent+indentΔ, o, &v->sub0);
 	}
 	if(v->format == 2){
 		Bprint(f, "%*s%s:\n", indent, "", "sub2");
-		print_SubtableCmap2(f, indent+indentΔ, &v->sub2);
+		print_SubtableCmap2(f, indent+indentΔ, o, &v->sub2);
 	}
 	if(v->format == 4){
 		Bprint(f, "%*s%s:\n", indent, "", "sub4");
-		print_SubtableCmap4(f, indent+indentΔ, &v->sub4);
+		print_SubtableCmap4(f, indent+indentΔ, o, &v->sub4);
 	}
 	if(v->format == 6){
 		Bprint(f, "%*s%s:\n", indent, "", "sub6");
-		print_SubtableCmap6(f, indent+indentΔ, &v->sub6);
+		print_SubtableCmap6(f, indent+indentΔ, o, &v->sub6);
 	}
 	if(v->format == 8){
 		Bprint(f, "%*s%s:\n", indent, "", "sub8");
-		print_SubtableCmap8(f, indent+indentΔ, &v->sub8);
+		print_SubtableCmap8(f, indent+indentΔ, o, &v->sub8);
 	}
 	if(v->format == 10){
 		Bprint(f, "%*s%s:\n", indent, "", "sub10");
-		print_SubtableCmap10(f, indent+indentΔ, &v->sub10);
+		print_SubtableCmap10(f, indent+indentΔ, o, &v->sub10);
 	}
 	if(v->format == 12 || v->format == 13){
 		Bprint(f, "%*s%s:\n", indent, "", "sub12or13");
-		print_SubtableCmap12or13(f, indent+indentΔ, &v->sub12or13);
+		print_SubtableCmap12or13(f, indent+indentΔ, o, &v->sub12or13);
 	}
 	if(v->format == 14){
 		Bprint(f, "%*s%s:\n", indent, "", "sub14");
-		print_SubtableCmap14(f, indent+indentΔ, &v->sub14);
+		print_SubtableCmap14(f, indent+indentΔ, o, &v->sub14);
 	}
+	USED(o);
 }
 int
 }
 void
-print_EncodingRecord(Biobuf *f, int indent, EncodingRecord *v)
+print_EncodingRecord(Biobuf *f, int indent, Otf *o, EncodingRecord *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "platformID", v->platformID);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "encodingID", v->encodingID);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "subtableOffset", v->subtableOffset);
 	Bprint(f, "%*s%s:\n", indent, "", "subtable");
 	if(v->subtable != nil)
-		print_SubtableCmap(f, indent+indentΔ, v->subtable);
+		print_SubtableCmap(f, indent+indentΔ, o, v->subtable);
+	USED(o);
 }
 int
 }
 void
-print_TableCmap(Biobuf *f, int indent, TableCmap *v)
+print_TableCmap(Biobuf *f, int indent, Otf *o, TableCmap *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "numTables", v->numTables);
 	for(int i = 0; i < v->numTables; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "encodingRecords", i);
-		print_EncodingRecord(f, indent+indentΔ, &v->encodingRecords[i]);
+		print_EncodingRecord(f, indent+indentΔ, o, &v->encodingRecords[i]);
 	}
+	USED(o);
 }
 int
 		goto err;
 	}
 	v->indexToLocFormat = b[50]<<8 | b[51];
+	o->indexToLocFormat = v->indexToLocFormat;
 	if(v->indexToLocFormat > 1){
 		werrstr("%s: invalid value: %d (0x%ux)", "indexToLocFormat", v->indexToLocFormat, v->indexToLocFormat);
 		goto err;
 }
 void
-print_TableHead(Biobuf *f, int indent, TableHead *v)
+print_TableHead(Biobuf *f, int indent, Otf *o, TableHead *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "flags", v->flags);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "unitsPerEm", v->unitsPerEm);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "macStyle", v->macStyle);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "lowestRecPPEM", v->lowestRecPPEM);
 	Bprint(f, "%*s%s: %d\n", indent, "", "indexToLocFormat", v->indexToLocFormat);
+	USED(o);
 }
 int
 		goto err;
 	}
 	v->numberOfHMetrics = b[34]<<8 | b[35];
+	o->numberOfHMetrics = v->numberOfHMetrics;
 	return 0;
 err:
 	werrstr("%s: %r", "TableHhea");
 }
 void
-print_TableHhea(Biobuf *f, int indent, TableHhea *v)
+print_TableHhea(Biobuf *f, int indent, Otf *o, TableHhea *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "majorVersion", v->majorVersion);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "minorVersion", v->minorVersion);
 	Bprint(f, "%*s%s: %d\n", indent, "", "caretOffset", v->caretOffset);
 	Bprint(f, "%*s%s: %d\n", indent, "", "metricDataFormat", v->metricDataFormat);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "numberOfHMetrics", v->numberOfHMetrics);
+	USED(o);
 }
 int
 }
 void
-print_LongHorMetric(Biobuf *f, int indent, LongHorMetric *v)
+print_LongHorMetric(Biobuf *f, int indent, Otf *o, LongHorMetric *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "advanceWidth", v->advanceWidth);
 	Bprint(f, "%*s%s: %d\n", indent, "", "lsb", v->lsb);
+	USED(o);
 }
 int
 		goto err;
 	}
 	v->numGlyphs = b[4]<<8 | b[5];
+	o->numGlyphs = v->numGlyphs;
 	return 0;
 err:
 	werrstr("%s: %r", "TableMaxp");
 }
 void
-print_TableMaxp(Biobuf *f, int indent, TableMaxp *v)
+print_TableMaxp(Biobuf *f, int indent, Otf *o, TableMaxp *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "numGlyphs", v->numGlyphs);
+	USED(o);
+}
+int
+read_TableHmtx(Otf *o, TableHmtx *v)
+{
+	u8int *b;
+	if(otfarray(o, &v->hMetrics, read_LongHorMetric, sizeof(LongHorMetric), (o->numberOfHMetrics+0)) < 0){
+		werrstr("%s: %r", "hMetrics");
+		goto err;
+	}
+	if((b = otfreadn(o, (o->numGlyphs-o->numberOfHMetrics)*2)) == nil)
+		goto err;
+	v->leftSideBearings = malloc((o->numGlyphs-o->numberOfHMetrics)*sizeof(*v->leftSideBearings));
+	for(int i = 0; i < (o->numGlyphs-o->numberOfHMetrics); i++)
+		v->leftSideBearings[i] = b[0+i*2]<<8 | b[1+i*2];
+	return 0;
+err:
+	werrstr("%s: %r", "TableHmtx");
+	return -1;
+}
+void
+print_TableHmtx(Biobuf *f, int indent, Otf *o, TableHmtx *v)
+{
+	for(int i = 0; i < (o->numberOfHMetrics+0); i++){
+		Bprint(f, "%*s%s[%d]:\n", indent, "", "hMetrics", i);
+		print_LongHorMetric(f, indent+indentΔ, o, &v->hMetrics[i]);
+	}
+	for(int i = 0; i < (o->numGlyphs-o->numberOfHMetrics); i++)
+		Bprint(f, "%*s%s[%d]: %d\n", indent, "", "leftSideBearings", i, v->leftSideBearings[i]);
+	USED(o);
 }
 int
 }
 void
-print_TablePost(Biobuf *f, int indent, TablePost *v)
+print_TablePost(Biobuf *f, int indent, Otf *o, TablePost *v)
 {
 	Bprint(f, "%*s%s: %g\n", indent, "", "italicAngle", v->italicAngle);
 	Bprint(f, "%*s%s: %d\n", indent, "", "underlinePosition", v->underlinePosition);
 	Bprint(f, "%*s%s: %d\n", indent, "", "underlineThickness", v->underlineThickness);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "isFixedPitch", v->isFixedPitch);
+	USED(o);
 }
 int
 }
 void
-print_NameRecord(Biobuf *f, int indent, NameRecord *v)
+print_NameRecord(Biobuf *f, int indent, Otf *o, NameRecord *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "platformID", v->platformID);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "encodingID", v->encodingID);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "nameID", v->nameID);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "length", v->length);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "stringOffset", v->stringOffset);
+	USED(o);
 }
 int
 }
 void
-print_LangTagRecord(Biobuf *f, int indent, LangTagRecord *v)
+print_LangTagRecord(Biobuf *f, int indent, Otf *o, LangTagRecord *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "length", v->length);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "langTagOffset", v->langTagOffset);
+	USED(o);
 }
 int
 }
 void
-print_TableName(Biobuf *f, int indent, TableName *v)
+print_TableName(Biobuf *f, int indent, Otf *o, TableName *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "version", v->version);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "count", v->count);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "storageOffset", v->storageOffset);
 	for(int i = 0; i < v->count; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "nameRecord", i);
-		print_NameRecord(f, indent+indentΔ, &v->nameRecord[i]);
+		print_NameRecord(f, indent+indentΔ, o, &v->nameRecord[i]);
 	}
 	if(v->version >= 1)
 		Bprint(f, "%*s%s: %ud\n", indent, "", "langTagCount", v->langTagCount);
 	if(v->version >= 1){
 		for(int i = 0; i < v->langTagCount; i++){
 			Bprint(f, "%*s%s[%d]:\n", indent, "", "langTagRecord", i);
-			print_LangTagRecord(f, indent+indentΔ, &v->langTagRecord[i]);
+			print_LangTagRecord(f, indent+indentΔ, o, &v->langTagRecord[i]);
 		}
 	}
+	USED(o);
 }
 int
 }
 void
-print_BigGlyphMetrics(Biobuf *f, int indent, BigGlyphMetrics *v)
+print_BigGlyphMetrics(Biobuf *f, int indent, Otf *o, BigGlyphMetrics *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "height", v->height);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "width", v->width);
 	Bprint(f, "%*s%s: %d\n", indent, "", "vertBearingX", v->vertBearingX);
 	Bprint(f, "%*s%s: %d\n", indent, "", "vertBearingY", v->vertBearingY);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "vertAdvance", v->vertAdvance);
+	USED(o);
 }
 int
 }
 void
-print_SmallGlyphMetrics(Biobuf *f, int indent, SmallGlyphMetrics *v)
+print_SmallGlyphMetrics(Biobuf *f, int indent, Otf *o, SmallGlyphMetrics *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "height", v->height);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "width", v->width);
 	Bprint(f, "%*s%s: %d\n", indent, "", "bearingX", v->bearingX);
 	Bprint(f, "%*s%s: %d\n", indent, "", "bearingY", v->bearingY);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "advance", v->advance);
+	USED(o);
 }
 int
 }
 void
-print_SbitLineMetrics(Biobuf *f, int indent, SbitLineMetrics *v)
+print_SbitLineMetrics(Biobuf *f, int indent, Otf *o, SbitLineMetrics *v)
 {
 	Bprint(f, "%*s%s: %d\n", indent, "", "ascender", v->ascender);
 	Bprint(f, "%*s%s: %d\n", indent, "", "descender", v->descender);
 	Bprint(f, "%*s%s: %d\n", indent, "", "minAdvanceSB", v->minAdvanceSB);
 	Bprint(f, "%*s%s: %d\n", indent, "", "maxBeforeBL", v->maxBeforeBL);
 	Bprint(f, "%*s%s: %d\n", indent, "", "minAfterBL", v->minAfterBL);
+	USED(o);
 }
 int
 read_IndexSubtable1(Otf *o, IndexSubtable1 *v)
 {
 	u8int *b;
-	if((b = otfreadn(o, 4)) == nil)
+	if((b = otfreadn(o, ((o->lastGlyphIndex-o->firstGlyphIndex)+2)*4)) == nil)
 		goto err;
-	v->sbitOffsets = b[0]<<24 | b[1]<<16 | b[2]<<8 | b[3];
+	v->sbitOffsets = malloc(((o->lastGlyphIndex-o->firstGlyphIndex)+2)*sizeof(*v->sbitOffsets));
+	for(int i = 0; i < ((o->lastGlyphIndex-o->firstGlyphIndex)+2); i++)
+		v->sbitOffsets[i] = b[0+i*4]<<24 | b[1+i*4]<<16 | b[2+i*4]<<8 | b[3+i*4];
 	return 0;
 err:
 	werrstr("%s: %r", "IndexSubtable1");
 }
 void
-print_IndexSubtable1(Biobuf *f, int indent, IndexSubtable1 *v)
+print_IndexSubtable1(Biobuf *f, int indent, Otf *o, IndexSubtable1 *v)
 {
-	Bprint(f, "%*s%s: %ud\n", indent, "", "sbitOffsets", v->sbitOffsets);
+	for(int i = 0; i < ((o->lastGlyphIndex-o->firstGlyphIndex)+2); i++)
+		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "sbitOffsets", i, v->sbitOffsets[i]);
+	USED(o);
 }
 int
 }
 void
-print_IndexSubtable2(Biobuf *f, int indent, IndexSubtable2 *v)
+print_IndexSubtable2(Biobuf *f, int indent, Otf *o, IndexSubtable2 *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "imageSize", v->imageSize);
 	Bprint(f, "%*s%s:\n", indent, "", "bigMetrics");
-	print_BigGlyphMetrics(f, indent+indentΔ, &v->bigMetrics);
+	print_BigGlyphMetrics(f, indent+indentΔ, o, &v->bigMetrics);
+	USED(o);
 }
 int
 read_IndexSubtable3(Otf *o, IndexSubtable3 *v)
 {
 	u8int *b;
-	if((b = otfreadn(o, 2)) == nil)
+	if((b = otfreadn(o, ((o->lastGlyphIndex-o->firstGlyphIndex)+2)*2)) == nil)
 		goto err;
-	v->sbitOffsets = b[0]<<8 | b[1];
+	v->sbitOffsets = malloc(((o->lastGlyphIndex-o->firstGlyphIndex)+2)*sizeof(*v->sbitOffsets));
+	for(int i = 0; i < ((o->lastGlyphIndex-o->firstGlyphIndex)+2); i++)
+		v->sbitOffsets[i] = b[0+i*2]<<8 | b[1+i*2];
 	return 0;
 err:
 	werrstr("%s: %r", "IndexSubtable3");
 }
 void
-print_IndexSubtable3(Biobuf *f, int indent, IndexSubtable3 *v)
+print_IndexSubtable3(Biobuf *f, int indent, Otf *o, IndexSubtable3 *v)
 {
-	Bprint(f, "%*s%s: %ud\n", indent, "", "sbitOffsets", v->sbitOffsets);
+	for(int i = 0; i < ((o->lastGlyphIndex-o->firstGlyphIndex)+2); i++)
+		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "sbitOffsets", i, v->sbitOffsets[i]);
+	USED(o);
 }
 int
 }
 void
-print_GlyphIdOffsetPair(Biobuf *f, int indent, GlyphIdOffsetPair *v)
+print_GlyphIdOffsetPair(Biobuf *f, int indent, Otf *o, GlyphIdOffsetPair *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "glyphID", v->glyphID);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "sbitOffset", v->sbitOffset);
+	USED(o);
 }
 int
 	if((b = otfreadn(o, 4)) == nil)
 		goto err;
 	v->numGlyphs = b[0]<<24 | b[1]<<16 | b[2]<<8 | b[3];
-	if(otfarray(o, &v->glyphArray, read_GlyphIdOffsetPair, sizeof(GlyphIdOffsetPair), v->numGlyphs+1) < 0){
+	if(otfarray(o, &v->glyphArray, read_GlyphIdOffsetPair, sizeof(GlyphIdOffsetPair), (v->numGlyphs+1)) < 0){
 		werrstr("%s: %r", "glyphArray");
 		goto err;
 	}
 }
 void
-print_IndexSubtable4(Biobuf *f, int indent, IndexSubtable4 *v)
+print_IndexSubtable4(Biobuf *f, int indent, Otf *o, IndexSubtable4 *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "numGlyphs", v->numGlyphs);
-	for(int i = 0; i < v->numGlyphs+1; i++){
+	for(int i = 0; i < (v->numGlyphs+1); i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "glyphArray", i);
-		print_GlyphIdOffsetPair(f, indent+indentΔ, &v->glyphArray[i]);
+		print_GlyphIdOffsetPair(f, indent+indentΔ, o, &v->glyphArray[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_IndexSubtable5(Biobuf *f, int indent, IndexSubtable5 *v)
+print_IndexSubtable5(Biobuf *f, int indent, Otf *o, IndexSubtable5 *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "imageSize", v->imageSize);
 	Bprint(f, "%*s%s:\n", indent, "", "bigMetrics");
-	print_BigGlyphMetrics(f, indent+indentΔ, &v->bigMetrics);
+	print_BigGlyphMetrics(f, indent+indentΔ, o, &v->bigMetrics);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "numGlyphs", v->numGlyphs);
 	for(int i = 0; i < v->numGlyphs; i++)
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "glyphIdArray", i, v->glyphIdArray[i]);
+	USED(o);
 }
 int
 }
 void
-print_IndexSubtable(Biobuf *f, int indent, IndexSubtable *v)
+print_IndexSubtable(Biobuf *f, int indent, Otf *o, IndexSubtable *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "indexFormat", v->indexFormat);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "imageFormat", v->imageFormat);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "imageDataOffset", v->imageDataOffset);
 	if(v->indexFormat == 1){
 		Bprint(f, "%*s%s:\n", indent, "", "sub1");
-		print_IndexSubtable1(f, indent+indentΔ, &v->sub1);
+		print_IndexSubtable1(f, indent+indentΔ, o, &v->sub1);
 	}
 	if(v->indexFormat == 2){
 		Bprint(f, "%*s%s:\n", indent, "", "sub2");
-		print_IndexSubtable2(f, indent+indentΔ, &v->sub2);
+		print_IndexSubtable2(f, indent+indentΔ, o, &v->sub2);
 	}
 	if(v->indexFormat == 3){
 		Bprint(f, "%*s%s:\n", indent, "", "sub3");
-		print_IndexSubtable3(f, indent+indentΔ, &v->sub3);
+		print_IndexSubtable3(f, indent+indentΔ, o, &v->sub3);
 	}
 	if(v->indexFormat == 4){
 		Bprint(f, "%*s%s:\n", indent, "", "sub4");
-		print_IndexSubtable4(f, indent+indentΔ, &v->sub4);
+		print_IndexSubtable4(f, indent+indentΔ, o, &v->sub4);
 	}
 	if(v->indexFormat == 5){
 		Bprint(f, "%*s%s:\n", indent, "", "sub5");
-		print_IndexSubtable5(f, indent+indentΔ, &v->sub5);
+		print_IndexSubtable5(f, indent+indentΔ, o, &v->sub5);
 	}
+	USED(o);
 }
 int
 	if((b = otfreadn(o, 8)) == nil)
 		goto err;
 	v->firstGlyphIndex = b[0]<<8 | b[1];
+	o->firstGlyphIndex = v->firstGlyphIndex;
 	v->lastGlyphIndex = b[2]<<8 | b[3];
+	o->lastGlyphIndex = v->lastGlyphIndex;
 	v->indexSubtableOffset = b[4]<<24 | b[5]<<16 | b[6]<<8 | b[7];
 	if(v->indexSubtableOffset != 0){
 		if(otfpushrange(o, v->indexSubtableOffset, -1) < 0)
 }
 void
-print_IndexSubtableRecord(Biobuf *f, int indent, IndexSubtableRecord *v)
+print_IndexSubtableRecord(Biobuf *f, int indent, Otf *o, IndexSubtableRecord *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "firstGlyphIndex", v->firstGlyphIndex);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "lastGlyphIndex", v->lastGlyphIndex);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "indexSubtableOffset", v->indexSubtableOffset);
 	Bprint(f, "%*s%s:\n", indent, "", "indexSubtable");
 	if(v->indexSubtable != nil)
-		print_IndexSubtable(f, indent+indentΔ, v->indexSubtable);
+		print_IndexSubtable(f, indent+indentΔ, o, v->indexSubtable);
+	USED(o);
 }
 int
 }
 void
-print_BitmapSize(Biobuf *f, int indent, BitmapSize *v)
+print_BitmapSize(Biobuf *f, int indent, Otf *o, BitmapSize *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "indexSubtableListOffset", v->indexSubtableListOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "indexSubtableListSize", v->indexSubtableListSize);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "numberOfIndexSubtables", v->numberOfIndexSubtables);
 	Bprint(f, "%*s%s:\n", indent, "", "hori");
-	print_SbitLineMetrics(f, indent+indentΔ, &v->hori);
+	print_SbitLineMetrics(f, indent+indentΔ, o, &v->hori);
 	Bprint(f, "%*s%s:\n", indent, "", "vert");
-	print_SbitLineMetrics(f, indent+indentΔ, &v->vert);
+	print_SbitLineMetrics(f, indent+indentΔ, o, &v->vert);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "startGlyphIndex", v->startGlyphIndex);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "endGlyphIndex", v->endGlyphIndex);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "ppemX", v->ppemX);
 	Bprint(f, "%*s%s: %d\n", indent, "", "flags", v->flags);
 	for(int i = 0; i < v->numberOfIndexSubtables; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "indexSubtableList", i);
-		print_IndexSubtableRecord(f, indent+indentΔ, &v->indexSubtableList[i]);
+		print_IndexSubtableRecord(f, indent+indentΔ, o, &v->indexSubtableList[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_TableEBDT(Biobuf *f, int indent, TableEBDT *v)
+print_TableEBDT(Biobuf *f, int indent, Otf *o, TableEBDT *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "majorVersion", v->majorVersion);
+	USED(o);
 }
 int
 }
 void
-print_TableEBLC(Biobuf *f, int indent, TableEBLC *v)
+print_TableEBLC(Biobuf *f, int indent, Otf *o, TableEBLC *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "numSizes", v->numSizes);
 	for(int i = 0; i < v->numSizes; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "bitmapSizes", i);
-		print_BitmapSize(f, indent+indentΔ, &v->bitmapSizes[i]);
+		print_BitmapSize(f, indent+indentΔ, o, &v->bitmapSizes[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_AttachList(Biobuf *f, int indent, AttachList *v)
+print_AttachList(Biobuf *f, int indent, Otf *o, AttachList *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "coverageOffset", v->coverageOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "glyphCount", v->glyphCount);
 	for(int i = 0; i < v->glyphCount; i++)
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "attachPointOffsets", i, v->attachPointOffsets[i]);
+	USED(o);
 }
 int
 }
 void
-print_AttachPoint(Biobuf *f, int indent, AttachPoint *v)
+print_AttachPoint(Biobuf *f, int indent, Otf *o, AttachPoint *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "pointCount", v->pointCount);
 	for(int i = 0; i < v->pointCount; i++)
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "pointIndices", i, v->pointIndices[i]);
+	USED(o);
 }
 int
 }
 void
-print_LigCaretList(Biobuf *f, int indent, LigCaretList *v)
+print_LigCaretList(Biobuf *f, int indent, Otf *o, LigCaretList *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "coverageOffset", v->coverageOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "ligGlyphCount", v->ligGlyphCount);
 	for(int i = 0; i < v->ligGlyphCount; i++)
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "ligGlyphOffsets", i, v->ligGlyphOffsets[i]);
+	USED(o);
 }
 int
 }
 void
-print_LigGlyph(Biobuf *f, int indent, LigGlyph *v)
+print_LigGlyph(Biobuf *f, int indent, Otf *o, LigGlyph *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "caretCount", v->caretCount);
 	for(int i = 0; i < v->caretCount; i++)
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "caretValueOffsets", i, v->caretValueOffsets[i]);
+	USED(o);
 }
 int
 }
 void
-print_CaretValue(Biobuf *f, int indent, CaretValue *v)
+print_CaretValue(Biobuf *f, int indent, Otf *o, CaretValue *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "format", v->format);
 	if(v->format == 1 || v->format == 3)
 		Bprint(f, "%*s%s: %ud\n", indent, "", "caretValuePointIndex", v->caretValuePointIndex);
 	if(v->format == 3)
 		Bprint(f, "%*s%s: %ud\n", indent, "", "deviceOffset", v->deviceOffset);
+	USED(o);
 }
 int
 }
 void
-print_ValueRecord(Biobuf *f, int indent, ValueRecord *v)
+print_ValueRecord(Biobuf *f, int indent, Otf *o, ValueRecord *v)
 {
 	Bprint(f, "%*s%s: %d\n", indent, "", "xPlacement", v->xPlacement);
 	Bprint(f, "%*s%s: %d\n", indent, "", "yPlacement", v->yPlacement);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "yPlaDeviceOffset", v->yPlaDeviceOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "xAdvDeviceOffset", v->xAdvDeviceOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "yAdvDeviceOffset", v->yAdvDeviceOffset);
+	USED(o);
 }
 int
 }
 void
-print_SinglePos(Biobuf *f, int indent, SinglePos *v)
+print_SinglePos(Biobuf *f, int indent, Otf *o, SinglePos *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "format", v->format);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "coverageOffset", v->coverageOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "valueFormat", v->valueFormat);
 	if(v->format == 1){
 		Bprint(f, "%*s%s:\n", indent, "", "valueRecord");
-		print_ValueRecord(f, indent+indentΔ, &v->valueRecord);
+		print_ValueRecord(f, indent+indentΔ, o, &v->valueRecord);
 	}
 	if(v->format == 2)
 		Bprint(f, "%*s%s: %ud\n", indent, "", "valueCount", v->valueCount);
 	if(v->format == 2){
 		for(int i = 0; i < v->valueCount; i++){
 			Bprint(f, "%*s%s[%d]:\n", indent, "", "valueRecords", i);
-			print_ValueRecord(f, indent+indentΔ, &v->valueRecords[i]);
+			print_ValueRecord(f, indent+indentΔ, o, &v->valueRecords[i]);
 		}
 	}
+	USED(o);
 }
 int
 }
 void
-print_TableGDEF(Biobuf *f, int indent, TableGDEF *v)
+print_TableGDEF(Biobuf *f, int indent, Otf *o, TableGDEF *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "minorVersion", v->minorVersion);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "glyphClassDefOffset", v->glyphClassDefOffset);
 		Bprint(f, "%*s%s: %ud\n", indent, "", "markGlyphSetsDefOffset", v->markGlyphSetsDefOffset);
 	if(v->minorVersion >= 3)
 		Bprint(f, "%*s%s: %ud\n", indent, "", "itemVarStoreOffset", v->itemVarStoreOffset);
+	USED(o);
 }
 int
 }
 void
-print_LangSys(Biobuf *f, int indent, LangSys *v)
+print_LangSys(Biobuf *f, int indent, Otf *o, LangSys *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "requiredFeatureIndex", v->requiredFeatureIndex);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "featureIndexCount", v->featureIndexCount);
 	for(int i = 0; i < v->featureIndexCount; i++)
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "featureIndices", i, v->featureIndices[i]);
+	USED(o);
 }
 int
 }
 void
-print_LangSysRecord(Biobuf *f, int indent, LangSysRecord *v)
+print_LangSysRecord(Biobuf *f, int indent, Otf *o, LangSysRecord *v)
 {
 	Bprint(f, "%*s%s: %t\n", indent, "", "langSysTag", v->langSysTag);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "langSysOffset", v->langSysOffset);
 	Bprint(f, "%*s%s:\n", indent, "", "langSys");
 	if(v->langSys != nil)
-		print_LangSys(f, indent+indentΔ, v->langSys);
+		print_LangSys(f, indent+indentΔ, o, v->langSys);
+	USED(o);
 }
 int
 }
 void
-print_Script(Biobuf *f, int indent, Script *v)
+print_Script(Biobuf *f, int indent, Otf *o, Script *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "defaultLangSysOffset", v->defaultLangSysOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "langSysCount", v->langSysCount);
 	for(int i = 0; i < v->langSysCount; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "langSysRecords", i);
-		print_LangSysRecord(f, indent+indentΔ, &v->langSysRecords[i]);
+		print_LangSysRecord(f, indent+indentΔ, o, &v->langSysRecords[i]);
 	}
 	Bprint(f, "%*s%s:\n", indent, "", "defaultLangSys");
 	if(v->defaultLangSys != nil)
-		print_LangSys(f, indent+indentΔ, v->defaultLangSys);
+		print_LangSys(f, indent+indentΔ, o, v->defaultLangSys);
+	USED(o);
 }
 int
 }
 void
-print_ScriptRecord(Biobuf *f, int indent, ScriptRecord *v)
+print_ScriptRecord(Biobuf *f, int indent, Otf *o, ScriptRecord *v)
 {
 	Bprint(f, "%*s%s: %t\n", indent, "", "scriptTag", v->scriptTag);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "scriptOffset", v->scriptOffset);
 	Bprint(f, "%*s%s:\n", indent, "", "script");
 	if(v->script != nil)
-		print_Script(f, indent+indentΔ, v->script);
+		print_Script(f, indent+indentΔ, o, v->script);
+	USED(o);
 }
 int
 }
 void
-print_ScriptList(Biobuf *f, int indent, ScriptList *v)
+print_ScriptList(Biobuf *f, int indent, Otf *o, ScriptList *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "scriptCount", v->scriptCount);
 	for(int i = 0; i < v->scriptCount; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "scriptRecords", i);
-		print_ScriptRecord(f, indent+indentΔ, &v->scriptRecords[i]);
+		print_ScriptRecord(f, indent+indentΔ, o, &v->scriptRecords[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_Feature(Biobuf *f, int indent, Feature *v)
+print_Feature(Biobuf *f, int indent, Otf *o, Feature *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "featureParamsOffset", v->featureParamsOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "lookupIndexCount", v->lookupIndexCount);
 	for(int i = 0; i < v->lookupIndexCount; i++)
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "lookupListIndices", i, v->lookupListIndices[i]);
+	USED(o);
 }
 int
 }
 void
-print_FeatureRecord(Biobuf *f, int indent, FeatureRecord *v)
+print_FeatureRecord(Biobuf *f, int indent, Otf *o, FeatureRecord *v)
 {
 	Bprint(f, "%*s%s: %t\n", indent, "", "featureTag", v->featureTag);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "featureOffset", v->featureOffset);
 	Bprint(f, "%*s%s:\n", indent, "", "feature");
 	if(v->feature != nil)
-		print_Feature(f, indent+indentΔ, v->feature);
+		print_Feature(f, indent+indentΔ, o, v->feature);
+	USED(o);
 }
 int
 }
 void
-print_FeatureList(Biobuf *f, int indent, FeatureList *v)
+print_FeatureList(Biobuf *f, int indent, Otf *o, FeatureList *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "featureCount", v->featureCount);
 	for(int i = 0; i < v->featureCount; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "featureRecords", i);
-		print_FeatureRecord(f, indent+indentΔ, &v->featureRecords[i]);
+		print_FeatureRecord(f, indent+indentΔ, o, &v->featureRecords[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_Lookup(Biobuf *f, int indent, Lookup *v)
+print_Lookup(Biobuf *f, int indent, Otf *o, Lookup *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "lookupType", v->lookupType);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "lookupFlag", v->lookupFlag);
 	for(int i = 0; i < v->subTableCount; i++)
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "subtableOffsets", i, v->subtableOffsets[i]);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "markFilteringSet", v->markFilteringSet);
+	USED(o);
 }
 int
 }
 void
-print_LookupList(Biobuf *f, int indent, LookupList *v)
+print_LookupList(Biobuf *f, int indent, Otf *o, LookupList *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "lookupCount", v->lookupCount);
 	for(int i = 0; i < v->lookupCount; i++)
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "lookupOffsets", i, v->lookupOffsets[i]);
+	USED(o);
 }
 int
 }
 void
-print_TableGPOS(Biobuf *f, int indent, TableGPOS *v)
+print_TableGPOS(Biobuf *f, int indent, Otf *o, TableGPOS *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "minorVersion", v->minorVersion);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "scriptListOffset", v->scriptListOffset);
 		Bprint(f, "%*s%s: %ud\n", indent, "", "featureVariationsOffset", v->featureVariationsOffset);
 	Bprint(f, "%*s%s:\n", indent, "", "scriptList");
 	if(v->scriptList != nil)
-		print_ScriptList(f, indent+indentΔ, v->scriptList);
+		print_ScriptList(f, indent+indentΔ, o, v->scriptList);
 	Bprint(f, "%*s%s:\n", indent, "", "featureList");
 	if(v->featureList != nil)
-		print_FeatureList(f, indent+indentΔ, v->featureList);
+		print_FeatureList(f, indent+indentΔ, o, v->featureList);
 	Bprint(f, "%*s%s:\n", indent, "", "lookupList");
 	if(v->lookupList != nil)
-		print_LookupList(f, indent+indentΔ, v->lookupList);
+		print_LookupList(f, indent+indentΔ, o, v->lookupList);
+	USED(o);
 }
 int
 }
 void
-print_TableGSUB(Biobuf *f, int indent, TableGSUB *v)
+print_TableGSUB(Biobuf *f, int indent, Otf *o, TableGSUB *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "minorVersion", v->minorVersion);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "scriptListOffset", v->scriptListOffset);
 		Bprint(f, "%*s%s: %ud\n", indent, "", "featureVariationsOffset", v->featureVariationsOffset);
 	Bprint(f, "%*s%s:\n", indent, "", "scriptList");
 	if(v->scriptList != nil)
-		print_ScriptList(f, indent+indentΔ, v->scriptList);
+		print_ScriptList(f, indent+indentΔ, o, v->scriptList);
 	Bprint(f, "%*s%s:\n", indent, "", "featureList");
 	if(v->featureList != nil)
-		print_FeatureList(f, indent+indentΔ, v->featureList);
+		print_FeatureList(f, indent+indentΔ, o, v->featureList);
+	USED(o);
 }
 int
 }
 void
-print_MathValueRecord(Biobuf *f, int indent, MathValueRecord *v)
+print_MathValueRecord(Biobuf *f, int indent, Otf *o, MathValueRecord *v)
 {
 	Bprint(f, "%*s%s: %d\n", indent, "", "value", v->value);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "deviceOffset", v->deviceOffset);
+	USED(o);
 }
 int
 }
 void
-print_MathConstants(Biobuf *f, int indent, MathConstants *v)
+print_MathConstants(Biobuf *f, int indent, Otf *o, MathConstants *v)
 {
 	Bprint(f, "%*s%s: %d\n", indent, "", "scriptPercentScaleDown", v->scriptPercentScaleDown);
 	Bprint(f, "%*s%s: %d\n", indent, "", "scriptScriptPercentScaleDown", v->scriptScriptPercentScaleDown);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "delimitedSubFormulaMinHeight", v->delimitedSubFormulaMinHeight);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "displayOperatorMinHeight", v->displayOperatorMinHeight);
 	Bprint(f, "%*s%s:\n", indent, "", "mathLeading");
-	print_MathValueRecord(f, indent+indentΔ, &v->mathLeading);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->mathLeading);
 	Bprint(f, "%*s%s:\n", indent, "", "axisHeight");
-	print_MathValueRecord(f, indent+indentΔ, &v->axisHeight);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->axisHeight);
 	Bprint(f, "%*s%s:\n", indent, "", "accentBaseHeight");
-	print_MathValueRecord(f, indent+indentΔ, &v->accentBaseHeight);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->accentBaseHeight);
 	Bprint(f, "%*s%s:\n", indent, "", "flattenedAccentBaseHeight");
-	print_MathValueRecord(f, indent+indentΔ, &v->flattenedAccentBaseHeight);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->flattenedAccentBaseHeight);
 	Bprint(f, "%*s%s:\n", indent, "", "subscriptShiftDown");
-	print_MathValueRecord(f, indent+indentΔ, &v->subscriptShiftDown);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->subscriptShiftDown);
 	Bprint(f, "%*s%s:\n", indent, "", "subscriptTopMax");
-	print_MathValueRecord(f, indent+indentΔ, &v->subscriptTopMax);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->subscriptTopMax);
 	Bprint(f, "%*s%s:\n", indent, "", "subscriptBaselineDropMin");
-	print_MathValueRecord(f, indent+indentΔ, &v->subscriptBaselineDropMin);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->subscriptBaselineDropMin);
 	Bprint(f, "%*s%s:\n", indent, "", "superscriptShiftUp");
-	print_MathValueRecord(f, indent+indentΔ, &v->superscriptShiftUp);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->superscriptShiftUp);
 	Bprint(f, "%*s%s:\n", indent, "", "superscriptShiftUpCramped");
-	print_MathValueRecord(f, indent+indentΔ, &v->superscriptShiftUpCramped);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->superscriptShiftUpCramped);
 	Bprint(f, "%*s%s:\n", indent, "", "superscriptBottomMin");
-	print_MathValueRecord(f, indent+indentΔ, &v->superscriptBottomMin);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->superscriptBottomMin);
 	Bprint(f, "%*s%s:\n", indent, "", "superscriptBaselineDropMax");
-	print_MathValueRecord(f, indent+indentΔ, &v->superscriptBaselineDropMax);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->superscriptBaselineDropMax);
 	Bprint(f, "%*s%s:\n", indent, "", "subSuperscriptGapMin");
-	print_MathValueRecord(f, indent+indentΔ, &v->subSuperscriptGapMin);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->subSuperscriptGapMin);
 	Bprint(f, "%*s%s:\n", indent, "", "superscriptBottomMaxWithSubscript");
-	print_MathValueRecord(f, indent+indentΔ, &v->superscriptBottomMaxWithSubscript);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->superscriptBottomMaxWithSubscript);
 	Bprint(f, "%*s%s:\n", indent, "", "spaceAfterScript");
-	print_MathValueRecord(f, indent+indentΔ, &v->spaceAfterScript);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->spaceAfterScript);
 	Bprint(f, "%*s%s:\n", indent, "", "upperLimitGapMin");
-	print_MathValueRecord(f, indent+indentΔ, &v->upperLimitGapMin);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->upperLimitGapMin);
 	Bprint(f, "%*s%s:\n", indent, "", "upperLimitBaselineRiseMin");
-	print_MathValueRecord(f, indent+indentΔ, &v->upperLimitBaselineRiseMin);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->upperLimitBaselineRiseMin);
 	Bprint(f, "%*s%s:\n", indent, "", "lowerLimitGapMin");
-	print_MathValueRecord(f, indent+indentΔ, &v->lowerLimitGapMin);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->lowerLimitGapMin);
 	Bprint(f, "%*s%s:\n", indent, "", "lowerLimitBaselineDropMin");
-	print_MathValueRecord(f, indent+indentΔ, &v->lowerLimitBaselineDropMin);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->lowerLimitBaselineDropMin);
 	Bprint(f, "%*s%s:\n", indent, "", "stackTopShiftUp");
-	print_MathValueRecord(f, indent+indentΔ, &v->stackTopShiftUp);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->stackTopShiftUp);
 	Bprint(f, "%*s%s:\n", indent, "", "stackTopDisplayStyleShiftUp");
-	print_MathValueRecord(f, indent+indentΔ, &v->stackTopDisplayStyleShiftUp);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->stackTopDisplayStyleShiftUp);
 	Bprint(f, "%*s%s:\n", indent, "", "stackBottomShiftDown");
-	print_MathValueRecord(f, indent+indentΔ, &v->stackBottomShiftDown);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->stackBottomShiftDown);
 	Bprint(f, "%*s%s:\n", indent, "", "stackBottomDisplayStyleShiftDown");
-	print_MathValueRecord(f, indent+indentΔ, &v->stackBottomDisplayStyleShiftDown);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->stackBottomDisplayStyleShiftDown);
 	Bprint(f, "%*s%s:\n", indent, "", "stackGapMin");
-	print_MathValueRecord(f, indent+indentΔ, &v->stackGapMin);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->stackGapMin);
 	Bprint(f, "%*s%s:\n", indent, "", "stackDisplayStyleGapMin");
-	print_MathValueRecord(f, indent+indentΔ, &v->stackDisplayStyleGapMin);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->stackDisplayStyleGapMin);
 	Bprint(f, "%*s%s:\n", indent, "", "stretchStackTopShiftUp");
-	print_MathValueRecord(f, indent+indentΔ, &v->stretchStackTopShiftUp);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->stretchStackTopShiftUp);
 	Bprint(f, "%*s%s:\n", indent, "", "stretchStackBottomShiftDown");
-	print_MathValueRecord(f, indent+indentΔ, &v->stretchStackBottomShiftDown);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->stretchStackBottomShiftDown);
 	Bprint(f, "%*s%s:\n", indent, "", "stretchStackGapAboveMin");
-	print_MathValueRecord(f, indent+indentΔ, &v->stretchStackGapAboveMin);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->stretchStackGapAboveMin);
 	Bprint(f, "%*s%s:\n", indent, "", "stretchStackGapBelowMin");
-	print_MathValueRecord(f, indent+indentΔ, &v->stretchStackGapBelowMin);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->stretchStackGapBelowMin);
 	Bprint(f, "%*s%s:\n", indent, "", "fractionNumeratorShiftUp");
-	print_MathValueRecord(f, indent+indentΔ, &v->fractionNumeratorShiftUp);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->fractionNumeratorShiftUp);
 	Bprint(f, "%*s%s:\n", indent, "", "fractionNumeratorDisplayStyleShiftUp");
-	print_MathValueRecord(f, indent+indentΔ, &v->fractionNumeratorDisplayStyleShiftUp);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->fractionNumeratorDisplayStyleShiftUp);
 	Bprint(f, "%*s%s:\n", indent, "", "fractionDenominatorShiftDown");
-	print_MathValueRecord(f, indent+indentΔ, &v->fractionDenominatorShiftDown);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->fractionDenominatorShiftDown);
 	Bprint(f, "%*s%s:\n", indent, "", "fractionDenominatorDisplayStyleShiftDown");
-	print_MathValueRecord(f, indent+indentΔ, &v->fractionDenominatorDisplayStyleShiftDown);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->fractionDenominatorDisplayStyleShiftDown);
 	Bprint(f, "%*s%s:\n", indent, "", "fractionNumeratorGapMin");
-	print_MathValueRecord(f, indent+indentΔ, &v->fractionNumeratorGapMin);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->fractionNumeratorGapMin);
 	Bprint(f, "%*s%s:\n", indent, "", "fractionNumDisplayStyleGapMin");
-	print_MathValueRecord(f, indent+indentΔ, &v->fractionNumDisplayStyleGapMin);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->fractionNumDisplayStyleGapMin);
 	Bprint(f, "%*s%s:\n", indent, "", "fractionRuleThickness");
-	print_MathValueRecord(f, indent+indentΔ, &v->fractionRuleThickness);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->fractionRuleThickness);
 	Bprint(f, "%*s%s:\n", indent, "", "fractionDenominatorGapMin");
-	print_MathValueRecord(f, indent+indentΔ, &v->fractionDenominatorGapMin);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->fractionDenominatorGapMin);
 	Bprint(f, "%*s%s:\n", indent, "", "fractionDenomDisplayStyleGapMin");
-	print_MathValueRecord(f, indent+indentΔ, &v->fractionDenomDisplayStyleGapMin);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->fractionDenomDisplayStyleGapMin);
 	Bprint(f, "%*s%s:\n", indent, "", "skewedFractionHorizontalGap");
-	print_MathValueRecord(f, indent+indentΔ, &v->skewedFractionHorizontalGap);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->skewedFractionHorizontalGap);
 	Bprint(f, "%*s%s:\n", indent, "", "skewedFractionVerticalGap");
-	print_MathValueRecord(f, indent+indentΔ, &v->skewedFractionVerticalGap);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->skewedFractionVerticalGap);
 	Bprint(f, "%*s%s:\n", indent, "", "overbarVerticalGap");
-	print_MathValueRecord(f, indent+indentΔ, &v->overbarVerticalGap);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->overbarVerticalGap);
 	Bprint(f, "%*s%s:\n", indent, "", "overbarRuleThickness");
-	print_MathValueRecord(f, indent+indentΔ, &v->overbarRuleThickness);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->overbarRuleThickness);
 	Bprint(f, "%*s%s:\n", indent, "", "overbarExtraAscender");
-	print_MathValueRecord(f, indent+indentΔ, &v->overbarExtraAscender);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->overbarExtraAscender);
 	Bprint(f, "%*s%s:\n", indent, "", "underbarVerticalGap");
-	print_MathValueRecord(f, indent+indentΔ, &v->underbarVerticalGap);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->underbarVerticalGap);
 	Bprint(f, "%*s%s:\n", indent, "", "underbarRuleThickness");
-	print_MathValueRecord(f, indent+indentΔ, &v->underbarRuleThickness);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->underbarRuleThickness);
 	Bprint(f, "%*s%s:\n", indent, "", "underbarExtraDescender");
-	print_MathValueRecord(f, indent+indentΔ, &v->underbarExtraDescender);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->underbarExtraDescender);
 	Bprint(f, "%*s%s:\n", indent, "", "radicalVerticalGap");
-	print_MathValueRecord(f, indent+indentΔ, &v->radicalVerticalGap);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->radicalVerticalGap);
 	Bprint(f, "%*s%s:\n", indent, "", "radicalDisplayStyleVerticalGap");
-	print_MathValueRecord(f, indent+indentΔ, &v->radicalDisplayStyleVerticalGap);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->radicalDisplayStyleVerticalGap);
 	Bprint(f, "%*s%s:\n", indent, "", "radicalRuleThickness");
-	print_MathValueRecord(f, indent+indentΔ, &v->radicalRuleThickness);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->radicalRuleThickness);
 	Bprint(f, "%*s%s:\n", indent, "", "radicalExtraAscender");
-	print_MathValueRecord(f, indent+indentΔ, &v->radicalExtraAscender);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->radicalExtraAscender);
 	Bprint(f, "%*s%s:\n", indent, "", "radicalKernBeforeDegree");
-	print_MathValueRecord(f, indent+indentΔ, &v->radicalKernBeforeDegree);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->radicalKernBeforeDegree);
 	Bprint(f, "%*s%s:\n", indent, "", "radicalKernAfterDegree");
-	print_MathValueRecord(f, indent+indentΔ, &v->radicalKernAfterDegree);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->radicalKernAfterDegree);
 	Bprint(f, "%*s%s: %d\n", indent, "", "radicalDegreeBottomRaisePercent", v->radicalDegreeBottomRaisePercent);
+	USED(o);
 }
 int
 }
 void
-print_MathItalicsCorrectionInfo(Biobuf *f, int indent, MathItalicsCorrectionInfo *v)
+print_MathItalicsCorrectionInfo(Biobuf *f, int indent, Otf *o, MathItalicsCorrectionInfo *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "italicsCorrectionCoverageOffset", v->italicsCorrectionCoverageOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "italicsCorrectionCount", v->italicsCorrectionCount);
 	for(int i = 0; i < v->italicsCorrectionCount; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "italicsCorrection", i);
-		print_MathValueRecord(f, indent+indentΔ, &v->italicsCorrection[i]);
+		print_MathValueRecord(f, indent+indentΔ, o, &v->italicsCorrection[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_MathTopAccentAttachment(Biobuf *f, int indent, MathTopAccentAttachment *v)
+print_MathTopAccentAttachment(Biobuf *f, int indent, Otf *o, MathTopAccentAttachment *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "topAccentCoverageOffset", v->topAccentCoverageOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "topAccentAttachmentCount", v->topAccentAttachmentCount);
 	for(int i = 0; i < v->topAccentAttachmentCount; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "topAccentAttachment", i);
-		print_MathValueRecord(f, indent+indentΔ, &v->topAccentAttachment[i]);
+		print_MathValueRecord(f, indent+indentΔ, o, &v->topAccentAttachment[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_MathKernInfoRecord(Biobuf *f, int indent, MathKernInfoRecord *v)
+print_MathKernInfoRecord(Biobuf *f, int indent, Otf *o, MathKernInfoRecord *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "topRightMathKernOffset", v->topRightMathKernOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "topLeftMathKernOffset", v->topLeftMathKernOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "bottomRightMathKernOffset", v->bottomRightMathKernOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "bottomLeftMathKernOffset", v->bottomLeftMathKernOffset);
+	USED(o);
 }
 int
 }
 void
-print_MathKernInfo(Biobuf *f, int indent, MathKernInfo *v)
+print_MathKernInfo(Biobuf *f, int indent, Otf *o, MathKernInfo *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "mathKernCoverageOffset", v->mathKernCoverageOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "mathKernCount", v->mathKernCount);
 	for(int i = 0; i < v->mathKernCount; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "mathKernInfoRecords", i);
-		print_MathKernInfoRecord(f, indent+indentΔ, &v->mathKernInfoRecords[i]);
+		print_MathKernInfoRecord(f, indent+indentΔ, o, &v->mathKernInfoRecords[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_MathKern(Biobuf *f, int indent, MathKern *v)
+print_MathKern(Biobuf *f, int indent, Otf *o, MathKern *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "heightCount", v->heightCount);
 	for(int i = 0; i < v->heightCount; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "correctionHeight", i);
-		print_MathValueRecord(f, indent+indentΔ, &v->correctionHeight[i]);
+		print_MathValueRecord(f, indent+indentΔ, o, &v->correctionHeight[i]);
 	}
 	for(int i = 0; i < v->heightCount; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "kernValues", i);
-		print_MathValueRecord(f, indent+indentΔ, &v->kernValues[i]);
+		print_MathValueRecord(f, indent+indentΔ, o, &v->kernValues[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_Coverage1(Biobuf *f, int indent, Coverage1 *v)
+print_Coverage1(Biobuf *f, int indent, Otf *o, Coverage1 *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "glyphCount", v->glyphCount);
 	for(int i = 0; i < v->glyphCount; i++)
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "glyphArray", i, v->glyphArray[i]);
+	USED(o);
 }
 int
 }
 void
-print_RangeRecord(Biobuf *f, int indent, RangeRecord *v)
+print_RangeRecord(Biobuf *f, int indent, Otf *o, RangeRecord *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "startGlyphID", v->startGlyphID);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "endGlyphID", v->endGlyphID);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "startCoverageIndex", v->startCoverageIndex);
+	USED(o);
 }
 int
 }
 void
-print_Coverage2(Biobuf *f, int indent, Coverage2 *v)
+print_Coverage2(Biobuf *f, int indent, Otf *o, Coverage2 *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "rangeCount", v->rangeCount);
 	for(int i = 0; i < v->rangeCount; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "rangeRecords", i);
-		print_RangeRecord(f, indent+indentΔ, &v->rangeRecords[i]);
+		print_RangeRecord(f, indent+indentΔ, o, &v->rangeRecords[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_Coverage(Biobuf *f, int indent, Coverage *v)
+print_Coverage(Biobuf *f, int indent, Otf *o, Coverage *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "format", v->format);
 	if(v->format == 1){
 		Bprint(f, "%*s%s:\n", indent, "", "cov1");
-		print_Coverage1(f, indent+indentΔ, &v->cov1);
+		print_Coverage1(f, indent+indentΔ, o, &v->cov1);
 	}
 	if(v->format == 2){
 		Bprint(f, "%*s%s:\n", indent, "", "cov2");
-		print_Coverage2(f, indent+indentΔ, &v->cov2);
+		print_Coverage2(f, indent+indentΔ, o, &v->cov2);
 	}
+	USED(o);
 }
 int
 }
 void
-print_MathVariants(Biobuf *f, int indent, MathVariants *v)
+print_MathVariants(Biobuf *f, int indent, Otf *o, MathVariants *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "minConnectorOverlap", v->minConnectorOverlap);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "vertGlyphCoverageOffset", v->vertGlyphCoverageOffset);
 		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "horizGlyphConstructionOffsets", i, v->horizGlyphConstructionOffsets[i]);
 	Bprint(f, "%*s%s:\n", indent, "", "vertGlyphCoverage");
 	if(v->vertGlyphCoverage != nil)
-		print_Coverage(f, indent+indentΔ, v->vertGlyphCoverage);
+		print_Coverage(f, indent+indentΔ, o, v->vertGlyphCoverage);
 	Bprint(f, "%*s%s:\n", indent, "", "horizGlyphCoverage");
 	if(v->horizGlyphCoverage != nil)
-		print_Coverage(f, indent+indentΔ, v->horizGlyphCoverage);
+		print_Coverage(f, indent+indentΔ, o, v->horizGlyphCoverage);
+	USED(o);
 }
 int
 }
 void
-print_MathGlyphInfo(Biobuf *f, int indent, MathGlyphInfo *v)
+print_MathGlyphInfo(Biobuf *f, int indent, Otf *o, MathGlyphInfo *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "mathItalicsCorrectionInfoOffset", v->mathItalicsCorrectionInfoOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "mathTopAccentAttachmentOffset", v->mathTopAccentAttachmentOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "mathKernInfoOffset", v->mathKernInfoOffset);
 	Bprint(f, "%*s%s:\n", indent, "", "mathItalicsCorrectionInfo");
 	if(v->mathItalicsCorrectionInfo != nil)
-		print_MathItalicsCorrectionInfo(f, indent+indentΔ, v->mathItalicsCorrectionInfo);
+		print_MathItalicsCorrectionInfo(f, indent+indentΔ, o, v->mathItalicsCorrectionInfo);
 	Bprint(f, "%*s%s:\n", indent, "", "mathTopAccentAttachment");
 	if(v->mathTopAccentAttachment != nil)
-		print_MathTopAccentAttachment(f, indent+indentΔ, v->mathTopAccentAttachment);
+		print_MathTopAccentAttachment(f, indent+indentΔ, o, v->mathTopAccentAttachment);
 	Bprint(f, "%*s%s:\n", indent, "", "mathKernInfo");
 	if(v->mathKernInfo != nil)
-		print_MathKernInfo(f, indent+indentΔ, v->mathKernInfo);
+		print_MathKernInfo(f, indent+indentΔ, o, v->mathKernInfo);
 	Bprint(f, "%*s%s:\n", indent, "", "extendedShapeCoverage");
 	if(v->extendedShapeCoverage != nil)
-		print_Coverage(f, indent+indentΔ, v->extendedShapeCoverage);
+		print_Coverage(f, indent+indentΔ, o, v->extendedShapeCoverage);
+	USED(o);
 }
 int
 }
 void
-print_MathGlyphVariantRecord(Biobuf *f, int indent, MathGlyphVariantRecord *v)
+print_MathGlyphVariantRecord(Biobuf *f, int indent, Otf *o, MathGlyphVariantRecord *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "variantGlyph", v->variantGlyph);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "advanceMeasurement", v->advanceMeasurement);
+	USED(o);
 }
 int
 }
 void
-print_GlyphPart(Biobuf *f, int indent, GlyphPart *v)
+print_GlyphPart(Biobuf *f, int indent, Otf *o, GlyphPart *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "glyphID", v->glyphID);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "startConnectorLength", v->startConnectorLength);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "endConnectorLength", v->endConnectorLength);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "fullAdvance", v->fullAdvance);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "partFlags", v->partFlags);
+	USED(o);
 }
 int
 }
 void
-print_GlyphAssembly(Biobuf *f, int indent, GlyphAssembly *v)
+print_GlyphAssembly(Biobuf *f, int indent, Otf *o, GlyphAssembly *v)
 {
 	Bprint(f, "%*s%s:\n", indent, "", "italicsCorrection");
-	print_MathValueRecord(f, indent+indentΔ, &v->italicsCorrection);
+	print_MathValueRecord(f, indent+indentΔ, o, &v->italicsCorrection);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "partCount", v->partCount);
 	for(int i = 0; i < v->partCount; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "partRecords", i);
-		print_GlyphPart(f, indent+indentΔ, &v->partRecords[i]);
+		print_GlyphPart(f, indent+indentΔ, o, &v->partRecords[i]);
 	}
+	USED(o);
 }
 int
 }
 void
-print_MathGlyphConstruction(Biobuf *f, int indent, MathGlyphConstruction *v)
+print_MathGlyphConstruction(Biobuf *f, int indent, Otf *o, MathGlyphConstruction *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "glyphAssemblyOffset", v->glyphAssemblyOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "variantCount", v->variantCount);
 	for(int i = 0; i < v->variantCount; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "mathGlyphVariantRecords", i);
-		print_MathGlyphVariantRecord(f, indent+indentΔ, &v->mathGlyphVariantRecords[i]);
+		print_MathGlyphVariantRecord(f, indent+indentΔ, o, &v->mathGlyphVariantRecords[i]);
 	}
 	Bprint(f, "%*s%s:\n", indent, "", "glyphAssembly");
 	if(v->glyphAssembly != nil)
-		print_GlyphAssembly(f, indent+indentΔ, v->glyphAssembly);
+		print_GlyphAssembly(f, indent+indentΔ, o, v->glyphAssembly);
+	USED(o);
 }
 int
 }
 void
-print_TableMATH(Biobuf *f, int indent, TableMATH *v)
+print_TableMATH(Biobuf *f, int indent, Otf *o, TableMATH *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "mathConstantsOffset", v->mathConstantsOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "mathGlyphInfoOffset", v->mathGlyphInfoOffset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "mathVariantsOffset", v->mathVariantsOffset);
 	Bprint(f, "%*s%s:\n", indent, "", "mathConstants");
 	if(v->mathConstants != nil)
-		print_MathConstants(f, indent+indentΔ, v->mathConstants);
+		print_MathConstants(f, indent+indentΔ, o, v->mathConstants);
 	Bprint(f, "%*s%s:\n", indent, "", "mathGlyphInfo");
 	if(v->mathGlyphInfo != nil)
-		print_MathGlyphInfo(f, indent+indentΔ, v->mathGlyphInfo);
+		print_MathGlyphInfo(f, indent+indentΔ, o, v->mathGlyphInfo);
 	Bprint(f, "%*s%s:\n", indent, "", "mathVariants");
 	if(v->mathVariants != nil)
-		print_MathVariants(f, indent+indentΔ, v->mathVariants);
+		print_MathVariants(f, indent+indentΔ, o, v->mathVariants);
+	USED(o);
+}
+int
+read_KernPair(Otf *o, KernPair *v)
+{
+	u8int *b;
+	if((b = otfreadn(o, 6)) == nil)
+		goto err;
+	v->left = b[0]<<8 | b[1];
+	v->right = b[2]<<8 | b[3];
+	v->value = b[4]<<8 | b[5];
+	return 0;
+err:
+	werrstr("%s: %r", "KernPair");
+	return -1;
+}
+void
+print_KernPair(Biobuf *f, int indent, Otf *o, KernPair *v)
+{
+	Bprint(f, "%*s%s: %ud\n", indent, "", "left", v->left);
+	Bprint(f, "%*s%s: %ud\n", indent, "", "right", v->right);
+	Bprint(f, "%*s%s: %d\n", indent, "", "value", v->value);
+	USED(o);
+}
+int
+read_KernSubtable0(Otf *o, KernSubtable0 *v)
+{
+	u8int *b;
+	if((b = otfreadn(o, 8)) == nil)
+		goto err;
+	v->nPairs = b[0]<<8 | b[1];
+	v->searchRange = b[2]<<8 | b[3];
+	v->entrySelector = b[4]<<8 | b[5];
+	v->rangeShift = b[6]<<8 | b[7];
+	if(otfarray(o, &v->kernPairs, read_KernPair, sizeof(KernPair), v->nPairs) < 0){
+		werrstr("%s: %r", "kernPairs");
+		goto err;
+	}
+	return 0;
+err:
+	werrstr("%s: %r", "KernSubtable0");
+	return -1;
+}
+void
+print_KernSubtable0(Biobuf *f, int indent, Otf *o, KernSubtable0 *v)
+{
+	Bprint(f, "%*s%s: %ud\n", indent, "", "nPairs", v->nPairs);
+	Bprint(f, "%*s%s: %ud\n", indent, "", "searchRange", v->searchRange);
+	Bprint(f, "%*s%s: %ud\n", indent, "", "entrySelector", v->entrySelector);
+	Bprint(f, "%*s%s: %ud\n", indent, "", "rangeShift", v->rangeShift);
+	for(int i = 0; i < v->nPairs; i++){
+		Bprint(f, "%*s%s[%d]:\n", indent, "", "kernPairs", i);
+		print_KernPair(f, indent+indentΔ, o, &v->kernPairs[i]);
+	}
+	USED(o);
+}
+int
+read_KernClass(Otf *o, KernClass *v)
+{
+	u8int *b;
+	if((b = otfreadn(o, 4)) == nil)
+		goto err;
+	v->firstGlyph = b[0]<<8 | b[1];
+	v->nGlyphs = b[2]<<8 | b[3];
+	if((b = otfreadn(o, v->nGlyphs*2)) == nil)
+		goto err;
+	v->values = malloc(v->nGlyphs*sizeof(*v->values));
+	for(int i = 0; i < v->nGlyphs; i++)
+		v->values[i] = b[0+i*2]<<8 | b[1+i*2];
+	return 0;
+err:
+	werrstr("%s: %r", "KernClass");
+	return -1;
+}
+void
+print_KernClass(Biobuf *f, int indent, Otf *o, KernClass *v)
+{
+	Bprint(f, "%*s%s: %ud\n", indent, "", "firstGlyph", v->firstGlyph);
+	Bprint(f, "%*s%s: %ud\n", indent, "", "nGlyphs", v->nGlyphs);
+	for(int i = 0; i < v->nGlyphs; i++)
+		Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "values", i, v->values[i]);
+	USED(o);
+}
+int
+read_KernSubtable2(Otf *o, KernSubtable2 *v)
+{
+	u8int *b;
+	if((b = otfreadn(o, 8)) == nil)
+		goto err;
+	v->rowWidth = b[0]<<8 | b[1];
+	v->leftClassOffset = b[2]<<8 | b[3];
+	v->rightClassOffset = b[4]<<8 | b[5];
+	v->kerningArrayOffset = b[6]<<8 | b[7];
+	if(v->leftClassOffset != 0){
+		if(otfpushrange(o, v->leftClassOffset, -1) < 0)
+			goto err;
+		v->leftClass = calloc(1, sizeof(*v->leftClass));
+		if(read_KernClass(o, v->leftClass) < 0){
+			werrstr("%s: %r", "leftClass");
+			goto err;
+		}
+		if(otfpoprange(o) < 0)
+			goto err;
+	}
+	if(v->rightClassOffset != 0){
+		if(otfpushrange(o, v->rightClassOffset, -1) < 0)
+			goto err;
+		v->rightClass = calloc(1, sizeof(*v->rightClass));
+		if(read_KernClass(o, v->rightClass) < 0){
+			werrstr("%s: %r", "rightClass");
+			goto err;
+		}
+		if(otfpoprange(o) < 0)
+			goto err;
+	}
+	if((b = otfreadn(o, (v->rowWidth/2)*2)) == nil)
+		goto err;
+	v->kerningArray = malloc((v->rowWidth/2)*sizeof(*v->kerningArray));
+	for(int i = 0; i < (v->rowWidth/2); i++)
+		v->kerningArray[i] = b[0+i*2]<<8 | b[1+i*2];
+	return 0;
+err:
+	werrstr("%s: %r", "KernSubtable2");
+	return -1;
+}
+void
+print_KernSubtable2(Biobuf *f, int indent, Otf *o, KernSubtable2 *v)
+{
+	Bprint(f, "%*s%s: %ud\n", indent, "", "rowWidth", v->rowWidth);
+	Bprint(f, "%*s%s: %ud\n", indent, "", "leftClassOffset", v->leftClassOffset);
+	Bprint(f, "%*s%s: %ud\n", indent, "", "rightClassOffset", v->rightClassOffset);
+	Bprint(f, "%*s%s: %ud\n", indent, "", "kerningArrayOffset", v->kerningArrayOffset);
+	Bprint(f, "%*s%s:\n", indent, "", "leftClass");
+	if(v->leftClass != nil)
+		print_KernClass(f, indent+indentΔ, o, v->leftClass);
+	Bprint(f, "%*s%s:\n", indent, "", "rightClass");
+	if(v->rightClass != nil)
+		print_KernClass(f, indent+indentΔ, o, v->rightClass);
+	for(int i = 0; i < (v->rowWidth/2); i++)
+		Bprint(f, "%*s%s[%d]: %d\n", indent, "", "kerningArray", i, v->kerningArray[i]);
+	USED(o);
+}
+int
+read_KernSubtable(Otf *o, KernSubtable *v)
+{
+	u8int *b;
+	if((b = otfreadn(o, 6)) == nil)
+		goto err;
+	u16int version = b[0]<<8 | b[1];
+	if(version != 0){
+		werrstr("%s: invalid value: %d (0x%ux)", "version", version, version);
+		goto err;
+	}
+	v->length = b[2]<<8 | b[3];
+	if(v->length < 6){
+		werrstr("%s: invalid value: %d (0x%ux)", "length", v->length, v->length);
+		goto err;
+	}
+	v->coverage = b[4]<<8 | b[5];
+	return 0;
+err:
+	werrstr("%s: %r", "KernSubtable");
+	return -1;
+}
+void
+print_KernSubtable(Biobuf *f, int indent, Otf *o, KernSubtable *v)
+{
+	Bprint(f, "%*s%s: %ud\n", indent, "", "length", v->length);
+	Bprint(f, "%*s%s: %ud\n", indent, "", "coverage", v->coverage);
+	USED(o);
+}
+int
+read_TableKern(Otf *o, TableKern *v)
+{
+	u8int *b;
+	if((b = otfreadn(o, 4)) == nil)
+		goto err;
+	u16int version = b[0]<<8 | b[1];
+	if(version != 0){
+		werrstr("%s: invalid value: %d (0x%ux)", "version", version, version);
+		goto err;
+	}
+	v->nTables = b[2]<<8 | b[3];
+	if(otfarray(o, &v->subtables, read_KernSubtable, sizeof(KernSubtable), v->nTables) < 0){
+		werrstr("%s: %r", "subtables");
+		goto err;
+	}
+	return 0;
+err:
+	werrstr("%s: %r", "TableKern");
+	return -1;
+}
+void
+print_TableKern(Biobuf *f, int indent, Otf *o, TableKern *v)
+{
+	Bprint(f, "%*s%s: %ud\n", indent, "", "nTables", v->nTables);
+	for(int i = 0; i < v->nTables; i++){
+		Bprint(f, "%*s%s[%d]:\n", indent, "", "subtables", i);
+		print_KernSubtable(f, indent+indentΔ, o, &v->subtables[i]);
+	}
+	USED(o);
+}
+int
+read_TableLoca(Otf *o, TableLoca *v)
+{
+	u8int *b;
+	if(o->indexToLocFormat == 0){
+		if((b = otfreadn(o, (o->numGlyphs+1)*2)) == nil)
+			goto err;
+		v->shortOffsets = malloc((o->numGlyphs+1)*sizeof(*v->shortOffsets));
+		for(int i = 0; i < (o->numGlyphs+1); i++)
+			v->shortOffsets[i] = b[0+i*2]<<8 | b[1+i*2];
+	}
+	if(o->indexToLocFormat == 1){
+		if((b = otfreadn(o, (o->numGlyphs+1)*4)) == nil)
+			goto err;
+		v->longOffsets = malloc((o->numGlyphs+1)*sizeof(*v->longOffsets));
+		for(int i = 0; i < (o->numGlyphs+1); i++)
+			v->longOffsets[i] = b[0+i*4]<<24 | b[1+i*4]<<16 | b[2+i*4]<<8 | b[3+i*4];
+	}
+	return 0;
+err:
+	werrstr("%s: %r", "TableLoca");
+	return -1;
+}
+void
+print_TableLoca(Biobuf *f, int indent, Otf *o, TableLoca *v)
+{
+	if(o->indexToLocFormat == 0){
+		for(int i = 0; i < (o->numGlyphs+1); i++)
+			Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "shortOffsets", i, v->shortOffsets[i]);
+	}
+	if(o->indexToLocFormat == 1){
+		for(int i = 0; i < (o->numGlyphs+1); i++)
+			Bprint(f, "%*s%s[%d]: %ud\n", indent, "", "longOffsets", i, v->longOffsets[i]);
+	}
+	USED(o);
 }
 int
 }
 void
-print_TableOS∕2(Biobuf *f, int indent, TableOS∕2 *v)
+print_TableOS∕2(Biobuf *f, int indent, Otf *o, TableOS∕2 *v)
 {
 	Bprint(f, "%*s%s: %ud\n", indent, "", "version", v->version);
 	Bprint(f, "%*s%s: %d\n", indent, "", "xAvgCharWidth", v->xAvgCharWidth);
 		Bprint(f, "%*s%s: %ud\n", indent, "", "usLowerOpticalPointSize", v->usLowerOpticalPointSize);
 	if(v->version >= 5)
 		Bprint(f, "%*s%s: %ud\n", indent, "", "usUpperOpticalPointSize", v->usUpperOpticalPointSize);
+	USED(o);
 }
 int
 }
 void
-print_TableRecord(Biobuf *f, int indent, TableRecord *v)
+print_TableRecord(Biobuf *f, int indent, Otf *o, TableRecord *v)
 {
 	Bprint(f, "%*s%s: %t\n", indent, "", "tableTag", v->tableTag);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "offset", v->offset);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "length", v->length);
 	if(v->print != nil && v->parsed != nil)
-		v->print(f, indent+indentΔ, v->parsed);
+		v->print(f, indent+indentΔ, o, v->parsed);
+	USED(o);
 }
 int
 		werrstr("%s: %r", "tableRecords");
 		goto err;
 	}
-	for(int i = 0; i < v->numTables; i++){
+	int retry = 0;
-		TableRecord *rec = &v->tableRecords[i];
+	do{
-		if(rec->length == 0)
+		for(int i = 0; i < v->numTables; i++){
-			continue;
+			TableRecord *rec = &v->tableRecords[i];
-		if(otfpushrange(o, rec->offset, rec->length) < 0)
+			if(rec->length == 0)
-			goto err;
+				continue;
-		switch(rec->tableTag){
+			if(otfpushrange(o, rec->offset, rec->length) < 0)
-		case (u32int)('c'<<24|'m'<<16|'a'<<8|'p'):
-			v->cmap = calloc(1, sizeof(TableCmap));
-			if(read_TableCmap(o, v->cmap) < 0){
-				free(v->cmap);
-				goto err;
-			}
-			rec->parsed = v->cmap;
-			rec->print = (void*)print_TableCmap;
-			break;
-		case (u32int)('h'<<24|'e'<<16|'a'<<8|'d'):
-			v->head = calloc(1, sizeof(TableHead));
-			if(read_TableHead(o, v->head) < 0){
-				free(v->head);
-				goto err;
-			}
-			rec->parsed = v->head;
-			rec->print = (void*)print_TableHead;
-			break;
-		case (u32int)('h'<<24|'h'<<16|'e'<<8|'a'):
-			v->hhea = calloc(1, sizeof(TableHhea));
-			if(read_TableHhea(o, v->hhea) < 0){
-				free(v->hhea);
 				goto err;
+			switch(rec->tableTag){
+			case (u32int)('c'<<24|'m'<<16|'a'<<8|'p'):
+				if(v->cmap != nil)
+					break;
+				v->cmap = calloc(1, sizeof(TableCmap));
+				if(read_TableCmap(o, v->cmap) < 0){
+					free(v->cmap);
+					goto err;
+				}
+				rec->parsed = v->cmap;
+				rec->print = (void*)print_TableCmap;
+				break;
+			case (u32int)('h'<<24|'e'<<16|'a'<<8|'d'):
+				if(v->head != nil)
+					break;
+				v->head = calloc(1, sizeof(TableHead));
+				if(read_TableHead(o, v->head) < 0){
+					free(v->head);
+					goto err;
+				}
+				rec->parsed = v->head;
+				rec->print = (void*)print_TableHead;
+				break;
+			case (u32int)('h'<<24|'h'<<16|'e'<<8|'a'):
+				if(v->hhea != nil)
+					break;
+				v->hhea = calloc(1, sizeof(TableHhea));
+				if(read_TableHhea(o, v->hhea) < 0){
+					free(v->hhea);
+					goto err;
+				}
+				rec->parsed = v->hhea;
+				rec->print = (void*)print_TableHhea;
+				break;
+			case (u32int)('m'<<24|'a'<<16|'x'<<8|'p'):
+				if(v->maxp != nil)
+					break;
+				v->maxp = calloc(1, sizeof(TableMaxp));
+				if(read_TableMaxp(o, v->maxp) < 0){
+					free(v->maxp);
+					goto err;
+				}
+				rec->parsed = v->maxp;
+				rec->print = (void*)print_TableMaxp;
+				break;
+			case (u32int)('h'<<24|'m'<<16|'t'<<8|'x'):
+				{
+					static int retried = 0;
+					if(v->hhea == nil || v->maxp == nil){
+						if(retried){
+							werrstr("%s: deps missing", "TableHmtx");
+							goto err;
+						}
+						retried = 1;
+						retry++;
+						break;
+					}
+					if(retried)
+						retry--;
+				}
+				if(v->hmtx != nil)
+					break;
+				v->hmtx = calloc(1, sizeof(TableHmtx));
+				if(read_TableHmtx(o, v->hmtx) < 0){
+					free(v->hmtx);
+					goto err;
+				}
+				rec->parsed = v->hmtx;
+				rec->print = (void*)print_TableHmtx;
+				break;
+			case (u32int)('p'<<24|'o'<<16|'s'<<8|'t'):
+				if(v->post != nil)
+					break;
+				v->post = calloc(1, sizeof(TablePost));
+				if(read_TablePost(o, v->post) < 0){
+					free(v->post);
+					goto err;
+				}
+				rec->parsed = v->post;
+				rec->print = (void*)print_TablePost;
+				break;
+			case (u32int)('n'<<24|'a'<<16|'m'<<8|'e'):
+				if(v->name != nil)
+					break;
+				v->name = calloc(1, sizeof(TableName));
+				if(read_TableName(o, v->name) < 0){
+					free(v->name);
+					goto err;
+				}
+				rec->parsed = v->name;
+				rec->print = (void*)print_TableName;
+				break;
+			case (u32int)('E'<<24|'B'<<16|'D'<<8|'T'):
+				if(v->ebdt != nil)
+					break;
+				v->ebdt = calloc(1, sizeof(TableEBDT));
+				if(read_TableEBDT(o, v->ebdt) < 0){
+					free(v->ebdt);
+					goto err;
+				}
+				rec->parsed = v->ebdt;
+				rec->print = (void*)print_TableEBDT;
+				break;
+			case (u32int)('E'<<24|'B'<<16|'L'<<8|'C'):
+				if(v->eblc != nil)
+					break;
+				v->eblc = calloc(1, sizeof(TableEBLC));
+				if(read_TableEBLC(o, v->eblc) < 0){
+					free(v->eblc);
+					goto err;
+				}
+				rec->parsed = v->eblc;
+				rec->print = (void*)print_TableEBLC;
+				break;
+			case (u32int)('G'<<24|'D'<<16|'E'<<8|'F'):
+				if(v->gdef != nil)
+					break;
+				v->gdef = calloc(1, sizeof(TableGDEF));
+				if(read_TableGDEF(o, v->gdef) < 0){
+					free(v->gdef);
+					goto err;
+				}
+				rec->parsed = v->gdef;
+				rec->print = (void*)print_TableGDEF;
+				break;
+			case (u32int)('G'<<24|'P'<<16|'O'<<8|'S'):
+				if(v->gpos != nil)
+					break;
+				v->gpos = calloc(1, sizeof(TableGPOS));
+				if(read_TableGPOS(o, v->gpos) < 0){
+					free(v->gpos);
+					goto err;
+				}
+				rec->parsed = v->gpos;
+				rec->print = (void*)print_TableGPOS;
+				break;
+			case (u32int)('G'<<24|'S'<<16|'U'<<8|'B'):
+				if(v->gsub != nil)
+					break;
+				v->gsub = calloc(1, sizeof(TableGSUB));
+				if(read_TableGSUB(o, v->gsub) < 0){
+					free(v->gsub);
+					goto err;
+				}
+				rec->parsed = v->gsub;
+				rec->print = (void*)print_TableGSUB;
+				break;
+			case (u32int)('M'<<24|'A'<<16|'T'<<8|'H'):
+				if(v->math != nil)
+					break;
+				v->math = calloc(1, sizeof(TableMATH));
+				if(read_TableMATH(o, v->math) < 0){
+					free(v->math);
+					goto err;
+				}
+				rec->parsed = v->math;
+				rec->print = (void*)print_TableMATH;
+				break;
+			case (u32int)('k'<<24|'e'<<16|'r'<<8|'n'):
+				if(v->kern != nil)
+					break;
+				v->kern = calloc(1, sizeof(TableKern));
+				if(read_TableKern(o, v->kern) < 0){
+					free(v->kern);
+					goto err;
+				}
+				rec->parsed = v->kern;
+				rec->print = (void*)print_TableKern;
+				break;
+			case (u32int)('l'<<24|'o'<<16|'c'<<8|'a'):
+				{
+					static int retried = 0;
+					if(v->head == nil){
+						if(retried){
+							werrstr("%s: deps missing", "TableLoca");
+							goto err;
+						}
+						retried = 1;
+						retry++;
+						break;
+					}
+					if(retried)
+						retry--;
+				}
+				if(v->loca != nil)
+					break;
+				v->loca = calloc(1, sizeof(TableLoca));
+				if(read_TableLoca(o, v->loca) < 0){
+					free(v->loca);
+					goto err;
+				}
+				rec->parsed = v->loca;
+				rec->print = (void*)print_TableLoca;
+				break;
+			case (u32int)('O'<<24|'S'<<16|'/'<<8|'2'):
+				if(v->os∕2 != nil)
+					break;
+				v->os∕2 = calloc(1, sizeof(TableOS∕2));
+				if(read_TableOS∕2(o, v->os∕2) < 0){
+					free(v->os∕2);
+					goto err;
+				}
+				rec->parsed = v->os∕2;
+				rec->print = (void*)print_TableOS∕2;
+				break;
 			}
-			rec->parsed = v->hhea;
+			if(otfpoprange(o) < 0)
-			rec->print = (void*)print_TableHhea;
-			break;
-		case (u32int)('m'<<24|'a'<<16|'x'<<8|'p'):
-			v->maxp = calloc(1, sizeof(TableMaxp));
-			if(read_TableMaxp(o, v->maxp) < 0){
-				free(v->maxp);
 				goto err;
-			}
-			rec->parsed = v->maxp;
-			rec->print = (void*)print_TableMaxp;
-			break;
-		case (u32int)('p'<<24|'o'<<16|'s'<<8|'t'):
-			v->post = calloc(1, sizeof(TablePost));
-			if(read_TablePost(o, v->post) < 0){
-				free(v->post);
-				goto err;
-			}
-			rec->parsed = v->post;
-			rec->print = (void*)print_TablePost;
-			break;
-		case (u32int)('n'<<24|'a'<<16|'m'<<8|'e'):
-			v->name = calloc(1, sizeof(TableName));
-			if(read_TableName(o, v->name) < 0){
-				free(v->name);
-				goto err;
-			}
-			rec->parsed = v->name;
-			rec->print = (void*)print_TableName;
-			break;
-		case (u32int)('E'<<24|'B'<<16|'D'<<8|'T'):
-			v->ebdt = calloc(1, sizeof(TableEBDT));
-			if(read_TableEBDT(o, v->ebdt) < 0){
-				free(v->ebdt);
-				goto err;
-			}
-			rec->parsed = v->ebdt;
-			rec->print = (void*)print_TableEBDT;
-			break;
-		case (u32int)('E'<<24|'B'<<16|'L'<<8|'C'):
-			v->eblc = calloc(1, sizeof(TableEBLC));
-			if(read_TableEBLC(o, v->eblc) < 0){
-				free(v->eblc);
-				goto err;
-			}
-			rec->parsed = v->eblc;
-			rec->print = (void*)print_TableEBLC;
-			break;
-		case (u32int)('G'<<24|'D'<<16|'E'<<8|'F'):
-			v->gdef = calloc(1, sizeof(TableGDEF));
-			if(read_TableGDEF(o, v->gdef) < 0){
-				free(v->gdef);
-				goto err;
-			}
-			rec->parsed = v->gdef;
-			rec->print = (void*)print_TableGDEF;
-			break;
-		case (u32int)('G'<<24|'P'<<16|'O'<<8|'S'):
-			v->gpos = calloc(1, sizeof(TableGPOS));
-			if(read_TableGPOS(o, v->gpos) < 0){
-				free(v->gpos);
-				goto err;
-			}
-			rec->parsed = v->gpos;
-			rec->print = (void*)print_TableGPOS;
-			break;
-		case (u32int)('G'<<24|'S'<<16|'U'<<8|'B'):
-			v->gsub = calloc(1, sizeof(TableGSUB));
-			if(read_TableGSUB(o, v->gsub) < 0){
-				free(v->gsub);
-				goto err;
-			}
-			rec->parsed = v->gsub;
-			rec->print = (void*)print_TableGSUB;
-			break;
-		case (u32int)('M'<<24|'A'<<16|'T'<<8|'H'):
-			v->math = calloc(1, sizeof(TableMATH));
-			if(read_TableMATH(o, v->math) < 0){
-				free(v->math);
-				goto err;
-			}
-			rec->parsed = v->math;
-			rec->print = (void*)print_TableMATH;
-			break;
-		case (u32int)('O'<<24|'S'<<16|'/'<<8|'2'):
-			v->os∕2 = calloc(1, sizeof(TableOS∕2));
-			if(read_TableOS∕2(o, v->os∕2) < 0){
-				free(v->os∕2);
-				goto err;
-			}
-			rec->parsed = v->os∕2;
-			rec->print = (void*)print_TableOS∕2;
-			break;
 		}
-		if(otfpoprange(o) < 0)
+	}while(retry > 0);
-			goto err;
-	}
 	return 0;
 err:
 	werrstr("%s: %r", "TableDirectory");
 }
 void
-print_TableDirectory(Biobuf *f, int indent, TableDirectory *v)
+print_TableDirectory(Biobuf *f, int indent, Otf *o, TableDirectory *v)
 {
 	Bprint(f, "%*s%s: %#ux\n", indent, "", "sfntVersion", v->sfntVersion);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "numTables", v->numTables);
 	Bprint(f, "%*s%s: %ud\n", indent, "", "rangeShift", v->rangeShift);
 	for(int i = 0; i < v->numTables; i++){
 		Bprint(f, "%*s%s[%d]:\n", indent, "", "tableRecords", i);
-		print_TableRecord(f, indent+indentΔ, &v->tableRecords[i]);
+		print_TableRecord(f, indent+indentΔ, o, &v->tableRecords[i]);
 	}
+	USED(o);
 }
 int indentΔ = 2;

otf.h+171−84

 typedef struct TableHhea TableHhea;
 typedef struct LongHorMetric LongHorMetric;
 typedef struct TableMaxp TableMaxp;
+typedef struct TableHmtx TableHmtx;
 typedef struct TablePost TablePost;
 typedef struct NameRecord NameRecord;
 typedef struct LangTagRecord LangTagRecord;
 typedef struct GlyphAssembly GlyphAssembly;
 typedef struct MathGlyphConstruction MathGlyphConstruction;
 typedef struct TableMATH TableMATH;
+typedef struct KernPair KernPair;
+typedef struct KernSubtable0 KernSubtable0;
+typedef struct KernClass KernClass;
+typedef struct KernSubtable2 KernSubtable2;
+typedef struct KernSubtable KernSubtable;
+typedef struct TableKern TableKern;
+typedef struct TableLoca TableLoca;
 typedef struct TableOS∕2 TableOS∕2;
 typedef struct TableRecord TableRecord;
 typedef struct TableDirectory TableDirectory;
 };
 int read_SubHeader(Otf *o, SubHeader *v);
-void print_SubHeader(Biobuf *f, int indent, SubHeader *v);
+void print_SubHeader(Biobuf *f, int indent, Otf *o, SubHeader *v);
 struct MapGroup {
 	u32int startCharCode;
 };
 int read_MapGroup(Otf *o, MapGroup *v);
-void print_MapGroup(Biobuf *f, int indent, MapGroup *v);
+void print_MapGroup(Biobuf *f, int indent, Otf *o, MapGroup *v);
 struct SubtableCmap0 {
 	u16int length;
 };
 int read_SubtableCmap0(Otf *o, SubtableCmap0 *v);
-void print_SubtableCmap0(Biobuf *f, int indent, SubtableCmap0 *v);
+void print_SubtableCmap0(Biobuf *f, int indent, Otf *o, SubtableCmap0 *v);
 struct SubtableCmap2 {
 	u16int length;
 };
 int read_SubtableCmap2(Otf *o, SubtableCmap2 *v);
-void print_SubtableCmap2(Biobuf *f, int indent, SubtableCmap2 *v);
+void print_SubtableCmap2(Biobuf *f, int indent, Otf *o, SubtableCmap2 *v);
 struct SubtableCmap4 {
 	u16int length;
 };
 int read_SubtableCmap4(Otf *o, SubtableCmap4 *v);
-void print_SubtableCmap4(Biobuf *f, int indent, SubtableCmap4 *v);
+void print_SubtableCmap4(Biobuf *f, int indent, Otf *o, SubtableCmap4 *v);
 struct SubtableCmap6 {
 	u16int length;
 };
 int read_SubtableCmap6(Otf *o, SubtableCmap6 *v);
-void print_SubtableCmap6(Biobuf *f, int indent, SubtableCmap6 *v);
+void print_SubtableCmap6(Biobuf *f, int indent, Otf *o, SubtableCmap6 *v);
 struct SubtableCmap8 {
 	u16int length;
 };
 int read_SubtableCmap8(Otf *o, SubtableCmap8 *v);
-void print_SubtableCmap8(Biobuf *f, int indent, SubtableCmap8 *v);
+void print_SubtableCmap8(Biobuf *f, int indent, Otf *o, SubtableCmap8 *v);
 struct SubtableCmap10 {
 	u16int reserved;
 };
 int read_SubtableCmap10(Otf *o, SubtableCmap10 *v);
-void print_SubtableCmap10(Biobuf *f, int indent, SubtableCmap10 *v);
+void print_SubtableCmap10(Biobuf *f, int indent, Otf *o, SubtableCmap10 *v);
 struct SubtableCmap12or13 {
 	u16int reserved;
 };
 int read_SubtableCmap12or13(Otf *o, SubtableCmap12or13 *v);
-void print_SubtableCmap12or13(Biobuf *f, int indent, SubtableCmap12or13 *v);
+void print_SubtableCmap12or13(Biobuf *f, int indent, Otf *o, SubtableCmap12or13 *v);
 struct UnicodeRange {
 	u32int startUnicodeValue;
 };
 int read_UnicodeRange(Otf *o, UnicodeRange *v);
-void print_UnicodeRange(Biobuf *f, int indent, UnicodeRange *v);
+void print_UnicodeRange(Biobuf *f, int indent, Otf *o, UnicodeRange *v);
 struct DefaultUVS {
 	u32int numUnicodeValueRanges;
 };
 int read_DefaultUVS(Otf *o, DefaultUVS *v);
-void print_DefaultUVS(Biobuf *f, int indent, DefaultUVS *v);
+void print_DefaultUVS(Biobuf *f, int indent, Otf *o, DefaultUVS *v);
 struct UVSMapping {
 	u32int unicodeValue;
 };
 int read_UVSMapping(Otf *o, UVSMapping *v);
-void print_UVSMapping(Biobuf *f, int indent, UVSMapping *v);
+void print_UVSMapping(Biobuf *f, int indent, Otf *o, UVSMapping *v);
 struct NonDefaultUVS {
 	u32int numUVSMappings;
 };
 int read_NonDefaultUVS(Otf *o, NonDefaultUVS *v);
-void print_NonDefaultUVS(Biobuf *f, int indent, NonDefaultUVS *v);
+void print_NonDefaultUVS(Biobuf *f, int indent, Otf *o, NonDefaultUVS *v);
 struct VariationSelector {
 	u32int varSelector;
 };
 int read_VariationSelector(Otf *o, VariationSelector *v);
-void print_VariationSelector(Biobuf *f, int indent, VariationSelector *v);
+void print_VariationSelector(Biobuf *f, int indent, Otf *o, VariationSelector *v);
 struct SubtableCmap14 {
 	u32int length;
 };
 int read_SubtableCmap14(Otf *o, SubtableCmap14 *v);
-void print_SubtableCmap14(Biobuf *f, int indent, SubtableCmap14 *v);
+void print_SubtableCmap14(Biobuf *f, int indent, Otf *o, SubtableCmap14 *v);
 struct SubtableCmap {
 	u16int format;
 };
 int read_SubtableCmap(Otf *o, SubtableCmap *v);
-void print_SubtableCmap(Biobuf *f, int indent, SubtableCmap *v);
+void print_SubtableCmap(Biobuf *f, int indent, Otf *o, SubtableCmap *v);
 struct EncodingRecord {
 	u16int platformID;
 };
 int read_EncodingRecord(Otf *o, EncodingRecord *v);
-void print_EncodingRecord(Biobuf *f, int indent, EncodingRecord *v);
+void print_EncodingRecord(Biobuf *f, int indent, Otf *o, EncodingRecord *v);
 struct TableCmap {
 	// u16int version;
 };
 int read_TableCmap(Otf *o, TableCmap *v);
-void print_TableCmap(Biobuf *f, int indent, TableCmap *v);
+void print_TableCmap(Biobuf *f, int indent, Otf *o, TableCmap *v);
 struct TableHead {
 	// u16int majorVersion;
 };
 int read_TableHead(Otf *o, TableHead *v);
-void print_TableHead(Biobuf *f, int indent, TableHead *v);
+void print_TableHead(Biobuf *f, int indent, Otf *o, TableHead *v);
 struct TableHhea {
 	u16int majorVersion;
 };
 int read_TableHhea(Otf *o, TableHhea *v);
-void print_TableHhea(Biobuf *f, int indent, TableHhea *v);
+void print_TableHhea(Biobuf *f, int indent, Otf *o, TableHhea *v);
 struct LongHorMetric {
 	u16int advanceWidth;
 };
 int read_LongHorMetric(Otf *o, LongHorMetric *v);
-void print_LongHorMetric(Biobuf *f, int indent, LongHorMetric *v);
+void print_LongHorMetric(Biobuf *f, int indent, Otf *o, LongHorMetric *v);
 struct TableMaxp {
 	// u32int version;
 };
 int read_TableMaxp(Otf *o, TableMaxp *v);
-void print_TableMaxp(Biobuf *f, int indent, TableMaxp *v);
+void print_TableMaxp(Biobuf *f, int indent, Otf *o, TableMaxp *v);
+struct TableHmtx {
+	LongHorMetric *hMetrics;
+	s16int *leftSideBearings;
+};
+int read_TableHmtx(Otf *o, TableHmtx *v);
+void print_TableHmtx(Biobuf *f, int indent, Otf *o, TableHmtx *v);
 struct TablePost {
 	// u32int version;
 };
 int read_TablePost(Otf *o, TablePost *v);
-void print_TablePost(Biobuf *f, int indent, TablePost *v);
+void print_TablePost(Biobuf *f, int indent, Otf *o, TablePost *v);
 struct NameRecord {
 	u16int platformID;
 };
 int read_NameRecord(Otf *o, NameRecord *v);
-void print_NameRecord(Biobuf *f, int indent, NameRecord *v);
+void print_NameRecord(Biobuf *f, int indent, Otf *o, NameRecord *v);
 struct LangTagRecord {
 	u16int length;
 };
 int read_LangTagRecord(Otf *o, LangTagRecord *v);
-void print_LangTagRecord(Biobuf *f, int indent, LangTagRecord *v);
+void print_LangTagRecord(Biobuf *f, int indent, Otf *o, LangTagRecord *v);
 struct TableName {
 	u16int version;
 };
 int read_TableName(Otf *o, TableName *v);
-void print_TableName(Biobuf *f, int indent, TableName *v);
+void print_TableName(Biobuf *f, int indent, Otf *o, TableName *v);
 struct BigGlyphMetrics {
 	u8int height;
 };
 int read_BigGlyphMetrics(Otf *o, BigGlyphMetrics *v);
-void print_BigGlyphMetrics(Biobuf *f, int indent, BigGlyphMetrics *v);
+void print_BigGlyphMetrics(Biobuf *f, int indent, Otf *o, BigGlyphMetrics *v);
 struct SmallGlyphMetrics {
 	u8int height;
 };
 int read_SmallGlyphMetrics(Otf *o, SmallGlyphMetrics *v);
-void print_SmallGlyphMetrics(Biobuf *f, int indent, SmallGlyphMetrics *v);
+void print_SmallGlyphMetrics(Biobuf *f, int indent, Otf *o, SmallGlyphMetrics *v);
 struct SbitLineMetrics {
 	s8int ascender;
 };
 int read_SbitLineMetrics(Otf *o, SbitLineMetrics *v);
-void print_SbitLineMetrics(Biobuf *f, int indent, SbitLineMetrics *v);
+void print_SbitLineMetrics(Biobuf *f, int indent, Otf *o, SbitLineMetrics *v);
 struct IndexSubtable1 {
-	u32int sbitOffsets;
+	u32int *sbitOffsets;
 };
 int read_IndexSubtable1(Otf *o, IndexSubtable1 *v);
-void print_IndexSubtable1(Biobuf *f, int indent, IndexSubtable1 *v);
+void print_IndexSubtable1(Biobuf *f, int indent, Otf *o, IndexSubtable1 *v);
 struct IndexSubtable2 {
 	u32int imageSize;
 };
 int read_IndexSubtable2(Otf *o, IndexSubtable2 *v);
-void print_IndexSubtable2(Biobuf *f, int indent, IndexSubtable2 *v);
+void print_IndexSubtable2(Biobuf *f, int indent, Otf *o, IndexSubtable2 *v);
 struct IndexSubtable3 {
-	u16int sbitOffsets;
+	u16int *sbitOffsets;
 };
 int read_IndexSubtable3(Otf *o, IndexSubtable3 *v);
-void print_IndexSubtable3(Biobuf *f, int indent, IndexSubtable3 *v);
+void print_IndexSubtable3(Biobuf *f, int indent, Otf *o, IndexSubtable3 *v);
 struct GlyphIdOffsetPair {
 	u16int glyphID;
 };
 int read_GlyphIdOffsetPair(Otf *o, GlyphIdOffsetPair *v);
-void print_GlyphIdOffsetPair(Biobuf *f, int indent, GlyphIdOffsetPair *v);
+void print_GlyphIdOffsetPair(Biobuf *f, int indent, Otf *o, GlyphIdOffsetPair *v);
 struct IndexSubtable4 {
 	u32int numGlyphs;
 };
 int read_IndexSubtable4(Otf *o, IndexSubtable4 *v);
-void print_IndexSubtable4(Biobuf *f, int indent, IndexSubtable4 *v);
+void print_IndexSubtable4(Biobuf *f, int indent, Otf *o, IndexSubtable4 *v);
 struct IndexSubtable5 {
 	u32int imageSize;
 };
 int read_IndexSubtable5(Otf *o, IndexSubtable5 *v);
-void print_IndexSubtable5(Biobuf *f, int indent, IndexSubtable5 *v);
+void print_IndexSubtable5(Biobuf *f, int indent, Otf *o, IndexSubtable5 *v);
 struct IndexSubtable {
 	u16int indexFormat;
 };
 int read_IndexSubtable(Otf *o, IndexSubtable *v);
-void print_IndexSubtable(Biobuf *f, int indent, IndexSubtable *v);
+void print_IndexSubtable(Biobuf *f, int indent, Otf *o, IndexSubtable *v);
 struct IndexSubtableRecord {
 	u16int firstGlyphIndex;
 };
 int read_IndexSubtableRecord(Otf *o, IndexSubtableRecord *v);
-void print_IndexSubtableRecord(Biobuf *f, int indent, IndexSubtableRecord *v);
+void print_IndexSubtableRecord(Biobuf *f, int indent, Otf *o, IndexSubtableRecord *v);
 struct BitmapSize {
 	u32int indexSubtableListOffset;
 };
 int read_BitmapSize(Otf *o, BitmapSize *v);
-void print_BitmapSize(Biobuf *f, int indent, BitmapSize *v);
+void print_BitmapSize(Biobuf *f, int indent, Otf *o, BitmapSize *v);
 struct TableEBDT {
 	u16int majorVersion;
 };
 int read_TableEBDT(Otf *o, TableEBDT *v);
-void print_TableEBDT(Biobuf *f, int indent, TableEBDT *v);
+void print_TableEBDT(Biobuf *f, int indent, Otf *o, TableEBDT *v);
 struct TableEBLC {
 	// u16int majorVersion;
 };
 int read_TableEBLC(Otf *o, TableEBLC *v);
-void print_TableEBLC(Biobuf *f, int indent, TableEBLC *v);
+void print_TableEBLC(Biobuf *f, int indent, Otf *o, TableEBLC *v);
 struct AttachList {
 	u16int coverageOffset;
 };
 int read_AttachList(Otf *o, AttachList *v);
-void print_AttachList(Biobuf *f, int indent, AttachList *v);
+void print_AttachList(Biobuf *f, int indent, Otf *o, AttachList *v);
 struct AttachPoint {
 	u16int pointCount;
 };
 int read_AttachPoint(Otf *o, AttachPoint *v);
-void print_AttachPoint(Biobuf *f, int indent, AttachPoint *v);
+void print_AttachPoint(Biobuf *f, int indent, Otf *o, AttachPoint *v);
 struct LigCaretList {
 	u16int coverageOffset;
 };
 int read_LigCaretList(Otf *o, LigCaretList *v);
-void print_LigCaretList(Biobuf *f, int indent, LigCaretList *v);
+void print_LigCaretList(Biobuf *f, int indent, Otf *o, LigCaretList *v);
 struct LigGlyph {
 	u16int caretCount;
 };
 int read_LigGlyph(Otf *o, LigGlyph *v);
-void print_LigGlyph(Biobuf *f, int indent, LigGlyph *v);
+void print_LigGlyph(Biobuf *f, int indent, Otf *o, LigGlyph *v);
 struct CaretValue {
 	u16int format;
 };
 int read_CaretValue(Otf *o, CaretValue *v);
-void print_CaretValue(Biobuf *f, int indent, CaretValue *v);
+void print_CaretValue(Biobuf *f, int indent, Otf *o, CaretValue *v);
 struct ValueRecord {
 	s16int xPlacement;
 };
 int read_ValueRecord(Otf *o, ValueRecord *v);
-void print_ValueRecord(Biobuf *f, int indent, ValueRecord *v);
+void print_ValueRecord(Biobuf *f, int indent, Otf *o, ValueRecord *v);
 struct SinglePos {
 	u16int format;
 };
 int read_SinglePos(Otf *o, SinglePos *v);
-void print_SinglePos(Biobuf *f, int indent, SinglePos *v);
+void print_SinglePos(Biobuf *f, int indent, Otf *o, SinglePos *v);
 struct TableGDEF {
 	// u16int majorVersion;
 };
 int read_TableGDEF(Otf *o, TableGDEF *v);
-void print_TableGDEF(Biobuf *f, int indent, TableGDEF *v);
+void print_TableGDEF(Biobuf *f, int indent, Otf *o, TableGDEF *v);
 struct LangSys {
 	// u16int lookupOrderOffset;
 };
 int read_LangSys(Otf *o, LangSys *v);
-void print_LangSys(Biobuf *f, int indent, LangSys *v);
+void print_LangSys(Biobuf *f, int indent, Otf *o, LangSys *v);
 struct LangSysRecord {
 	u32int langSysTag;
 };
 int read_LangSysRecord(Otf *o, LangSysRecord *v);
-void print_LangSysRecord(Biobuf *f, int indent, LangSysRecord *v);
+void print_LangSysRecord(Biobuf *f, int indent, Otf *o, LangSysRecord *v);
 struct Script {
 	u16int defaultLangSysOffset;
 };
 int read_Script(Otf *o, Script *v);
-void print_Script(Biobuf *f, int indent, Script *v);
+void print_Script(Biobuf *f, int indent, Otf *o, Script *v);
 struct ScriptRecord {
 	u32int scriptTag;
 };
 int read_ScriptRecord(Otf *o, ScriptRecord *v);
-void print_ScriptRecord(Biobuf *f, int indent, ScriptRecord *v);
+void print_ScriptRecord(Biobuf *f, int indent, Otf *o, ScriptRecord *v);
 struct ScriptList {
 	u16int scriptCount;
 };
 int read_ScriptList(Otf *o, ScriptList *v);
-void print_ScriptList(Biobuf *f, int indent, ScriptList *v);
+void print_ScriptList(Biobuf *f, int indent, Otf *o, ScriptList *v);
 struct Feature {
 	u16int featureParamsOffset;
 };
 int read_Feature(Otf *o, Feature *v);
-void print_Feature(Biobuf *f, int indent, Feature *v);
+void print_Feature(Biobuf *f, int indent, Otf *o, Feature *v);
 struct FeatureRecord {
 	u32int featureTag;
 };
 int read_FeatureRecord(Otf *o, FeatureRecord *v);
-void print_FeatureRecord(Biobuf *f, int indent, FeatureRecord *v);
+void print_FeatureRecord(Biobuf *f, int indent, Otf *o, FeatureRecord *v);
 struct FeatureList {
 	u16int featureCount;
 };
 int read_FeatureList(Otf *o, FeatureList *v);
-void print_FeatureList(Biobuf *f, int indent, FeatureList *v);
+void print_FeatureList(Biobuf *f, int indent, Otf *o, FeatureList *v);
 struct Lookup {
 	u16int lookupType;
 };
 int read_Lookup(Otf *o, Lookup *v);
-void print_Lookup(Biobuf *f, int indent, Lookup *v);
+void print_Lookup(Biobuf *f, int indent, Otf *o, Lookup *v);
 struct LookupList {
 	u16int lookupCount;
 };
 int read_LookupList(Otf *o, LookupList *v);
-void print_LookupList(Biobuf *f, int indent, LookupList *v);
+void print_LookupList(Biobuf *f, int indent, Otf *o, LookupList *v);
 struct TableGPOS {
 	// u16int majorVersion;
 };
 int read_TableGPOS(Otf *o, TableGPOS *v);
-void print_TableGPOS(Biobuf *f, int indent, TableGPOS *v);
+void print_TableGPOS(Biobuf *f, int indent, Otf *o, TableGPOS *v);
 struct TableGSUB {
 	// u16int majorVersion;
 };
 int read_TableGSUB(Otf *o, TableGSUB *v);
-void print_TableGSUB(Biobuf *f, int indent, TableGSUB *v);
+void print_TableGSUB(Biobuf *f, int indent, Otf *o, TableGSUB *v);
 struct MathValueRecord {
 	s16int value;
 };
 int read_MathValueRecord(Otf *o, MathValueRecord *v);
-void print_MathValueRecord(Biobuf *f, int indent, MathValueRecord *v);
+void print_MathValueRecord(Biobuf *f, int indent, Otf *o, MathValueRecord *v);
 struct MathConstants {
 	s16int scriptPercentScaleDown;
 };
 int read_MathConstants(Otf *o, MathConstants *v);
-void print_MathConstants(Biobuf *f, int indent, MathConstants *v);
+void print_MathConstants(Biobuf *f, int indent, Otf *o, MathConstants *v);
 struct MathItalicsCorrectionInfo {
 	u16int italicsCorrectionCoverageOffset;
 };
 int read_MathItalicsCorrectionInfo(Otf *o, MathItalicsCorrectionInfo *v);
-void print_MathItalicsCorrectionInfo(Biobuf *f, int indent, MathItalicsCorrectionInfo *v);
+void print_MathItalicsCorrectionInfo(Biobuf *f, int indent, Otf *o, MathItalicsCorrectionInfo *v);
 struct MathTopAccentAttachment {
 	u16int topAccentCoverageOffset;
 };
 int read_MathTopAccentAttachment(Otf *o, MathTopAccentAttachment *v);
-void print_MathTopAccentAttachment(Biobuf *f, int indent, MathTopAccentAttachment *v);
+void print_MathTopAccentAttachment(Biobuf *f, int indent, Otf *o, MathTopAccentAttachment *v);
 struct MathKernInfoRecord {
 	u16int topRightMathKernOffset;
 };
 int read_MathKernInfoRecord(Otf *o, MathKernInfoRecord *v);
-void print_MathKernInfoRecord(Biobuf *f, int indent, MathKernInfoRecord *v);
+void print_MathKernInfoRecord(Biobuf *f, int indent, Otf *o, MathKernInfoRecord *v);
 struct MathKernInfo {
 	u16int mathKernCoverageOffset;
 };
 int read_MathKernInfo(Otf *o, MathKernInfo *v);
-void print_MathKernInfo(Biobuf *f, int indent, MathKernInfo *v);
+void print_MathKernInfo(Biobuf *f, int indent, Otf *o, MathKernInfo *v);
 struct MathKern {
 	u16int heightCount;
 };
 int read_MathKern(Otf *o, MathKern *v);
-void print_MathKern(Biobuf *f, int indent, MathKern *v);
+void print_MathKern(Biobuf *f, int indent, Otf *o, MathKern *v);
 struct Coverage1 {
 	u16int glyphCount;
 };
 int read_Coverage1(Otf *o, Coverage1 *v);
-void print_Coverage1(Biobuf *f, int indent, Coverage1 *v);
+void print_Coverage1(Biobuf *f, int indent, Otf *o, Coverage1 *v);
 struct RangeRecord {
 	u16int startGlyphID;
 };
 int read_RangeRecord(Otf *o, RangeRecord *v);
-void print_RangeRecord(Biobuf *f, int indent, RangeRecord *v);
+void print_RangeRecord(Biobuf *f, int indent, Otf *o, RangeRecord *v);
 struct Coverage2 {
 	u16int rangeCount;
 };
 int read_Coverage2(Otf *o, Coverage2 *v);
-void print_Coverage2(Biobuf *f, int indent, Coverage2 *v);
+void print_Coverage2(Biobuf *f, int indent, Otf *o, Coverage2 *v);
 struct Coverage {
 	u16int format;
 };
 int read_Coverage(Otf *o, Coverage *v);
-void print_Coverage(Biobuf *f, int indent, Coverage *v);
+void print_Coverage(Biobuf *f, int indent, Otf *o, Coverage *v);
 struct MathVariants {
 	u16int minConnectorOverlap;
 };
 int read_MathVariants(Otf *o, MathVariants *v);
-void print_MathVariants(Biobuf *f, int indent, MathVariants *v);
+void print_MathVariants(Biobuf *f, int indent, Otf *o, MathVariants *v);
 struct MathGlyphInfo {
 	u16int mathItalicsCorrectionInfoOffset;
 };
 int read_MathGlyphInfo(Otf *o, MathGlyphInfo *v);
-void print_MathGlyphInfo(Biobuf *f, int indent, MathGlyphInfo *v);
+void print_MathGlyphInfo(Biobuf *f, int indent, Otf *o, MathGlyphInfo *v);
 struct MathGlyphVariantRecord {
 	u16int variantGlyph;
 };
 int read_MathGlyphVariantRecord(Otf *o, MathGlyphVariantRecord *v);
-void print_MathGlyphVariantRecord(Biobuf *f, int indent, MathGlyphVariantRecord *v);
+void print_MathGlyphVariantRecord(Biobuf *f, int indent, Otf *o, MathGlyphVariantRecord *v);
 struct GlyphPart {
 	u16int glyphID;
 };
 int read_GlyphPart(Otf *o, GlyphPart *v);
-void print_GlyphPart(Biobuf *f, int indent, GlyphPart *v);
+void print_GlyphPart(Biobuf *f, int indent, Otf *o, GlyphPart *v);
 struct GlyphAssembly {
 	MathValueRecord italicsCorrection;
 };
 int read_GlyphAssembly(Otf *o, GlyphAssembly *v);
-void print_GlyphAssembly(Biobuf *f, int indent, GlyphAssembly *v);
+void print_GlyphAssembly(Biobuf *f, int indent, Otf *o, GlyphAssembly *v);
 struct MathGlyphConstruction {
 	u16int glyphAssemblyOffset;
 };
 int read_MathGlyphConstruction(Otf *o, MathGlyphConstruction *v);
-void print_MathGlyphConstruction(Biobuf *f, int indent, MathGlyphConstruction *v);
+void print_MathGlyphConstruction(Biobuf *f, int indent, Otf *o, MathGlyphConstruction *v);
 struct TableMATH {
 	// u16int majorVersion;
 };
 int read_TableMATH(Otf *o, TableMATH *v);
-void print_TableMATH(Biobuf *f, int indent, TableMATH *v);
+void print_TableMATH(Biobuf *f, int indent, Otf *o, TableMATH *v);
+struct KernPair {
+	u16int left;
+	u16int right;
+	s16int value;
+};
+int read_KernPair(Otf *o, KernPair *v);
+void print_KernPair(Biobuf *f, int indent, Otf *o, KernPair *v);
+struct KernSubtable0 {
+	u16int nPairs;
+	u16int searchRange;
+	u16int entrySelector;
+	u16int rangeShift;
+	KernPair *kernPairs;
+};
+int read_KernSubtable0(Otf *o, KernSubtable0 *v);
+void print_KernSubtable0(Biobuf *f, int indent, Otf *o, KernSubtable0 *v);
+struct KernClass {
+	u16int firstGlyph;
+	u16int nGlyphs;
+	u16int *values;
+};
+int read_KernClass(Otf *o, KernClass *v);
+void print_KernClass(Biobuf *f, int indent, Otf *o, KernClass *v);
+struct KernSubtable2 {
+	u16int rowWidth;
+	u16int leftClassOffset;
+	u16int rightClassOffset;
+	u16int kerningArrayOffset;
+	KernClass *leftClass;
+	KernClass *rightClass;
+	s16int *kerningArray;
+};
+int read_KernSubtable2(Otf *o, KernSubtable2 *v);
+void print_KernSubtable2(Biobuf *f, int indent, Otf *o, KernSubtable2 *v);
+struct KernSubtable {
+	// u16int version;
+	u16int length;
+	u16int coverage;
+};
+int read_KernSubtable(Otf *o, KernSubtable *v);
+void print_KernSubtable(Biobuf *f, int indent, Otf *o, KernSubtable *v);
+struct TableKern {
+	// u16int version;
+	u16int nTables;
+	KernSubtable *subtables;
+};
+int read_TableKern(Otf *o, TableKern *v);
+void print_TableKern(Biobuf *f, int indent, Otf *o, TableKern *v);
+struct TableLoca {
+	u16int *shortOffsets;
+	u32int *longOffsets;
+};
+int read_TableLoca(Otf *o, TableLoca *v);
+void print_TableLoca(Biobuf *f, int indent, Otf *o, TableLoca *v);
 struct TableOS∕2 {
 	u16int version;
 };
 int read_TableOS∕2(Otf *o, TableOS∕2 *v);
-void print_TableOS∕2(Biobuf *f, int indent, TableOS∕2 *v);
+void print_TableOS∕2(Biobuf *f, int indent, Otf *o, TableOS∕2 *v);
 struct TableRecord {
 	u32int tableTag;
 	u32int offset;
 	u32int length;
 	void *parsed;
-	void (*print)(Biobuf *f, int indent, void *parsed);
+	void (*print)(Biobuf *f, int indent, Otf *o, void *parsed);
 };
 int read_TableRecord(Otf *o, TableRecord *v);
-void print_TableRecord(Biobuf *f, int indent, TableRecord *v);
+void print_TableRecord(Biobuf *f, int indent, Otf *o, TableRecord *v);
 struct TableDirectory {
 	u32int sfntVersion;
 	TableHead *head;
 	TableHhea *hhea;
 	TableMaxp *maxp;
+	TableHmtx *hmtx;
 	TablePost *post;
 	TableName *name;
 	TableEBDT *ebdt;
 	TableGPOS *gpos;
 	TableGSUB *gsub;
 	TableMATH *math;
+	TableKern *kern;
+	TableLoca *loca;
 	TableOS∕2 *os∕2;
 };
 int read_TableDirectory(Otf *o, TableDirectory *v);
-void print_TableDirectory(Biobuf *f, int indent, TableDirectory *v);
+void print_TableDirectory(Biobuf *f, int indent, Otf *o, TableDirectory *v);
 extern int indentΔ;

otf.rkt+101−42

          {uint16 macStyle}
          {uint16 lowestRecPPEM}
          {int16 fontDirectionHint unused (>= -2) (<= 2)}
-         {int16 indexToLocFormat (<= 1)}
+         {int16 indexToLocFormat ->o (<= 1)}
          {int16 glyphDataFormat unused (== 0)}
          #:tag "head")
          {int16 caretOffset}
          {int16 reserved [4] unused}
          {int16 metricDataFormat (== 0)}
-         {uint16 numberOfHMetrics}
+         {uint16 numberOfHMetrics ->o}
          #:tag "hhea")
 (mkcmplx LongHorMetric {UFWORD advanceWidth} {FWORD lsb})
-#|
-FIXME what. WHAT.
-(mkcmplx TableHmtx
-         {LongHorMetric hMetrics[TableHhea numberOfHMetrics]}
-                   {FWORD leftSideBearings[- (TableMaxp numGlyphs) (TableHhea numberOfHMetrics)]})
-|#
 (mkcmplx TableMaxp
          {Version16Dot16 version (== #x05000 #x10000) unused}
-         {uint16 numGlyphs}
+         {uint16 numGlyphs ->o}
          ; a bunch of fields ignored here
          #:tag "maxp")
+(mkcmplx TableHmtx
+         {LongHorMetric hMetrics [+ o->numberOfHMetrics 0]}
+         {FWORD leftSideBearings [- o->numGlyphs o->numberOfHMetrics]}
+         #:tag "hmtx"
+         #:after (list TableHhea TableMaxp))
 (mkcmplx TablePost
          {Version16Dot16 version (== #x10000 #x20000 #x25000 #x30000) unused}
          {Fixed italicAngle}
          {int8 minAfterBL}
          {int8 pad [2] unused})
-(mkcmplx IndexSubtable1 {Offset32 sbitOffsets} #;[+ (- lastGlyphIndex firstGlyphIndex) 2])
+(mkcmplx IndexSubtable1 {Offset32 sbitOffsets [+ (- o->lastGlyphIndex o->firstGlyphIndex) 2]})
 (mkcmplx IndexSubtable2 {uint32 imageSize} {BigGlyphMetrics bigMetrics})
-; FIXME
+(mkcmplx IndexSubtable3 {Offset16 sbitOffsets [+ (- o->lastGlyphIndex o->firstGlyphIndex) 2]})
-(mkcmplx IndexSubtable3 {Offset16 sbitOffsets} #;[+ (- lastGlyphIndex firstGlyphIndex) 2])
 (mkcmplx GlyphIdOffsetPair {uint16 glyphID} {Offset16 sbitOffset})
          {IndexSubtable5 sub5 (== indexFormat 5)})
 (mkcmplx IndexSubtableRecord
-         {uint16 firstGlyphIndex}
+         {uint16 firstGlyphIndex ->o}
-         {uint16 lastGlyphIndex}
+         {uint16 lastGlyphIndex ->o}
          {Offset32 indexSubtableOffset}
          {IndexSubtable indexSubtable (at indexSubtableOffset)})
          {MathVariants mathVariants (at mathVariantsOffset)}
          #:tag "MATH")
+(mkcmplx KernPair {uint16 left} {uint16 right} {FWORD value})
+(mkcmplx KernSubtable0
+         {uint16 nPairs}
+         {uint16 searchRange}
+         {uint16 entrySelector}
+         {uint16 rangeShift}
+         {KernPair kernPairs [nPairs]})
+(mkcmplx KernClass {uint16 firstGlyph} {uint16 nGlyphs} {uint16 values [nGlyphs]})
+(mkcmplx KernSubtable2
+         {uint16 rowWidth}
+         {Offset16 leftClassOffset}
+         {Offset16 rightClassOffset}
+         {Offset16 kerningArrayOffset}
+         {KernClass leftClass (at leftClassOffset)}
+         {KernClass rightClass (at rightClassOffset)}
+         {FWORD kerningArray [/ rowWidth 2]})
+(mkcmplx KernSubtable
+         {uint16 version (== 0) unused}
+         {uint16 length (>= 6)} ; including this header
+         {uint16 coverage}) ; FIXME the rest depends on the coverage bits (8-15 = 0 or 2)
+(mkcmplx TableKern
+         {uint16 version (== 0) unused}
+         {uint16 nTables}
+         {KernSubtable subtables [nTables]}
+         #:tag "kern")
+(mkcmplx TableLoca
+         {Offset16 shortOffsets [+ o->numGlyphs 1] (== o->indexToLocFormat 0)}
+         {Offset32 longOffsets [+ o->numGlyphs 1] (== o->indexToLocFormat 1)}
+         #:tag "loca"
+         #:after (list TableHead))
 (mkcmplx TableOS∕2
          {uint16 version (<= 5)}
          {FWORD xAvgCharWidth}
          {uint32 checksum unused hex}
          {Offset32 offset}
          {uint32 length}
-         #:extra (list (cons 'field
+         #:extra
-                             (list (~a "void *parsed;")
+         (list (cons 'field
-                                   (~a "void (*print)(Biobuf *f, int indent, void *parsed);")))
+                     (list (~a "void *parsed;")
-                       (cons 'print
+                           (~a "void (*print)(Biobuf *f, int indent, Otf *o, void *parsed);")))
-                             (list (~a "if(v->print != nil && v->parsed != nil)")
+               (cons 'print
-                                   (~a "\tv->print(f, indent+indentΔ, v->parsed);")))))
+                     (list (~a "if(v->print != nil && v->parsed != nil)")
+                           (~a "	v->print(f, indent+indentΔ, o, v->parsed);")))))
 (define (c-friendly-name t)
   (string-replace (string-trim (string-downcase t)) "/" "∕"))
     (define (ft t i)
       (~a "'" (string-ref t i) "'" (if (< i 3) (~a "<<" (* 8 (- 3 i))) "")))
     (define case-tag (~a "(u32int)(" (string-join (map (λ (i) (ft tag i)) (range 4)) "|") ")"))
-    (list (~a "\tcase " case-tag ":")
+    (define after (cmplx-after c))
-          (~a "\t\tv->" (ptr c) " = calloc(1, sizeof(" (cmplx-name c) "));")
+    (define if-ready (string-join (map (λ (ac) (~a "v->" (ptr ac) " == nil")) after) " || "))
-          (~a "\t\tif(read_" (cmplx-name c) "(o, v->" (ptr c) ") < 0){")
+    (list (~a "case " case-tag ":")
-          (~a "\t\t\tfree(v->" (ptr c) ");")
+          (indent (if (empty? after)
-          (~a "\t\t\tgoto err;")
+                      empty
-          (~a "\t\t}")
+                      (list (~a "{")
-          (~a "\t\trec->parsed = v->" (ptr c) ";")
+                            (~a "	static int retried = 0;")
-          (~a "\t\trec->print = (void*)print_" (cmplx-name c) ";")
+                            (~a "	if(" if-ready "){")
-          (~a "\t\tbreak;")))
+                            (~a "		if(retried){")
+                            (~a "			werrstr(\"%s: deps missing\", \"" (cmplx-name c) "\");")
+                            (~a "			goto err;")
+                            (~a "		}")
+                            (~a "		retried = 1;")
+                            (~a "		retry++;")
+                            (~a "		break;")
+                            (~a "	}")
+                            (~a "	if(retried)")
+                            (~a "		retry--;")
+                            (~a "}"))))
+          (~a "	if(v->" (ptr c) " != nil)") ; don't reparse the same table
+          (~a "		break;")
+          (~a "	v->" (ptr c) " = calloc(1, sizeof(" (cmplx-name c) "));")
+          (~a "	if(read_" (cmplx-name c) "(o, v->" (ptr c) ") < 0){")
+          (~a "		free(v->" (ptr c) ");")
+          (~a "		goto err;")
+          (~a "	}")
+          (~a "	rec->parsed = v->" (ptr c) ";")
+          (~a "	rec->print = (void*)print_" (cmplx-name c) ";")
+          (~a "	break;")))
   (list (cons 'field (map (λ (c) (~a (cmplx-name c) " *" (ptr c) ";")) tagged))
         (cons 'read
-              (list (~a "for(int i = 0; i < v->numTables; i++){")
+              (list (~a "int retry = 0;")
-                    (~a "\tTableRecord *rec = &v->tableRecords[i];")
+                    (~a "do{")
-                    (~a "\tif(rec->length == 0)") ; skip all empty tables
+                    (~a "	for(int i = 0; i < v->numTables; i++){")
-                    (~a "\t\tcontinue;")
+                    (~a "		TableRecord *rec = &v->tableRecords[i];")
-                    (~a "\tif(otfpushrange(o, rec->offset, rec->length) < 0)")
+                    (~a "		if(rec->length == 0)") ; skip all empty tables
-                    (~a "\t\tgoto err;")
+                    (~a "			continue;")
-                    (~a "\tswitch(rec->tableTag){")
+                    (~a "		if(otfpushrange(o, rec->offset, rec->length) < 0)")
-                    (map case-statement tagged)
+                    (~a "			goto err;")
-                    (~a "\t}")
+                    (~a "		switch(rec->tableTag){")
-                    (~a "\tif(otfpoprange(o) < 0)")
+                    (indent (indent (map case-statement tagged)))
-                    (~a "\t\tgoto err;")
+                    (~a "		}")
-                    (~a "}")))))
+                    (~a "		if(otfpoprange(o) < 0)")
+                    (~a "			goto err;")
+                    (~a "	}")
+                    (~a "}while(retry > 0);")))))
 (mkcmplx TableDirectory
          {uint32 sfntVersion (== #x00010000 #x4f54544f) hex}

test.c+1−1

@@ -20,7 +20,7 @@ main(int argc, char **argv) · 19 unmodified lines
20	}else if(read_TableDirectory(o, &td) != 0){	20	}else if(read_TableDirectory(o, &td) != 0){
21	fprint(2, "%s: %r\n", argv[i]);	21	fprint(2, "%s: %r\n", argv[i]);
22	} else {	22	} else {
23	print_TableDirectory(out, indentΔ, &td);	23	print_TableDirectory(out, indentΔ, o, &td);
24	}	24	}
25	otfclose(o);	25	otfclose(o);
26	}	26	}

more logic for reading tables with rather peculiar dependencies

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code