shithub: fnt

ref: def6bc8aa2a70c6dd9f7974ca12992efd32b2ebd
dir: /plan9/otf.h/

/* this file is generated. do not modify. */
typedef struct Otf Otf;
#ifdef __unix__
#include <stdint.h>
typedef int8_t s8int;
typedef int16_t s16int;
typedef int32_t s32int;
typedef int64_t s64int;
typedef uint8_t u8int;
typedef uint16_t u16int;
typedef uint32_t u32int;
typedef uint64_t u64int;
char *otferrstr(void);
#else
#pragma incomplete Otf
#endif

typedef struct Otfile Otfile;

struct Otfile {
	void *aux;
	int (*seek)(void *aux, int off, int whence);
	int (*read)(void *aux, void *dst, int sz);
	int (*print)(void *aux, const char *fmt, ...);
};

typedef struct ComponentGlyph ComponentGlyph;

enum {
	CGLYPH_FL_ROUND_TO_GRID_XY = 1<<2,
	CGLYPH_FL_SCALE = 1<<3,
	CGLYPH_FL_MORE_COMPONENTS = 1<<5,
	CGLYPH_FL_SCALE_XY = 1<<6,
	CGLYPH_FL_2X2_TRANSFORM = 1<<7,
	CGLYPH_FL_INSTRUCTIONS = 1<<8,
	CGLYPH_FL_METRICS = 1<<9,
	CGLYPH_FL_OVERLAP_COMPOUND = 1<<10,
	CGLYPH_FL_SCALED_COMPONENT_OFFSET = 1<<11,
	CGLYPH_FL_UNSCALED_COMPONENT_OFFSET = 1<<12,
};

struct ComponentGlyph {
	u16int flags;
	u16int glyphIndex;
	int arg1;
	int arg2;
	float scale, scaleX, scale01, scale10, scaleY;
	u16int numInstr;
	u8int *instr;
	ComponentGlyph *next;
};

typedef struct Point Point;

struct Point {
	int x;
	int y;
	int onCurve;
};

typedef struct SimpleGlyph SimpleGlyph;

struct SimpleGlyph {
	int numEndPtsOfContours;
	u16int *endPtsOfContours;
	u16int instructionLength;
	u8int *instructions;

	int numPoints;
	Point *points;
};

extern int indentΔ;

Otf *otfopen(Otfile *in);
void otfprint(Otf *o, Otfile *out, int indent);
void otfclose(Otf *o);

/* FIXME these will go, this is for debugging and designing the drawing logic */
typedef struct Glyf Glyf;
Glyf *otfglyf(Otf *o, int index);
int otfglyfnum(Otf *o);
u8int *otfdrawglyf(Glyf *g, int ppem, int *wo, int *ho);

typedef struct SubHeader SubHeader;
typedef struct MapGroup MapGroup;
typedef struct SubtableCmap0 SubtableCmap0;
typedef struct SubtableCmap2 SubtableCmap2;
typedef struct SubtableCmap4 SubtableCmap4;
typedef struct SubtableCmap6 SubtableCmap6;
typedef struct SubtableCmap8 SubtableCmap8;
typedef struct SubtableCmap10 SubtableCmap10;
typedef struct SubtableCmap12or13 SubtableCmap12or13;
typedef struct UnicodeRange UnicodeRange;
typedef struct DefaultUVS DefaultUVS;
typedef struct UVSMapping UVSMapping;
typedef struct NonDefaultUVS NonDefaultUVS;
typedef struct VariationSelector VariationSelector;
typedef struct SubtableCmap14 SubtableCmap14;
typedef struct SubtableCmap SubtableCmap;
typedef struct EncodingRecord EncodingRecord;
typedef struct TableCmap TableCmap;
typedef struct TableHead TableHead;
typedef struct TableHhea TableHhea;
typedef struct Glyf Glyf;
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 TableName TableName;
typedef struct BigGlyphMetrics BigGlyphMetrics;
typedef struct SmallGlyphMetrics SmallGlyphMetrics;
typedef struct SbitLineMetrics SbitLineMetrics;
typedef struct IndexSubtable1 IndexSubtable1;
typedef struct IndexSubtable2 IndexSubtable2;
typedef struct IndexSubtable3 IndexSubtable3;
typedef struct GlyphIdOffsetPair GlyphIdOffsetPair;
typedef struct IndexSubtable4 IndexSubtable4;
typedef struct IndexSubtable5 IndexSubtable5;
typedef struct IndexSubtable IndexSubtable;
typedef struct IndexSubtableRecord IndexSubtableRecord;
typedef struct BitmapSize BitmapSize;
typedef struct TableEBDT TableEBDT;
typedef struct TableEBLC TableEBLC;
typedef struct AttachList AttachList;
typedef struct AttachPoint AttachPoint;
typedef struct LigCaretList LigCaretList;
typedef struct LigGlyph LigGlyph;
typedef struct CaretValue CaretValue;
typedef struct ValueRecord ValueRecord;
typedef struct SinglePos SinglePos;
typedef struct TableGDEF TableGDEF;
typedef struct LangSys LangSys;
typedef struct LangSysRecord LangSysRecord;
typedef struct Script Script;
typedef struct ScriptRecord ScriptRecord;
typedef struct ScriptList ScriptList;
typedef struct Feature Feature;
typedef struct FeatureRecord FeatureRecord;
typedef struct FeatureList FeatureList;
typedef struct Lookup Lookup;
typedef struct LookupList LookupList;
typedef struct TableGPOS TableGPOS;
typedef struct TableGSUB TableGSUB;
typedef struct MathValueRecord MathValueRecord;
typedef struct MathConstants MathConstants;
typedef struct MathItalicsCorrectionInfo MathItalicsCorrectionInfo;
typedef struct MathTopAccentAttachment MathTopAccentAttachment;
typedef struct MathKernInfoRecord MathKernInfoRecord;
typedef struct MathKernInfo MathKernInfo;
typedef struct MathKern MathKern;
typedef struct Coverage1 Coverage1;
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 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 VariationAxisRecord VariationAxisRecord;
typedef struct UserTuple UserTuple;
typedef struct InstanceRecord InstanceRecord;
typedef struct AxisInstances AxisInstances;
typedef struct TableFvar TableFvar;
typedef struct RegionAxisCoordinates RegionAxisCoordinates;
typedef struct VariationRegion VariationRegion;
typedef struct VariationRegionList VariationRegionList;
typedef struct ItemVariationData ItemVariationData;
typedef struct ItemVariationStore ItemVariationStore;
typedef struct DeltaSetIndexMap DeltaSetIndexMap;
typedef struct TableHVAR TableHVAR;
typedef struct TableFFTM TableFFTM;
typedef struct SignatureBlock1 SignatureBlock1;
typedef struct SignatureRecord SignatureRecord;
typedef struct TableDSIG TableDSIG;
typedef struct AxisRecord AxisRecord;
typedef struct DesignAxes DesignAxes;
typedef struct TableSTAT TableSTAT;
typedef struct GaspRange GaspRange;
typedef struct TableGasp TableGasp;
typedef struct Tuple Tuple;
typedef struct TupleVariationHeader TupleVariationHeader;
typedef struct GlyphVariationData GlyphVariationData;
typedef struct TableGvar TableGvar;
typedef struct AxisValueMap AxisValueMap;
typedef struct SegmentMaps SegmentMaps;
typedef struct TableAvar TableAvar;
typedef struct TableOS∕2 TableOS∕2;
typedef struct TableRecord TableRecord;
typedef struct TableDirectory TableDirectory;

