From 969afd706e9b52adc79f6210c0088b2c6bbae9bc Mon Sep 17 00:00:00 2001
From: Behdad Esfahbod <behdad@behdad.org>
Date: Mon, 18 May 2009 05:47:47 -0400
Subject: [PATCH] [GSUB] Implement ReverseChainSingleSubst

GSUB is done!
---
 src/hb-ot-layout-gsub-private.h     | 55 +++++++++++++++++++++++++++----------
 src/hb-ot-layout-gsubgpos-private.h | 43 +++++++++--------------------
 2 files changed, 54 insertions(+), 44 deletions(-)

diff --git a/src/hb-ot-layout-gsub-private.h b/src/hb-ot-layout-gsub-private.h
index dd929c0..da31a70 100644
--- 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
--- 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;
   }
-- 
2.7.4