[GSUB] Implement ReverseChainSingleSubst

GSUB is done!

diff --git a/src/hb-ot-layout-gsub-private.h b/src/hb-ot-layout-gsub-private.h
index dd929c0..da31a70 100644 (file)
--- a/src/hb-ot-layout-gsub-private.h
+++ b/src/hb-ot-layout-gsub-private.h
@@ -540,29 +540,56 @@ ASSERT_SIZE (ExtensionSubst, 2);
 
 
 struct ReverseChainSingleSubstFormat1 {
-  /* TODO */
+
+  friend struct ReverseChainSingleSubst;
+
+  private:
   inline bool substitute (LOOKUP_ARGS_DEF) const {
+
+    if (HB_UNLIKELY (context_length != NO_CONTEXT))
+      return false; /* No chaining to this type */
+
+    unsigned int index = (this+coverage) (IN_CURGLYPH ());
+    if (HB_LIKELY (index == NOT_COVERED))
+      return false;
+
+    const OffsetArrayOf<Coverage> &lookahead = * (const OffsetArrayOf<Coverage> *)
+                                                ((const char *) &backtrack + backtrack.get_size ());
+    const ArrayOf<GlyphID> &substitute = * (const ArrayOf<GlyphID> *)
+                                          ((const char *) &lookahead + lookahead.get_size ());
+
+    if (match_backtrack (LOOKUP_ARGS,
+                        backtrack.len, (USHORT *) backtrack.array,
+                        match_coverage, (char *) this) &&
+        match_lookahead (LOOKUP_ARGS,
+                        lookahead.len, (USHORT *) lookahead.array,
+                        match_coverage, (char *) this,
+                        1))
+    {
+      IN_CURGLYPH() = substitute[index];
+      buffer->in_pos--; /* Reverse! */
+      return true;
+    }
+
     return false;
   }
 
   private:
   USHORT       format;                 /* Format identifier--format = 1 */
-  Offset       coverage;               /* Offset to Coverage table -- from
-                                        * beginning of Substitution table */
-  USHORT       backtrackGlyphCount;    /* Number of glyphs in the backtracking
-                                        * sequence */
-  Offset       backtrackCoverage[];    /* Array of offsets to coverage tables
+  OffsetTo<Coverage>
+               coverage;               /* Offset to Coverage table--from
+                                        * beginning of table */
+  OffsetArrayOf<Coverage>
+               backtrack;              /* Array of coverage tables
                                         * in backtracking sequence, in  glyph
                                         * sequence order */
-  USHORT       lookaheadGlyphCount;    /* Number of glyphs in lookahead
-                                        * sequence */
-  Offset       lookaheadCoverage[];    /* Array of offsets to coverage tables
-                                        * in lookahead sequence, in  glyph
+  OffsetArrayOf<Coverage>
+               lookaheadX;             /* Array of coverage tables
+                                        * in lookahead sequence, in glyph
                                         * sequence order */
-  USHORT       glyphCount;             /* Number of GlyphIDs in the Substitute
-                                        * array */
-  GlyphID      substituteGlyphs[];     /* Array of substitute
-                                        * GlyphIDs--ordered by Coverage  Index */
+  ArrayOf<GlyphID>
+               substituteX;            /* Array of substitute
+                                        * GlyphIDs--ordered by Coverage Index */
 };
 ASSERT_SIZE (ReverseChainSingleSubstFormat1, 10);
 

diff --git a/src/hb-ot-layout-gsubgpos-private.h b/src/hb-ot-layout-gsubgpos-private.h
index 15d48bd..5e36a1f 100644 (file)
--- a/src/hb-ot-layout-gsubgpos-private.h
+++ b/src/hb-ot-layout-gsubgpos-private.h
@@ -221,11 +221,6 @@ static inline bool context_lookup (LOOKUP_ARGS_DEF,
                                   const LookupRecord lookupRecord[],
                                   ContextLookupContext &context)
 {
-  /* First guess */
-  if (HB_UNLIKELY (buffer->in_pos + inputCount > buffer->in_length ||
-                  inputCount > context_length))
-    return false;
-
   return match_input (LOOKUP_ARGS,
                      inputCount, input,
                      context.funcs.match, context.match_data,
@@ -246,10 +241,8 @@ struct Rule {
                                       ((const char *) input +
                                        sizeof (input[0]) * (inputCount ? inputCount - 1 : 0));
     return context_lookup (LOOKUP_ARGS,
-                          inputCount,
-                          input,
-                          lookupCount,
-                          lookupRecord,
+                          inputCount, input,
+                          lookupCount, lookupRecord,
                           context);
   }
 
@@ -374,10 +367,8 @@ struct ContextFormat3 {
       (char *) this
     };
     return context_lookup (LOOKUP_ARGS,
-                          glyphCount,
-                          (const USHORT *) (coverage + 1),
-                          lookupCount,
-                          lookupRecord,
+                          glyphCount, (const USHORT *) (coverage + 1),
+                          lookupCount, lookupRecord,
                           context);
   }
 
@@ -473,14 +464,10 @@ struct ChainRule {
     const ArrayOf<LookupRecord> &lookup = * (const ArrayOf<LookupRecord> *)
                                            ((const char *) &lookahead + lookahead.get_size ());
     return chain_context_lookup (LOOKUP_ARGS,
-                                backtrack.len,
-                                backtrack.array,
-                                input.len,
-                                input.array + 1,
-                                lookahead.len,
-                                lookahead.array,
-                                lookup.len,
-                                lookup.array,
+                                backtrack.len, backtrack.array,
+                                input.len, input.array + 1,
+                                lookahead.len, lookahead.array,
+                                lookup.len, lookup.array,
                                 context);
     return false;
   }
@@ -623,7 +610,7 @@ struct ChainContextFormat3 {
       return false;
 
     const OffsetArrayOf<Coverage> &lookahead = * (const OffsetArrayOf<Coverage> *)
-                                        ((const char *) &input + input.get_size ());
+                                                ((const char *) &input + input.get_size ());
     const ArrayOf<LookupRecord> &lookup = * (const ArrayOf<LookupRecord> *)
                                            ((const char *) &lookahead + lookahead.get_size ());
     struct ChainContextLookupContext context = {
@@ -631,14 +618,10 @@ struct ChainContextFormat3 {
       {(char *) this, (char *) this, (char *) this}
     };
     return chain_context_lookup (LOOKUP_ARGS,
-                                backtrack.len,
-                                (USHORT *) backtrack.array,
-                                input.len,
-                                (USHORT *) input.array,
-                                lookahead.len,
-                                (USHORT *) lookahead.array,
-                                lookup.len,
-                                lookup.array,
+                                backtrack.len, (USHORT *) backtrack.array,
+                                input.len, (USHORT *) input.array,
+                                lookahead.len, (USHORT *) lookahead.array,
+                                lookup.len, lookup.array,
                                 context);
     return false;
   }