public bool Apply(
                            FontTable          Table,
                            GlyphInfoList   GlyphInfo,      // List of GlyphInfo structs
                            int             FirstGlyph,     // where to apply it
                            out int         NextGlyph       // Next glyph to process
                         )
        {
            Invariant.Assert(FirstGlyph >= 0);
        
            NextGlyph = FirstGlyph + 1; //In case we don't match;
                
            ushort GlyphId = GlyphInfo.Glyphs[FirstGlyph];
            int CoverageIndex = Coverage(Table).GetGlyphIndex(Table,GlyphId);
            if (CoverageIndex == -1) return false;
            
            switch(Format(Table))
            {
                case 1:
                    GlyphInfo.Glyphs[FirstGlyph] = (ushort)(GlyphId + Format1DeltaGlyphId(Table));
                    GlyphInfo.GlyphFlags[FirstGlyph] = (ushort)(GlyphFlags.Unresolved | GlyphFlags.Substituted);
                    NextGlyph = FirstGlyph + 1;
                    return true;

                case 2:
                    GlyphInfo.Glyphs[FirstGlyph] = Format2SubstituteGlyphId(Table,(ushort)CoverageIndex);
                    GlyphInfo.GlyphFlags[FirstGlyph] = (ushort)(GlyphFlags.Unresolved | GlyphFlags.Substituted);
                    NextGlyph = FirstGlyph + 1;
                    return true;

                default:
                    NextGlyph = FirstGlyph+1;
                    return false;
            }
        }

 public bool IsLookupCovered(
                 FontTable table,
                 uint[] glyphBits,
                 ushort minGlyphId, 
                 ushort maxGlyphId)
 { 
     return true; 
 }

 public bool IsLookupCovered(
                 FontTable table, 
                 uint[] glyphBits, 
                 ushort minGlyphId, 
                 ushort maxGlyphId)
 {
     return Coverage(table).IsAnyGlyphCovered(table,
                                              glyphBits,
                                              minGlyphId,
                                              maxGlyphId
                                             );
 }

 public ushort GlyphCount(FontTable Table)
 {
     return Table.GetUShort(offset + offsetGlyphCount);
 }

 // Not used. This value should be equal to glyph count in Coverage.
 // Keeping it for future reference
 //private ushort Foramt2GlyphCount(FontTable Table)
 //{
 //    Debug.Assert(Format(Table)==2);
 //    return Table.GetUShort(offset + offsetFormat2GlyphCount);
 //}       
 private ushort Format2SubstituteGlyphId(FontTable Table,ushort Index)
 {
     Invariant.Assert(Format(Table)==2);
     return Table.GetUShort(offset + offsetFormat2SubstitutehArray + 
                                     Index * sizeFormat2SubstituteSize);
 }

 public ushort Format(FontTable Table)
 {
     return Table.GetUShort(offset + offsetFormat);
 }

 // Not used. This value should be equal to glyph count in Coverage.
 // Keeping it for future reference
 //private ushort SequenceCount(FontTable Table)
 //{
 //    return Table.GetUShort(offset + offsetSequenceCount);
 //}
 
 private MultipleSubstitutionSequenceTable Sequence(FontTable Table, int Index)
 {
     return new MultipleSubstitutionSequenceTable(
                                 offset + 
                                 Table.GetUShort(offset +
                                                 offsetSequenceArray +
                                                 Index * sizeSequenceOffset)
                                );
 }

 private LigatureSetTable LigatureSet(FontTable Table, ushort Index)
 {
     return new LigatureSetTable(offset+Table.GetUShort(offset+
                                                        offsetLigatureSetArray + 
                                                        Index * sizeLigatureSet));
 }

 private ushort LigatureSetCount(FontTable Table)
 {
     return Table.GetUShort(offset + offsetLigatureSetCount);
 }

        public unsafe bool Apply( 
            IOpenTypeFont           Font,           // Font access interface 
            OpenTypeTags            TableTag,       // Layout table tag (GSUB or GPOS)
            FontTable               Table,          // Layout table (GSUB or GPOS) 
            LayoutMetrics           Metrics,        // LayoutMetrics
            int                     CharCount,      // Characters count (i.e. Charmap.Length);
            UshortList              Charmap,        // Char to glyph mapping
            GlyphInfoList           GlyphInfo,      // List of GlyphInfo structs 
            int*                    Advances,       // Glyph adv.widths
            LayoutOffset*           Offsets,        // Glyph offsets 
            ushort                  LookupFlags,    // Lookup table flags 
            int                     FirstGlyph,     // where to apply it
            int                     AfterLastGlyph, // how long is a context we can use 
            uint                    Parameter,      // lookup parameter
            int                     nestingLevel,   // Contextual lookup nesting level
            out int                 NextGlyph       // out: next glyph index
            ) 
        {
            Invariant.Assert(Format(Table)==3); 
 
            NextGlyph = FirstGlyph + 1; //in case we don't match
 
            int glyphCount = GlyphInfo.Length;
            int glyphIndex;

            ushort backtrackGlyphCount = BacktrackGlyphCount(Table); 
            ushort inputGlyphCount     = InputGlyphCount(Table);
            ushort lookaheadGlyphCount = LookaheadGlyphCount(Table); 
 
            if (FirstGlyph < backtrackGlyphCount ||
                (FirstGlyph + inputGlyphCount) > AfterLastGlyph) 
            {
                return false;
            }
 
            bool match = true;
 
            //Check backtrack sequence 
            glyphIndex = FirstGlyph;
            for(ushort backtrackIndex = 0; 
                backtrackIndex < backtrackGlyphCount && match;
                backtrackIndex++)
            {
                 glyphIndex = LayoutEngine.GetNextGlyphInLookup(Font, GlyphInfo, 
                                                                glyphIndex-1,
                                                                LookupFlags, 
                                                                LayoutEngine.LookBackward 
                                                               );
 
                if (glyphIndex<0 ||
                    BacktrackCoverage(Table,backtrackIndex)
                            .GetGlyphIndex(Table,GlyphInfo.Glyphs[glyphIndex])<0)
                { 
                    match=false;
                } 
            } 

            if (!match) return false; 

            glyphIndex = FirstGlyph;
            for(ushort inputIndex = 0;
                inputIndex < inputGlyphCount && match; 
                inputIndex++)
            { 
                if (glyphIndex>=AfterLastGlyph || 
                    InputCoverage(Table,inputIndex)
                    .GetGlyphIndex(Table,GlyphInfo.Glyphs[glyphIndex])<0) 
                {
                    match=false;
                }
                else 
                {
                    glyphIndex = LayoutEngine.GetNextGlyphInLookup(Font, GlyphInfo, 
                        glyphIndex + 1, 
                        LookupFlags,
                        LayoutEngine.LookForward 
                        );
                }
            }
 
            if (!match) return false;
 
            int afterInputGlyph = glyphIndex; // remember where we were after input seqence 

            for(ushort lookaheadIndex = 0; 
                lookaheadIndex < lookaheadGlyphCount && match;
                lookaheadIndex++)
            {
                if (glyphIndex>=GlyphInfo.Length || 
                    LookaheadCoverage(Table,lookaheadIndex)
                    .GetGlyphIndex(Table,GlyphInfo.Glyphs[glyphIndex])<0) 
                { 
                    match=false;
                } 
                else
                {
                    glyphIndex = LayoutEngine.
                                    GetNextGlyphInLookup(Font, GlyphInfo, 
                                                         glyphIndex + 1,
                                                         LookupFlags, 
//.........这里部分代码省略.........

        public CoverageChainingSubtable(FontTable Table, int Offset)
        { 
            offset = Offset;
            offsetInputGlyphCount = offsetBacktrackGlyphCount + sizeGlyphCount + 
                                      Table.GetUShort(offset+offsetBacktrackGlyphCount) * 
                                                                    sizeCoverageOffset;
 
            offsetLookaheadGlyphCount = offsetInputGlyphCount + sizeGlyphCount +
                                          Table.GetUShort(offset+offsetInputGlyphCount) *
                                                                   sizeCoverageOffset;
        } 

 public ContextualLookupRecords ContextualLookups(FontTable Table) 
 {
     int recordCountOffset = offset + offsetLookaheadGlyphCount + sizeGlyphCount + 
                             LookaheadGlyphCount(Table) * sizeCoverageOffset; 
     return new ContextualLookupRecords(recordCountOffset+sizeGlyphCount,
                                         Table.GetUShort(recordCountOffset)); 
 }

 public CoverageTable LookaheadCoverage(FontTable Table, ushort Index)
 { 
     return new CoverageTable(offset +
                                 Table.GetUShort(offset+ 
                                                 offsetLookaheadGlyphCount + 
                                                 sizeGlyphCount +
                                                 Index*sizeCoverageOffset) 
                             );
 }

 public CoverageTable BacktrackCoverage(FontTable Table, ushort Index) 
 {
     return new CoverageTable(offset +
                                 Table.GetUShort(offset+
                                                 offsetBacktrackGlyphCount + 
                                                 sizeGlyphCount +
                                                 Index*sizeCoverageOffset) 
                             ); 
 }

 public ushort Glyph(FontTable Table, ushort index)
 {
     return Table.GetUShort(offset + offsetGlyphArray + index * sizeGlyphId);
 }

 private short Format1DeltaGlyphId(FontTable Table)
 {
     Invariant.Assert(Format(Table)==1);
     return Table.GetShort(offset + offsetFormat1DeltaGlyphId);
 }

 public ushort LigatureCount(FontTable Table)
 {
     return Table.GetUShort(offset + offsetLigatureCount);
 }

 public LigatureTable Ligature(FontTable Table, ushort Index)
 {
     return new LigatureTable(offset + Table.GetUShort(offset + 
         offsetLigatureArray + 
         Index * sizeLigatureOffset));
 }

 private CoverageTable Coverage(FontTable Table)
 {
     return new CoverageTable(offset + Table.GetUShort(offset + offsetCoverage));
 }

 public ushort LigatureGlyph(FontTable Table)
 {
     return Table.GetUShort(offset + offsetLigatureGlyph);
 }