struct SubHeader {
	u16int firstCode;
	u16int entryCode;
	s16int idDelta;
	u16int idRangeOffset;
};

int read_SubHeader(Otf *o, SubHeader *v);
void print_SubHeader(Otfile *f, int indent, Otf *o, SubHeader *v);

struct MapGroup {
	u32int startCharCode;
	u32int endCharCode;
	u32int startGlyphID;
};

int read_MapGroup(Otf *o, MapGroup *v);
void print_MapGroup(Otfile *f, int indent, Otf *o, MapGroup *v);

struct SubtableCmap0 {
	u16int length;
	u16int language;
	u8int glyphIdArray[256];
};

int read_SubtableCmap0(Otf *o, SubtableCmap0 *v);
void print_SubtableCmap0(Otfile *f, int indent, Otf *o, SubtableCmap0 *v);

struct SubtableCmap2 {
	u16int length;
	u16int language;
	u16int subHeaderKeys[256];
};

int read_SubtableCmap2(Otf *o, SubtableCmap2 *v);
void print_SubtableCmap2(Otfile *f, int indent, Otf *o, SubtableCmap2 *v);

struct SubtableCmap4 {
	u16int length;
	u16int language;
	u16int segCountX2;
	u16int searchRange;
	u16int entrySelector;
	u16int rangeShift;
	u16int *endCode;
	// u16int reservedPad;
	u16int *startCode;
	s16int *idDelta;
	s16int *idRangeOffset;
};

int read_SubtableCmap4(Otf *o, SubtableCmap4 *v);
void print_SubtableCmap4(Otfile *f, int indent, Otf *o, SubtableCmap4 *v);

struct SubtableCmap6 {
	u16int length;
	u16int language;
	u16int firstCode;
	u16int entryCount;
	u16int *glyphIdArray;
};

int read_SubtableCmap6(Otf *o, SubtableCmap6 *v);
void print_SubtableCmap6(Otfile *f, int indent, Otf *o, SubtableCmap6 *v);

struct SubtableCmap8 {
	u16int length;
	u16int language;
	u8int is32[8192];
	u32int numGroups;
	MapGroup *groups;
};

int read_SubtableCmap8(Otf *o, SubtableCmap8 *v);
void print_SubtableCmap8(Otfile *f, int indent, Otf *o, SubtableCmap8 *v);

struct SubtableCmap10 {
	u16int reserved;
	u32int length;
	u32int language;
	u32int startCharCode;
	u32int numChars;
};

int read_SubtableCmap10(Otf *o, SubtableCmap10 *v);
void print_SubtableCmap10(Otfile *f, int indent, Otf *o, SubtableCmap10 *v);

struct SubtableCmap12or13 {
	u16int reserved;
	u32int length;
	u32int language;
	u32int numGroups;
	MapGroup *groups;
};

int read_SubtableCmap12or13(Otf *o, SubtableCmap12or13 *v);
void print_SubtableCmap12or13(Otfile *f, int indent, Otf *o, SubtableCmap12or13 *v);

struct UnicodeRange {
	u32int startUnicodeValue;
	u8int additionalCount;
};

int read_UnicodeRange(Otf *o, UnicodeRange *v);
void print_UnicodeRange(Otfile *f, int indent, Otf *o, UnicodeRange *v);

struct DefaultUVS {
	u32int numUnicodeValueRanges;
	UnicodeRange *ranges;
};

int read_DefaultUVS(Otf *o, DefaultUVS *v);
void print_DefaultUVS(Otfile *f, int indent, Otf *o, DefaultUVS *v);

struct UVSMapping {
	u32int unicodeValue;
	u16int glyphID;
};

int read_UVSMapping(Otf *o, UVSMapping *v);
void print_UVSMapping(Otfile *f, int indent, Otf *o, UVSMapping *v);

struct NonDefaultUVS {
	u32int numUVSMappings;
	UVSMapping *uvsMappings;
};

int read_NonDefaultUVS(Otf *o, NonDefaultUVS *v);
void print_NonDefaultUVS(Otfile *f, int indent, Otf *o, NonDefaultUVS *v);

struct VariationSelector {
	u32int varSelector;
	u32int defaultUVSOffset;
	u32int nonDefaultUVSOffset;
	DefaultUVS *defaultUVS;
	NonDefaultUVS *nonDefaultUVS;
};

int read_VariationSelector(Otf *o, VariationSelector *v);
void print_VariationSelector(Otfile *f, int indent, Otf *o, VariationSelector *v);

struct SubtableCmap14 {
	u32int length;
	u32int numVarSelectorRecords;
	VariationSelector *varSelector;
};

int read_SubtableCmap14(Otf *o, SubtableCmap14 *v);
void print_SubtableCmap14(Otfile *f, int indent, Otf *o, SubtableCmap14 *v);

struct SubtableCmap {
	u16int format;
	SubtableCmap0 sub0;
	SubtableCmap2 sub2;
	SubtableCmap4 sub4;
	SubtableCmap6 sub6;
	SubtableCmap8 sub8;
	SubtableCmap10 sub10;
	SubtableCmap12or13 sub12or13;
	SubtableCmap14 sub14;
};

