text: /*
       File:       SFNTLayoutTypes.h
   
       Contains:   SFNT file layout structures and constants.
   
       Version:    QuickTime 7.3
   
       Copyright:  (c) 2007 (c) 1994-2001 by Apple Computer, Inc., all rights reserved.
   
       Bugs?:      For bug reports, consult the following page on
                   the World Wide Web:
   
                       http://developer.apple.com/bugreporter/
   
  */
  #ifndef __SFNTLAYOUTTYPES__
  #define __SFNTLAYOUTTYPES__
  
  #ifndef __MACTYPES__
  #include <MacTypes.h>
  #endif
  
  
  
  #if PRAGMA_ONCE
  #pragma once
  #endif
  
  #if PRAGMA_IMPORT
  #pragma import on
  #endif
  
  #if PRAGMA_STRUCT_ALIGN
      #pragma options align=mac68k
  #elif PRAGMA_STRUCT_PACKPUSH
      #pragma pack(push, 2)
  #elif PRAGMA_STRUCT_PACK
      #pragma pack(2)
  #endif
  
  /* ----------------------------------------------------------------------------------------- */
  /* CONSTANTS */
  /*
      The following values can be used to set run feature values. Note that unless the
      feature is defaulted differently in different fonts, the zero value for the
      selectors represents the default value.  Check the following URL site for further info:
      "http://fonts.apple.com/Registry"
  */
  
  
  /*
   *  Summary:
   *    Feature types
   */
  enum {
    kAllTypographicFeaturesType   = 0,
    kLigaturesType                = 1,
    kCursiveConnectionType        = 2,
    kLetterCaseType               = 3,
    kVerticalSubstitutionType     = 4,
    kLinguisticRearrangementType  = 5,
    kNumberSpacingType            = 6,
    kSmartSwashType               = 8,
    kDiacriticsType               = 9,
    kVerticalPositionType         = 10,
    kFractionsType                = 11,
    kOverlappingCharactersType    = 13,
    kTypographicExtrasType        = 14,
    kMathematicalExtrasType       = 15,
    kOrnamentSetsType             = 16,
    kCharacterAlternativesType    = 17,
    kDesignComplexityType         = 18,
    kStyleOptionsType             = 19,
    kCharacterShapeType           = 20,
    kNumberCaseType               = 21,
    kTextSpacingType              = 22,
    kTransliterationType          = 23,
    kAnnotationType               = 24,
    kKanaSpacingType              = 25,
    kIdeographicSpacingType       = 26,
    kUnicodeDecompositionType     = 27,
    kRubyKanaType                 = 28,
    kCJKSymbolAlternativesType    = 29,
    kIdeographicAlternativesType  = 30,
    kCJKVerticalRomanPlacementType = 31,
    kItalicCJKRomanType           = 32,
    kCJKRomanSpacingType          = 103,
    kLastFeatureType              = -1
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kAllTypographicFeaturesType
   */
  enum {
    kAllTypeFeaturesOnSelector    = 0,
    kAllTypeFeaturesOffSelector   = 1
  };
  
  
  
  /*
   *  Summary:
   *    Selectors for feature type kLigaturesType
   */
  enum {
    kRequiredLigaturesOnSelector  = 0,
    kRequiredLigaturesOffSelector = 1,
    kCommonLigaturesOnSelector    = 2,
    kCommonLigaturesOffSelector   = 3,
    kRareLigaturesOnSelector      = 4,
    kRareLigaturesOffSelector     = 5,
    kLogosOnSelector              = 6,
    kLogosOffSelector             = 7,
    kRebusPicturesOnSelector      = 8,
    kRebusPicturesOffSelector     = 9,
    kDiphthongLigaturesOnSelector = 10,
    kDiphthongLigaturesOffSelector = 11,
    kSquaredLigaturesOnSelector   = 12,
    kSquaredLigaturesOffSelector  = 13,
    kAbbrevSquaredLigaturesOnSelector = 14,
    kAbbrevSquaredLigaturesOffSelector = 15,
    kSymbolLigaturesOnSelector    = 16,
    kSymbolLigaturesOffSelector   = 17
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kCursiveConnectionType
   */
  enum {
    kUnconnectedSelector          = 0,
    kPartiallyConnectedSelector   = 1,
    kCursiveSelector              = 2
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kLetterCaseType
   */
  enum {
    kUpperAndLowerCaseSelector    = 0,
    kAllCapsSelector              = 1,
    kAllLowerCaseSelector         = 2,
    kSmallCapsSelector            = 3,
    kInitialCapsSelector          = 4,
    kInitialCapsAndSmallCapsSelector = 5
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kVerticalSubstitutionType
   */
  enum {
    kSubstituteVerticalFormsOnSelector = 0,
    kSubstituteVerticalFormsOffSelector = 1
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kLinguisticRearrangementType
   */
  enum {
    kLinguisticRearrangementOnSelector = 0,
    kLinguisticRearrangementOffSelector = 1
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kNumberSpacingType
   */
  enum {
    kMonospacedNumbersSelector    = 0,
    kProportionalNumbersSelector  = 1,
    kThirdWidthNumbersSelector    = 2,
    kQuarterWidthNumbersSelector  = 3
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kSmartSwashType
   */
  enum {
    kWordInitialSwashesOnSelector = 0,
    kWordInitialSwashesOffSelector = 1,
    kWordFinalSwashesOnSelector   = 2,
    kWordFinalSwashesOffSelector  = 3,
    kLineInitialSwashesOnSelector = 4,
    kLineInitialSwashesOffSelector = 5,
    kLineFinalSwashesOnSelector   = 6,
    kLineFinalSwashesOffSelector  = 7,
    kNonFinalSwashesOnSelector    = 8,
    kNonFinalSwashesOffSelector   = 9
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kDiacriticsType
   */
  enum {
    kShowDiacriticsSelector       = 0,
    kHideDiacriticsSelector       = 1,
    kDecomposeDiacriticsSelector  = 2
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kVerticalPositionType
   */
  enum {
    kNormalPositionSelector       = 0,
    kSuperiorsSelector            = 1,
    kInferiorsSelector            = 2,
    kOrdinalsSelector             = 3
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kFractionsType
   */
  enum {
    kNoFractionsSelector          = 0,
    kVerticalFractionsSelector    = 1,
    kDiagonalFractionsSelector    = 2
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kOverlappingCharactersType
   */
  enum {
    kPreventOverlapOnSelector     = 0,
    kPreventOverlapOffSelector    = 1
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kTypographicExtrasType
   */
  enum {
    kHyphensToEmDashOnSelector    = 0,
    kHyphensToEmDashOffSelector   = 1,
    kHyphenToEnDashOnSelector     = 2,
    kHyphenToEnDashOffSelector    = 3,
    kSlashedZeroOnSelector        = 4,
    kSlashedZeroOffSelector       = 5,
    kFormInterrobangOnSelector    = 6,
    kFormInterrobangOffSelector   = 7,
    kSmartQuotesOnSelector        = 8,
    kSmartQuotesOffSelector       = 9,
    kPeriodsToEllipsisOnSelector  = 10,
    kPeriodsToEllipsisOffSelector = 11
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kMathematicalExtrasType
   */
  enum {
    kHyphenToMinusOnSelector      = 0,
    kHyphenToMinusOffSelector     = 1,
    kAsteriskToMultiplyOnSelector = 2,
    kAsteriskToMultiplyOffSelector = 3,
    kSlashToDivideOnSelector      = 4,
    kSlashToDivideOffSelector     = 5,
    kInequalityLigaturesOnSelector = 6,
    kInequalityLigaturesOffSelector = 7,
    kExponentsOnSelector          = 8,
    kExponentsOffSelector         = 9
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kOrnamentSetsType
   */
  enum {
    kNoOrnamentsSelector          = 0,
    kDingbatsSelector             = 1,
    kPiCharactersSelector         = 2,
    kFleuronsSelector             = 3,
    kDecorativeBordersSelector    = 4,
    kInternationalSymbolsSelector = 5,
    kMathSymbolsSelector          = 6
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kCharacterAlternativesType
   */
  enum {
    kNoAlternatesSelector         = 0
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kDesignComplexityType
   */
  enum {
    kDesignLevel1Selector         = 0,
    kDesignLevel2Selector         = 1,
    kDesignLevel3Selector         = 2,
    kDesignLevel4Selector         = 3,
    kDesignLevel5Selector         = 4
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kStyleOptionsType
   */
  enum {
    kNoStyleOptionsSelector       = 0,
    kDisplayTextSelector          = 1,
    kEngravedTextSelector         = 2,
    kIlluminatedCapsSelector      = 3,
    kTitlingCapsSelector          = 4,
    kTallCapsSelector             = 5
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kCharacterShapeType
   */
  enum {
    kTraditionalCharactersSelector = 0,
    kSimplifiedCharactersSelector = 1,
    kJIS1978CharactersSelector    = 2,
    kJIS1983CharactersSelector    = 3,
    kJIS1990CharactersSelector    = 4,
    kTraditionalAltOneSelector    = 5,
    kTraditionalAltTwoSelector    = 6,
    kTraditionalAltThreeSelector  = 7,
    kTraditionalAltFourSelector   = 8,
    kTraditionalAltFiveSelector   = 9,
    kExpertCharactersSelector     = 10
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kNumberCaseType
   */
  enum {
    kLowerCaseNumbersSelector     = 0,
    kUpperCaseNumbersSelector     = 1
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kTextSpacingType
   */
  enum {
    kProportionalTextSelector     = 0,
    kMonospacedTextSelector       = 1,
    kHalfWidthTextSelector        = 2
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kTransliterationType
   */
  enum {
    kNoTransliterationSelector    = 0,
    kHanjaToHangulSelector        = 1,
    kHiraganaToKatakanaSelector   = 2,
    kKatakanaToHiraganaSelector   = 3,
    kKanaToRomanizationSelector   = 4,
    kRomanizationToHiraganaSelector = 5,
    kRomanizationToKatakanaSelector = 6,
    kHanjaToHangulAltOneSelector  = 7,
    kHanjaToHangulAltTwoSelector  = 8,
    kHanjaToHangulAltThreeSelector = 9
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kAnnotationType
   */
  enum {
    kNoAnnotationSelector         = 0,
    kBoxAnnotationSelector        = 1,
    kRoundedBoxAnnotationSelector = 2,
    kCircleAnnotationSelector     = 3,
    kInvertedCircleAnnotationSelector = 4,
    kParenthesisAnnotationSelector = 5,
    kPeriodAnnotationSelector     = 6,
    kRomanNumeralAnnotationSelector = 7,
    kDiamondAnnotationSelector    = 8,
    kInvertedBoxAnnotationSelector = 9,
    kInvertedRoundedBoxAnnotationSelector = 10
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kKanaSpacingType
   */
  enum {
    kFullWidthKanaSelector        = 0,
    kProportionalKanaSelector     = 1
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kIdeographicSpacingType
   */
  enum {
    kFullWidthIdeographsSelector  = 0,
    kProportionalIdeographsSelector = 1,
    kHalfWidthIdeographsSelector  = 2
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kUnicodeDecompositionType
   */
  enum {
    kCanonicalCompositionOnSelector = 0,
    kCanonicalCompositionOffSelector = 1,
    kCompatibilityCompositionOnSelector = 2,
    kCompatibilityCompositionOffSelector = 3,
    kTranscodingCompositionOnSelector = 4,
    kTranscodingCompositionOffSelector = 5
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kRubyKanaType
   */
  enum {
    kNoRubyKanaSelector           = 0,
    kRubyKanaSelector             = 1
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kCJKSymbolAlternativesType
   */
  enum {
    kNoCJKSymbolAlternativesSelector = 0,
    kCJKSymbolAltOneSelector      = 1,
    kCJKSymbolAltTwoSelector      = 2,
    kCJKSymbolAltThreeSelector    = 3,
    kCJKSymbolAltFourSelector     = 4,
    kCJKSymbolAltFiveSelector     = 5
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kIdeographicAlternativesType
   */
  enum {
    kNoIdeographicAlternativesSelector = 0,
    kIdeographicAltOneSelector    = 1,
    kIdeographicAltTwoSelector    = 2,
    kIdeographicAltThreeSelector  = 3,
    kIdeographicAltFourSelector   = 4,
    kIdeographicAltFiveSelector   = 5
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kCJKVerticalRomanPlacementType
   */
  enum {
    kCJKVerticalRomanCenteredSelector = 0,
    kCJKVerticalRomanHBaselineSelector = 1
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kItalicCJKRomanType
   */
  enum {
    kNoCJKItalicRomanSelector     = 0,
    kCJKItalicRomanSelector       = 1
  };
  
  
  /*
   *  Summary:
   *    Selectors for feature type kCJKRomanSpacingType
   */
  enum {
    kHalfWidthCJKRomanSelector    = 0,
    kProportionalCJKRomanSelector = 1,
    kDefaultCJKRomanSelector      = 2,
    kFullWidthCJKRomanSelector    = 3
  };
  
  /* --------------------------------------------------------------------------- */
  /* ---------------- Table Specific Typedefs and Constants -------------------- */
  /* --------------------------------------------------------------------------- */
  /* FORMATS FOR TABLE: lookup tables - used within various other tables */
  enum {
    kSFNTLookupSimpleArray        = 0,    /* a simple array indexed by glyph code */
    kSFNTLookupSegmentSingle      = 2,    /* segment mapping to single value */
    kSFNTLookupSegmentArray       = 4,    /* segment mapping to lookup array */
    kSFNTLookupSingleTable        = 6,    /* sorted list of glyph, value pairs */
    kSFNTLookupTrimmedArray       = 8     /* a simple trimmed array indexed by glyph code */
  };
  
  typedef UInt16                          SFNTLookupTableFormat;
  typedef UInt16                          SFNTLookupValue;
  typedef UInt16                          SFNTLookupOffset;
  typedef UInt32                          SFNTLookupKind;
  /*
      A BinarySearchHeader defines the five standard fields needed to perform quick
      lookups in a lookup table (note that using UInt16s, and not ItemCounts or
      similar types, is important here, since these tables are in fonts, and the
      documented font formats specify 16-bit quantities).
  */
  struct SFNTLookupBinarySearchHeader {
    UInt16              unitSize;               /* size of a unit in bytes */
    UInt16              nUnits;                 /* number of units in table */
    UInt16              searchRange;            /* (largest power of two <= nUnits) * unitSize */
    UInt16              entrySelector;          /* log2 (largest power of two <= nUnits) */
    UInt16              rangeShift;             /* (nUnits - largest power of two <= nUnits) * unitSize */
  };
  typedef struct SFNTLookupBinarySearchHeader SFNTLookupBinarySearchHeader;
  /* A format 0 lookup table maps all glyphs in the font to lookup values */
  struct SFNTLookupArrayHeader {
    SFNTLookupValue     lookupValues[1];
  };
  typedef struct SFNTLookupArrayHeader    SFNTLookupArrayHeader;
  /* A format 8 lookup table maps some range of glyphs in the font to lookup values */
  struct SFNTLookupTrimmedArrayHeader {
    UInt16              firstGlyph;
    UInt16              count;
    SFNTLookupValue     valueArray[1];
  };
  typedef struct SFNTLookupTrimmedArrayHeader SFNTLookupTrimmedArrayHeader;
  /*
      Format 2 and format 4 lookup tables map ranges of glyphs to either single lookup
      values (format 2), or per-glyph lookup values (format 4). Since both formats
      use the same kind of data, only one unified set of segment-related structures
      is defined.
  */
  struct SFNTLookupSegment {
    UInt16              lastGlyph;
    UInt16              firstGlyph;
    UInt16              value[1];
  };
  typedef struct SFNTLookupSegment        SFNTLookupSegment;
  struct SFNTLookupSegmentHeader {
    SFNTLookupBinarySearchHeader  binSearch;
    SFNTLookupSegment   segments[1];
  };
  typedef struct SFNTLookupSegmentHeader  SFNTLookupSegmentHeader;
  /* A format 6 lookup table maps single glyphs to lookup values. */
  struct SFNTLookupSingle {
    UInt16              glyph;
    UInt16              value[1];
  };
  typedef struct SFNTLookupSingle         SFNTLookupSingle;
  struct SFNTLookupSingleHeader {
    SFNTLookupBinarySearchHeader  binSearch;
    SFNTLookupSingle    entries[1];
  };
  typedef struct SFNTLookupSingleHeader   SFNTLookupSingleHeader;
  /* The format-specific part of the subtable header */
  union SFNTLookupFormatSpecificHeader {
    SFNTLookupArrayHeader  theArray;
    SFNTLookupSegmentHeader  segment;
    SFNTLookupSingleHeader  single;
    SFNTLookupTrimmedArrayHeader  trimmedArray;
  };
  typedef union SFNTLookupFormatSpecificHeader SFNTLookupFormatSpecificHeader;
  /* The overall subtable header */
  struct SFNTLookupTable {
    SFNTLookupTableFormat  format;              /* table format */
    SFNTLookupFormatSpecificHeader  fsHeader;   /* format specific header */
  };
  typedef struct SFNTLookupTable          SFNTLookupTable;
  typedef SFNTLookupTable *               SFNTLookupTablePtr;
  typedef SFNTLookupTablePtr *            SFNTLookupTableHandle;
  /* --------------------------------------------------------------------------- */
  /* GENERAL FORMATS FOR STATE TABLES -- prefix "ST" */
  enum {
    kSTClassEndOfText             = 0,
    kSTClassOutOfBounds           = 1,
    kSTClassDeletedGlyph          = 2,
    kSTClassEndOfLine             = 3,
    kSTSetMark                    = 0x8000,
    kSTNoAdvance                  = 0x4000,
    kSTMarkEnd                    = 0x2000,
    kSTLigActionMask              = 0x3FFF,
    kSTRearrVerbMask              = 0x000F
  };
  
  typedef UInt8                           STClass;
  typedef UInt8                           STEntryIndex;
  struct STHeader {
    UInt8               filler;
    STClass             nClasses;
    UInt16              classTableOffset;
    UInt16              stateArrayOffset;
    UInt16              entryTableOffset;
  };
  typedef struct STHeader                 STHeader;
  struct STClassTable {
    UInt16              firstGlyph;
    UInt16              nGlyphs;
    STClass             classes[1];
  };
  typedef struct STClassTable             STClassTable;
  struct STEntryZero {
    UInt16              newState;
    UInt16              flags;
  };
  typedef struct STEntryZero              STEntryZero;
  struct STEntryOne {
    UInt16              newState;
    UInt16              flags;
    UInt16              offset1;
  };
  typedef struct STEntryOne               STEntryOne;
  struct STEntryTwo {
    UInt16              newState;
    UInt16              flags;
    UInt16              offset1;
    UInt16              offset2;
  };
  typedef struct STEntryTwo               STEntryTwo;
  /* --------------------------------------------------------------------------- */
  /* GENERAL FORMATS FOR STATE TABLES to be used with 'morx' tables -- prefix "STX" */
  enum {
    kSTXHasLigAction              = 0x2000
  };
  
  
  typedef UInt16                          STXClass;
  typedef UInt16                          STXStateIndex;
  typedef UInt16                          STXEntryIndex;
  struct STXHeader {
    UInt32              nClasses;
    UInt32              classTableOffset;
    UInt32              stateArrayOffset;
    UInt32              entryTableOffset;
  };
  typedef struct STXHeader                STXHeader;
  
  typedef SFNTLookupTable                 STXClassTable;
  struct STXEntryZero {
    STXStateIndex       newState;
    UInt16              flags;
  };
  typedef struct STXEntryZero             STXEntryZero;
  struct STXEntryOne {
    STXStateIndex       newState;
    UInt16              flags;
    UInt16              index1;
  };
  typedef struct STXEntryOne              STXEntryOne;
  struct STXEntryTwo {
    STXStateIndex       newState;
    UInt16              flags;
    UInt16              index1;
    UInt16              index2;
  };
  typedef struct STXEntryTwo              STXEntryTwo;
  /* --------------------------------------------------------------------------- */
  /* FORMATS FOR TABLE: 'lcar' */
  /* CONSTANTS */
  enum {
    kLCARTag                      = 0x6C636172, /* 'lcar' */
    kLCARCurrentVersion           = 0x00010000, /* current version number for 'lcar' table */
    kLCARLinearFormat             = 0,
    kLCARCtlPointFormat           = 1
  };
  
  /* TYPES */
  struct LcarCaretClassEntry {
    UInt16              count;
    UInt16              partials[1];            /* these are either FUnits or control-point numbers */
  };
  typedef struct LcarCaretClassEntry      LcarCaretClassEntry;
  struct LcarCaretTable {
    Fixed               version;
    UInt16              format;
    SFNTLookupTable     lookup;
  };
  typedef struct LcarCaretTable           LcarCaretTable;
  typedef LcarCaretTable *                LcarCaretTablePtr;
  /* --------------------------------------------------------------------------- */
  /* FORMATS FOR TABLE: 'just' */
  /* CONSTANTS */
  enum {
    kJUSTTag                      = 0x6A757374, /* 'just' */
    kJUSTCurrentVersion           = 0x00010000,
    kJUSTStandardFormat           = 0,
    kJUSTnoGlyphcode              = 0xFFFF, /* used in a pcConditionalAddAction */
    kJUSTpcDecompositionAction    = 0,
    kJUSTpcUnconditionalAddAction = 1,
    kJUSTpcConditionalAddAction   = 2,
    kJUSTpcGlyphStretchAction     = 3,
    kJUSTpcDuctilityAction        = 4,
    kJUSTpcGlyphRepeatAddAction   = 5
  };
  
  /* Justification priority levels */
  enum {
    kJUSTKashidaPriority          = 0,
    kJUSTSpacePriority            = 1,
    kJUSTLetterPriority           = 2,
    kJUSTNullPriority             = 3,
    kJUSTPriorityCount            = 4
  };
  
  /* Justification flags */
  enum {
    kJUSTOverridePriority         = 0x8000,
    kJUSTOverrideLimits           = 0x4000,
    kJUSTOverrideUnlimited        = 0x2000,
    kJUSTUnlimited                = 0x1000,
    kJUSTPriorityMask             = 0x0003
  };
  
  /* TYPES */
  typedef UInt16                          JustPCActionType;
  typedef UInt16                          JustificationFlags;
  /* A JustPCDecompositionAction defines a ligature decomposition action. */
  struct JustPCDecompositionAction {
    Fixed               lowerLimit;
    Fixed               upperLimit;
    UInt16              order;
    UInt16              count;
    UInt16              glyphs[1];
  };
  typedef struct JustPCDecompositionAction JustPCDecompositionAction;
  /* A JUSTPCUnconditionalAddAction defines an unconditional glyph add action. */
  
  typedef UInt16                          JustPCUnconditionalAddAction;
  /*
      A JUSTPCConditionalAddAction defines a glyph substitution and add action. If the addGlyph
      is equal to kJUSTnoGlyphcode, then no glyph will be added, and the justification for
      the line will be redone.
  */
  struct JustPCConditionalAddAction {
    Fixed               substThreshhold;        /* threshhold of growth factor at which subst occurs */
    UInt16              addGlyph;
    UInt16              substGlyph;
  };
  typedef struct JustPCConditionalAddAction JustPCConditionalAddAction;
  /* A PCDuctilityAction defines a ductile axis along which the glyph will be varied. */
  struct JustPCDuctilityAction {
    UInt32              ductilityAxis;
    Fixed               minimumLimit;
    Fixed               noStretchValue;
    Fixed               maximumLimit;
  };
  typedef struct JustPCDuctilityAction    JustPCDuctilityAction;
  /*
      A PCGlyphRepetitionAction defines a glyph which will not be stretched or otherwise
      transformed, but rather which will be emplaced however many times are needed to fill
      the needed gap.
  */
  struct JustPCGlyphRepeatAddAction {
    UInt16              flags;
    UInt16              glyph;
  };
  typedef struct JustPCGlyphRepeatAddAction JustPCGlyphRepeatAddAction;
  /* PCActionSubrecords contain the actual postcompensation actions. */
  struct JustPCActionSubrecord {
    UInt16              theClass;               /* justification class value associated with this rec */
    JustPCActionType    theType;
    UInt32              length;
    UInt32              data;                   /* not really a UInt32; cast as ptr to appropriate action */
  };
  typedef struct JustPCActionSubrecord    JustPCActionSubrecord;
  /* The set of postcompensation records is defined in a PCAction struct. */
  struct JustPCAction {
    UInt32              actionCount;            /* long for alignment purposes */
    JustPCActionSubrecord  actions[1];
  };
  typedef struct JustPCAction             JustPCAction;
  /*
      JustWidthDeltaEntry is the justification table entry structure.  The justClass value (which is
      actually limited to 7 bits by the state table structure) is defined as a long for PPC alignment reasons.
  */
  struct JustWidthDeltaEntry {
    UInt32              justClass;
    Fixed               beforeGrowLimit;        /* ems AW can grow by at most on LT */
    Fixed               beforeShrinkLimit;      /* ems AW can shrink by at most on LT */
    Fixed               afterGrowLimit;         /* ems AW can grow by at most on RB */
    Fixed               afterShrinkLimit;       /* ems AW can shrink by at most on RB */
    JustificationFlags  growFlags;              /* flags controlling grow case */
    JustificationFlags  shrinkFlags;            /* flags controlling shrink case */
  };
  typedef struct JustWidthDeltaEntry      JustWidthDeltaEntry;
  struct JustWidthDeltaGroup {
    UInt32              count;
    JustWidthDeltaEntry  entries[1];
  };
  typedef struct JustWidthDeltaGroup      JustWidthDeltaGroup;
  /* Overall structure of a postcompensation table is defined in PostcompTable. */
  struct JustPostcompTable {
    SFNTLookupTable     lookupTable;
                                                /* action records here */
  };
  typedef struct JustPostcompTable        JustPostcompTable;
  struct JustDirectionTable {
    UInt16              justClass;              /* offset to state table (0=none) */
    UInt16              widthDeltaClusters;     /* offset to clusters */
    UInt16              postcomp;               /* offset to postcomp table (0=none) */
    SFNTLookupTable     lookup;
  };
  typedef struct JustDirectionTable       JustDirectionTable;
  struct JustTable {
    Fixed               version;
    UInt16              format;
    UInt16              horizHeaderOffset;
    UInt16              vertHeaderOffset;
  };
  typedef struct JustTable                JustTable;
  /* --------------------------------------------------------------------------- */
  /* FORMATS FOR TABLE: 'opbd' */
  /* CONSTANTS */
  enum {
    kOPBDTag                      = 0x6F706264, /* 'opbd' */
    kOPBDCurrentVersion           = 0x00010000,
    kOPBDDistanceFormat           = 0,
    kOPBDControlPointFormat       = 1
  };
  
  /* TYPES */
  
  typedef UInt16                          OpbdTableFormat;
  /*
      The OpbdSideValues struct is the lookup result from the FindSingle call for the
      optical tables. It contains the 4 FUnit values that are relevant to the specified
      glyph, or the 4 control gxPoint values.
  */
  struct OpbdSideValues {
    SInt16              leftSideShift;
    SInt16              topSideShift;
    SInt16              rightSideShift;
    SInt16              bottomSideShift;
  };
  typedef struct OpbdSideValues           OpbdSideValues;
  struct OpbdTable {
    Fixed               version;
    OpbdTableFormat     format;
    SFNTLookupTable     lookupTable;
  };
  typedef struct OpbdTable                OpbdTable;
  /* --------------------------------------------------------------------------- */
  /* FORMATS FOR TABLE: 'mort' */
  /* CONSTANTS */
  enum {
    kMORTTag                      = 0x6D6F7274, /* 'mort' */
    kMORTCurrentVersion           = 0x00010000, /* current version number for 'mort' table */
                                          /* Coverage masks */
    kMORTCoverVertical            = 0x8000,
    kMORTCoverDescending          = 0x4000,
    kMORTCoverIgnoreVertical      = 0x2000,
    kMORTCoverTypeMask            = 0x000F, /* Subtable types */
    kMORTRearrangementType        = 0,
    kMORTContextualType           = 1,
    kMORTLigatureType             = 2,
    kMORTSwashType                = 4,
    kMORTInsertionType            = 5,    /* Ligature subtable constants */
    kMORTLigLastAction            = (long)0x80000000,
    kMORTLigStoreLigature         = 0x40000000,
    kMORTLigFormOffsetMask        = 0x3FFFFFFF,
    kMORTLigFormOffsetShift       = 2,    /* Rearrangement subtable actions */
    kMORTraNoAction               = 0,    /*    no action   */
    kMORTraxA                     = 1,    /*      Ax => xA    */
    kMORTraDx                     = 2,    /*      xD => Dx    */
    kMORTraDxA                    = 3,    /*     AxD => DxA   */
    kMORTraxAB                    = 4,    /*   ABx => xAB   */
    kMORTraxBA                    = 5,    /*   ABx => xBA   */
    kMORTraCDx                    = 6,    /*   xCD => CDx   */
    kMORTraDCx                    = 7,    /*   xCD => DCx   */
    kMORTraCDxA                   = 8,    /*  AxCD => CDxA  */
    kMORTraDCxA                   = 9,    /*  AxCD => DCxA  */
    kMORTraDxAB                   = 10,   /*  ABxD => DxAB  */
    kMORTraDxBA                   = 11,   /*  ABxD => DxBA  */
    kMORTraCDxAB                  = 12,   /* ABxCD => CDxAB */
    kMORTraCDxBA                  = 13,   /* ABxCD => CDxBA */
    kMORTraDCxAB                  = 14,   /* ABxCD => DCxAB */
    kMORTraDCxBA                  = 15,   /* ABxCD => DCxBA */
                                          /* Insertion subtable constants */
    kMORTDoInsertionsBefore       = 0x80,
    kMORTIsSplitVowelPiece        = 0x40,
    kMORTInsertionsCountMask      = 0x3F,
    kMORTCurrInsertKashidaLike    = 0x2000,
    kMORTMarkInsertKashidaLike    = 0x1000,
    kMORTCurrInsertBefore         = 0x0800,
    kMORTMarkInsertBefore         = 0x0400,
    kMORTMarkJustTableCountMask   = 0x3F80,
    kMORTMarkJustTableCountShift  = 7,    /* JustTableIndex for marked character */
    kMORTCurrJustTableCountMask   = 0x007F,
    kMORTCurrJustTableCountShift  = 0,    /* JustTableIndex for current character */
    kMORTCurrInsertCountMask      = 0x03E0,
    kMORTCurrInsertCountShift     = 5,    /* count to insert after current glyphRec */
    kMORTMarkInsertCountMask      = 0x001F,
    kMORTMarkInsertCountShift     = 0     /* count to insert after marked glyphRec */
  };
  
  /* TYPES */
  
  typedef UInt32                          MortSubtableMaskFlags;
  typedef UInt32                          MortLigatureActionEntry;
  struct MortRearrangementSubtable {
    STHeader            header;
  };
  typedef struct MortRearrangementSubtable MortRearrangementSubtable;
  struct MortContextualSubtable {
    STHeader            header;
    UInt16              substitutionTableOffset;
  };
  typedef struct MortContextualSubtable   MortContextualSubtable;
  struct MortLigatureSubtable {
    STHeader            header;
    UInt16              ligatureActionTableOffset;
    UInt16              componentTableOffset;
    UInt16              ligatureTableOffset;
  };
  typedef struct MortLigatureSubtable     MortLigatureSubtable;
  struct MortSwashSubtable {
    SFNTLookupTable     lookup;
  };
  typedef struct MortSwashSubtable        MortSwashSubtable;
  struct MortInsertionSubtable {
    STHeader            header;
  };
  typedef struct MortInsertionSubtable    MortInsertionSubtable;
  union MortSpecificSubtable {
    MortRearrangementSubtable  rearrangement;
    MortContextualSubtable  contextual;
    MortLigatureSubtable  ligature;
    MortSwashSubtable   swash;
    MortInsertionSubtable  insertion;
  };
  typedef union MortSpecificSubtable      MortSpecificSubtable;
  struct MortSubtable {
    UInt16              length;
    UInt16              coverage;
    MortSubtableMaskFlags  flags;
    MortSpecificSubtable  u;
  };
  typedef struct MortSubtable             MortSubtable;
  struct MortFeatureEntry {
    UInt16              featureType;
    UInt16              featureSelector;
    MortSubtableMaskFlags  enableFlags;
    MortSubtableMaskFlags  disableFlags;
  };
  typedef struct MortFeatureEntry         MortFeatureEntry;
  struct MortChain {
    MortSubtableMaskFlags  defaultFlags;        /* default flags for this chain */
    UInt32              length;                 /* byte length of this chain */
    UInt16              nFeatures;              /* number of feature entries */
    UInt16              nSubtables;             /* number of subtables */
    MortFeatureEntry    featureEntries[1];
                                                /* the subtables follow */
  };
  typedef struct MortChain                MortChain;
  struct MortTable {
    Fixed               version;
    UInt32              nChains;
    MortChain           chains[1];
  };
  typedef struct MortTable                MortTable;
  /* --------------------------------------------------------------------------- */
  /* FORMATS FOR TABLE: 'morx' (version 2 and beyond metamorphosis tables) */
  /* CONSTANTS */
  enum {
    kMORXTag                      = 0x6D6F7278, /* 'morx' */
    kMORXCurrentVersion           = 0x00020000, /* version number for current 'morx' table */
                                          /* Coverage masks */
    kMORXCoverVertical            = (long)0x80000000,
    kMORXCoverDescending          = 0x40000000,
    kMORXCoverIgnoreVertical      = 0x20000000,
    kMORXCoverTypeMask            = 0x000000FF
  };
  
  /* TYPES */
  struct MorxRearrangementSubtable {
    STXHeader           header;
  };
  typedef struct MorxRearrangementSubtable MorxRearrangementSubtable;
  struct MorxContextualSubtable {
    STXHeader           header;
    UInt32              substitutionTableOffset;
  };
  typedef struct MorxContextualSubtable   MorxContextualSubtable;
  struct MorxLigatureSubtable {
    STXHeader           header;
    UInt32              ligatureActionTableOffset;
    UInt32              componentTableOffset;
    UInt32              ligatureTableOffset;
  };
  typedef struct MorxLigatureSubtable     MorxLigatureSubtable;
  struct MorxInsertionSubtable {
    STXHeader           header;
    UInt32              insertionGlyphTableOffset;
  };
  typedef struct MorxInsertionSubtable    MorxInsertionSubtable;
  union MorxSpecificSubtable {
    MorxRearrangementSubtable  rearrangement;
    MorxContextualSubtable  contextual;
    MorxLigatureSubtable  ligature;
    MortSwashSubtable   swash;
    MorxInsertionSubtable  insertion;
  };
  typedef union MorxSpecificSubtable      MorxSpecificSubtable;
  struct MorxSubtable {
    UInt32              length;
    UInt32              coverage;
    MortSubtableMaskFlags  flags;
    MorxSpecificSubtable  u;
  };
  typedef struct MorxSubtable             MorxSubtable;
  struct MorxChain {
    MortSubtableMaskFlags  defaultFlags;        /* default flags for this chain */
    UInt32              length;                 /* byte length of this chain */
    UInt32              nFeatures;              /* number of feature entries */
    UInt32              nSubtables;             /* number of subtables */
    MortFeatureEntry    featureEntries[1];
                                                /* the subtables follow */
  };
  typedef struct MorxChain                MorxChain;
  struct MorxTable {
    Fixed               version;
    UInt32              nChains;
    MorxChain           chains[1];
  };
  typedef struct MorxTable                MorxTable;
  /* --------------------------------------------------------------------------- */
  /* FORMATS FOR TABLE: 'prop' */
  /* CONSTANTS */
  enum {
    kPROPTag                      = 0x70726F70, /* 'prop' */
    kPROPCurrentVersion           = 0x00030000, /* current version number for 'prop' table */
    kPROPPairOffsetShift          = 8,
    kPROPPairOffsetSign           = 7,
    kPROPIsFloaterMask            = 0x8000, /* glyph is floater */
    kPROPCanHangLTMask            = 0x4000, /* glyph can hang left/top */
    kPROPCanHangRBMask            = 0x2000, /* glyph can hang right/bottom */
    kPROPUseRLPairMask            = 0x1000, /* if glyph lands in RL streak, use paired glyph */
    kPROPPairOffsetMask           = 0x0F00, /* 4-bit signed offset to other pair member */
    kPROPRightConnectMask         = 0x0080, /* glyph connects to glyph on right */
    kPROPZeroReserved             = 0x0060, /* must be zero */
    kPROPDirectionMask            = 0x001F /* direction bits */
  };
  
  /* These are the Unicode direction classes (plus the Special European Number class). */
  enum {
    kPROPLDirectionClass          = 0,    /* Left-to-Right */
    kPROPRDirectionClass          = 1,    /* Right-to-Left */
    kPROPALDirectionClass         = 2,    /* Right-to-Left Arabic Letter */
    kPROPENDirectionClass         = 3,    /* European Number */
    kPROPESDirectionClass         = 4,    /* European Number Seperator */
    kPROPETDirectionClass         = 5,    /* European Number Terminator */
    kPROPANDirectionClass         = 6,    /* Arabic Number */
    kPROPCSDirectionClass         = 7,    /* Common Number Seperator */
    kPROPPSDirectionClass         = 8,    /* Paragraph Seperator (also referred to as Block Separator) */
    kPROPSDirectionClass          = 9,    /* Segment Seperator */
    kPROPWSDirectionClass         = 10,   /* Whitespace */
    kPROPONDirectionClass         = 11,   /* Other Neutral */
    kPROPSENDirectionClass        = 12,   /* Special European Number (not a Unicode class) */
    kPROPLREDirectionClass        = 13,   /* Left-to-Right Embeding */
    kPROPLRODirectionClass        = 14,   /* Left-to-Right Override */
    kPROPRLEDirectionClass        = 15,   /* Right-to-Left Embeding */
    kPROPRLODirectionClass        = 16,   /* Right-to-Left Override */
    kPROPPDFDirectionClass        = 17,   /* Pop Directional Format */
    kPROPNSMDirectionClass        = 18,   /* Non-Spacing Mark */
    kPROPBNDirectionClass         = 19,   /* Boundary Neutral */
    kPROPNumDirectionClasses      = 20    /* Number of Unicode directional types + Special European Number */
  };
  
  /* TYPES */
  
  typedef UInt16                          PropCharProperties;
  struct PropTable {
    Fixed               version;
    UInt16              format;
    PropCharProperties  defaultProps;
    SFNTLookupTable     lookup;
  };
  typedef struct PropTable                PropTable;
  struct PropLookupSegment {
    UInt16              lastGlyph;
    UInt16              firstGlyph;
    UInt16              value;
  };
  typedef struct PropLookupSegment        PropLookupSegment;
  struct PropLookupSingle {
    UInt16              glyph;
    PropCharProperties  props;
  };
  typedef struct PropLookupSingle         PropLookupSingle;
  /* --------------------------------------------------------------------------- */
  /* FORMATS FOR TABLE: 'trak' */
  /* CONSTANTS */
  enum {
    kTRAKTag                      = 0x7472616B, /* 'trak' */
    kTRAKCurrentVersion           = 0x00010000, /* current version number for 'trak' table */
    kTRAKUniformFormat            = 0     /*    kTRAKPerGlyphFormat         = 2*/
  };
  
  /* TYPES */
  
  typedef SInt16                          TrakValue;
  struct TrakTableEntry {
    Fixed               track;
    UInt16              nameTableIndex;
    UInt16              sizesOffset;            /* offset to array of TrackingValues */
  };
  typedef struct TrakTableEntry           TrakTableEntry;
  struct TrakTableData {
    UInt16              nTracks;
    UInt16              nSizes;
    UInt32              sizeTableOffset;
    TrakTableEntry      trakTable[1];
  };
  typedef struct TrakTableData            TrakTableData;
  struct TrakTable {
    Fixed               version;
    UInt16              format;
    UInt16              horizOffset;
    UInt16              vertOffset;
  };
  typedef struct TrakTable                TrakTable;
  /* --------------------------------------------------------------------------- */
  /* FORMATS FOR TABLE: 'kern' */
  /* CONSTANTS */
  enum {
    kKERNTag                      = 0x6B65726E, /* 'kern' */
    kKERNCurrentVersion           = 0x00010000,
    kKERNVertical                 = 0x8000, /* set if this table has vertical kerning information */
    kKERNResetCrossStream         = 0x8000, /* this value in a cross-stream table means reset to zero */
    kKERNCrossStream              = 0x4000, /* set if this table contains cross-stream kerning values */
    kKERNVariation                = 0x2000, /* set if this table contains variation kerning values */
    kKERNUnusedBits               = 0x1F00, /* UNUSED, MUST BE ZERO */
    kKERNFormatMask               = 0x00FF /* format of this subtable */
  };
  
  enum {
    kKERNOrderedList              = 0,    /* ordered list of kerning pairs */
    kKERNStateTable               = 1,    /* state table for n-way contextual kerning */
    kKERNSimpleArray              = 2,    /* simple n X m array of kerning values */
    kKERNIndexArray               = 3     /* modifed version of SimpleArray */
  };
  
  /* Message Type Flags */
  enum {
    kKERNLineStart                = 0x00000001, /* Array of glyphs starts a line */
    kKERNLineEndKerning           = 0x00000002, /* Array of glyphs ends a line */
    kKERNNoCrossKerning           = 0x00000004, /* Prohibit cross kerning */
    kKERNNotesRequested           = 0x00000008, /* Caller wants kerning notes */
    kKERNNoStakeNote              = 1,    /* Indicates a glyph was involved in a kerning pair/group */
    kKERNCrossStreamResetNote     = 2,    /* Indicates a return-to-baseline in cross-stream kerning */
    kKERNNotApplied               = 0x00000001 /* All kerning values were zero, kerning call had no effect */
  };
  
  /* TYPES */
  
  typedef UInt8                           KernTableFormat;
  typedef UInt16                          KernSubtableInfo;
  typedef SInt16                          KernKerningValue;
  typedef UInt16                          KernArrayOffset;
  /* header for version 0 kerning table */
  struct KernVersion0Header {
    UInt16              version;                /* font version number (will be 0!) */
    UInt16              nTables;                /* number of subtables present */
    UInt16              firstSubtable[1];       /* first subtable starts here */
  };
  typedef struct KernVersion0Header       KernVersion0Header;
  /* Header for a kerning table */
  struct KernTableHeader {
    Fixed               version;                /* font version number (currently 1.0) */
    SInt32              nTables;                /* number of subtables present */
    UInt16              firstSubtable[1];       /* first subtable starts here */
  };
  typedef struct KernTableHeader          KernTableHeader;
  typedef KernTableHeader *               KernTableHeaderPtr;
  typedef KernTableHeaderPtr *            KernTableHeaderHandle;
  /*
      F O R M A T   S P E C I F I C   D E F I N I T I O N S
  
      kernOrderedList:
      
      The table is a sorted list of [left glyph, right glyph, value] triples.
      There's enough information in the header so that the list can be
      efficiently binary searched. 
  */
  /* defines a single kerning pair of Glyphcodes  */
  struct KernKerningPair {
    UInt16              left;
    UInt16              right;
  };
  typedef struct KernKerningPair          KernKerningPair;
  /* a single list entry */
  struct KernOrderedListEntry {
    KernKerningPair     pair;                   /* the kerning pair */
    KernKerningValue    value;                  /* the kerning value for the above pair */
  };
  typedef struct KernOrderedListEntry     KernOrderedListEntry;
  typedef KernOrderedListEntry *          KernOrderedListEntryPtr;
  /* the header information for binary searching the list */
  struct KernOrderedListHeader {
    UInt16              nPairs;                 /* number of kerning pairs in table */
    UInt16              searchRange;            /* (largest power of two <= nPairs) * entry size */
    UInt16              entrySelector;          /* log2 (largest power of two <= nPairs) */
    UInt16              rangeShift;             /* (nPairs - largest power of two <= nPairs) * entry size */
    UInt16              table[1];               /* entries are first glyph, second glyph, and value */
  };
  typedef struct KernOrderedListHeader    KernOrderedListHeader;
  /* KernStateTable: like the the generic state tables */
  struct KernStateHeader {
    STHeader            header;                 /* state table header */
    UInt16              valueTable;             /* offset to kerning value table */
    UInt8               firstTable[1];          /* first table starts here */
  };
  typedef struct KernStateHeader          KernStateHeader;
  struct KernStateEntry {
    UInt16              newState;
    UInt16              flags;                  /* flags per above enum */
  };
  typedef struct KernStateEntry           KernStateEntry;
  /*
      Kern offset table header.
      The offset table is a trimmed array from firstGlyph to limitGlyph.
      Glyphs outside of this range should get zero for right-hand glyphs
      and the offset of the beginning of the kerning array for left-hand glyphs.
  */
  struct KernOffsetTable {
    UInt16              firstGlyph;             /* first glyph in class range */
    UInt16              nGlyphs;                /* number of glyphs in class range */
    KernArrayOffset     offsetTable[1];         /* offset table starts here */
  };
  typedef struct KernOffsetTable          KernOffsetTable;
  typedef KernOffsetTable *               KernOffsetTablePtr;
  /* Header information for accessing offset tables and kerning array */
  /*
      KernSimpleArray:
      
      The array is an nXm array of kenring values. Each row in the array
      represents one left-hand glyph, and each column one right-hand glyph.
      The zeroth row and column always represent glyphs that are out of bounds
      and will always contain zero.
      
      A pair is looked up by indexing the left-hand glyph through the left
      offset table, the right-hand glyph through the right offset table,
      adding both offsets to the starting address of the kerning array,
      and fetching the kerning value pointed to.
  */
  /* Kern offset table header. */
  /* The offset table is a trimmed array from firstGlyph to limitGlyph. */
  /* Glyphs outside of this range should get zero for right-hand glyphs */
  /* and the offset of the beginning of the kerning array for left- */
  /* hand glyphs. */
  struct KernSimpleArrayHeader {
    UInt16              rowWidth;               /* width, in bytes, of a row in the table */
    UInt16              leftOffsetTable;        /* offset to left-hand offset table */
    UInt16              rightOffsetTable;       /* offset to right-hand offset table */
    KernArrayOffset     theArray;               /* offset to start of kerning array */
    UInt16              firstTable[1];          /* first offset table starts here... */
  };
  typedef struct KernSimpleArrayHeader    KernSimpleArrayHeader;
  /* Index Array */
  struct KernIndexArrayHeader {
    UInt16              glyphCount;
    UInt8               kernValueCount;
    UInt8               leftClassCount;
    UInt8               rightClassCount;
    UInt8               flags;                  /* set to 0 for now */
    SInt16              kernValue[1];           /* actual kerning values reference by index in kernIndex */
    UInt8               leftClass[1];           /* maps left glyph to offset into kern index */
    UInt8               rightClass[1];          /* maps right glyph to offset into kern index */
    UInt8               kernIndex[1];           /* contains indicies into kernValue */
  };
  typedef struct KernIndexArrayHeader     KernIndexArrayHeader;
  /* format specific part of subtable header */
  union KernFormatSpecificHeader {
    KernOrderedListHeader  orderedList;
    KernStateHeader     stateTable;
    KernSimpleArrayHeader  simpleArray;
    KernIndexArrayHeader  indexArray;
  };
  typedef union KernFormatSpecificHeader  KernFormatSpecificHeader;
  /* version 0 subtable header */
  struct KernVersion0SubtableHeader {
    UInt16              version;                /* kerning table version number */
    UInt16              length;                 /* length in bytes (including this header) */
    KernSubtableInfo    stInfo;                 /* sub-table info */
    KernFormatSpecificHeader  fsHeader;         /* format specific sub-header */
  };
  typedef struct KernVersion0SubtableHeader KernVersion0SubtableHeader;
  /* Overall Subtable header format */
  struct KernSubtableHeader {
    SInt32              length;                 /* length in bytes (including this header) */
    KernSubtableInfo    stInfo;                 /* subtable info */
    SInt16              tupleIndex;             /* tuple index for variation subtables */
    KernFormatSpecificHeader  fsHeader;         /* format specific sub-header */
  };
  typedef struct KernSubtableHeader       KernSubtableHeader;
  typedef KernSubtableHeader *            KernSubtableHeaderPtr;
  /* --------------------------------------------------------------------------- */
  /* FORMATS FOR TABLE: 'bsln' */
  /* CONSTANTS */
  enum {
    kBSLNTag                      = 0x62736C6E, /* 'bsln' */
    kBSLNCurrentVersion           = 0x00010000, /* current version number for 'bsln' table */
    kBSLNDistanceFormatNoMap      = 0,
    kBSLNDistanceFormatWithMap    = 1,
    kBSLNControlPointFormatNoMap  = 2,
    kBSLNControlPointFormatWithMap = 3
  };
  
  /* Baseline classes and constants */
  enum {
    kBSLNRomanBaseline            = 0,
    kBSLNIdeographicCenterBaseline = 1,
    kBSLNIdeographicLowBaseline   = 2,
    kBSLNHangingBaseline          = 3,
    kBSLNMathBaseline             = 4,
    kBSLNLastBaseline             = 31,
    kBSLNNumBaselineClasses       = kBSLNLastBaseline + 1,
    kBSLNNoBaselineOverride       = 255
  };
  
  /* TYPES */
  typedef UInt32                          BslnBaselineClass;
  /* The BslnBaselineRecord array defines the baseline deltas for the line. */
  typedef Fixed                           BslnBaselineRecord[32];
  /*
      BslnFormat0Part is the format-specific data for a distance table with no mapping (i.e.
      all the glyphs belong to the defaultBaseline).
  */
  struct BslnFormat0Part {
    SInt16              deltas[32];
  };
  typedef struct BslnFormat0Part          BslnFormat0Part;
  /* BslnFormat1Part is the format-specific data for a distance table with a gxMapping. */
  struct BslnFormat1Part {
    SInt16              deltas[32];
    SFNTLookupTable     mappingData;
  };
  typedef struct BslnFormat1Part          BslnFormat1Part;
  /*
      BslnFormat2Part is the format-specific data for a control-point table with no
      mapping (i.e. all the glyphs belong to the defaultBaseline). It specifies a single
      glyph to use and the set of control points in that glyph that designate each of
      the baselines.
  */
  struct BslnFormat2Part {
    UInt16              stdGlyph;
    SInt16              ctlPoints[32];
  };
  typedef struct BslnFormat2Part          BslnFormat2Part;
  /*
      BslnFormat3Part is the format-specific data for a distance table with a mapping. Like
      format 2, it contains a single glyph and its set of control-point values for each
      of the baselines.
  */
  struct BslnFormat3Part {
    UInt16              stdGlyph;
    SInt16              ctlPoints[32];
    SFNTLookupTable     mappingData;
  };
  typedef struct BslnFormat3Part          BslnFormat3Part;
  /* The BslnFormatUnion is a union containing the format-specific parts of the baseline table. */
  union BslnFormatUnion {
    BslnFormat0Part     fmt0Part;
    BslnFormat1Part     fmt1Part;
    BslnFormat2Part     fmt2Part;
    BslnFormat3Part     fmt3Part;
  };
  typedef union BslnFormatUnion           BslnFormatUnion;
  /* The table format used in BaselineTable */
  
  typedef UInt16                          BslnTableFormat;
  /* BaselineTable defines the top-level format of the baseline table in the font. */
  struct BslnTable {
    Fixed               version;
    BslnTableFormat     format;
    UInt16              defaultBaseline;
    BslnFormatUnion     parts;
  };
  typedef struct BslnTable                BslnTable;
  typedef BslnTable *                     BslnTablePtr;
  /* --------------------------------------------------------------------------- */
  
  #if PRAGMA_STRUCT_ALIGN
      #pragma options align=reset
  #elif PRAGMA_STRUCT_PACKPUSH
      #pragma pack(pop)
  #elif PRAGMA_STRUCT_PACK
      #pragma pack()
  #endif
  
  #ifdef PRAGMA_IMPORT_OFF
  #pragma import off
  #elif PRAGMA_IMPORT
  #pragma import reset
  #endif
  
  
  #endif /* __SFNTLAYOUTTYPES__ */
  
  