shithub: fnt

Download patch

ref: 3c6cc9377be0d201f63491f2878332a62c4dcaa2
parent: 18b2e53f5039cd7da7541ad622c0923c7d4e2872
author: Sigrid Solveig Haflínudóttir <sigrid@ftrv.se>
date: Thu Jul 25 20:52:46 EDT 2024 

extend generator with offset'ed arrays support


--- a/gen.rkt
+++ b/gen.rkt
@@ -112,7 +112,7 @@
     ['< '>=]
     ['> '<=]))
 
-(define-struct field (type name attrs)
+(define-struct field (type name in-struct attrs)
   #:transparent
   #:methods gen:code
   [(define/generic super-c-type c-type)
@@ -119,13 +119,15 @@
    (define (gen-h f)
      (define cnt (field-count f))
      (define fixed-array (number? cnt))
-     (define is-ptr (and (cmplx? (field-type f)) (field-offset f)))
-     (list (~a (if (field-unused? f) "// " "")
-               (super-c-type (field-type f))
-               " "
-               (if (or is-ptr (and cnt (not fixed-array))) "*" "")
-               (field-name f)
-               (if fixed-array (~a "[" cnt "];") ";"))))
+     (define is-ptr (and (cmplx? (field-type f)) (field-at f)))
+     (list (if (field-in-struct f)
+               (~a (if (field-unused? f) "// " "")
+                   (super-c-type (field-type f))
+                   " "
+                   (if (or is-ptr (and cnt (not fixed-array))) "*" "")
+                   (field-name f)
+                   (if fixed-array (~a "[" cnt "];") ";"))
+               empty)))
    (define (gen-c f b index)
      (define (size t)
        (if (type? t) (type-size t) 0))
@@ -137,7 +139,7 @@
        (if (<= x 32768) (~r x) (~r x #:base 16 #:sign '("0x" "" "-0x"))))
      (define (parse-if-error read)
        (define t (field-type f))
-       (define is-ptr (and (cmplx? (field-type f)) (field-offset f)))
+       (define is-ptr (and (cmplx? (field-type f)) (field-at f)))
        (match (field-count f)
          [#f
           (if (or declared (not (field-unused? f)))
@@ -191,16 +193,38 @@
                               " && ")]))
             ts))
      (define (at lst)
-       (define at (field-offset f))
+       (define offset (field-offset f))
+       (define offset-plus (if offset (~a (fmt-expr offset) "+") ""))
+       (define offset-and (if offset (~a (fmt-expr offset) " != 0 && ") ""))
+       (define at (field-at f))
+       (define count (field-count f))
        (if (not at)
            lst
-           (list (~a "if(" (fmt-expr at) " != 0){")
-                 (~a "	if(otfpushrange(o, " (fmt-expr at) ", -1) < 0)")
-                 (~a "		goto err;")
-                 (indent lst)
-                 (~a "	if(otfpoprange(o) < 0)")
-                 (~a "		goto err;")
-                 (~a "}"))))
+           (if (field-array-with-offsets f)
+               (list
+                (~a "if(" offset-and (field-count f) " > 0){")
+                (~a "	" ref " = calloc(" count ", sizeof(*" ref "));")
+                (~a "	for(int i = 0; i < " count "; i++){")
+                (if offset empty (list (~a "		if(" (fmt-expr at) "[i] == 0)") (~a "			continue;")))
+                (~a "		if(otfpushrange(o, " offset-plus (fmt-expr at) "[i], -1))")
+                (~a "			goto err;")
+                (~a "		int r = read_" (name (field-type f)) "(o, " ref "+i);")
+                (~a "		if(otfpoprange(o) < 0)")
+                (~a "			goto err;")
+                ; FIXME do this only if the field is allowed to fail being read
+                (~a "		if(r < 0){")
+                (~a "			memset(" ref "+i, 0, sizeof(*" ref "));")
+                (~a "			break;")
+                (~a "		}")
+                (~a "	}")
+                (~a "}"))
+               (list (~a "if(" (fmt-expr at) " != 0){")
+                     (~a "	if(otfpushrange(o, " offset-plus (fmt-expr at) ", -1) < 0)")
+                     (~a "		goto err;")
+                     (indent lst)
+                     (~a "	if(otfpoprange(o) < 0)")
+                     (~a "		goto err;")
+                     (~a "}")))))
      (at (list*
           (parse-if-error #t)
           (if index
@@ -233,9 +257,19 @@
 (define (field-verb f)
   (field-attr f 'verb))
 
-(define (field-offset f)
+(define (field-at f)
   (field-attr f 'at))
 
+(define (field-offset f)
+  (field-attr f 'offset))
+
+; returns #t if it's an array with each element having its own
+; offset pointed to by elements of another array field
+(define (field-array-with-offsets f)
+  (define v (assoc 'at (field-attrs f)))
+  (define a (caddr v))
+  (>= (length a) 1))
+
 (define (field-cond f)
   (define v (assoc 'cond (field-attrs f)))
   (and v (rest v)))
@@ -290,7 +324,7 @@
           (block (~a "for(int i = 0; i < " cnt "; i++)")
                  (indent (list* print-index (if basic-array empty lst)))))
         identity))
-  (define is-ptr (and (cmplx? t) (field-offset f) (not cnt)))
+  (define is-ptr (and (cmplx? t) (field-at f) (not cnt)))
   (define lst
     (flatten
      (list
@@ -367,7 +401,7 @@
          (or (empty? g)
              (and (type? (field-type f))
                   (type? (field-type (car g)))
-                  (not (or (field-offset f) (field-offset (car g))))
+                  (not (or (field-at f) (field-at (car g))))
                   (no-vla? f)
                   (no-vla? (car g))
                   (equal? (field-cond f) (field-cond (car g))))))
@@ -402,7 +436,7 @@
         (if (cmplx? (field-type (car fields)))
             (map (λ (f) (super-gen-c f #f #f)) fields)
             (let* ([sum (foldr (λ (f accu) (add (field-size f) accu)) 0 fields)]
-                   [lst (flatten (list (if (field-offset (car fields))
+                   [lst (flatten (list (if (field-at (car fields))
                                            empty
                                            (list (~a "if((b = otfreadn(o, " sum ")) == nil)")
                                                  (~a "	goto err;")
@@ -517,15 +551,20 @@
     #:description "field reference"
     (pattern ref:id
       #:fail-when (not (assoc (syntax-e #'ref) fields)) "no such field"
-      #:with type (cadr (assoc (syntax-e #'ref) fields))))
+      #:with type (cadr (assoc (syntax-e #'ref) fields))
+      #:with attrs (caddr (assoc (syntax-e #'ref) fields))))
 
   (syntax-parse stx
     [(_ type name {~literal ->o}) #''(->o #t)]
+    [(_ _ _ ({~literal offset} ref:ref))
+     #:fail-when (not (type-offset? (syntax-e #'ref.type))) "can't be used as an offset"
+     #''(offset ref)]
+    [(_ _ _ ({~literal offset} e:expr)) #''(offset e)]
     [(_ _ _ ({~literal at} ref:ref))
      #:fail-when (not (type-offset? (syntax-e #'ref.type))) "can't be used as an offset"
-     #''(at ref)]
+     #''(at ref ref.attrs)]
     ; FIXME - check fields and ops/numbers
-    [(_ _ _ ({~literal at} e:expr)) #''(at e)]
+    [(_ _ _ ({~literal at} e:expr)) #''(at e ())]
     [(_ type _ {~literal hex})
      #:fail-when (not (type-number? (syntax-e #'type))) "not a number type"
      #'(list 'verb (verb-hex (type-bits type)))]
@@ -559,7 +598,9 @@
   (define-syntax-class name
     #:description "field name"
     (pattern name:id
-      #:fail-when (assoc (syntax-e #'name) fields) "duplicate field name"))
+      ;#:fail-when (assoc (syntax-e #'name) fields) "duplicate field name"
+      ; FIXME this should fail as duplicate if types are different or no/same condition is used
+      ))
 
   (define-syntax-class type
     #:description "field type"
@@ -569,9 +610,11 @@
   (syntax-parse stx
     [(_ type:type name:name attrs ...)
      (begin
-       (set! fields (cons (syntax->datum #'(name type)) fields))
-       #'(field type
+       (define uniq (not (assoc (syntax-e #'name) fields)))
+       (set! fields (cons (syntax->datum #'(name type (attrs ...))) fields))
+       #`(field type
                 `name
+                #,uniq
                 (list (mkattr type `name [~@ attrs]) ...)))]))
 
 (define-syntax (mkfields stx)
--- a/otf.rkt
+++ b/otf.rkt
@@ -455,14 +455,26 @@
 
 (mkcmplx FeatureList {uint16 featureCount} {FeatureRecord featureRecords [featureCount]})
 
+(define lookupFlags
+  #hash((0 . LOOKUP_FL_RIGHT_TO_LEFT)
+        (1 . LOOKUP_FL_IGNORE_BASE_GLYPHS)
+        (2 . LOOKUP_FL_IGNORE_LIGATURES)
+        (3 . LOOKUP_FL_IGNORE_MARKS)
+        (4 . LOOKUP_FL_USE_MARK_FILTERING_SET)))
+; FIXME 0xff00 is attachment class filter
+
 (mkcmplx Lookup
          {uint16 lookupType}
-         {uint16 lookupFlag}
+         {uint16 lookupFlag hex (bits lookupFlags)}
          {uint16 subTableCount}
          {Offset16 subtableOffsets [subTableCount]}
          {uint16 markFilteringSet})
+; FIXME lookup subtable based on current table (GPOS vs GSUB) and lookupType
 
-(mkcmplx LookupList {uint16 lookupCount} {Offset16 lookupOffsets [lookupCount]})
+(mkcmplx LookupList
+         {uint16 lookupCount}
+         {Offset16 lookupOffsets [lookupCount]}
+         {Lookup lookups [lookupCount] (at lookupOffsets)})
 
 (mkcmplx TableGPOS
          {uint16 majorVersion (== 1) unused}
@@ -584,27 +596,6 @@
          {Coverage1 cov1 (== format 1)}
          {Coverage2 cov2 (== format 2)})
 
-(mkcmplx MathVariants
-         {UFWORD minConnectorOverlap}
-         {Offset16 vertGlyphCoverageOffset}
-         {Offset16 horizGlyphCoverageOffset}
-         {uint16 vertGlyphCount}
-         {uint16 horizGlyphCount}
-         {Offset16 vertGlyphConstructionOffsets [vertGlyphCount]}
-         {Offset16 horizGlyphConstructionOffsets [horizGlyphCount]}
-         {Coverage vertGlyphCoverage (at vertGlyphCoverageOffset)}
-         {Coverage horizGlyphCoverage (at horizGlyphCoverageOffset)})
-
-(mkcmplx MathGlyphInfo
-         {Offset16 mathItalicsCorrectionInfoOffset}
-         {Offset16 mathTopAccentAttachmentOffset}
-         {Offset16 extendedShapeCoverageOffset}
-         {Offset16 mathKernInfoOffset}
-         {MathItalicsCorrectionInfo mathItalicsCorrectionInfo (at mathItalicsCorrectionInfoOffset)}
-         {MathTopAccentAttachment mathTopAccentAttachment (at mathTopAccentAttachmentOffset)}
-         {MathKernInfo mathKernInfo (at mathKernInfoOffset)}
-         {Coverage extendedShapeCoverage (at extendedShapeCoverageOffset)})
-
 (mkcmplx MathGlyphVariantRecord {uint16 variantGlyph} {UFWORD advanceMeasurement})
 
 (mkcmplx GlyphPart
@@ -625,6 +616,30 @@
          {MathGlyphVariantRecord mathGlyphVariantRecords [variantCount]}
          {GlyphAssembly glyphAssembly (at glyphAssemblyOffset)})
 
+(mkcmplx
+ MathVariants
+ {UFWORD minConnectorOverlap}
+ {Offset16 vertGlyphCoverageOffset}
+ {Offset16 horizGlyphCoverageOffset}
+ {uint16 vertGlyphCount}
+ {uint16 horizGlyphCount}
+ {Offset16 vertGlyphConstructionOffsets [vertGlyphCount]}
+ {Offset16 horizGlyphConstructionOffsets [horizGlyphCount]}
+ {Coverage vertGlyphCoverage (at vertGlyphCoverageOffset)}
+ {Coverage horizGlyphCoverage (at horizGlyphCoverageOffset)}
+ {MathGlyphConstruction vertGlyphConstruction [vertGlyphCount] (at vertGlyphConstructionOffsets)}
+ {MathGlyphConstruction horizGlyphConstruction [horizGlyphCount] (at horizGlyphConstructionOffsets)})
+
+(mkcmplx MathGlyphInfo
+         {Offset16 mathItalicsCorrectionInfoOffset}
+         {Offset16 mathTopAccentAttachmentOffset}
+         {Offset16 extendedShapeCoverageOffset}
+         {Offset16 mathKernInfoOffset}
+         {MathItalicsCorrectionInfo mathItalicsCorrectionInfo (at mathItalicsCorrectionInfoOffset)}
+         {MathTopAccentAttachment mathTopAccentAttachment (at mathTopAccentAttachmentOffset)}
+         {MathKernInfo mathKernInfo (at mathKernInfoOffset)}
+         {Coverage extendedShapeCoverage (at extendedShapeCoverageOffset)})
+
 (mkcmplx TableMATH
          {uint16 majorVersion (== 1) unused}
          {uint16 minorVersion (== 0) unused}
@@ -656,10 +671,18 @@
          {KernClass rightClass (at rightClassOffset)}
          {FWORD kerningArray [/ rowWidth 2]})
 
+(define kernCoverageFlags
+  #hash((0 . KERN_FL_HORIZONTAL)
+        (1 . KERN_FL_MINIMUM)
+        (2 . KERN_FL_CROSS_STREAM)
+        (3 . KERN_FL_OVERRIDE)))
+
 (mkcmplx KernSubtable
          {uint16 version (== 0) unused}
          {uint16 length (>= 6)} ; including this header
-         {uint16 coverage hex}) ; FIXME the rest depends on the coverage bits (8-15 = 0 or 2)
+         {uint16 coverage hex (bits kernCoverageFlags)}
+         {KernSubtable0 sub0 (== (>> coverage 8) 0)}
+         {KernSubtable2 sub2 (== (>> coverage 8) 2)})
 
 (mkcmplx TableKern
          {uint16 version (== 0) unused}
@@ -674,6 +697,24 @@
          #:after (list TableHead TableMaxp)
          #:optional #t)
 
+(mkcmplx GlyphData {int16 originOffsetX} {int16 originOffsetY} {Tag graphicType})
+
+(mkcmplx SbixStrike
+         {uint16 ppem}
+         {uint16 ppi}
+         {Offset32 glyphDataOffsets [+ o->numGlyphs 1]}
+         {GlyphData glyphData [o->numGlyphs] (at glyphDataOffsets)})
+
+(define sbixFlags #hash((1 . SBIX_FL_DRAW_OUTLINES)))
+
+(mkcmplx TableSbix
+         {uint16 version (== 1) unused}
+         {uint16 flags hex (bits sbixFlags)}
+         {uint32 numStrikes}
+         {Offset32 strikeOffsets [numStrikes]}
+         {SbixStrike strikes [numStrikes] (at strikeOffsets)}
+         #:tag "sbix")
+
 (define variationAxisRecordFlags #hash((0 . VARIATIONAXISRECORD_FL_HIDDEN_AXIS)))
 
 (mkcmplx VariationAxisRecord
@@ -732,10 +773,7 @@
          {Offset32 variationRegionListOffset}
          {uint16 itemVariationDataCount}
          {Offset32 itemVariationDataOffsets [itemVariationDataCount]}
-         #;{ItemVariationData
-            itemVariationData
-            [itemVariationDataCount]
-            (at itemVariationDataOffsets)}) ; FIXME offsets array
+         {ItemVariationData itemVariationData [itemVariationDataCount] (at itemVariationDataOffsets)})
 
 (mkcmplx DeltaSetIndexMap
          {uint8 format (== 0 1)}
@@ -792,9 +830,44 @@
          {uint16 axisOrdering}
          {uint8 unused [- o->designAxisSize 8] unused})
 
+(mkcmplx AxisValueTable1 {uint16 axisIndex} {uint16 flags} {uint16 valueNameID} {Fixed value})
+
+(mkcmplx AxisValueTable2
+         {uint16 axisIndex}
+         {uint16 flags}
+         {uint16 valueNameID}
+         {Fixed nominalValue}
+         {Fixed rangeMinValue}
+         {Fixed rangeMaxValue})
+
+(mkcmplx AxisValueTable3
+         {uint16 axisIndex}
+         {uint16 flags}
+         {uint16 valueNameID}
+         {Fixed value}
+         {Fixed linkedValue})
+
+(mkcmplx AxisValue {uint16 axisIndex} {Fixed value})
+
+(mkcmplx AxisValueTable4
+         {uint16 axisCount}
+         {uint16 flags}
+         {uint16 valueNameID}
+         {AxisValue axisValues [axisCount]})
+
+(mkcmplx AxisValueTable
+         {uint16 format}
+         {AxisValueTable1 f1 (== format 1)} ; FIXME should be a union
+         {AxisValueTable2 f2 (== format 2)}
+         {AxisValueTable3 f3 (== format 3)}
+         {AxisValueTable3 f4 (== format 4)})
+
 (mkcmplx DesignAxes
          {AxisRecord designAxes [o->designAxisCount]}
-         {Offset16 axisValueOffsets [o->axisValueCount]}) ; FIXME array of offsets
+         {Offset16
+          axisValueTableOffsets
+          [o->axisValueCount]} ; FIXME each offset is from the start of this field itself?
+         {AxisValueTable axisValueTables [o->axisValueCount] (at axisValueTableOffsets)})
 
 (mkcmplx TableSTAT
          {uint16 majorVersion (== 1) unused}
@@ -803,13 +876,19 @@
          {uint16 designAxisCount ->o}
          {Offset32 designAxesOffset}
          {uint16 axisValueCount ->o}
-         {Offset32 offsetToAxisValueOffsets}
+         {Offset32 offsetToAxisValueOffsets} ; FIXME wtf???
          {uint16 elidedFallbackNameID (> minorVersion 0)}
          {DesignAxes designAxes (at designAxesOffset)}
          #:tag "STAT")
 
-(mkcmplx GaspRange {uint16 rangeMaxPPEM} {uint16 rangeGaspBehavior hex})
+(define rangeGaspBehaviorFlags
+  #hash((0 . GASP_GRIDFIT)
+        (1 . GASP_DOGRAY)
+        (2 . GASP_SYMMETRIC_GRIDFIT)
+        (3 . GASP_SYMMETRIC_SMOOTHING)))
 
+(mkcmplx GaspRange {uint16 rangeMaxPPEM} {uint16 rangeGaspBehavior hex (bits rangeGaspBehaviorFlags)})
+
 (mkcmplx TableGasp
          {uint16 version (== 0 1)}
          {uint16 numRanges}
@@ -826,9 +905,10 @@
 (mkcmplx TupleVariationHeader
          {uint16 variationDataSize}
          {uint16 tupleIndex (bits tupleIndexFlags)} ; FIXME 0xfff is TUPLE_INDEX_MASK
-         {Tuple peakTuple}
-         {Tuple intermediateStartTuple}
-         {Tuple intermediateEndTuple})
+         {Tuple peakTuple (!= (& tupleIndex TUPLEINDEX_FL_EMBEDDED_PEAK_TUPLE) 0)}
+         {Tuple intermediateStartTuple (!= (& tupleIndex TUPLEINDEX_FL_INTERMEDIATE_REGION) 0)}
+         {Tuple intermediateEndTuple (!= (& tupleIndex TUPLEINDEX_FL_INTERMEDIATE_REGION) 0)})
+; FIXME there is delta packed stuff here
 
 (define glyphVariationDataCountFlags #hash((15 . COUNT_FL_SHARED_POINT_NUMBERS)))
 
@@ -843,14 +923,26 @@
  TableGvar
  {uint16 majorVersion (== 1) unused}
  {uint16 minorVersion (== 0) unused}
- {uint16 axisCount #;(== o->axisCount)} ; FIXME
+ {uint16 axisCount ->o}
  {uint16 sharedTupleCount}
  {Offset32 sharedTuplesOffset}
- {uint16 glyphCount #;(== o->glyphCount)} ; FIXME
+ {uint16 glyphCount}
  {uint16 flags hex (bits gvarFlags)}
  {Offset32 glyphVariationDataArrayOffset}
  {Offset16 glyphVariationDataOffsetsShort [+ glyphCount 1] (== (& flags GVAR_FL_LONG_OFFSETS) 0)}
  {Offset32 glyphVariationDataOffsetsLong [+ glyphCount 1] (!= (& flags GVAR_FL_LONG_OFFSETS) 0)}
+ {GlyphVariationData
+  glyphVariationData
+  [glyphCount]
+  (offset glyphVariationDataArrayOffset)
+  (at glyphVariationDataOffsetsShort)
+  (== (& flags GVAR_FL_LONG_OFFSETS) 0)}
+ {GlyphVariationData
+  glyphVariationData
+  [glyphCount]
+  (offset glyphVariationDataArrayOffset)
+  (at glyphVariationDataOffsetsLong)
+  (!= (& flags GVAR_FL_LONG_OFFSETS) 0)}
  {Tuple sharedTuples [sharedTupleCount] (at sharedTuplesOffset)}
  #:tag "gvar"
  #:after (list TableFvar))
--- a/plan9/otf.c
+++ b/plan9/otf.c
@@ -3505,7 +3505,7 @@
 print_Lookup(Otfile *f, int indent, Otf *o, Lookup *v)
 {
 	f->print(f->aux, "%*s%s: %ud\n", indent, "", "lookupType", v->lookupType);
-	f->print(f->aux, "%*s%s: %ud\n", indent, "", "lookupFlag", v->lookupFlag);
+	f->print(f->aux, "%*s%s: %#ux%s%s%s%s%s\n", indent, "", "lookupFlag", v->lookupFlag, (v->lookupFlag&LOOKUP_FL_RIGHT_TO_LEFT)?" LOOKUP_FL_RIGHT_TO_LEFT":"", (v->lookupFlag&LOOKUP_FL_IGNORE_BASE_GLYPHS)?" LOOKUP_FL_IGNORE_BASE_GLYPHS":"", (v->lookupFlag&LOOKUP_FL_IGNORE_LIGATURES)?" LOOKUP_FL_IGNORE_LIGATURES":"", (v->lookupFlag&LOOKUP_FL_IGNORE_MARKS)?" LOOKUP_FL_IGNORE_MARKS":"", (v->lookupFlag&LOOKUP_FL_USE_MARK_FILTERING_SET)?" LOOKUP_FL_USE_MARK_FILTERING_SET":"");
 	f->print(f->aux, "%*s%s: %ud\n", indent, "", "subTableCount", v->subTableCount);
 	for(int i = 0; i < v->subTableCount; i++)
 		f->print(f->aux, "%*s%s[%d]: %ud\n", indent, "", "subtableOffsets", i, v->subtableOffsets[i]);
@@ -3525,6 +3525,22 @@
 	v->lookupOffsets = malloc(v->lookupCount*sizeof(*v->lookupOffsets));
 	for(int i = 0; i < v->lookupCount; i++)
 		v->lookupOffsets[i] = b[0+i*2]<<8 | b[1+i*2];
+	if(v->lookupCount > 0){
+		v->lookups = calloc(v->lookupCount, sizeof(*v->lookups));
+		for(int i = 0; i < v->lookupCount; i++){
+			if(v->lookupOffsets[i] == 0)
+				continue;
+			if(otfpushrange(o, v->lookupOffsets[i], -1))
+				goto err;
+			int r = read_Lookup(o, v->lookups+i);
+			if(otfpoprange(o) < 0)
+				goto err;
+			if(r < 0){
+				memset(v->lookups+i, 0, sizeof(*v->lookups));
+				break;
+			}
+		}
+	}
 	return 0;
 err:
 	werrstr("%s: %r", "LookupList");
@@ -3537,6 +3553,10 @@
 	f->print(f->aux, "%*s%s: %ud\n", indent, "", "lookupCount", v->lookupCount);
 	for(int i = 0; i < v->lookupCount; i++)
 		f->print(f->aux, "%*s%s[%d]: %ud\n", indent, "", "lookupOffsets", i, v->lookupOffsets[i]);
+	for(int i = 0; i < v->lookupCount; i++){
+		f->print(f->aux, "%*s%s[%d]:\n", indent, "", "lookups", i);
+		print_Lookup(f, indent+indentΔ, o, &v->lookups[i]);
+	}
 	USED(o);
 }
 
@@ -4328,6 +4348,134 @@
 }
 
 int
+read_MathGlyphVariantRecord(Otf *o, MathGlyphVariantRecord *v)
+{
+	u8int *b = nil; USED(b);
+	if((b = otfreadn(o, 4)) == nil)
+		goto err;
+	v->variantGlyph = b[0]<<8 | b[1];
+	v->advanceMeasurement = b[2]<<8 | b[3];
+	return 0;
+err:
+	werrstr("%s: %r", "MathGlyphVariantRecord");
+	return -1;
+}
+
+void
+print_MathGlyphVariantRecord(Otfile *f, int indent, Otf *o, MathGlyphVariantRecord *v)
+{
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "variantGlyph", v->variantGlyph);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "advanceMeasurement", v->advanceMeasurement);
+	USED(o);
+}
+
+int
+read_GlyphPart(Otf *o, GlyphPart *v)
+{
+	u8int *b = nil; USED(b);
+	if((b = otfreadn(o, 10)) == nil)
+		goto err;
+	v->glyphID = b[0]<<8 | b[1];
+	v->startConnectorLength = b[2]<<8 | b[3];
+	v->endConnectorLength = b[4]<<8 | b[5];
+	v->fullAdvance = b[6]<<8 | b[7];
+	v->partFlags = b[8]<<8 | b[9];
+	return 0;
+err:
+	werrstr("%s: %r", "GlyphPart");
+	return -1;
+}
+
+void
+print_GlyphPart(Otfile *f, int indent, Otf *o, GlyphPart *v)
+{
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "glyphID", v->glyphID);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "startConnectorLength", v->startConnectorLength);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "endConnectorLength", v->endConnectorLength);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "fullAdvance", v->fullAdvance);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "partFlags", v->partFlags);
+	USED(o);
+}
+
+int
+read_GlyphAssembly(Otf *o, GlyphAssembly *v)
+{
+	u8int *b = nil; USED(b);
+	if(read_MathValueRecord(o, &v->italicsCorrection) < 0){
+		werrstr("%s: %r", "italicsCorrection");
+		goto err;
+	}
+	if((b = otfreadn(o, 2)) == nil)
+		goto err;
+	v->partCount = b[0]<<8 | b[1];
+	if(otfarray(o, &v->partRecords, read_GlyphPart, sizeof(GlyphPart), v->partCount) < 0){
+		werrstr("%s: %r", "partRecords");
+		goto err;
+	}
+	return 0;
+err:
+	werrstr("%s: %r", "GlyphAssembly");
+	return -1;
+}
+
+void
+print_GlyphAssembly(Otfile *f, int indent, Otf *o, GlyphAssembly *v)
+{
+	f->print(f->aux, "%*s%s:\n", indent, "", "italicsCorrection");
+	print_MathValueRecord(f, indent+indentΔ, o, &v->italicsCorrection);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "partCount", v->partCount);
+	for(int i = 0; i < v->partCount; i++){
+		f->print(f->aux, "%*s%s[%d]:\n", indent, "", "partRecords", i);
+		print_GlyphPart(f, indent+indentΔ, o, &v->partRecords[i]);
+	}
+	USED(o);
+}
+
+int
+read_MathGlyphConstruction(Otf *o, MathGlyphConstruction *v)
+{
+	u8int *b = nil; USED(b);
+	if((b = otfreadn(o, 4)) == nil)
+		goto err;
+	v->glyphAssemblyOffset = b[0]<<8 | b[1];
+	v->variantCount = b[2]<<8 | b[3];
+	if(otfarray(o, &v->mathGlyphVariantRecords, read_MathGlyphVariantRecord, sizeof(MathGlyphVariantRecord), v->variantCount) < 0){
+		werrstr("%s: %r", "mathGlyphVariantRecords");
+		goto err;
+	}
+	if(v->glyphAssemblyOffset != 0){
+		if(otfpushrange(o, v->glyphAssemblyOffset, -1) < 0)
+			goto err;
+		v->glyphAssembly = calloc(1, sizeof(*v->glyphAssembly));
+		if(read_GlyphAssembly(o, v->glyphAssembly) < 0){
+			werrstr("%s: %r", "glyphAssembly");
+			goto err;
+		}
+		if(otfpoprange(o) < 0)
+			goto err;
+	}
+	return 0;
+err:
+	werrstr("%s: %r", "MathGlyphConstruction");
+	return -1;
+}
+
+void
+print_MathGlyphConstruction(Otfile *f, int indent, Otf *o, MathGlyphConstruction *v)
+{
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "glyphAssemblyOffset", v->glyphAssemblyOffset);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "variantCount", v->variantCount);
+	for(int i = 0; i < v->variantCount; i++){
+		f->print(f->aux, "%*s%s[%d]:\n", indent, "", "mathGlyphVariantRecords", i);
+		print_MathGlyphVariantRecord(f, indent+indentΔ, o, &v->mathGlyphVariantRecords[i]);
+	}
+	f->print(f->aux, "%*s%s:\n", indent, "", "glyphAssembly");
+	if(v->glyphAssembly != nil)
+		print_GlyphAssembly(f, indent+indentΔ, o, v->glyphAssembly);
+	USED(o);
+}
+
+int
 read_MathVariants(Otf *o, MathVariants *v)
 {
 	u8int *b = nil; USED(b);
@@ -4370,6 +4518,38 @@
 		if(otfpoprange(o) < 0)
 			goto err;
 	}
+	if(v->vertGlyphCount > 0){
+		v->vertGlyphConstruction = calloc(v->vertGlyphCount, sizeof(*v->vertGlyphConstruction));
+		for(int i = 0; i < v->vertGlyphCount; i++){
+			if(v->vertGlyphConstructionOffsets[i] == 0)
+				continue;
+			if(otfpushrange(o, v->vertGlyphConstructionOffsets[i], -1))
+				goto err;
+			int r = read_MathGlyphConstruction(o, v->vertGlyphConstruction+i);
+			if(otfpoprange(o) < 0)
+				goto err;
+			if(r < 0){
+				memset(v->vertGlyphConstruction+i, 0, sizeof(*v->vertGlyphConstruction));
+				break;
+			}
+		}
+	}
+	if(v->horizGlyphCount > 0){
+		v->horizGlyphConstruction = calloc(v->horizGlyphCount, sizeof(*v->horizGlyphConstruction));
+		for(int i = 0; i < v->horizGlyphCount; i++){
+			if(v->horizGlyphConstructionOffsets[i] == 0)
+				continue;
+			if(otfpushrange(o, v->horizGlyphConstructionOffsets[i], -1))
+				goto err;
+			int r = read_MathGlyphConstruction(o, v->horizGlyphConstruction+i);
+			if(otfpoprange(o) < 0)
+				goto err;
+			if(r < 0){
+				memset(v->horizGlyphConstruction+i, 0, sizeof(*v->horizGlyphConstruction));
+				break;
+			}
+		}
+	}
 	return 0;
 err:
 	werrstr("%s: %r", "MathVariants");
@@ -4394,6 +4574,14 @@
 	f->print(f->aux, "%*s%s:\n", indent, "", "horizGlyphCoverage");
 	if(v->horizGlyphCoverage != nil)
 		print_Coverage(f, indent+indentΔ, o, v->horizGlyphCoverage);
+	for(int i = 0; i < v->vertGlyphCount; i++){
+		f->print(f->aux, "%*s%s[%d]:\n", indent, "", "vertGlyphConstruction", i);
+		print_MathGlyphConstruction(f, indent+indentΔ, o, &v->vertGlyphConstruction[i]);
+	}
+	for(int i = 0; i < v->horizGlyphCount; i++){
+		f->print(f->aux, "%*s%s[%d]:\n", indent, "", "horizGlyphConstruction", i);
+		print_MathGlyphConstruction(f, indent+indentΔ, o, &v->horizGlyphConstruction[i]);
+	}
 	USED(o);
 }
 
@@ -4480,134 +4668,6 @@
 }
 
 int
-read_MathGlyphVariantRecord(Otf *o, MathGlyphVariantRecord *v)
-{
-	u8int *b = nil; USED(b);
-	if((b = otfreadn(o, 4)) == nil)
-		goto err;
-	v->variantGlyph = b[0]<<8 | b[1];
-	v->advanceMeasurement = b[2]<<8 | b[3];
-	return 0;
-err:
-	werrstr("%s: %r", "MathGlyphVariantRecord");
-	return -1;
-}
-
-void
-print_MathGlyphVariantRecord(Otfile *f, int indent, Otf *o, MathGlyphVariantRecord *v)
-{
-	f->print(f->aux, "%*s%s: %ud\n", indent, "", "variantGlyph", v->variantGlyph);
-	f->print(f->aux, "%*s%s: %ud\n", indent, "", "advanceMeasurement", v->advanceMeasurement);
-	USED(o);
-}
-
-int
-read_GlyphPart(Otf *o, GlyphPart *v)
-{
-	u8int *b = nil; USED(b);
-	if((b = otfreadn(o, 10)) == nil)
-		goto err;
-	v->glyphID = b[0]<<8 | b[1];
-	v->startConnectorLength = b[2]<<8 | b[3];
-	v->endConnectorLength = b[4]<<8 | b[5];
-	v->fullAdvance = b[6]<<8 | b[7];
-	v->partFlags = b[8]<<8 | b[9];
-	return 0;
-err:
-	werrstr("%s: %r", "GlyphPart");
-	return -1;
-}
-
-void
-print_GlyphPart(Otfile *f, int indent, Otf *o, GlyphPart *v)
-{
-	f->print(f->aux, "%*s%s: %ud\n", indent, "", "glyphID", v->glyphID);
-	f->print(f->aux, "%*s%s: %ud\n", indent, "", "startConnectorLength", v->startConnectorLength);
-	f->print(f->aux, "%*s%s: %ud\n", indent, "", "endConnectorLength", v->endConnectorLength);
-	f->print(f->aux, "%*s%s: %ud\n", indent, "", "fullAdvance", v->fullAdvance);
-	f->print(f->aux, "%*s%s: %ud\n", indent, "", "partFlags", v->partFlags);
-	USED(o);
-}
-
-int
-read_GlyphAssembly(Otf *o, GlyphAssembly *v)
-{
-	u8int *b = nil; USED(b);
-	if(read_MathValueRecord(o, &v->italicsCorrection) < 0){
-		werrstr("%s: %r", "italicsCorrection");
-		goto err;
-	}
-	if((b = otfreadn(o, 2)) == nil)
-		goto err;
-	v->partCount = b[0]<<8 | b[1];
-	if(otfarray(o, &v->partRecords, read_GlyphPart, sizeof(GlyphPart), v->partCount) < 0){
-		werrstr("%s: %r", "partRecords");
-		goto err;
-	}
-	return 0;
-err:
-	werrstr("%s: %r", "GlyphAssembly");
-	return -1;
-}
-
-void
-print_GlyphAssembly(Otfile *f, int indent, Otf *o, GlyphAssembly *v)
-{
-	f->print(f->aux, "%*s%s:\n", indent, "", "italicsCorrection");
-	print_MathValueRecord(f, indent+indentΔ, o, &v->italicsCorrection);
-	f->print(f->aux, "%*s%s: %ud\n", indent, "", "partCount", v->partCount);
-	for(int i = 0; i < v->partCount; i++){
-		f->print(f->aux, "%*s%s[%d]:\n", indent, "", "partRecords", i);
-		print_GlyphPart(f, indent+indentΔ, o, &v->partRecords[i]);
-	}
-	USED(o);
-}
-
-int
-read_MathGlyphConstruction(Otf *o, MathGlyphConstruction *v)
-{
-	u8int *b = nil; USED(b);
-	if((b = otfreadn(o, 4)) == nil)
-		goto err;
-	v->glyphAssemblyOffset = b[0]<<8 | b[1];
-	v->variantCount = b[2]<<8 | b[3];
-	if(otfarray(o, &v->mathGlyphVariantRecords, read_MathGlyphVariantRecord, sizeof(MathGlyphVariantRecord), v->variantCount) < 0){
-		werrstr("%s: %r", "mathGlyphVariantRecords");
-		goto err;
-	}
-	if(v->glyphAssemblyOffset != 0){
-		if(otfpushrange(o, v->glyphAssemblyOffset, -1) < 0)
-			goto err;
-		v->glyphAssembly = calloc(1, sizeof(*v->glyphAssembly));
-		if(read_GlyphAssembly(o, v->glyphAssembly) < 0){
-			werrstr("%s: %r", "glyphAssembly");
-			goto err;
-		}
-		if(otfpoprange(o) < 0)
-			goto err;
-	}
-	return 0;
-err:
-	werrstr("%s: %r", "MathGlyphConstruction");
-	return -1;
-}
-
-void
-print_MathGlyphConstruction(Otfile *f, int indent, Otf *o, MathGlyphConstruction *v)
-{
-	f->print(f->aux, "%*s%s: %ud\n", indent, "", "glyphAssemblyOffset", v->glyphAssemblyOffset);
-	f->print(f->aux, "%*s%s: %ud\n", indent, "", "variantCount", v->variantCount);
-	for(int i = 0; i < v->variantCount; i++){
-		f->print(f->aux, "%*s%s[%d]:\n", indent, "", "mathGlyphVariantRecords", i);
-		print_MathGlyphVariantRecord(f, indent+indentΔ, o, &v->mathGlyphVariantRecords[i]);
-	}
-	f->print(f->aux, "%*s%s:\n", indent, "", "glyphAssembly");
-	if(v->glyphAssembly != nil)
-		print_GlyphAssembly(f, indent+indentΔ, o, v->glyphAssembly);
-	USED(o);
-}
-
-int
 read_TableMATH(Otf *o, TableMATH *v)
 {
 	u8int *b = nil; USED(b);
@@ -4848,6 +4908,18 @@
 		goto err;
 	}
 	v->coverage = b[4]<<8 | b[5];
+	if((v->coverage>>8) == 0){
+		if(read_KernSubtable0(o, &v->sub0) < 0){
+			werrstr("%s: %r", "sub0");
+			goto err;
+		}
+	}
+	if((v->coverage>>8) == 2){
+		if(read_KernSubtable2(o, &v->sub2) < 0){
+			werrstr("%s: %r", "sub2");
+			goto err;
+		}
+	}
 	return 0;
 err:
 	werrstr("%s: %r", "KernSubtable");
@@ -4858,7 +4930,15 @@
 print_KernSubtable(Otfile *f, int indent, Otf *o, KernSubtable *v)
 {
 	f->print(f->aux, "%*s%s: %ud\n", indent, "", "length", v->length);
-	f->print(f->aux, "%*s%s: %#ux\n", indent, "", "coverage", v->coverage);
+	f->print(f->aux, "%*s%s: %#ux%s%s%s%s\n", indent, "", "coverage", v->coverage, (v->coverage&KERN_FL_HORIZONTAL)?" KERN_FL_HORIZONTAL":"", (v->coverage&KERN_FL_MINIMUM)?" KERN_FL_MINIMUM":"", (v->coverage&KERN_FL_CROSS_STREAM)?" KERN_FL_CROSS_STREAM":"", (v->coverage&KERN_FL_OVERRIDE)?" KERN_FL_OVERRIDE":"");
+	if((v->coverage>>8) == 0){
+		f->print(f->aux, "%*s%s:\n", indent, "", "sub0");
+		print_KernSubtable0(f, indent+indentΔ, o, &v->sub0);
+	}
+	if((v->coverage>>8) == 2){
+		f->print(f->aux, "%*s%s:\n", indent, "", "sub2");
+		print_KernSubtable2(f, indent+indentΔ, o, &v->sub2);
+	}
 	USED(o);
 }
 
@@ -4934,6 +5014,133 @@
 }
 
 int
+read_GlyphData(Otf *o, GlyphData *v)
+{
+	u8int *b = nil; USED(b);
+	if((b = otfreadn(o, 8)) == nil)
+		goto err;
+	v->originOffsetX = b[0]<<8 | b[1];
+	v->originOffsetY = b[2]<<8 | b[3];
+	v->graphicType = b[4]<<24 | b[5]<<16 | b[6]<<8 | b[7];
+	return 0;
+err:
+	werrstr("%s: %r", "GlyphData");
+	return -1;
+}
+
+void
+print_GlyphData(Otfile *f, int indent, Otf *o, GlyphData *v)
+{
+	f->print(f->aux, "%*s%s: %d\n", indent, "", "originOffsetX", v->originOffsetX);
+	f->print(f->aux, "%*s%s: %d\n", indent, "", "originOffsetY", v->originOffsetY);
+	f->print(f->aux, "%*s%s: %c%c%c%c\n", indent, "", "graphicType", v->graphicType>>24, v->graphicType>>16, v->graphicType>>8, v->graphicType>>0);
+	USED(o);
+}
+
+int
+read_SbixStrike(Otf *o, SbixStrike *v)
+{
+	u8int *b = nil; USED(b);
+	if((b = otfreadn(o, 4)) == nil)
+		goto err;
+	v->ppem = b[0]<<8 | b[1];
+	v->ppi = b[2]<<8 | b[3];
+	if((b = otfreadn(o, (o->numGlyphs+1)*4)) == nil)
+		goto err;
+	v->glyphDataOffsets = malloc((o->numGlyphs+1)*sizeof(*v->glyphDataOffsets));
+	for(int i = 0; i < (o->numGlyphs+1); i++)
+		v->glyphDataOffsets[i] = b[0+i*4]<<24 | b[1+i*4]<<16 | b[2+i*4]<<8 | b[3+i*4];
+	if(o->numGlyphs > 0){
+		v->glyphData = calloc(o->numGlyphs, sizeof(*v->glyphData));
+		for(int i = 0; i < o->numGlyphs; i++){
+			if(v->glyphDataOffsets[i] == 0)
+				continue;
+			if(otfpushrange(o, v->glyphDataOffsets[i], -1))
+				goto err;
+			int r = read_GlyphData(o, v->glyphData+i);
+			if(otfpoprange(o) < 0)
+				goto err;
+			if(r < 0){
+				memset(v->glyphData+i, 0, sizeof(*v->glyphData));
+				break;
+			}
+		}
+	}
+	return 0;
+err:
+	werrstr("%s: %r", "SbixStrike");
+	return -1;
+}
+
+void
+print_SbixStrike(Otfile *f, int indent, Otf *o, SbixStrike *v)
+{
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "ppem", v->ppem);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "ppi", v->ppi);
+	for(int i = 0; i < (o->numGlyphs+1); i++)
+		f->print(f->aux, "%*s%s[%d]: %ud\n", indent, "", "glyphDataOffsets", i, v->glyphDataOffsets[i]);
+	for(int i = 0; i < o->numGlyphs; i++){
+		f->print(f->aux, "%*s%s[%d]:\n", indent, "", "glyphData", i);
+		print_GlyphData(f, indent+indentΔ, o, &v->glyphData[i]);
+	}
+	USED(o);
+}
+
+int
+read_TableSbix(Otf *o, TableSbix *v)
+{
+	u8int *b = nil; USED(b);
+	if((b = otfreadn(o, 8)) == nil)
+		goto err;
+	u16int version = b[0]<<8 | b[1];
+	if(version != 1){
+		werrstr("%s: invalid value: %d (%#ux)", "version", version, version);
+		goto err;
+	}
+	v->flags = b[2]<<8 | b[3];
+	v->numStrikes = b[4]<<24 | b[5]<<16 | b[6]<<8 | b[7];
+	if((b = otfreadn(o, v->numStrikes*4)) == nil)
+		goto err;
+	v->strikeOffsets = malloc(v->numStrikes*sizeof(*v->strikeOffsets));
+	for(int i = 0; i < v->numStrikes; i++)
+		v->strikeOffsets[i] = b[0+i*4]<<24 | b[1+i*4]<<16 | b[2+i*4]<<8 | b[3+i*4];
+	if(v->numStrikes > 0){
+		v->strikes = calloc(v->numStrikes, sizeof(*v->strikes));
+		for(int i = 0; i < v->numStrikes; i++){
+			if(v->strikeOffsets[i] == 0)
+				continue;
+			if(otfpushrange(o, v->strikeOffsets[i], -1))
+				goto err;
+			int r = read_SbixStrike(o, v->strikes+i);
+			if(otfpoprange(o) < 0)
+				goto err;
+			if(r < 0){
+				memset(v->strikes+i, 0, sizeof(*v->strikes));
+				break;
+			}
+		}
+	}
+	return 0;
+err:
+	werrstr("%s: %r", "TableSbix");
+	return -1;
+}
+
+void
+print_TableSbix(Otfile *f, int indent, Otf *o, TableSbix *v)
+{
+	f->print(f->aux, "%*s%s: %#ux%s\n", indent, "", "flags", v->flags, (v->flags&SBIX_FL_DRAW_OUTLINES)?" SBIX_FL_DRAW_OUTLINES":"");
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "numStrikes", v->numStrikes);
+	for(int i = 0; i < v->numStrikes; i++)
+		f->print(f->aux, "%*s%s[%d]: %ud\n", indent, "", "strikeOffsets", i, v->strikeOffsets[i]);
+	for(int i = 0; i < v->numStrikes; i++){
+		f->print(f->aux, "%*s%s[%d]:\n", indent, "", "strikes", i);
+		print_SbixStrike(f, indent+indentΔ, o, &v->strikes[i]);
+	}
+	USED(o);
+}
+
+int
 read_VariationAxisRecord(Otf *o, VariationAxisRecord *v)
 {
 	u8int *b = nil; USED(b);
@@ -5239,6 +5446,22 @@
 	v->itemVariationDataOffsets = malloc(v->itemVariationDataCount*sizeof(*v->itemVariationDataOffsets));
 	for(int i = 0; i < v->itemVariationDataCount; i++)
 		v->itemVariationDataOffsets[i] = b[0+i*4]<<24 | b[1+i*4]<<16 | b[2+i*4]<<8 | b[3+i*4];
+	if(v->itemVariationDataCount > 0){
+		v->itemVariationData = calloc(v->itemVariationDataCount, sizeof(*v->itemVariationData));
+		for(int i = 0; i < v->itemVariationDataCount; i++){
+			if(v->itemVariationDataOffsets[i] == 0)
+				continue;
+			if(otfpushrange(o, v->itemVariationDataOffsets[i], -1))
+				goto err;
+			int r = read_ItemVariationData(o, v->itemVariationData+i);
+			if(otfpoprange(o) < 0)
+				goto err;
+			if(r < 0){
+				memset(v->itemVariationData+i, 0, sizeof(*v->itemVariationData));
+				break;
+			}
+		}
+	}
 	return 0;
 err:
 	werrstr("%s: %r", "ItemVariationStore");
@@ -5252,6 +5475,10 @@
 	f->print(f->aux, "%*s%s: %ud\n", indent, "", "itemVariationDataCount", v->itemVariationDataCount);
 	for(int i = 0; i < v->itemVariationDataCount; i++)
 		f->print(f->aux, "%*s%s[%d]: %ud\n", indent, "", "itemVariationDataOffsets", i, v->itemVariationDataOffsets[i]);
+	for(int i = 0; i < v->itemVariationDataCount; i++){
+		f->print(f->aux, "%*s%s[%d]:\n", indent, "", "itemVariationData", i);
+		print_ItemVariationData(f, indent+indentΔ, o, &v->itemVariationData[i]);
+	}
 	USED(o);
 }
 
@@ -5556,6 +5783,204 @@
 }
 
 int
+read_AxisValueTable1(Otf *o, AxisValueTable1 *v)
+{
+	u8int *b = nil; USED(b);
+	if((b = otfreadn(o, 10)) == nil)
+		goto err;
+	v->axisIndex = b[0]<<8 | b[1];
+	v->flags = b[2]<<8 | b[3];
+	v->valueNameID = b[4]<<8 | b[5];
+	v->value = (b[6]<<24 | b[7]<<16 | b[8]<<8 | b[9])/65536.0f;
+	return 0;
+err:
+	werrstr("%s: %r", "AxisValueTable1");
+	return -1;
+}
+
+void
+print_AxisValueTable1(Otfile *f, int indent, Otf *o, AxisValueTable1 *v)
+{
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "axisIndex", v->axisIndex);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "flags", v->flags);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "valueNameID", v->valueNameID);
+	f->print(f->aux, "%*s%s: %g\n", indent, "", "value", v->value);
+	USED(o);
+}
+
+int
+read_AxisValueTable2(Otf *o, AxisValueTable2 *v)
+{
+	u8int *b = nil; USED(b);
+	if((b = otfreadn(o, 18)) == nil)
+		goto err;
+	v->axisIndex = b[0]<<8 | b[1];
+	v->flags = b[2]<<8 | b[3];
+	v->valueNameID = b[4]<<8 | b[5];
+	v->nominalValue = (b[6]<<24 | b[7]<<16 | b[8]<<8 | b[9])/65536.0f;
+	v->rangeMinValue = (b[10]<<24 | b[11]<<16 | b[12]<<8 | b[13])/65536.0f;
+	v->rangeMaxValue = (b[14]<<24 | b[15]<<16 | b[16]<<8 | b[17])/65536.0f;
+	return 0;
+err:
+	werrstr("%s: %r", "AxisValueTable2");
+	return -1;
+}
+
+void
+print_AxisValueTable2(Otfile *f, int indent, Otf *o, AxisValueTable2 *v)
+{
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "axisIndex", v->axisIndex);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "flags", v->flags);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "valueNameID", v->valueNameID);
+	f->print(f->aux, "%*s%s: %g\n", indent, "", "nominalValue", v->nominalValue);
+	f->print(f->aux, "%*s%s: %g\n", indent, "", "rangeMinValue", v->rangeMinValue);
+	f->print(f->aux, "%*s%s: %g\n", indent, "", "rangeMaxValue", v->rangeMaxValue);
+	USED(o);
+}
+
+int
+read_AxisValueTable3(Otf *o, AxisValueTable3 *v)
+{
+	u8int *b = nil; USED(b);
+	if((b = otfreadn(o, 14)) == nil)
+		goto err;
+	v->axisIndex = b[0]<<8 | b[1];
+	v->flags = b[2]<<8 | b[3];
+	v->valueNameID = b[4]<<8 | b[5];
+	v->value = (b[6]<<24 | b[7]<<16 | b[8]<<8 | b[9])/65536.0f;
+	v->linkedValue = (b[10]<<24 | b[11]<<16 | b[12]<<8 | b[13])/65536.0f;
+	return 0;
+err:
+	werrstr("%s: %r", "AxisValueTable3");
+	return -1;
+}
+
+void
+print_AxisValueTable3(Otfile *f, int indent, Otf *o, AxisValueTable3 *v)
+{
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "axisIndex", v->axisIndex);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "flags", v->flags);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "valueNameID", v->valueNameID);
+	f->print(f->aux, "%*s%s: %g\n", indent, "", "value", v->value);
+	f->print(f->aux, "%*s%s: %g\n", indent, "", "linkedValue", v->linkedValue);
+	USED(o);
+}
+
+int
+read_AxisValue(Otf *o, AxisValue *v)
+{
+	u8int *b = nil; USED(b);
+	if((b = otfreadn(o, 6)) == nil)
+		goto err;
+	v->axisIndex = b[0]<<8 | b[1];
+	v->value = (b[2]<<24 | b[3]<<16 | b[4]<<8 | b[5])/65536.0f;
+	return 0;
+err:
+	werrstr("%s: %r", "AxisValue");
+	return -1;
+}
+
+void
+print_AxisValue(Otfile *f, int indent, Otf *o, AxisValue *v)
+{
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "axisIndex", v->axisIndex);
+	f->print(f->aux, "%*s%s: %g\n", indent, "", "value", v->value);
+	USED(o);
+}
+
+int
+read_AxisValueTable4(Otf *o, AxisValueTable4 *v)
+{
+	u8int *b = nil; USED(b);
+	if((b = otfreadn(o, 6)) == nil)
+		goto err;
+	v->axisCount = b[0]<<8 | b[1];
+	v->flags = b[2]<<8 | b[3];
+	v->valueNameID = b[4]<<8 | b[5];
+	if(otfarray(o, &v->axisValues, read_AxisValue, sizeof(AxisValue), v->axisCount) < 0){
+		werrstr("%s: %r", "axisValues");
+		goto err;
+	}
+	return 0;
+err:
+	werrstr("%s: %r", "AxisValueTable4");
+	return -1;
+}
+
+void
+print_AxisValueTable4(Otfile *f, int indent, Otf *o, AxisValueTable4 *v)
+{
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "axisCount", v->axisCount);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "flags", v->flags);
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "valueNameID", v->valueNameID);
+	for(int i = 0; i < v->axisCount; i++){
+		f->print(f->aux, "%*s%s[%d]:\n", indent, "", "axisValues", i);
+		print_AxisValue(f, indent+indentΔ, o, &v->axisValues[i]);
+	}
+	USED(o);
+}
+
+int
+read_AxisValueTable(Otf *o, AxisValueTable *v)
+{
+	u8int *b = nil; USED(b);
+	if((b = otfreadn(o, 2)) == nil)
+		goto err;
+	v->format = b[0]<<8 | b[1];
+	if(v->format == 1){
+		if(read_AxisValueTable1(o, &v->f1) < 0){
+			werrstr("%s: %r", "f1");
+			goto err;
+		}
+	}
+	if(v->format == 2){
+		if(read_AxisValueTable2(o, &v->f2) < 0){
+			werrstr("%s: %r", "f2");
+			goto err;
+		}
+	}
+	if(v->format == 3){
+		if(read_AxisValueTable3(o, &v->f3) < 0){
+			werrstr("%s: %r", "f3");
+			goto err;
+		}
+	}
+	if(v->format == 4){
+		if(read_AxisValueTable3(o, &v->f4) < 0){
+			werrstr("%s: %r", "f4");
+			goto err;
+		}
+	}
+	return 0;
+err:
+	werrstr("%s: %r", "AxisValueTable");
+	return -1;
+}
+
+void
+print_AxisValueTable(Otfile *f, int indent, Otf *o, AxisValueTable *v)
+{
+	f->print(f->aux, "%*s%s: %ud\n", indent, "", "format", v->format);
+	if(v->format == 1){
+		f->print(f->aux, "%*s%s:\n", indent, "", "f1");
+		print_AxisValueTable1(f, indent+indentΔ, o, &v->f1);
+	}
+	if(v->format == 2){
+		f->print(f->aux, "%*s%s:\n", indent, "", "f2");
+		print_AxisValueTable2(f, indent+indentΔ, o, &v->f2);
+	}
+	if(v->format == 3){
+		f->print(f->aux, "%*s%s:\n", indent, "", "f3");
+		print_AxisValueTable3(f, indent+indentΔ, o, &v->f3);
+	}
+	if(v->format == 4){
+		f->print(f->aux, "%*s%s:\n", indent, "", "f4");
+		print_AxisValueTable3(f, indent+indentΔ, o, &v->f4);
+	}
+	USED(o);
+}
+
+int
 read_DesignAxes(Otf *o, DesignAxes *v)
 {
 	u8int *b = nil; USED(b);
@@ -5565,9 +5990,25 @@
 	}
 	if((b = otfreadn(o, o->axisValueCount*2)) == nil)
 		goto err;
-	v->axisValueOffsets = malloc(o->axisValueCount*sizeof(*v->axisValueOffsets));
+	v->axisValueTableOffsets = malloc(o->axisValueCount*sizeof(*v->axisValueTableOffsets));
 	for(int i = 0; i < o->axisValueCount; i++)
-		v->axisValueOffsets[i] = b[0+i*2]<<8 | b[1+i*2];
+		v->axisValueTableOffsets[i] = b[0+i*2]<<8 | b[1+i*2];
+	if(o->axisValueCount > 0){
+		v->axisValueTables = calloc(o->axisValueCount, sizeof(*v->axisValueTables));
+		for(int i = 0; i < o->axisValueCount; i++){
+			if(v->axisValueTableOffsets[i] == 0)
+				continue;
+			if(otfpushrange(o, v->axisValueTableOffsets[i], -1))
+				goto err;
+			int r = read_AxisValueTable(o, v->axisValueTables+i);
+			if(otfpoprange(o) < 0)
+				goto err;
+			if(r < 0){
+				memset(v->axisValueTables+i, 0, sizeof(*v->axisValueTables));
+				break;
+			}
+		}
+	}
 	return 0;
 err:
 	werrstr("%s: %r", "DesignAxes");
@@ -5582,7 +6023,11 @@
 		print_AxisRecord(f, indent+indentΔ, o, &v->designAxes[i]);
 	}
 	for(int i = 0; i < o->axisValueCount; i++)
-		f->print(f->aux, "%*s%s[%d]: %ud\n", indent, "", "axisValueOffsets", i, v->axisValueOffsets[i]);
+		f->print(f->aux, "%*s%s[%d]: %ud\n", indent, "", "axisValueTableOffsets", i, v->axisValueTableOffsets[i]);
+	for(int i = 0; i < o->axisValueCount; i++){
+		f->print(f->aux, "%*s%s[%d]:\n", indent, "", "axisValueTables", i);
+		print_AxisValueTable(f, indent+indentΔ, o, &v->axisValueTables[i]);
+	}
 	USED(o);
 }
 
@@ -5670,7 +6115,7 @@
 print_GaspRange(Otfile *f, int indent, Otf *o, GaspRange *v)
 {
 	f->print(f->aux, "%*s%s: %ud\n", indent, "", "rangeMaxPPEM", v->rangeMaxPPEM);
-	f->print(f->aux, "%*s%s: %#ux\n", indent, "", "rangeGaspBehavior", v->rangeGaspBehavior);
+	f->print(f->aux, "%*s%s: %#ux%s%s%s%s\n", indent, "", "rangeGaspBehavior", v->rangeGaspBehavior, (v->rangeGaspBehavior&GASP_GRIDFIT)?" GASP_GRIDFIT":"", (v->rangeGaspBehavior&GASP_DOGRAY)?" GASP_DOGRAY":"", (v->rangeGaspBehavior&GASP_SYMMETRIC_GRIDFIT)?" GASP_SYMMETRIC_GRIDFIT":"", (v->rangeGaspBehavior&GASP_SYMMETRIC_SMOOTHING)?" GASP_SYMMETRIC_SMOOTHING":"");
 	USED(o);
 }
 
@@ -5739,17 +6184,23 @@
 		goto err;
 	v->variationDataSize = b[0]<<8 | b[1];
 	v->tupleIndex = b[2]<<8 | b[3];
-	if(read_Tuple(o, &v->peakTuple) < 0){
-		werrstr("%s: %r", "peakTuple");
-		goto err;
+	if((v->tupleIndex&TUPLEINDEX_FL_EMBEDDED_PEAK_TUPLE) != 0){
+		if(read_Tuple(o, &v->peakTuple) < 0){
+			werrstr("%s: %r", "peakTuple");
+			goto err;
+		}
 	}
-	if(read_Tuple(o, &v->intermediateStartTuple) < 0){
-		werrstr("%s: %r", "intermediateStartTuple");
-		goto err;
+	if((v->tupleIndex&TUPLEINDEX_FL_INTERMEDIATE_REGION) != 0){
+		if(read_Tuple(o, &v->intermediateStartTuple) < 0){
+			werrstr("%s: %r", "intermediateStartTuple");
+			goto err;
+		}
 	}
-	if(read_Tuple(o, &v->intermediateEndTuple) < 0){
-		werrstr("%s: %r", "intermediateEndTuple");
-		goto err;
+	if((v->tupleIndex&TUPLEINDEX_FL_INTERMEDIATE_REGION) != 0){
+		if(read_Tuple(o, &v->intermediateEndTuple) < 0){
+			werrstr("%s: %r", "intermediateEndTuple");
+			goto err;
+		}
 	}
 	return 0;
 err:
@@ -5762,12 +6213,18 @@
 {
 	f->print(f->aux, "%*s%s: %ud\n", indent, "", "variationDataSize", v->variationDataSize);
 	f->print(f->aux, "%*s%s: %ud%s%s%s\n", indent, "", "tupleIndex", v->tupleIndex, (v->tupleIndex&TUPLEINDEX_FL_PRIVATE_POINT_NUMBERS)?" TUPLEINDEX_FL_PRIVATE_POINT_NUMBERS":"", (v->tupleIndex&TUPLEINDEX_FL_INTERMEDIATE_REGION)?" TUPLEINDEX_FL_INTERMEDIATE_REGION":"", (v->tupleIndex&TUPLEINDEX_FL_EMBEDDED_PEAK_TUPLE)?" TUPLEINDEX_FL_EMBEDDED_PEAK_TUPLE":"");
-	f->print(f->aux, "%*s%s:\n", indent, "", "peakTuple");
-	print_Tuple(f, indent+indentΔ, o, &v->peakTuple);
-	f->print(f->aux, "%*s%s:\n", indent, "", "intermediateStartTuple");
-	print_Tuple(f, indent+indentΔ, o, &v->intermediateStartTuple);
-	f->print(f->aux, "%*s%s:\n", indent, "", "intermediateEndTuple");
-	print_Tuple(f, indent+indentΔ, o, &v->intermediateEndTuple);
+	if((v->tupleIndex&TUPLEINDEX_FL_EMBEDDED_PEAK_TUPLE) != 0){
+		f->print(f->aux, "%*s%s:\n", indent, "", "peakTuple");
+		print_Tuple(f, indent+indentΔ, o, &v->peakTuple);
+	}
+	if((v->tupleIndex&TUPLEINDEX_FL_INTERMEDIATE_REGION) != 0){
+		f->print(f->aux, "%*s%s:\n", indent, "", "intermediateStartTuple");
+		print_Tuple(f, indent+indentΔ, o, &v->intermediateStartTuple);
+	}
+	if((v->tupleIndex&TUPLEINDEX_FL_INTERMEDIATE_REGION) != 0){
+		f->print(f->aux, "%*s%s:\n", indent, "", "intermediateEndTuple");
+		print_Tuple(f, indent+indentΔ, o, &v->intermediateEndTuple);
+	}
 	USED(o);
 }
 
@@ -5818,6 +6275,7 @@
 		goto err;
 	}
 	v->axisCount = b[4]<<8 | b[5];
+	o->axisCount = v->axisCount;
 	v->sharedTupleCount = b[6]<<8 | b[7];
 	v->sharedTuplesOffset = b[8]<<24 | b[9]<<16 | b[10]<<8 | b[11];
 	v->glyphCount = b[12]<<8 | b[13];
@@ -5837,6 +6295,38 @@
 		for(int i = 0; i < (v->glyphCount+1); i++)
 			v->glyphVariationDataOffsetsLong[i] = b[0+i*4]<<24 | b[1+i*4]<<16 | b[2+i*4]<<8 | b[3+i*4];
 	}
+	if((v->flags&GVAR_FL_LONG_OFFSETS) == 0){
+		if(v->glyphVariationDataArrayOffset != 0 && v->glyphCount > 0){
+			v->glyphVariationData = calloc(v->glyphCount, sizeof(*v->glyphVariationData));
+			for(int i = 0; i < v->glyphCount; i++){
+				if(otfpushrange(o, v->glyphVariationDataArrayOffset+v->glyphVariationDataOffsetsShort[i], -1))
+					goto err;
+				int r = read_GlyphVariationData(o, v->glyphVariationData+i);
+				if(otfpoprange(o) < 0)
+					goto err;
+				if(r < 0){
+					memset(v->glyphVariationData+i, 0, sizeof(*v->glyphVariationData));
+					break;
+				}
+			}
+		}
+	}
+	if((v->flags&GVAR_FL_LONG_OFFSETS) != 0){
+		if(v->glyphVariationDataArrayOffset != 0 && v->glyphCount > 0){
+			v->glyphVariationData = calloc(v->glyphCount, sizeof(*v->glyphVariationData));
+			for(int i = 0; i < v->glyphCount; i++){
+				if(otfpushrange(o, v->glyphVariationDataArrayOffset+v->glyphVariationDataOffsetsLong[i], -1))
+					goto err;
+				int r = read_GlyphVariationData(o, v->glyphVariationData+i);
+				if(otfpoprange(o) < 0)
+					goto err;
+				if(r < 0){
+					memset(v->glyphVariationData+i, 0, sizeof(*v->glyphVariationData));
+					break;
+				}
+			}
+		}
+	}
 	if(v->sharedTuplesOffset != 0){
 		if(otfpushrange(o, v->sharedTuplesOffset, -1) < 0)
 			goto err;
@@ -5857,6 +6347,7 @@
 print_TableGvar(Otfile *f, int indent, Otf *o, TableGvar *v)
 {
 	f->print(f->aux, "%*s%s: %ud\n", indent, "", "axisCount", v->axisCount);
+	o->axisCount = v->axisCount;
 	f->print(f->aux, "%*s%s: %ud\n", indent, "", "sharedTupleCount", v->sharedTupleCount);
 	f->print(f->aux, "%*s%s: %ud\n", indent, "", "sharedTuplesOffset", v->sharedTuplesOffset);
 	f->print(f->aux, "%*s%s: %ud\n", indent, "", "glyphCount", v->glyphCount);
@@ -5870,6 +6361,18 @@
 		for(int i = 0; i < (v->glyphCount+1); i++)
 			f->print(f->aux, "%*s%s[%d]: %ud\n", indent, "", "glyphVariationDataOffsetsLong", i, v->glyphVariationDataOffsetsLong[i]);
 	}
+	if((v->flags&GVAR_FL_LONG_OFFSETS) == 0){
+		for(int i = 0; i < v->glyphCount; i++){
+			f->print(f->aux, "%*s%s[%d]:\n", indent, "", "glyphVariationData", i);
+			print_GlyphVariationData(f, indent+indentΔ, o, &v->glyphVariationData[i]);
+		}
+	}
+	if((v->flags&GVAR_FL_LONG_OFFSETS) != 0){
+		for(int i = 0; i < v->glyphCount; i++){
+			f->print(f->aux, "%*s%s[%d]:\n", indent, "", "glyphVariationData", i);
+			print_GlyphVariationData(f, indent+indentΔ, o, &v->glyphVariationData[i]);
+		}
+	}
 	for(int i = 0; i < v->sharedTupleCount; i++){
 		f->print(f->aux, "%*s%s[%d]:\n", indent, "", "sharedTuples", i);
 		print_Tuple(f, indent+indentΔ, o, &v->sharedTuples[i]);
@@ -6349,6 +6852,18 @@
 				}
 				rec->parsed = v->loca;
 				rec->print = (void*)print_TableLoca;
+				break;
+			case (u32int)('s'<<24|'b'<<16|'i'<<8|'x'):
+				if(v->sbix != nil)
+					break;
+				v->sbix = calloc(1, sizeof(TableSbix));
+				if(read_TableSbix(o, v->sbix) < 0){
+					free(v->sbix);
+					v->sbix = nil;
+					goto err;
+				}
+				rec->parsed = v->sbix;
+				rec->print = (void*)print_TableSbix;
 				break;
 			case (u32int)('f'<<24|'v'<<16|'a'<<8|'r'):
 				if(v->fvar != nil)
--- a/plan9/otf.h
+++ b/plan9/otf.h
@@ -209,12 +209,12 @@
 typedef struct RangeRecord RangeRecord;
 typedef struct Coverage2 Coverage2;
 typedef struct Coverage Coverage;
-typedef struct MathVariants MathVariants;
-typedef struct MathGlyphInfo MathGlyphInfo;
 typedef struct MathGlyphVariantRecord MathGlyphVariantRecord;
 typedef struct GlyphPart GlyphPart;
 typedef struct GlyphAssembly GlyphAssembly;
 typedef struct MathGlyphConstruction MathGlyphConstruction;
+typedef struct MathVariants MathVariants;
+typedef struct MathGlyphInfo MathGlyphInfo;
 typedef struct TableMATH TableMATH;
 typedef struct KernPair KernPair;
 typedef struct KernSubtable0 KernSubtable0;
@@ -223,6 +223,9 @@
 typedef struct KernSubtable KernSubtable;
 typedef struct TableKern TableKern;
 typedef struct TableLoca TableLoca;
+typedef struct GlyphData GlyphData;
+typedef struct SbixStrike SbixStrike;
+typedef struct TableSbix TableSbix;
 typedef struct VariationAxisRecord VariationAxisRecord;
 typedef struct UserTuple UserTuple;
 typedef struct InstanceRecord InstanceRecord;
@@ -240,6 +243,12 @@
 typedef struct SignatureRecord SignatureRecord;
 typedef struct TableDSIG TableDSIG;
 typedef struct AxisRecord AxisRecord;
+typedef struct AxisValueTable1 AxisValueTable1;
+typedef struct AxisValueTable2 AxisValueTable2;
+typedef struct AxisValueTable3 AxisValueTable3;
+typedef struct AxisValue AxisValue;
+typedef struct AxisValueTable4 AxisValueTable4;
+typedef struct AxisValueTable AxisValueTable;
 typedef struct DesignAxes DesignAxes;
 typedef struct TableSTAT TableSTAT;
 typedef struct GaspRange GaspRange;
@@ -909,6 +918,15 @@
 int read_FeatureList(Otf *o, FeatureList *v);
 void print_FeatureList(Otfile *f, int indent, Otf *o, FeatureList *v);
 
+enum { // Lookup
+	// lookupFlag
+	LOOKUP_FL_RIGHT_TO_LEFT = 1<<0,
+	LOOKUP_FL_IGNORE_BASE_GLYPHS = 1<<1,
+	LOOKUP_FL_IGNORE_LIGATURES = 1<<2,
+	LOOKUP_FL_IGNORE_MARKS = 1<<3,
+	LOOKUP_FL_USE_MARK_FILTERING_SET = 1<<4,
+};
+
 struct Lookup {
 	u16int lookupType;
 	u16int lookupFlag;
@@ -923,6 +941,7 @@
 struct LookupList {
 	u16int lookupCount;
 	u16int *lookupOffsets;
+	Lookup *lookups;
 };
 
 int read_LookupList(Otf *o, LookupList *v);
@@ -1107,35 +1126,6 @@
 int read_Coverage(Otf *o, Coverage *v);
 void print_Coverage(Otfile *f, int indent, Otf *o, Coverage *v);
 
-struct MathVariants {
-	u16int minConnectorOverlap;
-	u16int vertGlyphCoverageOffset;
-	u16int horizGlyphCoverageOffset;
-	u16int vertGlyphCount;
-	u16int horizGlyphCount;
-	u16int *vertGlyphConstructionOffsets;
-	u16int *horizGlyphConstructionOffsets;
-	Coverage *vertGlyphCoverage;
-	Coverage *horizGlyphCoverage;
-};
-
-int read_MathVariants(Otf *o, MathVariants *v);
-void print_MathVariants(Otfile *f, int indent, Otf *o, MathVariants *v);
-
-struct MathGlyphInfo {
-	u16int mathItalicsCorrectionInfoOffset;
-	u16int mathTopAccentAttachmentOffset;
-	u16int extendedShapeCoverageOffset;
-	u16int mathKernInfoOffset;
-	MathItalicsCorrectionInfo *mathItalicsCorrectionInfo;
-	MathTopAccentAttachment *mathTopAccentAttachment;
-	MathKernInfo *mathKernInfo;
-	Coverage *extendedShapeCoverage;
-};
-
-int read_MathGlyphInfo(Otf *o, MathGlyphInfo *v);
-void print_MathGlyphInfo(Otfile *f, int indent, Otf *o, MathGlyphInfo *v);
-
 struct MathGlyphVariantRecord {
 	u16int variantGlyph;
 	u16int advanceMeasurement;
@@ -1174,6 +1164,37 @@
 int read_MathGlyphConstruction(Otf *o, MathGlyphConstruction *v);
 void print_MathGlyphConstruction(Otfile *f, int indent, Otf *o, MathGlyphConstruction *v);
 
+struct MathVariants {
+	u16int minConnectorOverlap;
+	u16int vertGlyphCoverageOffset;
+	u16int horizGlyphCoverageOffset;
+	u16int vertGlyphCount;
+	u16int horizGlyphCount;
+	u16int *vertGlyphConstructionOffsets;
+	u16int *horizGlyphConstructionOffsets;
+	Coverage *vertGlyphCoverage;
+	Coverage *horizGlyphCoverage;
+	MathGlyphConstruction *vertGlyphConstruction;
+	MathGlyphConstruction *horizGlyphConstruction;
+};
+
+int read_MathVariants(Otf *o, MathVariants *v);
+void print_MathVariants(Otfile *f, int indent, Otf *o, MathVariants *v);
+
+struct MathGlyphInfo {
+	u16int mathItalicsCorrectionInfoOffset;
+	u16int mathTopAccentAttachmentOffset;
+	u16int extendedShapeCoverageOffset;
+	u16int mathKernInfoOffset;
+	MathItalicsCorrectionInfo *mathItalicsCorrectionInfo;
+	MathTopAccentAttachment *mathTopAccentAttachment;
+	MathKernInfo *mathKernInfo;
+	Coverage *extendedShapeCoverage;
+};
+
+int read_MathGlyphInfo(Otf *o, MathGlyphInfo *v);
+void print_MathGlyphInfo(Otfile *f, int indent, Otf *o, MathGlyphInfo *v);
+
 struct TableMATH {
 	// u16int majorVersion;
 	// u16int minorVersion;
@@ -1230,10 +1251,20 @@
 int read_KernSubtable2(Otf *o, KernSubtable2 *v);
 void print_KernSubtable2(Otfile *f, int indent, Otf *o, KernSubtable2 *v);
 
+enum { // KernSubtable
+	// coverage
+	KERN_FL_HORIZONTAL = 1<<0,
+	KERN_FL_MINIMUM = 1<<1,
+	KERN_FL_CROSS_STREAM = 1<<2,
+	KERN_FL_OVERRIDE = 1<<3,
+};
+
 struct KernSubtable {
 	// u16int version;
 	u16int length;
 	u16int coverage;
+	KernSubtable0 sub0;
+	KernSubtable2 sub2;
 };
 
 int read_KernSubtable(Otf *o, KernSubtable *v);
@@ -1256,6 +1287,41 @@
 int read_TableLoca(Otf *o, TableLoca *v);
 void print_TableLoca(Otfile *f, int indent, Otf *o, TableLoca *v);
 
+struct GlyphData {
+	s16int originOffsetX;
+	s16int originOffsetY;
+	u32int graphicType;
+};
+
+int read_GlyphData(Otf *o, GlyphData *v);
+void print_GlyphData(Otfile *f, int indent, Otf *o, GlyphData *v);
+
+struct SbixStrike {
+	u16int ppem;
+	u16int ppi;
+	u32int *glyphDataOffsets;
+	GlyphData *glyphData;
+};
+
+int read_SbixStrike(Otf *o, SbixStrike *v);
+void print_SbixStrike(Otfile *f, int indent, Otf *o, SbixStrike *v);
+
+enum { // TableSbix
+	// flags
+	SBIX_FL_DRAW_OUTLINES = 1<<1,
+};
+
+struct TableSbix {
+	// u16int version;
+	u16int flags;
+	u32int numStrikes;
+	u32int *strikeOffsets;
+	SbixStrike *strikes;
+};
+
+int read_TableSbix(Otf *o, TableSbix *v);
+void print_TableSbix(Otfile *f, int indent, Otf *o, TableSbix *v);
+
 enum { // VariationAxisRecord
 	// flags
 	VARIATIONAXISRECORD_FL_HIDDEN_AXIS = 1<<0,
@@ -1353,6 +1419,7 @@
 	u32int variationRegionListOffset;
 	u16int itemVariationDataCount;
 	u32int *itemVariationDataOffsets;
+	ItemVariationData *itemVariationData;
 };
 
 int read_ItemVariationStore(Otf *o, ItemVariationStore *v);
@@ -1440,9 +1507,72 @@
 int read_AxisRecord(Otf *o, AxisRecord *v);
 void print_AxisRecord(Otfile *f, int indent, Otf *o, AxisRecord *v);
 
+struct AxisValueTable1 {
+	u16int axisIndex;
+	u16int flags;
+	u16int valueNameID;
+	double value;
+};
+
+int read_AxisValueTable1(Otf *o, AxisValueTable1 *v);
+void print_AxisValueTable1(Otfile *f, int indent, Otf *o, AxisValueTable1 *v);
+
+struct AxisValueTable2 {
+	u16int axisIndex;
+	u16int flags;
+	u16int valueNameID;
+	double nominalValue;
+	double rangeMinValue;
+	double rangeMaxValue;
+};
+
+int read_AxisValueTable2(Otf *o, AxisValueTable2 *v);
+void print_AxisValueTable2(Otfile *f, int indent, Otf *o, AxisValueTable2 *v);
+
+struct AxisValueTable3 {
+	u16int axisIndex;
+	u16int flags;
+	u16int valueNameID;
+	double value;
+	double linkedValue;
+};
+
+int read_AxisValueTable3(Otf *o, AxisValueTable3 *v);
+void print_AxisValueTable3(Otfile *f, int indent, Otf *o, AxisValueTable3 *v);
+
+struct AxisValue {
+	u16int axisIndex;
+	double value;
+};
+
+int read_AxisValue(Otf *o, AxisValue *v);
+void print_AxisValue(Otfile *f, int indent, Otf *o, AxisValue *v);
+
+struct AxisValueTable4 {
+	u16int axisCount;
+	u16int flags;
+	u16int valueNameID;
+	AxisValue *axisValues;
+};
+
+int read_AxisValueTable4(Otf *o, AxisValueTable4 *v);
+void print_AxisValueTable4(Otfile *f, int indent, Otf *o, AxisValueTable4 *v);
+
+struct AxisValueTable {
+	u16int format;
+	AxisValueTable1 f1;
+	AxisValueTable2 f2;
+	AxisValueTable3 f3;
+	AxisValueTable3 f4;
+};
+
+int read_AxisValueTable(Otf *o, AxisValueTable *v);
+void print_AxisValueTable(Otfile *f, int indent, Otf *o, AxisValueTable *v);
+
 struct DesignAxes {
 	AxisRecord *designAxes;
-	u16int *axisValueOffsets;
+	u16int *axisValueTableOffsets;
+	AxisValueTable *axisValueTables;
 };
 
 int read_DesignAxes(Otf *o, DesignAxes *v);
@@ -1463,6 +1593,14 @@
 int read_TableSTAT(Otf *o, TableSTAT *v);
 void print_TableSTAT(Otfile *f, int indent, Otf *o, TableSTAT *v);
 
+enum { // GaspRange
+	// rangeGaspBehavior
+	GASP_GRIDFIT = 1<<0,
+	GASP_DOGRAY = 1<<1,
+	GASP_SYMMETRIC_GRIDFIT = 1<<2,
+	GASP_SYMMETRIC_SMOOTHING = 1<<3,
+};
+
 struct GaspRange {
 	u16int rangeMaxPPEM;
 	u16int rangeGaspBehavior;
@@ -1535,6 +1673,7 @@
 	u32int glyphVariationDataArrayOffset;
 	u16int *glyphVariationDataOffsetsShort;
 	u32int *glyphVariationDataOffsetsLong;
+	GlyphVariationData *glyphVariationData;
 	Tuple *sharedTuples;
 };
 
@@ -1647,6 +1786,7 @@
 	TableMATH *math;
 	TableKern *kern;
 	TableLoca *loca;
+	TableSbix *sbix;
 	TableFvar *fvar;
 	TableHVAR *hvar;
 	TableFFTM *fftm;