int read_SubtableCmap(Otf *o, SubtableCmap *v);
void print_SubtableCmap(Otfile *f, int indent, Otf *o, SubtableCmap *v);

struct EncodingRecord {
	u16int platformID;
	u16int encodingID;
	u32int subtableOffset;
	SubtableCmap *subtable;
};

int read_EncodingRecord(Otf *o, EncodingRecord *v);
void print_EncodingRecord(Otfile *f, int indent, Otf *o, EncodingRecord *v);

struct TableCmap {
	// u16int version;
	u16int numTables;
	EncodingRecord *encodingRecords;
};

int read_TableCmap(Otf *o, TableCmap *v);
void print_TableCmap(Otfile *f, int indent, Otf *o, TableCmap *v);

enum { // TableHead
	// flags
	HEAD_FL_BASELINE_Y_0 = 1<<0,
	HEAD_FL_LEFT_SIDEBEARING_X_0 = 1<<1,
	HEAD_FL_INSTR_DEP_POINT_SZ = 1<<2,
	HEAD_FL_FORCE_PPEM_INT = 1<<3,
	HEAD_FL_INSTR_ALT_ADVANCE_WIDTH = 1<<4,
	HEAD_FL_LOSSLESS = 1<<11,
	HEAD_FL_CONVERTED = 1<<12,
	HEAD_FL_CLEARTYPE = 1<<13,
	HEAD_FL_LAST_RESORT = 1<<14,
};

struct TableHead {
	// u16int majorVersion;
	// u16int minorVersion;
	// double fontRevision;
	// u32int checksumAdjustment;
	// u32int magicNumber;
	u16int flags;
	u16int unitsPerEm;
	s64int created;
	s64int modified;
	s16int xMin;
	s16int yMin;
	s16int xMax;
	s16int yMax;
	u16int macStyle;
	u16int lowestRecPPEM;
	// s16int fontDirectionHint;
	s16int indexToLocFormat;
	// s16int glyphDataFormat;
};

int read_TableHead(Otf *o, TableHead *v);
void print_TableHead(Otfile *f, int indent, Otf *o, TableHead *v);

struct TableHhea {
	u16int majorVersion;
	u16int minorVersion;
	s16int ascender;
	s16int descender;
	s16int lineGap;
	u16int advanceWidthMax;
	s16int minLeftSideBearing;
	s16int minRightSideBearing;
	s16int xMaxExtent;
	s16int caretSlopeRise;
	s16int caretSlopeRun;
	s16int caretOffset;
	// s16int reserved[4];
	s16int metricDataFormat;
	u16int numberOfHMetrics;
};

int read_TableHhea(Otf *o, TableHhea *v);
void print_TableHhea(Otfile *f, int indent, Otf *o, TableHhea *v);

struct Glyf {
	s16int numberOfContours;
	s16int xMin;
	s16int yMin;
	s16int xMax;
	s16int yMax;
	ComponentGlyph *component;
	SimpleGlyph *simple;
	u16int unitsPerEm;
};

int read_Glyf(Otf *o, Glyf *v);
void print_Glyf(Otfile *f, int indent, Otf *o, Glyf *v);

struct LongHorMetric {
	u16int advanceWidth;
	s16int lsb;
};

int read_LongHorMetric(Otf *o, LongHorMetric *v);
void print_LongHorMetric(Otfile *f, int indent, Otf *o, LongHorMetric *v);

struct TableMaxp {
	// u32int version;
	u16int numGlyphs;
};

int read_TableMaxp(Otf *o, TableMaxp *v);
void print_TableMaxp(Otfile *f, int indent, Otf *o, TableMaxp *v);

struct TableHmtx {
	LongHorMetric *hMetrics;
	s16int *leftSideBearings;
};

int read_TableHmtx(Otf *o, TableHmtx *v);
void print_TableHmtx(Otfile *f, int indent, Otf *o, TableHmtx *v);

struct TablePost {
	// u32int version;
	double italicAngle;
	s16int underlinePosition;
	s16int underlineThickness;
	u32int isFixedPitch;
};

int read_TablePost(Otf *o, TablePost *v);
void print_TablePost(Otfile *f, int indent, Otf *o, TablePost *v);

struct NameRecord {
	u16int platformID;
	u16int encodingID;
	u16int languageID;
	u16int nameID;
	u16int stringLength;
	u16int stringOffset;
	char *string;
};

int read_NameRecord(Otf *o, NameRecord *v);
void print_NameRecord(Otfile *f, int indent, Otf *o, NameRecord *v);

struct LangTagRecord {
	u16int length;
	u16int langTagOffset;
	char *langTag;
};

int read_LangTagRecord(Otf *o, LangTagRecord *v);
void print_LangTagRecord(Otfile *f, int indent, Otf *o, LangTagRecord *v);

struct TableName {
	u16int version;
	u16int count;
	u16int storageOffset;
	NameRecord *nameRecord;
	u16int langTagCount;
	LangTagRecord *langTagRecord;
};

int read_TableName(Otf *o, TableName *v);
void print_TableName(Otfile *f, int indent, Otf *o, TableName *v);

struct BigGlyphMetrics {
	u8int height;
	u8int width;
	s8int horiBearingX;
	s8int horiBearingY;
	u8int horiAdvance;
	s8int vertBearingX;
	s8int vertBearingY;
	u8int vertAdvance;
};

int read_BigGlyphMetrics(Otf *o, BigGlyphMetrics *v);
void print_BigGlyphMetrics(Otfile *f, int indent, Otf *o, BigGlyphMetrics *v);

struct SmallGlyphMetrics {
	u8int height;
	u8int width;
	s8int bearingX;
	s8int bearingY;
	u8int advance;
};

int read_SmallGlyphMetrics(Otf *o, SmallGlyphMetrics *v);
void print_SmallGlyphMetrics(Otfile *f, int indent, Otf *o, SmallGlyphMetrics *v);

struct SbitLineMetrics {
	s8int ascender;
	s8int descender;
	u8int widthMax;
	s8int caretSlopeNumerator;
	s8int caretSlopeDenumerator;
	s8int caretOffset;
	s8int minOriginSB;
	s8int minAdvanceSB;
	s8int maxBeforeBL;
	s8int minAfterBL;
	// s8int pad[2];
};

int read_SbitLineMetrics(Otf *o, SbitLineMetrics *v);
void print_SbitLineMetrics(Otfile *f, int indent, Otf *o, SbitLineMetrics *v);

struct IndexSubtable1 {
	u32int *sbitOffsets;
};

int read_IndexSubtable1(Otf *o, IndexSubtable1 *v);
void print_IndexSubtable1(Otfile *f, int indent, Otf *o, IndexSubtable1 *v);

struct IndexSubtable2 {
	u32int imageSize;
	BigGlyphMetrics bigMetrics;
};

int read_IndexSubtable2(Otf *o, IndexSubtable2 *v);
void print_IndexSubtable2(Otfile *f, int indent, Otf *o, IndexSubtable2 *v);

struct IndexSubtable3 {
	u16int *sbitOffsets;
};

int read_IndexSubtable3(Otf *o, IndexSubtable3 *v);
void print_IndexSubtable3(Otfile *f, int indent, Otf *o, IndexSubtable3 *v);

struct GlyphIdOffsetPair {
	u16int glyphID;
	u16int sbitOffset;
};

int read_GlyphIdOffsetPair(Otf *o, GlyphIdOffsetPair *v);
void print_GlyphIdOffsetPair(Otfile *f, int indent, Otf *o, GlyphIdOffsetPair *v);

struct IndexSubtable4 {
	u32int numGlyphs;
	GlyphIdOffsetPair *glyphArray;
};

int read_IndexSubtable4(Otf *o, IndexSubtable4 *v);
void print_IndexSubtable4(Otfile *f, int indent, Otf *o, IndexSubtable4 *v);

struct IndexSubtable5 {
	u32int imageSize;
	BigGlyphMetrics bigMetrics;
	u32int numGlyphs;
	u16int *glyphIdArray;
};

int read_IndexSubtable5(Otf *o, IndexSubtable5 *v);
void print_IndexSubtable5(Otfile *f, int indent, Otf *o, IndexSubtable5 *v);

struct IndexSubtable {
	u16int indexFormat;
	u16int imageFormat;
	u32int imageDataOffset;
	IndexSubtable1 sub1;
	IndexSubtable2 sub2;
	IndexSubtable3 sub3;
	IndexSubtable4 sub4;
	IndexSubtable5 sub5;
};

int read_IndexSubtable(Otf *o, IndexSubtable *v);
void print_IndexSubtable(Otfile *f, int indent, Otf *o, IndexSubtable *v);

struct IndexSubtableRecord {
	u16int firstGlyphIndex;
	u16int lastGlyphIndex;
	u32int indexSubtableOffset;
	IndexSubtable *indexSubtable;
};

int read_IndexSubtableRecord(Otf *o, IndexSubtableRecord *v);
void print_IndexSubtableRecord(Otfile *f, int indent, Otf *o, IndexSubtableRecord *v);

enum { // BitmapSize
	// flags
	BITMAPSIZE_FL_HORIZONTAL_METRICS = 1<<0,
	BITMAPSIZE_FL_VERTICAL_METRICS = 1<<1,
};

struct BitmapSize {
	u32int indexSubtableListOffset;
	u32int indexSubtableListSize;
	u32int numberOfIndexSubtables;
	// u32int colorRef;
	SbitLineMetrics hori;
	SbitLineMetrics vert;
	u16int startGlyphIndex;
	u16int endGlyphIndex;
	u8int ppemX;
	u8int ppemY;
	u8int bitDepth;
	s8int flags;
	IndexSubtableRecord *indexSubtableList;
};

int read_BitmapSize(Otf *o, BitmapSize *v);
void print_BitmapSize(Otfile *f, int indent, Otf *o, BitmapSize *v);

struct TableEBDT {
	u16int majorVersion;
	// u16int minorVersion;
};

int read_TableEBDT(Otf *o, TableEBDT *v);
void print_TableEBDT(Otfile *f, int indent, Otf *o, TableEBDT *v);

struct TableEBLC {
	// u16int majorVersion;
	// u16int minorVersion;
	u32int numSizes;
	BitmapSize *bitmapSizes;
};

int read_TableEBLC(Otf *o, TableEBLC *v);
void print_TableEBLC(Otfile *f, int indent, Otf *o, TableEBLC *v);

struct AttachList {
	u16int coverageOffset;
	u16int glyphCount;
	u16int *attachPointOffsets;
};

int read_AttachList(Otf *o, AttachList *v);
void print_AttachList(Otfile *f, int indent, Otf *o, AttachList *v);

struct AttachPoint {
	u16int pointCount;
	u16int *pointIndices;
};

int read_AttachPoint(Otf *o, AttachPoint *v);
void print_AttachPoint(Otfile *f, int indent, Otf *o, AttachPoint *v);

struct LigCaretList {
	u16int coverageOffset;
	u16int ligGlyphCount;
	u16int *ligGlyphOffsets;
};

int read_LigCaretList(Otf *o, LigCaretList *v);
void print_LigCaretList(Otfile *f, int indent, Otf *o, LigCaretList *v);

struct LigGlyph {
	u16int caretCount;
	u16int *caretValueOffsets;
};

int read_LigGlyph(Otf *o, LigGlyph *v);
void print_LigGlyph(Otfile *f, int indent, Otf *o, LigGlyph *v);

struct CaretValue {
	u16int format;
	s16int coordinate;
	u16int caretValuePointIndex;
	u16int deviceOffset;
};

int read_CaretValue(Otf *o, CaretValue *v);
void print_CaretValue(Otfile *f, int indent, Otf *o, CaretValue *v);

struct ValueRecord {
	s16int xPlacement;
	s16int yPlacement;
	s16int xAdvance;
	s16int yAdvance;
	u16int xPlaDeviceOffset;
	u16int yPlaDeviceOffset;
	u16int xAdvDeviceOffset;
	u16int yAdvDeviceOffset;
};

int read_ValueRecord(Otf *o, ValueRecord *v);
void print_ValueRecord(Otfile *f, int indent, Otf *o, ValueRecord *v);

struct SinglePos {
	u16int format;
	u16int coverageOffset;
	u16int valueFormat;
	ValueRecord valueRecord;
	u16int valueCount;
	ValueRecord *valueRecords;
};

int read_SinglePos(Otf *o, SinglePos *v);
void print_SinglePos(Otfile *f, int indent, Otf *o, SinglePos *v);

struct TableGDEF {
	// u16int majorVersion;
	u16int minorVersion;
	u16int glyphClassDefOffset;
	u16int attachListOffset;
	u16int ligCaretListOffset;
	u16int markAttachClassDefOffset;
	u16int markGlyphSetsDefOffset;
	u32int itemVarStoreOffset;
};

int read_TableGDEF(Otf *o, TableGDEF *v);
void print_TableGDEF(Otfile *f, int indent, Otf *o, TableGDEF *v);

struct LangSys {
	// u16int lookupOrderOffset;
	u16int requiredFeatureIndex;
	u16int featureIndexCount;
	u16int *featureIndices;
};

int read_LangSys(Otf *o, LangSys *v);
void print_LangSys(Otfile *f, int indent, Otf *o, LangSys *v);

struct LangSysRecord {
	u32int langSysTag;
	u16int langSysOffset;
	LangSys *langSys;
};

int read_LangSysRecord(Otf *o, LangSysRecord *v);
void print_LangSysRecord(Otfile *f, int indent, Otf *o, LangSysRecord *v);

struct Script {
	u16int defaultLangSysOffset;
	u16int langSysCount;
	LangSysRecord *langSysRecords;
	LangSys *defaultLangSys;
};

int read_Script(Otf *o, Script *v);
void print_Script(Otfile *f, int indent, Otf *o, Script *v);

struct ScriptRecord {
	u32int scriptTag;
	u16int scriptOffset;
	Script *script;
};

int read_ScriptRecord(Otf *o, ScriptRecord *v);
void print_ScriptRecord(Otfile *f, int indent, Otf *o, ScriptRecord *v);

struct ScriptList {
	u16int scriptCount;
	ScriptRecord *scriptRecords;
};

int read_ScriptList(Otf *o, ScriptList *v);
void print_ScriptList(Otfile *f, int indent, Otf *o, ScriptList *v);

struct Feature {
	u16int featureParamsOffset;
	u16int lookupIndexCount;
	u16int *lookupListIndices;
};

int read_Feature(Otf *o, Feature *v);
void print_Feature(Otfile *f, int indent, Otf *o, Feature *v);

struct FeatureRecord {
	u32int featureTag;
	u16int featureOffset;
	Feature *feature;
};

int read_FeatureRecord(Otf *o, FeatureRecord *v);
void print_FeatureRecord(Otfile *f, int indent, Otf *o, FeatureRecord *v);

struct FeatureList {
	u16int featureCount;
	FeatureRecord *featureRecords;
};

int read_FeatureList(Otf *o, FeatureList *v);
void print_FeatureList(Otfile *f, int indent, Otf *o, FeatureList *v);

struct Lookup {
	u16int lookupType;
	u16int lookupFlag;
	u16int subTableCount;
	u16int *subtableOffsets;
	u16int markFilteringSet;
};

int read_Lookup(Otf *o, Lookup *v);
void print_Lookup(Otfile *f, int indent, Otf *o, Lookup *v);

struct LookupList {
	u16int lookupCount;
	u16int *lookupOffsets;
};

int read_LookupList(Otf *o, LookupList *v);
void print_LookupList(Otfile *f, int indent, Otf *o, LookupList *v);

struct TableGPOS {
	// u16int majorVersion;
	u16int minorVersion;
	u16int scriptListOffset;
	u16int featureListOffset;
	u16int lookupListOffset;
	u32int featureVariationsOffset;
	ScriptList *scriptList;
	FeatureList *featureList;
	LookupList *lookupList;
};

int read_TableGPOS(Otf *o, TableGPOS *v);
void print_TableGPOS(Otfile *f, int indent, Otf *o, TableGPOS *v);

struct TableGSUB {
	// u16int majorVersion;
	u16int minorVersion;
	u16int scriptListOffset;
	u16int featureListOffset;
	u16int lookupListOffset;
	u32int featureVariationsOffset;
	ScriptList *scriptList;
	FeatureList *featureList;
};

int read_TableGSUB(Otf *o, TableGSUB *v);
void print_TableGSUB(Otfile *f, int indent, Otf *o, TableGSUB *v);

struct MathValueRecord {
	s16int value;
	u16int deviceOffset;
};

int read_MathValueRecord(Otf *o, MathValueRecord *v);
void print_MathValueRecord(Otfile *f, int indent, Otf *o, MathValueRecord *v);

struct MathConstants {
	s16int scriptPercentScaleDown;
	s16int scriptScriptPercentScaleDown;
	u16int delimitedSubFormulaMinHeight;
	u16int displayOperatorMinHeight;
	MathValueRecord mathLeading;
	MathValueRecord axisHeight;
	MathValueRecord accentBaseHeight;
	MathValueRecord flattenedAccentBaseHeight;
	MathValueRecord subscriptShiftDown;
	MathValueRecord subscriptTopMax;
	MathValueRecord subscriptBaselineDropMin;
	MathValueRecord superscriptShiftUp;
	MathValueRecord superscriptShiftUpCramped;
	MathValueRecord superscriptBottomMin;
	MathValueRecord superscriptBaselineDropMax;
	MathValueRecord subSuperscriptGapMin;
	MathValueRecord superscriptBottomMaxWithSubscript;
	MathValueRecord spaceAfterScript;
	MathValueRecord upperLimitGapMin;
	MathValueRecord upperLimitBaselineRiseMin;
	MathValueRecord lowerLimitGapMin;
	MathValueRecord lowerLimitBaselineDropMin;
	MathValueRecord stackTopShiftUp;
	MathValueRecord stackTopDisplayStyleShiftUp;
	MathValueRecord stackBottomShiftDown;
	MathValueRecord stackBottomDisplayStyleShiftDown;
	MathValueRecord stackGapMin;
	MathValueRecord stackDisplayStyleGapMin;
	MathValueRecord stretchStackTopShiftUp;
	MathValueRecord stretchStackBottomShiftDown;
	MathValueRecord stretchStackGapAboveMin;
	MathValueRecord stretchStackGapBelowMin;
	MathValueRecord fractionNumeratorShiftUp;
	MathValueRecord fractionNumeratorDisplayStyleShiftUp;
	MathValueRecord fractionDenominatorShiftDown;
	MathValueRecord fractionDenominatorDisplayStyleShiftDown;
	MathValueRecord fractionNumeratorGapMin;
	MathValueRecord fractionNumDisplayStyleGapMin;
	MathValueRecord fractionRuleThickness;
	MathValueRecord fractionDenominatorGapMin;
	MathValueRecord fractionDenomDisplayStyleGapMin;
	MathValueRecord skewedFractionHorizontalGap;
	MathValueRecord skewedFractionVerticalGap;
	MathValueRecord overbarVerticalGap;
	MathValueRecord overbarRuleThickness;
	MathValueRecord overbarExtraAscender;
	MathValueRecord underbarVerticalGap;
	MathValueRecord underbarRuleThickness;
	MathValueRecord underbarExtraDescender;
	MathValueRecord radicalVerticalGap;
	MathValueRecord radicalDisplayStyleVerticalGap;
	MathValueRecord radicalRuleThickness;
	MathValueRecord radicalExtraAscender;
	MathValueRecord radicalKernBeforeDegree;
	MathValueRecord radicalKernAfterDegree;
	s16int radicalDegreeBottomRaisePercent;
};

int read_MathConstants(Otf *o, MathConstants *v);
void print_MathConstants(Otfile *f, int indent, Otf *o, MathConstants *v);

struct MathItalicsCorrectionInfo {
	u16int italicsCorrectionCoverageOffset;
	u16int italicsCorrectionCount;
	MathValueRecord *italicsCorrection;
};

int read_MathItalicsCorrectionInfo(Otf *o, MathItalicsCorrectionInfo *v);
void print_MathItalicsCorrectionInfo(Otfile *f, int indent, Otf *o, MathItalicsCorrectionInfo *v);

struct MathTopAccentAttachment {
	u16int topAccentCoverageOffset;
	u16int topAccentAttachmentCount;
	MathValueRecord *topAccentAttachment;
};

int read_MathTopAccentAttachment(Otf *o, MathTopAccentAttachment *v);
void print_MathTopAccentAttachment(Otfile *f, int indent, Otf *o, MathTopAccentAttachment *v);

struct MathKernInfoRecord {
	u16int topRightMathKernOffset;
	u16int topLeftMathKernOffset;
	u16int bottomRightMathKernOffset;
	u16int bottomLeftMathKernOffset;
};

int read_MathKernInfoRecord(Otf *o, MathKernInfoRecord *v);
void print_MathKernInfoRecord(Otfile *f, int indent, Otf *o, MathKernInfoRecord *v);

struct MathKernInfo {
	u16int mathKernCoverageOffset;
	u16int mathKernCount;
	MathKernInfoRecord *mathKernInfoRecords;
};

int read_MathKernInfo(Otf *o, MathKernInfo *v);
void print_MathKernInfo(Otfile *f, int indent, Otf *o, MathKernInfo *v);

struct MathKern {
	u16int heightCount;
	MathValueRecord *correctionHeight;
	MathValueRecord *kernValues;
};

int read_MathKern(Otf *o, MathKern *v);
void print_MathKern(Otfile *f, int indent, Otf *o, MathKern *v);

struct Coverage1 {
	u16int glyphCount;
	u16int *glyphArray;
};

int read_Coverage1(Otf *o, Coverage1 *v);
void print_Coverage1(Otfile *f, int indent, Otf *o, Coverage1 *v);

struct RangeRecord {
	u16int startGlyphID;
	u16int endGlyphID;
	u16int startCoverageIndex;
};

int read_RangeRecord(Otf *o, RangeRecord *v);
void print_RangeRecord(Otfile *f, int indent, Otf *o, RangeRecord *v);

struct Coverage2 {
	u16int rangeCount;
	RangeRecord *rangeRecords;
};

int read_Coverage2(Otf *o, Coverage2 *v);
void print_Coverage2(Otfile *f, int indent, Otf *o, Coverage2 *v);

struct Coverage {
	u16int format;
	Coverage1 cov1;
	Coverage2 cov2;
};

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;
};

int read_MathGlyphVariantRecord(Otf *o, MathGlyphVariantRecord *v);
void print_MathGlyphVariantRecord(Otfile *f, int indent, Otf *o, MathGlyphVariantRecord *v);

struct GlyphPart {
	u16int glyphID;
	u16int startConnectorLength;
	u16int endConnectorLength;
	u16int fullAdvance;
	u16int partFlags;
};

int read_GlyphPart(Otf *o, GlyphPart *v);
void print_GlyphPart(Otfile *f, int indent, Otf *o, GlyphPart *v);

struct GlyphAssembly {
	MathValueRecord italicsCorrection;
	u16int partCount;
	GlyphPart *partRecords;
};

int read_GlyphAssembly(Otf *o, GlyphAssembly *v);
void print_GlyphAssembly(Otfile *f, int indent, Otf *o, GlyphAssembly *v);

struct MathGlyphConstruction {
	u16int glyphAssemblyOffset;
	u16int variantCount;
	MathGlyphVariantRecord *mathGlyphVariantRecords;
	GlyphAssembly *glyphAssembly;
};

int read_MathGlyphConstruction(Otf *o, MathGlyphConstruction *v);
void print_MathGlyphConstruction(Otfile *f, int indent, Otf *o, MathGlyphConstruction *v);

struct TableMATH {
	// u16int majorVersion;
	// u16int minorVersion;
	u16int mathConstantsOffset;
	u16int mathGlyphInfoOffset;
	u16int mathVariantsOffset;
	MathConstants *mathConstants;
	MathGlyphInfo *mathGlyphInfo;
	MathVariants *mathVariants;
};

int read_TableMATH(Otf *o, TableMATH *v);
void print_TableMATH(Otfile *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(Otfile *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(Otfile *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(Otfile *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(Otfile *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(Otfile *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(Otfile *f, int indent, Otf *o, TableKern *v);

struct TableLoca {
	u16int *shortOffsets;
	u32int *longOffsets;
};

int read_TableLoca(Otf *o, TableLoca *v);
void print_TableLoca(Otfile *f, int indent, Otf *o, TableLoca *v);

enum { // VariationAxisRecord
	// flags
	VARIATIONAXISRECORD_FL_HIDDEN_AXIS = 1<<0,
};

struct VariationAxisRecord {
	u32int axisTag;
	double minValue;
	double defaultValue;
	double maxValue;
	u16int flags;
	u16int axisNameID;
};

int read_VariationAxisRecord(Otf *o, VariationAxisRecord *v);
void print_VariationAxisRecord(Otfile *f, int indent, Otf *o, VariationAxisRecord *v);

struct UserTuple {
	double *coordinates;
};

int read_UserTuple(Otf *o, UserTuple *v);
void print_UserTuple(Otfile *f, int indent, Otf *o, UserTuple *v);

struct InstanceRecord {
	u16int subfamilyNameID;
	// u16int flags;
	UserTuple coordinates;
	u16int postScriptNameID;
};

int read_InstanceRecord(Otf *o, InstanceRecord *v);
void print_InstanceRecord(Otfile *f, int indent, Otf *o, InstanceRecord *v);

struct AxisInstances {
	VariationAxisRecord *axes;
	InstanceRecord *instaces;
};

int read_AxisInstances(Otf *o, AxisInstances *v);
void print_AxisInstances(Otfile *f, int indent, Otf *o, AxisInstances *v);

struct TableFvar {
	// u16int majorVersion;
	// u16int minorVersion;
	u16int axesArrayOffset;
	// u16int reserved;
	u16int axisCount;
	// u16int axisSize;
	u16int instanceCount;
	u16int instanceSize;
	AxisInstances *axisInstances;
};

int read_TableFvar(Otf *o, TableFvar *v);
void print_TableFvar(Otfile *f, int indent, Otf *o, TableFvar *v);

struct RegionAxisCoordinates {
	double startCoord;
	double peakCoord;
	double endCoord;
};

int read_RegionAxisCoordinates(Otf *o, RegionAxisCoordinates *v);
void print_RegionAxisCoordinates(Otfile *f, int indent, Otf *o, RegionAxisCoordinates *v);

struct VariationRegion {
	RegionAxisCoordinates *regionAxes;
};

int read_VariationRegion(Otf *o, VariationRegion *v);
void print_VariationRegion(Otfile *f, int indent, Otf *o, VariationRegion *v);

struct VariationRegionList {
	u16int axisCount;
	u16int regionCount;
	VariationRegion *variationRegion;
};

int read_VariationRegionList(Otf *o, VariationRegionList *v);
void print_VariationRegionList(Otfile *f, int indent, Otf *o, VariationRegionList *v);

struct ItemVariationData {
	u16int itemCount;
	u16int wordDeltaCount;
	u16int regionIndexCount;
	u16int *regionIndexes;
};

int read_ItemVariationData(Otf *o, ItemVariationData *v);
void print_ItemVariationData(Otfile *f, int indent, Otf *o, ItemVariationData *v);

struct ItemVariationStore {
	// u16int format;
	u32int variationRegionListOffset;
	u16int itemVariationDataCount;
	u32int *itemVariationDataOffsets;
};

int read_ItemVariationStore(Otf *o, ItemVariationStore *v);
void print_ItemVariationStore(Otfile *f, int indent, Otf *o, ItemVariationStore *v);

struct DeltaSetIndexMap {
	u8int format;
	u8int entryFormat;
	u16int mapCount0;
	u32int mapCount1;
	u8int mapData;
};

int read_DeltaSetIndexMap(Otf *o, DeltaSetIndexMap *v);
void print_DeltaSetIndexMap(Otfile *f, int indent, Otf *o, DeltaSetIndexMap *v);

struct TableHVAR {
	// u16int majorVersion;
	// u16int minorVersion;
	u32int itemVariationStoreOffset;
	u32int advanceWidthMappingOffset;
	u32int lsbMappingOffset;
	u32int rsbMappingOffset;
	ItemVariationStore *itemVariationStore;
	DeltaSetIndexMap *advanceWidthMapping;
	DeltaSetIndexMap *lsbMapping;
	DeltaSetIndexMap *rsbMapping;
};

int read_TableHVAR(Otf *o, TableHVAR *v);
void print_TableHVAR(Otfile *f, int indent, Otf *o, TableHVAR *v);

struct TableFFTM {
	u32int version;
	s64int fontforge;
	s64int created;
	s64int modified;
};

int read_TableFFTM(Otf *o, TableFFTM *v);
void print_TableFFTM(Otfile *f, int indent, Otf *o, TableFFTM *v);

struct SignatureBlock1 {
	// u16int reserved1;
	// u16int reserved2;
	u32int signatureLength;
	u8int *signature;
};

int read_SignatureBlock1(Otf *o, SignatureBlock1 *v);
void print_SignatureBlock1(Otfile *f, int indent, Otf *o, SignatureBlock1 *v);

struct SignatureRecord {
	u32int format;
	u32int length;
	u32int signatureBlockOffset;
	SignatureBlock1 *signatureBlock1;
};

int read_SignatureRecord(Otf *o, SignatureRecord *v);
void print_SignatureRecord(Otfile *f, int indent, Otf *o, SignatureRecord *v);

enum { // TableDSIG
	// flags
	DSIG_CANNOT_BE_RESIGNED = 1<<0,
};

struct TableDSIG {
	// u32int version;
	u16int numSignatures;
	u16int flags;
	SignatureRecord *signatureRecords;
};

int read_TableDSIG(Otf *o, TableDSIG *v);
void print_TableDSIG(Otfile *f, int indent, Otf *o, TableDSIG *v);

struct AxisRecord {
	u32int axisTag;
	u16int axisNameID;
	u16int axisOrdering;
	// u8int *unused;
};

int read_AxisRecord(Otf *o, AxisRecord *v);
void print_AxisRecord(Otfile *f, int indent, Otf *o, AxisRecord *v);

struct DesignAxes {
	AxisRecord *designAxes;
	u16int *axisValueOffsets;
};

int read_DesignAxes(Otf *o, DesignAxes *v);
void print_DesignAxes(Otfile *f, int indent, Otf *o, DesignAxes *v);

struct TableSTAT {
	// u16int majorVersion;
	u16int minorVersion;
	u16int designAxisSize;
	u16int designAxisCount;
	u32int designAxesOffset;
	u16int axisValueCount;
	u32int offsetToAxisValueOffsets;
	u16int elidedFallbackNameID;
	DesignAxes *designAxes;
};

int read_TableSTAT(Otf *o, TableSTAT *v);
void print_TableSTAT(Otfile *f, int indent, Otf *o, TableSTAT *v);

struct GaspRange {
	u16int rangeMaxPPEM;
	u16int rangeGaspBehavior;
};

int read_GaspRange(Otf *o, GaspRange *v);
void print_GaspRange(Otfile *f, int indent, Otf *o, GaspRange *v);

struct TableGasp {
	u16int version;
	u16int numRanges;
	GaspRange *gaspRanges;
};

int read_TableGasp(Otf *o, TableGasp *v);
void print_TableGasp(Otfile *f, int indent, Otf *o, TableGasp *v);

struct Tuple {
	double *coordinates;
};

int read_Tuple(Otf *o, Tuple *v);
void print_Tuple(Otfile *f, int indent, Otf *o, Tuple *v);

enum { // TupleVariationHeader
	// tupleIndex
	TUPLEINDEX_FL_PRIVATE_POINT_NUMBERS = 1<<13,
	TUPLEINDEX_FL_INTERMEDIATE_REGION = 1<<14,
	TUPLEINDEX_FL_EMBEDDED_PEAK_TUPLE = 1<<15,
};

struct TupleVariationHeader {
	u16int variationDataSize;
	u16int tupleIndex;
	Tuple peakTuple;
	Tuple intermediateStartTuple;
	Tuple intermediateEndTuple;
};

int read_TupleVariationHeader(Otf *o, TupleVariationHeader *v);
void print_TupleVariationHeader(Otfile *f, int indent, Otf *o, TupleVariationHeader *v);

enum { // GlyphVariationData
	// tupleVariationCount
	COUNT_FL_SHARED_POINT_NUMBERS = 1<<15,
};

struct GlyphVariationData {
	u16int tupleVariationCount;
	u16int dataOffset;
	TupleVariationHeader *tupleVariationHeaders;
};

int read_GlyphVariationData(Otf *o, GlyphVariationData *v);
void print_GlyphVariationData(Otfile *f, int indent, Otf *o, GlyphVariationData *v);

enum { // TableGvar
	// flags
	GVAR_FL_LONG_OFFSETS = 1<<0,
};

struct TableGvar {
	// u16int majorVersion;
	// u16int minorVersion;
	u16int axisCount;
	u16int sharedTupleCount;
	u32int sharedTuplesOffset;
	u16int glyphCount;
	u16int flags;
	u32int glyphVariationDataArrayOffset;
	u16int *glyphVariationDataOffsetsShort;
	u32int *glyphVariationDataOffsetsLong;
	Tuple *sharedTuples;
};

int read_TableGvar(Otf *o, TableGvar *v);
void print_TableGvar(Otfile *f, int indent, Otf *o, TableGvar *v);

struct AxisValueMap {
	double fromCoordinate;
	double toCoordinate;
};

int read_AxisValueMap(Otf *o, AxisValueMap *v);
void print_AxisValueMap(Otfile *f, int indent, Otf *o, AxisValueMap *v);

struct SegmentMaps {
	u16int positionMapCount;
	AxisValueMap *axisValueMaps;
};

int read_SegmentMaps(Otf *o, SegmentMaps *v);
void print_SegmentMaps(Otfile *f, int indent, Otf *o, SegmentMaps *v);

struct TableAvar {
	// u16int majorVersion;
	// u16int minorVersion;
	// u16int reserved;
	u16int axisCount;
	SegmentMaps *axisSegmentMaps;
};

int read_TableAvar(Otf *o, TableAvar *v);
void print_TableAvar(Otfile *f, int indent, Otf *o, TableAvar *v);

struct TableOS∕2 {
	u16int version;
	s16int xAvgCharWidth;
	u16int usWeightClass;
	u16int usWidthClass;
	u16int fsType;
	s16int ySubscriptXSize;
	s16int ySubscriptYSize;
	s16int ySubscriptXOffset;
	s16int ySubscriptYOffset;
	s16int ySuperscriptXSize;
	s16int ySuperscriptYSize;
	s16int ySuperscriptXOffset;
	s16int ySuperscriptYOffset;
	s16int yStrikeoutSize;
	s16int yStrikeoutPosition;
	s16int sFamilyClass;
	u8int panose[10];
	u32int ulUnicodeRange1;
	u32int ulUnicodeRange2;
	u32int ulUnicodeRange3;
	u32int ulUnicodeRange4;
	u32int achVendID;
	u16int fsSelection;
	u16int usFirstCharIndex;
	u16int usLastCharIndex;
	s16int sTypoAscender;
	s16int sTypoDescender;
	s16int sTypoLineGap;
	u16int usWinAscent;
	u16int usWinDescent;
	u32int ulCodePageRange1;
	u32int ulCodePageRange2;
	s16int sxHeight;
	s16int sCapHeight;
	u16int usDefaultChar;
	u16int usBreakChar;
	u16int usMaxContext;
	u16int usLowerOpticalPointSize;
	u16int usUpperOpticalPointSize;
};

int read_TableOS∕2(Otf *o, TableOS∕2 *v);
void print_TableOS∕2(Otfile *f, int indent, Otf *o, TableOS∕2 *v);

struct TableRecord {
	u32int tableTag;
	// u32int checksum;
	u32int offset;
	u32int length;
	void *parsed;
	void (*print)(Otfile *f, int indent, Otf *o, void *parsed);
};

int read_TableRecord(Otf *o, TableRecord *v);
void print_TableRecord(Otfile *f, int indent, Otf *o, TableRecord *v);

struct TableDirectory {
	u32int sfntVersion;
	u16int numTables;
	u16int searchRange;
	u16int entrySelector;
	u16int rangeShift;
	TableRecord *tableRecords;
	TableCmap *cmap;
	TableHead *head;
	TableHhea *hhea;
	TableMaxp *maxp;
	TableHmtx *hmtx;
	TablePost *post;
	TableName *name;
	TableEBDT *ebdt;
	TableEBLC *eblc;
	TableGDEF *gdef;
	TableGPOS *gpos;
	TableGSUB *gsub;
	TableMATH *math;
	TableKern *kern;
	TableLoca *loca;
	TableFvar *fvar;
	TableHVAR *hvar;
	TableFFTM *fftm;
	TableDSIG *dsig;
	TableSTAT *stat;
	TableGasp *gasp;
	TableGvar *gvar;
	TableAvar *avar;
	TableOS∕2 *os∕2;
};

int read_TableDirectory(Otf *o, TableDirectory *v);
void print_TableDirectory(Otfile *f, int indent, Otf *o, TableDirectory *v);