diff --git a/src/hb-open-file-private.hh b/src/hb-open-file-private.hh
index c56ce8f..905f50f 100644
--- a/src/hb-open-file-private.hh
+++ b/src/hb-open-file-private.hh
@@ -48,9 +48,9 @@
 
 typedef struct TableDirectory
 {
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this);
+    return c->check_struct (this);
   }
 
   Tag		tag;		/* 4-byte identifier. */
@@ -98,10 +98,10 @@
   }
 
   public:
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this)
-	&& context->check_array (tableDir, TableDirectory::static_size, numTables);
+    return c->check_struct (this)
+	&& c->check_array (tableDir, TableDirectory::static_size, numTables);
   }
 
   private:
@@ -127,9 +127,9 @@
   inline unsigned int get_face_count (void) const { return table.len; }
   inline const OpenTypeFontFace& get_face (unsigned int i) const { return this+table[i]; }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return table.sanitize (context, this);
+    return table.sanitize (c, this);
   }
 
   private:
@@ -166,12 +166,12 @@
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (unlikely (!u.header.version.sanitize (context))) return false;
+    if (unlikely (!u.header.version.sanitize (c))) return false;
     switch (u.header.version) {
     case 2: /* version 2 is compatible with version 1 */
-    case 1: return u.version1.sanitize (context);
+    case 1: return u.version1.sanitize (c);
     default:return true;
     }
   }
@@ -228,15 +228,15 @@
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (unlikely (!u.tag.sanitize (context))) return false;
+    if (unlikely (!u.tag.sanitize (c))) return false;
     switch (u.tag) {
     case CFFTag:	/* All the non-collection tags */
     case TrueTag:
     case Typ1Tag:
-    case TrueTypeTag:	return u.fontFace.sanitize (context);
-    case TTCTag:	return u.ttcHeader.sanitize (context);
+    case TrueTypeTag:	return u.fontFace.sanitize (c);
+    case TTCTag:	return u.ttcHeader.sanitize (c);
     default:		return true;
     }
   }
diff --git a/src/hb-open-type-private.hh b/src/hb-open-type-private.hh
index a57bef5..16cc376 100644
--- a/src/hb-open-type-private.hh
+++ b/src/hb-open-type-private.hh
@@ -176,7 +176,7 @@
 
 
 #define TRACE_SANITIZE() \
-	hb_trace_t<HB_DEBUG_SANITIZE> trace (&context->debug_depth, "SANITIZE", HB_FUNC, this); \
+	hb_trace_t<HB_DEBUG_SANITIZE> trace (&c->debug_depth, "SANITIZE", HB_FUNC, this); \
 
 
 struct hb_sanitize_context_t
@@ -278,7 +278,7 @@
 struct Sanitizer
 {
   static hb_blob_t *sanitize (hb_blob_t *blob) {
-    hb_sanitize_context_t context[1] = {{0}};
+    hb_sanitize_context_t c[1] = {{0}};
     bool sane;
 
     /* TODO is_sane() stuff */
@@ -287,36 +287,36 @@
     if (HB_DEBUG_SANITIZE)
       fprintf (stderr, "Sanitizer %p start %s\n", blob, HB_FUNC);
 
-    context->init (blob);
+    c->init (blob);
 
-    if (unlikely (!context->start)) {
-      context->finish ();
+    if (unlikely (!c->start)) {
+      c->finish ();
       return blob;
     }
 
-    Type *t = CastP<Type> (const_cast<char *> (context->start));
+    Type *t = CastP<Type> (const_cast<char *> (c->start));
 
-    sane = t->sanitize (context);
+    sane = t->sanitize (c);
     if (sane) {
-      if (context->edit_count) {
+      if (c->edit_count) {
 	if (HB_DEBUG_SANITIZE)
 	  fprintf (stderr, "Sanitizer %p passed first round with %d edits; doing a second round %s\n",
-		   blob, context->edit_count, HB_FUNC);
+		   blob, c->edit_count, HB_FUNC);
 
         /* sanitize again to ensure no toe-stepping */
-        context->edit_count = 0;
-	sane = t->sanitize (context);
-	if (context->edit_count) {
+        c->edit_count = 0;
+	sane = t->sanitize (c);
+	if (c->edit_count) {
 	  if (HB_DEBUG_SANITIZE)
 	    fprintf (stderr, "Sanitizer %p requested %d edits in second round; FAILLING %s\n",
-		     blob, context->edit_count, HB_FUNC);
+		     blob, c->edit_count, HB_FUNC);
 	  sane = false;
 	}
       }
-      context->finish ();
+      c->finish ();
     } else {
-      unsigned int edit_count = context->edit_count;
-      context->finish ();
+      unsigned int edit_count = c->edit_count;
+      c->finish ();
       if (edit_count && !hb_blob_is_writable (blob) && hb_blob_try_writable (blob)) {
         /* ok, we made it writable by relocating.  try again */
 	if (HB_DEBUG_SANITIZE)
@@ -391,9 +391,9 @@
   inline operator Type(void) const { return v; }
   inline bool operator == (const IntType<Type> &o) const { return v == o.v; }
   inline bool operator != (const IntType<Type> &o) const { return v != o.v; }
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return likely (context->check_struct (this));
+    return likely (c->check_struct (this));
   }
   protected:
   BEInt<Type, sizeof (Type)> v;
@@ -459,9 +459,9 @@
 {
   inline operator uint32_t (void) const { return (major << 16) + minor; }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this);
+    return c->check_struct (this);
   }
 
   USHORT major;
@@ -487,28 +487,28 @@
     return StructAtOffset<Type> (base, offset);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context, void *base) {
+  inline bool sanitize (hb_sanitize_context_t *c, void *base) {
     TRACE_SANITIZE ();
-    if (unlikely (!context->check_struct (this))) return false;
+    if (unlikely (!c->check_struct (this))) return false;
     unsigned int offset = *this;
     if (unlikely (!offset)) return true;
     Type &obj = StructAtOffset<Type> (base, offset);
-    return likely (obj.sanitize (context)) || neuter (context);
+    return likely (obj.sanitize (c)) || neuter (c);
   }
   template <typename T>
-  inline bool sanitize (hb_sanitize_context_t *context, void *base, T user_data) {
+  inline bool sanitize (hb_sanitize_context_t *c, void *base, T user_data) {
     TRACE_SANITIZE ();
-    if (unlikely (!context->check_struct (this))) return false;
+    if (unlikely (!c->check_struct (this))) return false;
     unsigned int offset = *this;
     if (unlikely (!offset)) return true;
     Type &obj = StructAtOffset<Type> (base, offset);
-    return likely (obj.sanitize (context, user_data)) || neuter (context);
+    return likely (obj.sanitize (c, user_data)) || neuter (c);
   }
 
   private:
   /* Set the offset to Null */
-  inline bool neuter (hb_sanitize_context_t *context) {
-    if (context->can_edit (this, this->static_size)) {
+  inline bool neuter (hb_sanitize_context_t *c) {
+    if (c->can_edit (this, this->static_size)) {
       this->set (0); /* 0 is Null offset */
       return true;
     }
@@ -552,9 +552,9 @@
   inline unsigned int get_size () const
   { return len.static_size + len * Type::static_size; }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (unlikely (!sanitize_shallow (context))) return false;
+    if (unlikely (!sanitize_shallow (c))) return false;
     /* Note: for structs that do not reference other structs,
      * we do not need to call their sanitize() as we already did
      * a bound check on the aggregate array size, hence the return.
@@ -565,35 +565,35 @@
      * other structs. */
     unsigned int count = len;
     for (unsigned int i = 0; i < count; i++)
-      if (array[i].sanitize (context))
+      if (array[i].sanitize (c))
         return false;
     return true;
   }
-  inline bool sanitize (hb_sanitize_context_t *context, void *base) {
+  inline bool sanitize (hb_sanitize_context_t *c, void *base) {
     TRACE_SANITIZE ();
-    if (unlikely (!sanitize_shallow (context))) return false;
+    if (unlikely (!sanitize_shallow (c))) return false;
     unsigned int count = len;
     for (unsigned int i = 0; i < count; i++)
-      if (unlikely (!array[i].sanitize (context, base)))
+      if (unlikely (!array[i].sanitize (c, base)))
         return false;
     return true;
   }
   template <typename T>
-  inline bool sanitize (hb_sanitize_context_t *context, void *base, T user_data) {
+  inline bool sanitize (hb_sanitize_context_t *c, void *base, T user_data) {
     TRACE_SANITIZE ();
-    if (unlikely (!sanitize_shallow (context))) return false;
+    if (unlikely (!sanitize_shallow (c))) return false;
     unsigned int count = len;
     for (unsigned int i = 0; i < count; i++)
-      if (unlikely (!array[i].sanitize (context, base, user_data)))
+      if (unlikely (!array[i].sanitize (c, base, user_data)))
         return false;
     return true;
   }
 
   private:
-  inline bool sanitize_shallow (hb_sanitize_context_t *context) {
+  inline bool sanitize_shallow (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this)
-	&& context->check_array (this, Type::static_size, len);
+    return c->check_struct (this)
+	&& c->check_array (this, Type::static_size, len);
   }
 
   public:
@@ -633,14 +633,14 @@
     return this+this->array[i];
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return OffsetArrayOf<Type>::sanitize (context, this);
+    return OffsetArrayOf<Type>::sanitize (c, this);
   }
   template <typename T>
-  inline bool sanitize (hb_sanitize_context_t *context, T user_data) {
+  inline bool sanitize (hb_sanitize_context_t *c, T user_data) {
     TRACE_SANITIZE ();
-    return OffsetArrayOf<Type>::sanitize (context, this, user_data);
+    return OffsetArrayOf<Type>::sanitize (c, this, user_data);
   }
 };
 
@@ -658,14 +658,14 @@
   inline unsigned int get_size () const
   { return len.static_size + (len ? len - 1 : 0) * Type::static_size; }
 
-  inline bool sanitize_shallow (hb_sanitize_context_t *context) {
-    return context->check_struct (this)
-	&& context->check_array (this, Type::static_size, len);
+  inline bool sanitize_shallow (hb_sanitize_context_t *c) {
+    return c->check_struct (this)
+	&& c->check_array (this, Type::static_size, len);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (unlikely (!sanitize_shallow (context))) return false;
+    if (unlikely (!sanitize_shallow (c))) return false;
     /* Note: for structs that do not reference other structs,
      * we do not need to call their sanitize() as we already did
      * a bound check on the aggregate array size, hence the return.
@@ -677,7 +677,7 @@
     unsigned int count = len ? len - 1 : 0;
     Type *a = array;
     for (unsigned int i = 0; i < count; i++)
-      if (unlikely (!a[i].sanitize (context)))
+      if (unlikely (!a[i].sanitize (c)))
         return false;
     return true;
   }
diff --git a/src/hb-ot-layout-common-private.hh b/src/hb-ot-layout-common-private.hh
index 8c04150..4ab4ee5 100644
--- a/src/hb-ot-layout-common-private.hh
+++ b/src/hb-ot-layout-common-private.hh
@@ -51,10 +51,10 @@
 template <typename Type>
 struct Record
 {
-  inline bool sanitize (hb_sanitize_context_t *context, void *base) {
+  inline bool sanitize (hb_sanitize_context_t *c, void *base) {
     TRACE_SANITIZE ();
-    return context->check_struct (this)
-	&& offset.sanitize (context, base);
+    return c->check_struct (this)
+	&& offset.sanitize (c, base);
   }
 
   Tag		tag;		/* 4-byte Tag identifier */
@@ -110,9 +110,9 @@
   inline const Type& operator [] (unsigned int i) const
   { return this+RecordArrayOf<Type>::operator [](i).offset; }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return RecordArrayOf<Type>::sanitize (context, this);
+    return RecordArrayOf<Type>::sanitize (c, this);
   }
 };
 
@@ -158,10 +158,10 @@
    return reqFeatureIndex;;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this)
-	&& featureIndex.sanitize (context);
+    return c->check_struct (this)
+	&& featureIndex.sanitize (c);
   }
 
   Offset	lookupOrder;	/* = Null (reserved for an offset to a
@@ -197,10 +197,10 @@
   inline bool has_default_lang_sys (void) const { return defaultLangSys != 0; }
   inline const LangSys& get_default_lang_sys (void) const { return this+defaultLangSys; }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return defaultLangSys.sanitize (context, this)
-	&& langSys.sanitize (context, this);
+    return defaultLangSys.sanitize (c, this)
+	&& langSys.sanitize (c, this);
   }
 
   private:
@@ -228,10 +228,10 @@
 					  unsigned int *lookup_tags /* OUT */) const
   { return lookupIndex.get_indexes (start_index, lookup_count, lookup_tags); }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this)
-	&& lookupIndex.sanitize (context);
+    return c->check_struct (this)
+	&& lookupIndex.sanitize (c);
   }
 
   /* LONGTERMTODO: implement get_feature_parameters() */
@@ -280,15 +280,15 @@
     return flag;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
     /* Real sanitize of the subtables is done by GSUB/GPOS/... */
-    if (!(context->check_struct (this)
-       && subTable.sanitize (context))) return false;
+    if (!(c->check_struct (this)
+       && subTable.sanitize (c))) return false;
     if (unlikely (lookupFlag & LookupFlag::UseMarkFilteringSet))
     {
       USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
-      if (!markFilteringSet.sanitize (context)) return false;
+      if (!markFilteringSet.sanitize (c)) return false;
     }
     return true;
   }
@@ -330,9 +330,9 @@
     return NOT_COVERED;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return glyphArray.sanitize (context);
+    return glyphArray.sanitize (c);
   }
 
   private:
@@ -356,9 +356,9 @@
   }
 
   public:
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this);
+    return c->check_struct (this);
   }
 
   private:
@@ -389,9 +389,9 @@
     return NOT_COVERED;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return rangeRecord.sanitize (context);
+    return rangeRecord.sanitize (c);
   }
 
   private:
@@ -417,12 +417,12 @@
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
-    case 2: return u.format2.sanitize (context);
+    case 1: return u.format1.sanitize (c);
+    case 2: return u.format2.sanitize (c);
     default:return true;
     }
   }
@@ -454,10 +454,10 @@
     return 0;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this)
-	&& classValue.sanitize (context);
+    return c->check_struct (this)
+	&& classValue.sanitize (c);
   }
 
   USHORT	classFormat;		/* Format identifier--format = 1 */
@@ -481,9 +481,9 @@
   }
 
   public:
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this);
+    return c->check_struct (this);
   }
 
   private:
@@ -513,9 +513,9 @@
     return 0;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return rangeRecord.sanitize (context);
+    return rangeRecord.sanitize (c);
   }
 
   USHORT	classFormat;	/* Format identifier--format = 2 */
@@ -539,12 +539,12 @@
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
-    case 2: return u.format2.sanitize (context);
+    case 1: return u.format1.sanitize (c);
+    case 2: return u.format2.sanitize (c);
     default:return true;
     }
   }
@@ -598,10 +598,10 @@
     return USHORT::static_size * (4 + ((endSize - startSize) >> (4 - f)));
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this)
-	&& context->check_range (this, this->get_size ());
+    return c->check_struct (this)
+	&& c->check_range (this, this->get_size ());
   }
 
   private:
diff --git a/src/hb-ot-layout-gdef-private.hh b/src/hb-ot-layout-gdef-private.hh
index d43a4c2..63fbee7 100644
--- a/src/hb-ot-layout-gdef-private.hh
+++ b/src/hb-ot-layout-gdef-private.hh
@@ -66,10 +66,10 @@
     return points.len;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return coverage.sanitize (context, this)
-	&& attachPoint.sanitize (context, this);
+    return coverage.sanitize (c, this)
+	&& attachPoint.sanitize (c, this);
   }
 
   private:
@@ -92,15 +92,15 @@
   friend struct CaretValue;
 
   private:
-  inline int get_caret_value (hb_ot_layout_context_t *context, hb_codepoint_t glyph_id HB_UNUSED) const
+  inline int get_caret_value (hb_ot_layout_context_t *c, hb_codepoint_t glyph_id HB_UNUSED) const
   {
     /* TODO vertical */
-    return _hb_16dot16_mul_round (context->font->x_scale, coordinate);
+    return _hb_16dot16_mul_round (c->font->x_scale, coordinate);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this);
+    return c->check_struct (this);
   }
 
   private:
@@ -115,19 +115,19 @@
   friend struct CaretValue;
 
   private:
-  inline int get_caret_value (hb_ot_layout_context_t *context, hb_codepoint_t glyph_id) const
+  inline int get_caret_value (hb_ot_layout_context_t *c, hb_codepoint_t glyph_id) const
   {
     /* TODO vertical */
     hb_position_t x, y;
-    if (hb_font_get_contour_point (context->font, context->face, caretValuePoint, glyph_id, &x, &y))
+    if (hb_font_get_contour_point (c->font, c->face, caretValuePoint, glyph_id, &x, &y))
       return x;
     else
       return 0;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this);
+    return c->check_struct (this);
   }
 
   private:
@@ -141,17 +141,17 @@
 {
   friend struct CaretValue;
 
-  inline int get_caret_value (hb_ot_layout_context_t *context, hb_codepoint_t glyph_id HB_UNUSED) const
+  inline int get_caret_value (hb_ot_layout_context_t *c, hb_codepoint_t glyph_id HB_UNUSED) const
   {
     /* TODO vertical */
-    return _hb_16dot16_mul_round (context->font->x_scale, coordinate) +
-	   ((this+deviceTable).get_delta (context->font->x_ppem) << 16);
+    return _hb_16dot16_mul_round (c->font->x_scale, coordinate) +
+	   ((this+deviceTable).get_delta (c->font->x_ppem) << 16);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this)
-	&& deviceTable.sanitize (context, this);
+    return c->check_struct (this)
+	&& deviceTable.sanitize (c, this);
   }
 
   private:
@@ -167,23 +167,23 @@
 
 struct CaretValue
 {
-  inline int get_caret_value (hb_ot_layout_context_t *context, hb_codepoint_t glyph_id) const
+  inline int get_caret_value (hb_ot_layout_context_t *c, hb_codepoint_t glyph_id) const
   {
     switch (u.format) {
-    case 1: return u.format1.get_caret_value (context, glyph_id);
-    case 2: return u.format2.get_caret_value (context, glyph_id);
-    case 3: return u.format3.get_caret_value (context, glyph_id);
+    case 1: return u.format1.get_caret_value (c, glyph_id);
+    case 2: return u.format2.get_caret_value (c, glyph_id);
+    case 3: return u.format3.get_caret_value (c, glyph_id);
     default:return 0;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
-    case 2: return u.format2.sanitize (context);
-    case 3: return u.format3.sanitize (context);
+    case 1: return u.format1.sanitize (c);
+    case 2: return u.format2.sanitize (c);
+    case 3: return u.format3.sanitize (c);
     default:return true;
     }
   }
@@ -201,7 +201,7 @@
 
 struct LigGlyph
 {
-  inline unsigned int get_lig_carets (hb_ot_layout_context_t *context,
+  inline unsigned int get_lig_carets (hb_ot_layout_context_t *c,
 				      hb_codepoint_t glyph_id,
 				      unsigned int start_offset,
 				      unsigned int *caret_count /* IN/OUT */,
@@ -211,15 +211,15 @@
       const OffsetTo<CaretValue> *array = carets.sub_array (start_offset, caret_count);
       unsigned int count = *caret_count;
       for (unsigned int i = 0; i < count; i++)
-	caret_array[i] = (this+array[i]).get_caret_value (context, glyph_id);
+	caret_array[i] = (this+array[i]).get_caret_value (c, glyph_id);
     }
 
     return carets.len;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return carets.sanitize (context, this);
+    return carets.sanitize (c, this);
   }
 
   private:
@@ -233,7 +233,7 @@
 
 struct LigCaretList
 {
-  inline unsigned int get_lig_carets (hb_ot_layout_context_t *context,
+  inline unsigned int get_lig_carets (hb_ot_layout_context_t *c,
 				      hb_codepoint_t glyph_id,
 				      unsigned int start_offset,
 				      unsigned int *caret_count /* IN/OUT */,
@@ -247,13 +247,13 @@
       return 0;
     }
     const LigGlyph &lig_glyph = this+ligGlyph[index];
-    return lig_glyph.get_lig_carets (context, glyph_id, start_offset, caret_count, caret_array);
+    return lig_glyph.get_lig_carets (c, glyph_id, start_offset, caret_count, caret_array);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return coverage.sanitize (context, this)
-	&& ligGlyph.sanitize (context, this);
+    return coverage.sanitize (c, this)
+	&& ligGlyph.sanitize (c, this);
   }
 
   private:
@@ -273,9 +273,9 @@
   inline bool covers (unsigned int set_index, hb_codepoint_t glyph_id) const
   { return (this+coverage[set_index]).get_coverage (glyph_id) != NOT_COVERED; }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return coverage.sanitize (context, this);
+    return coverage.sanitize (c, this);
   }
 
   private:
@@ -297,11 +297,11 @@
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
+    case 1: return u.format1.sanitize (c);
     default:return true;
     }
   }
@@ -348,25 +348,25 @@
   { return (this+attachList).get_attach_points (glyph_id, start_offset, point_count, point_array); }
 
   inline bool has_lig_carets () const { return ligCaretList != 0; }
-  inline unsigned int get_lig_carets (hb_ot_layout_context_t *context,
+  inline unsigned int get_lig_carets (hb_ot_layout_context_t *c,
 				      hb_codepoint_t glyph_id,
 				      unsigned int start_offset,
 				      unsigned int *caret_count /* IN/OUT */,
 				      int *caret_array /* OUT */) const
-  { return (this+ligCaretList).get_lig_carets (context, glyph_id, start_offset, caret_count, caret_array); }
+  { return (this+ligCaretList).get_lig_carets (c, glyph_id, start_offset, caret_count, caret_array); }
 
   inline bool has_mark_sets () const { return version >= 0x00010002 && markGlyphSetsDef[0] != 0; }
   inline bool mark_set_covers (unsigned int set_index, hb_codepoint_t glyph_id) const
   { return version >= 0x00010002 && (this+markGlyphSetsDef[0]).covers (set_index, glyph_id); }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return version.sanitize (context) && likely (version.major == 1)
-	&& glyphClassDef.sanitize (context, this)
-	&& attachList.sanitize (context, this)
-	&& ligCaretList.sanitize (context, this)
-	&& markAttachClassDef.sanitize (context, this)
-	&& (version < 0x00010002 || markGlyphSetsDef[0].sanitize (context, this));
+    return version.sanitize (c) && likely (version.major == 1)
+	&& glyphClassDef.sanitize (c, this)
+	&& attachList.sanitize (c, this)
+	&& ligCaretList.sanitize (c, this)
+	&& markAttachClassDef.sanitize (c, this)
+	&& (version < 0x00010002 || markGlyphSetsDef[0].sanitize (c, this));
   }
 
   private:
diff --git a/src/hb-ot-layout-gpos-private.hh b/src/hb-ot-layout-gpos-private.hh
index b12a046..b072ca9 100644
--- a/src/hb-ot-layout-gpos-private.hh
+++ b/src/hb-ot-layout-gpos-private.hh
@@ -31,7 +31,7 @@
 
 
 #undef BUFFER
-#define BUFFER context->buffer
+#define BUFFER c->buffer
 
 
 #define HB_OT_LAYOUT_GPOS_NO_LAST ((unsigned int) -1)
@@ -133,7 +133,7 @@
   }
 
   private:
-  inline bool sanitize_value_devices (hb_sanitize_context_t *context, void *base, Value *values) {
+  inline bool sanitize_value_devices (hb_sanitize_context_t *c, void *base, Value *values) {
     unsigned int format = *this;
 
     if (format & xPlacement) values++;
@@ -141,10 +141,10 @@
     if (format & xAdvance)   values++;
     if (format & yAdvance)   values++;
 
-    if ((format & xPlaDevice) && !get_device (values++).sanitize (context, base)) return false;
-    if ((format & yPlaDevice) && !get_device (values++).sanitize (context, base)) return false;
-    if ((format & xAdvDevice) && !get_device (values++).sanitize (context, base)) return false;
-    if ((format & yAdvDevice) && !get_device (values++).sanitize (context, base)) return false;
+    if ((format & xPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
+    if ((format & yPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
+    if ((format & xAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
+    if ((format & yAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
 
     return true;
   }
@@ -164,22 +164,22 @@
     return (format & devices) != 0;
   }
 
-  inline bool sanitize_value (hb_sanitize_context_t *context, void *base, Value *values) {
+  inline bool sanitize_value (hb_sanitize_context_t *c, void *base, Value *values) {
     TRACE_SANITIZE ();
-    return context->check_range (values, get_size ())
-	&& (!has_device () || sanitize_value_devices (context, base, values));
+    return c->check_range (values, get_size ())
+	&& (!has_device () || sanitize_value_devices (c, base, values));
   }
 
-  inline bool sanitize_values (hb_sanitize_context_t *context, void *base, Value *values, unsigned int count) {
+  inline bool sanitize_values (hb_sanitize_context_t *c, void *base, Value *values, unsigned int count) {
     TRACE_SANITIZE ();
     unsigned int len = get_len ();
 
-    if (!context->check_array (values, get_size (), count)) return false;
+    if (!c->check_array (values, get_size (), count)) return false;
 
     if (!has_device ()) return true;
 
     for (unsigned int i = 0; i < count; i++) {
-      if (!sanitize_value_devices (context, base, values))
+      if (!sanitize_value_devices (c, base, values))
         return false;
       values += len;
     }
@@ -188,13 +188,13 @@
   }
 
   /* Just sanitize referenced Device tables.  Doesn't check the values themselves. */
-  inline bool sanitize_values_stride_unsafe (hb_sanitize_context_t *context, void *base, Value *values, unsigned int count, unsigned int stride) {
+  inline bool sanitize_values_stride_unsafe (hb_sanitize_context_t *c, void *base, Value *values, unsigned int count, unsigned int stride) {
     TRACE_SANITIZE ();
 
     if (!has_device ()) return true;
 
     for (unsigned int i = 0; i < count; i++) {
-      if (!sanitize_value_devices (context, base, values))
+      if (!sanitize_value_devices (c, base, values))
         return false;
       values += stride;
     }
@@ -216,9 +216,9 @@
       *y = _hb_16dot16_mul_round (layout->font->y_scale, yCoordinate);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this);
+    return c->check_struct (this);
   }
 
   private:
@@ -248,9 +248,9 @@
       *y = y_ppem && ret ? cy : _hb_16dot16_mul_round (layout->font->y_scale, yCoordinate);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this);
+    return c->check_struct (this);
   }
 
   private:
@@ -280,11 +280,11 @@
 	*y += (this+yDeviceTable).get_delta (layout->font->y_ppem) << 16;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this)
-	&& xDeviceTable.sanitize (context, this)
-	&& yDeviceTable.sanitize (context, this);
+    return c->check_struct (this)
+	&& xDeviceTable.sanitize (c, this)
+	&& yDeviceTable.sanitize (c, this);
   }
 
   private:
@@ -317,13 +317,13 @@
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
-    case 2: return u.format2.sanitize (context);
-    case 3: return u.format3.sanitize (context);
+    case 1: return u.format1.sanitize (c);
+    case 2: return u.format2.sanitize (c);
+    case 3: return u.format3.sanitize (c);
     default:return true;
     }
   }
@@ -347,14 +347,14 @@
     return this+matrix[row * cols + col];
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context, unsigned int cols) {
+  inline bool sanitize (hb_sanitize_context_t *c, unsigned int cols) {
     TRACE_SANITIZE ();
-    if (!context->check_struct (this)) return false;
+    if (!c->check_struct (this)) return false;
     if (unlikely (cols >= ((unsigned int) -1) / rows)) return false;
     unsigned int count = rows * cols;
-    if (!context->check_array (matrix, matrix[0].static_size, count)) return false;
+    if (!c->check_array (matrix, matrix[0].static_size, count)) return false;
     for (unsigned int i = 0; i < count; i++)
-      if (!matrix[i].sanitize (context, this)) return false;
+      if (!matrix[i].sanitize (c, this)) return false;
     return true;
   }
 
@@ -372,10 +372,10 @@
 {
   friend struct MarkArray;
 
-  inline bool sanitize (hb_sanitize_context_t *context, void *base) {
+  inline bool sanitize (hb_sanitize_context_t *c, void *base) {
     TRACE_SANITIZE ();
-    return context->check_struct (this)
-	&& markAnchor.sanitize (context, base);
+    return c->check_struct (this)
+	&& markAnchor.sanitize (c, base);
   }
 
   private:
@@ -389,7 +389,7 @@
 
 struct MarkArray : ArrayOf<MarkRecord>	/* Array of MarkRecords--in Coverage order */
 {
-  inline bool apply (hb_apply_context_t *context,
+  inline bool apply (hb_apply_context_t *c,
 		     unsigned int mark_index, unsigned int glyph_index,
 		     const AnchorMatrix &anchors, unsigned int class_count,
 		     unsigned int glyph_pos) const
@@ -403,23 +403,23 @@
 
     hb_position_t mark_x, mark_y, base_x, base_y;
 
-    mark_anchor.get_anchor (context->layout, IN_CURGLYPH (), &mark_x, &mark_y);
-    glyph_anchor.get_anchor (context->layout, IN_GLYPH (glyph_pos), &base_x, &base_y);
+    mark_anchor.get_anchor (c->layout, IN_CURGLYPH (), &mark_x, &mark_y);
+    glyph_anchor.get_anchor (c->layout, IN_GLYPH (glyph_pos), &base_x, &base_y);
 
-    hb_internal_glyph_position_t *o = POSITION (context->buffer->in_pos);
+    hb_internal_glyph_position_t *o = POSITION (c->buffer->in_pos);
     o->x_advance = 0;
     o->y_advance = 0;
     o->x_offset  = base_x - mark_x;
     o->y_offset  = base_y - mark_y;
-    o->back      = context->buffer->in_pos - glyph_pos;
+    o->back      = c->buffer->in_pos - glyph_pos;
 
-    context->buffer->in_pos++;
+    c->buffer->in_pos++;
     return true;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return ArrayOf<MarkRecord>::sanitize (context, this);
+    return ArrayOf<MarkRecord>::sanitize (c, this);
   }
 };
 
@@ -431,24 +431,24 @@
   friend struct SinglePos;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     unsigned int index = (this+coverage) (IN_CURGLYPH ());
     if (likely (index == NOT_COVERED))
       return false;
 
-    valueFormat.apply_value (context->layout, this, values, CURPOSITION ());
+    valueFormat.apply_value (c->layout, this, values, CURPOSITION ());
 
-    context->buffer->in_pos++;
+    c->buffer->in_pos++;
     return true;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this)
-	&& coverage.sanitize (context, this)
-	&& valueFormat.sanitize_value (context, this, values);
+    return c->check_struct (this)
+	&& coverage.sanitize (c, this)
+	&& valueFormat.sanitize_value (c, this, values);
   }
 
   private:
@@ -470,7 +470,7 @@
   friend struct SinglePos;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     unsigned int index = (this+coverage) (IN_CURGLYPH ());
@@ -480,19 +480,19 @@
     if (likely (index >= valueCount))
       return false;
 
-    valueFormat.apply_value (context->layout, this,
+    valueFormat.apply_value (c->layout, this,
 			     &values[index * valueFormat.get_len ()],
 			     CURPOSITION ());
 
-    context->buffer->in_pos++;
+    c->buffer->in_pos++;
     return true;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this)
-	&& coverage.sanitize (context, this)
-	&& valueFormat.sanitize_values (context, this, values, valueCount);
+    return c->check_struct (this)
+	&& coverage.sanitize (c, this)
+	&& valueFormat.sanitize_values (c, this, values, valueCount);
   }
 
   private:
@@ -514,22 +514,22 @@
   friend struct PosLookupSubTable;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     switch (u.format) {
-    case 1: return u.format1.apply (context);
-    case 2: return u.format2.apply (context);
+    case 1: return u.format1.apply (c);
+    case 2: return u.format2.apply (c);
     default:return false;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
-    case 2: return u.format2.sanitize (context);
+    case 1: return u.format1.sanitize (c);
+    case 2: return u.format2.sanitize (c);
     default:return true;
     }
   }
@@ -561,7 +561,7 @@
 {
   friend struct PairPosFormat1;
 
-  inline bool apply (hb_apply_context_t *context,
+  inline bool apply (hb_apply_context_t *c,
 		     const ValueFormat *valueFormats,
 		     unsigned int pos) const
   {
@@ -576,11 +576,11 @@
     {
       if (IN_GLYPH (pos) == record->secondGlyph)
       {
-	valueFormats[0].apply_value (context->layout, this, &record->values[0], CURPOSITION ());
-	valueFormats[1].apply_value (context->layout, this, &record->values[len1], POSITION (pos));
+	valueFormats[0].apply_value (c->layout, this, &record->values[0], CURPOSITION ());
+	valueFormats[1].apply_value (c->layout, this, &record->values[len1], POSITION (pos));
 	if (len2)
 	  pos++;
-	context->buffer->in_pos = pos;
+	c->buffer->in_pos = pos;
 	return true;
       }
       record = &StructAtOffset<PairValueRecord> (record, record_size);
@@ -596,15 +596,15 @@
     unsigned int stride; /* 1 + len1 + len2 */
   };
 
-  inline bool sanitize (hb_sanitize_context_t *context, const sanitize_closure_t *closure) {
+  inline bool sanitize (hb_sanitize_context_t *c, const sanitize_closure_t *closure) {
     TRACE_SANITIZE ();
-    if (!(context->check_struct (this)
-       && context->check_array (array, USHORT::static_size * closure->stride, len))) return false;
+    if (!(c->check_struct (this)
+       && c->check_array (array, USHORT::static_size * closure->stride, len))) return false;
 
     unsigned int count = len;
     PairValueRecord *record = CastP<PairValueRecord> (array);
-    return closure->valueFormats[0].sanitize_values_stride_unsafe (context, closure->base, &record->values[0], count, closure->stride)
-	&& closure->valueFormats[1].sanitize_values_stride_unsafe (context, closure->base, &record->values[closure->len1], count, closure->stride);
+    return closure->valueFormats[0].sanitize_values_stride_unsafe (c, closure->base, &record->values[0], count, closure->stride)
+	&& closure->valueFormats[1].sanitize_values_stride_unsafe (c, closure->base, &record->values[closure->len1], count, closure->stride);
   }
 
   private:
@@ -620,29 +620,29 @@
   friend struct PairPos;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length);
-    if (unlikely (context->buffer->in_pos + 2 > end))
+    unsigned int end = MIN (c->buffer->in_length, c->buffer->in_pos + c->context_length);
+    if (unlikely (c->buffer->in_pos + 2 > end))
       return false;
 
     unsigned int index = (this+coverage) (IN_CURGLYPH ());
     if (likely (index == NOT_COVERED))
       return false;
 
-    unsigned int j = context->buffer->in_pos + 1;
-    while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), context->lookup_flag, NULL))
+    unsigned int j = c->buffer->in_pos + 1;
+    while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), c->lookup_flag, NULL))
     {
       if (unlikely (j == end))
 	return false;
       j++;
     }
 
-    return (this+pairSet[index]).apply (context, &valueFormat1, j);
+    return (this+pairSet[index]).apply (c, &valueFormat1, j);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
 
     unsigned int len1 = valueFormat1.get_len ();
@@ -654,9 +654,9 @@
       1 + len1 + len2
     };
 
-    return context->check_struct (this)
-	&& coverage.sanitize (context, this)
-	&& pairSet.sanitize (context, this, &closure);
+    return c->check_struct (this)
+	&& coverage.sanitize (c, this)
+	&& pairSet.sanitize (c, this, &closure);
   }
 
   private:
@@ -682,19 +682,19 @@
   friend struct PairPos;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length);
-    if (unlikely (context->buffer->in_pos + 2 > end))
+    unsigned int end = MIN (c->buffer->in_length, c->buffer->in_pos + c->context_length);
+    if (unlikely (c->buffer->in_pos + 2 > end))
       return false;
 
     unsigned int index = (this+coverage) (IN_CURGLYPH ());
     if (likely (index == NOT_COVERED))
       return false;
 
-    unsigned int j = context->buffer->in_pos + 1;
-    while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), context->lookup_flag, NULL))
+    unsigned int j = c->buffer->in_pos + 1;
+    while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), c->lookup_flag, NULL))
     {
       if (unlikely (j == end))
 	return false;
@@ -711,31 +711,31 @@
       return false;
 
     const Value *v = &values[record_len * (klass1 * class2Count + klass2)];
-    valueFormat1.apply_value (context->layout, this, v, CURPOSITION ());
-    valueFormat2.apply_value (context->layout, this, v + len1, POSITION (j));
+    valueFormat1.apply_value (c->layout, this, v, CURPOSITION ());
+    valueFormat2.apply_value (c->layout, this, v + len1, POSITION (j));
 
     if (len2)
       j++;
-    context->buffer->in_pos = j;
+    c->buffer->in_pos = j;
 
     return true;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!(context->check_struct (this)
-       && coverage.sanitize (context, this)
-       && classDef1.sanitize (context, this)
-       && classDef2.sanitize (context, this))) return false;
+    if (!(c->check_struct (this)
+       && coverage.sanitize (c, this)
+       && classDef1.sanitize (c, this)
+       && classDef2.sanitize (c, this))) return false;
 
     unsigned int len1 = valueFormat1.get_len ();
     unsigned int len2 = valueFormat2.get_len ();
     unsigned int stride = len1 + len2;
     unsigned int record_size = valueFormat1.get_size () + valueFormat2.get_size ();
     unsigned int count = (unsigned int) class1Count * (unsigned int) class2Count;
-    return context->check_array (values, record_size, count) &&
-	   valueFormat1.sanitize_values_stride_unsafe (context, this, &values[0], count, stride) &&
-	   valueFormat2.sanitize_values_stride_unsafe (context, this, &values[len1], count, stride);
+    return c->check_array (values, record_size, count) &&
+	   valueFormat1.sanitize_values_stride_unsafe (c, this, &values[0], count, stride) &&
+	   valueFormat2.sanitize_values_stride_unsafe (c, this, &values[len1], count, stride);
   }
 
   private:
@@ -773,22 +773,22 @@
   friend struct PosLookupSubTable;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     switch (u.format) {
-    case 1: return u.format1.apply (context);
-    case 2: return u.format2.apply (context);
+    case 1: return u.format1.apply (c);
+    case 2: return u.format2.apply (c);
     default:return false;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
-    case 2: return u.format2.sanitize (context);
+    case 1: return u.format1.sanitize (c);
+    case 2: return u.format2.sanitize (c);
     default:return true;
     }
   }
@@ -806,10 +806,10 @@
 {
   friend struct CursivePosFormat1;
 
-  inline bool sanitize (hb_sanitize_context_t *context, void *base) {
+  inline bool sanitize (hb_sanitize_context_t *c, void *base) {
     TRACE_SANITIZE ();
-    return entryAnchor.sanitize (context, base)
-	&& exitAnchor.sanitize (context, base);
+    return entryAnchor.sanitize (c, base)
+	&& exitAnchor.sanitize (c, base);
   }
 
   private:
@@ -830,7 +830,7 @@
   friend struct CursivePos;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     /* Now comes the messiest part of the whole OpenType
@@ -950,12 +950,12 @@
        Since horizontal advance widths or vertical advance heights
        can be used alone but not together, no ambiguity occurs.        */
 
-    struct hb_ot_layout_context_t::info_t::gpos_t *gpi = &context->layout->info.gpos;
+    struct hb_ot_layout_context_t::info_t::gpos_t *gpi = &c->layout->info.gpos;
     hb_codepoint_t last_pos = gpi->last;
     gpi->last = HB_OT_LAYOUT_GPOS_NO_LAST;
 
     /* We don't handle mark glyphs here. */
-    if (context->property == HB_OT_LAYOUT_GLYPH_CLASS_MARK)
+    if (c->property == HB_OT_LAYOUT_GLYPH_CLASS_MARK)
       return false;
 
     unsigned int index = (this+coverage) (IN_CURGLYPH ());
@@ -968,14 +968,14 @@
       goto end;
 
     hb_position_t entry_x, entry_y;
-    (this+record.entryAnchor).get_anchor (context->layout, IN_CURGLYPH (), &entry_x, &entry_y);
+    (this+record.entryAnchor).get_anchor (c->layout, IN_CURGLYPH (), &entry_x, &entry_y);
 
     /* TODO vertical */
 
-    if (context->buffer->direction == HB_DIRECTION_RTL)
+    if (c->buffer->direction == HB_DIRECTION_RTL)
     {
       /* advance is absolute, not relative */
-      POSITION (context->buffer->in_pos)->x_advance = entry_x - gpi->anchor_x;
+      POSITION (c->buffer->in_pos)->x_advance = entry_x - gpi->anchor_x;
     }
     else
     {
@@ -983,32 +983,32 @@
       POSITION (last_pos)->x_advance = gpi->anchor_x - entry_x;
     }
 
-    if  (context->lookup_flag & LookupFlag::RightToLeft)
+    if  (c->lookup_flag & LookupFlag::RightToLeft)
     {
-      POSITION (last_pos)->cursive_chain = last_pos - context->buffer->in_pos;
+      POSITION (last_pos)->cursive_chain = last_pos - c->buffer->in_pos;
       POSITION (last_pos)->y_offset = entry_y - gpi->anchor_y;
     }
     else
     {
-      POSITION (context->buffer->in_pos)->cursive_chain = context->buffer->in_pos - last_pos;
-      POSITION (context->buffer->in_pos)->y_offset = gpi->anchor_y - entry_y;
+      POSITION (c->buffer->in_pos)->cursive_chain = c->buffer->in_pos - last_pos;
+      POSITION (c->buffer->in_pos)->y_offset = gpi->anchor_y - entry_y;
     }
 
   end:
     if (record.exitAnchor)
     {
-      gpi->last = context->buffer->in_pos;
-      (this+record.exitAnchor).get_anchor (context->layout, IN_CURGLYPH (), &gpi->anchor_x, &gpi->anchor_y);
+      gpi->last = c->buffer->in_pos;
+      (this+record.exitAnchor).get_anchor (c->layout, IN_CURGLYPH (), &gpi->anchor_x, &gpi->anchor_y);
     }
 
-    context->buffer->in_pos++;
+    c->buffer->in_pos++;
     return true;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return coverage.sanitize (context, this)
-	&& entryExitRecord.sanitize (context, this);
+    return coverage.sanitize (c, this)
+	&& entryExitRecord.sanitize (c, this);
   }
 
   private:
@@ -1028,20 +1028,20 @@
   friend struct PosLookupSubTable;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     switch (u.format) {
-    case 1: return u.format1.apply (context);
+    case 1: return u.format1.apply (c);
     default:return false;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
+    case 1: return u.format1.sanitize (c);
     default:return true;
     }
   }
@@ -1064,7 +1064,7 @@
   friend struct MarkBasePos;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     unsigned int mark_index = (this+markCoverage) (IN_CURGLYPH ());
@@ -1073,13 +1073,13 @@
 
     /* now we search backwards for a non-mark glyph */
     unsigned int property;
-    unsigned int j = context->buffer->in_pos;
+    unsigned int j = c->buffer->in_pos;
     do
     {
       if (unlikely (!j))
 	return false;
       j--;
-    } while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property));
+    } while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property));
 
     /* The following assertion is too strong, so we've disabled it. */
     if (false && !(property & HB_OT_LAYOUT_GLYPH_CLASS_BASE_GLYPH))
@@ -1089,16 +1089,16 @@
     if (base_index == NOT_COVERED)
       return false;
 
-    return (this+markArray).apply (context, mark_index, base_index, this+baseArray, classCount, j);
+    return (this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, j);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this)
-        && markCoverage.sanitize (context, this)
-	&& baseCoverage.sanitize (context, this)
-	&& markArray.sanitize (context, this)
-	&& baseArray.sanitize (context, this, (unsigned int) classCount);
+    return c->check_struct (this)
+        && markCoverage.sanitize (c, this)
+	&& baseCoverage.sanitize (c, this)
+	&& markArray.sanitize (c, this)
+	&& baseArray.sanitize (c, this, (unsigned int) classCount);
   }
 
   private:
@@ -1125,20 +1125,20 @@
   friend struct PosLookupSubTable;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     switch (u.format) {
-    case 1: return u.format1.apply (context);
+    case 1: return u.format1.apply (c);
     default:return false;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
+    case 1: return u.format1.sanitize (c);
     default:return true;
     }
   }
@@ -1166,7 +1166,7 @@
   friend struct MarkLigPos;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     unsigned int mark_index = (this+markCoverage) (IN_CURGLYPH ());
@@ -1175,13 +1175,13 @@
 
     /* now we search backwards for a non-mark glyph */
     unsigned int property;
-    unsigned int j = context->buffer->in_pos;
+    unsigned int j = c->buffer->in_pos;
     do
     {
       if (unlikely (!j))
 	return false;
       j--;
-    } while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property));
+    } while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), LookupFlag::IgnoreMarks, &property));
 
     /* The following assertion is too strong, so we've disabled it. */
     if (false && !(property & HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE))
@@ -1203,25 +1203,25 @@
      * is identical to the ligature ID of the found ligature.  If yes, we
      * can directly use the component index.  If not, we attach the mark
      * glyph to the last component of the ligature. */
-    if (IN_LIGID (j) && IN_LIGID (j) == IN_LIGID (context->buffer->in_pos) && IN_COMPONENT (context->buffer->in_pos))
+    if (IN_LIGID (j) && IN_LIGID (j) == IN_LIGID (c->buffer->in_pos) && IN_COMPONENT (c->buffer->in_pos))
     {
-      comp_index = IN_COMPONENT (context->buffer->in_pos) - 1;
+      comp_index = IN_COMPONENT (c->buffer->in_pos) - 1;
       if (comp_index >= comp_count)
 	comp_index = comp_count - 1;
     }
     else
       comp_index = comp_count - 1;
 
-    return (this+markArray).apply (context, mark_index, comp_index, lig_attach, classCount, j);
+    return (this+markArray).apply (c, mark_index, comp_index, lig_attach, classCount, j);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this)
-        && markCoverage.sanitize (context, this)
-	&& ligatureCoverage.sanitize (context, this)
-	&& markArray.sanitize (context, this)
-	&& ligatureArray.sanitize (context, this, (unsigned int) classCount);
+    return c->check_struct (this)
+        && markCoverage.sanitize (c, this)
+	&& ligatureCoverage.sanitize (c, this)
+	&& markArray.sanitize (c, this)
+	&& ligatureArray.sanitize (c, this, (unsigned int) classCount);
   }
 
   private:
@@ -1249,20 +1249,20 @@
   friend struct PosLookupSubTable;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     switch (u.format) {
-    case 1: return u.format1.apply (context);
+    case 1: return u.format1.apply (c);
     default:return false;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
+    case 1: return u.format1.sanitize (c);
     default:return true;
     }
   }
@@ -1285,7 +1285,7 @@
   friend struct MarkMarkPos;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     unsigned int mark1_index = (this+mark1Coverage) (IN_CURGLYPH ());
@@ -1294,13 +1294,13 @@
 
     /* now we search backwards for a suitable mark glyph until a non-mark glyph */
     unsigned int property;
-    unsigned int j = context->buffer->in_pos;
+    unsigned int j = c->buffer->in_pos;
     do
     {
       if (unlikely (!j))
 	return false;
       j--;
-    } while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), context->lookup_flag, &property));
+    } while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), c->lookup_flag, &property));
 
     if (!(property & HB_OT_LAYOUT_GLYPH_CLASS_MARK))
       return false;
@@ -1308,24 +1308,24 @@
     /* Two marks match only if they belong to the same base, or same component
      * of the same ligature.  That is, the component numbers must match, and
      * if those are non-zero, the ligid number should also match. */
-    if ((IN_COMPONENT (j) != IN_COMPONENT (context->buffer->in_pos)) ||
-	(IN_COMPONENT (j) && IN_LIGID (j) != IN_LIGID (context->buffer->in_pos)))
+    if ((IN_COMPONENT (j) != IN_COMPONENT (c->buffer->in_pos)) ||
+	(IN_COMPONENT (j) && IN_LIGID (j) != IN_LIGID (c->buffer->in_pos)))
       return false;
 
     unsigned int mark2_index = (this+mark2Coverage) (IN_GLYPH (j));
     if (mark2_index == NOT_COVERED)
       return false;
 
-    return (this+mark1Array).apply (context, mark1_index, mark2_index, this+mark2Array, classCount, j);
+    return (this+mark1Array).apply (c, mark1_index, mark2_index, this+mark2Array, classCount, j);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this)
-	&& mark1Coverage.sanitize (context, this)
-	&& mark2Coverage.sanitize (context, this)
-	&& mark1Array.sanitize (context, this)
-	&& mark2Array.sanitize (context, this, (unsigned int) classCount);
+    return c->check_struct (this)
+	&& mark1Coverage.sanitize (c, this)
+	&& mark2Coverage.sanitize (c, this)
+	&& mark1Array.sanitize (c, this)
+	&& mark2Array.sanitize (c, this, (unsigned int) classCount);
   }
 
   private:
@@ -1354,20 +1354,20 @@
   friend struct PosLookupSubTable;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     switch (u.format) {
-    case 1: return u.format1.apply (context);
+    case 1: return u.format1.apply (c);
     default:return false;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
+    case 1: return u.format1.sanitize (c);
     default:return true;
     }
   }
@@ -1380,17 +1380,17 @@
 };
 
 
-static inline bool position_lookup (hb_apply_context_t *context, unsigned int lookup_index);
+static inline bool position_lookup (hb_apply_context_t *c, unsigned int lookup_index);
 
 struct ContextPos : Context
 {
   friend struct PosLookupSubTable;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    return Context::apply (context, position_lookup);
+    return Context::apply (c, position_lookup);
   }
 };
 
@@ -1399,10 +1399,10 @@
   friend struct PosLookupSubTable;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    return ChainContext::apply (context, position_lookup);
+    return ChainContext::apply (c, position_lookup);
   }
 };
 
@@ -1419,9 +1419,9 @@
     return StructAtOffset<PosLookupSubTable> (this, offset);
   }
 
-  inline bool apply (hb_apply_context_t *context) const;
+  inline bool apply (hb_apply_context_t *c) const;
 
-  inline bool sanitize (hb_sanitize_context_t *context);
+  inline bool sanitize (hb_sanitize_context_t *c);
 };
 
 
@@ -1447,35 +1447,35 @@
     Extension		= 9
   };
 
-  inline bool apply (hb_apply_context_t *context, unsigned int lookup_type) const
+  inline bool apply (hb_apply_context_t *c, unsigned int lookup_type) const
   {
     TRACE_APPLY ();
     switch (lookup_type) {
-    case Single:		return u.single.apply (context);
-    case Pair:			return u.pair.apply (context);
-    case Cursive:		return u.cursive.apply (context);
-    case MarkBase:		return u.markBase.apply (context);
-    case MarkLig:		return u.markLig.apply (context);
-    case MarkMark:		return u.markMark.apply (context);
-    case Context:		return u.context.apply (context);
-    case ChainContext:		return u.chainContext.apply (context);
-    case Extension:		return u.extension.apply (context);
+    case Single:		return u.single.apply (c);
+    case Pair:			return u.pair.apply (c);
+    case Cursive:		return u.cursive.apply (c);
+    case MarkBase:		return u.markBase.apply (c);
+    case MarkLig:		return u.markLig.apply (c);
+    case MarkMark:		return u.markMark.apply (c);
+    case Context:		return u.c.apply (c);
+    case ChainContext:		return u.chainContext.apply (c);
+    case Extension:		return u.extension.apply (c);
     default:return false;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context, unsigned int lookup_type) {
+  inline bool sanitize (hb_sanitize_context_t *c, unsigned int lookup_type) {
     TRACE_SANITIZE ();
     switch (lookup_type) {
-    case Single:		return u.single.sanitize (context);
-    case Pair:			return u.pair.sanitize (context);
-    case Cursive:		return u.cursive.sanitize (context);
-    case MarkBase:		return u.markBase.sanitize (context);
-    case MarkLig:		return u.markLig.sanitize (context);
-    case MarkMark:		return u.markMark.sanitize (context);
-    case Context:		return u.context.sanitize (context);
-    case ChainContext:		return u.chainContext.sanitize (context);
-    case Extension:		return u.extension.sanitize (context);
+    case Single:		return u.single.sanitize (c);
+    case Pair:			return u.pair.sanitize (c);
+    case Cursive:		return u.cursive.sanitize (c);
+    case MarkBase:		return u.markBase.sanitize (c);
+    case MarkLig:		return u.markLig.sanitize (c);
+    case MarkMark:		return u.markMark.sanitize (c);
+    case Context:		return u.c.sanitize (c);
+    case ChainContext:		return u.chainContext.sanitize (c);
+    case Extension:		return u.extension.sanitize (c);
     default:return true;
     }
   }
@@ -1489,7 +1489,7 @@
   MarkBasePos		markBase;
   MarkLigPos		markLig;
   MarkMarkPos		markMark;
-  ContextPos		context;
+  ContextPos		c;
   ChainContextPos	chainContext;
   ExtensionPos		extension;
   } u;
@@ -1509,19 +1509,19 @@
 			  unsigned int    nesting_level_left) const
   {
     unsigned int lookup_type = get_type ();
-    hb_apply_context_t context[1] = {{0}};
+    hb_apply_context_t c[1] = {{0}};
 
-    context->layout = layout;
-    context->buffer = buffer;
-    context->context_length = context_length;
-    context->nesting_level_left = nesting_level_left;
-    context->lookup_flag = get_flag ();
+    c->layout = layout;
+    c->buffer = buffer;
+    c->context_length = context_length;
+    c->nesting_level_left = nesting_level_left;
+    c->lookup_flag = get_flag ();
 
-    if (!_hb_ot_layout_check_glyph_property (context->layout->face, IN_CURINFO (), context->lookup_flag, &context->property))
+    if (!_hb_ot_layout_check_glyph_property (c->layout->face, IN_CURINFO (), c->lookup_flag, &c->property))
       return false;
 
     for (unsigned int i = 0; i < get_subtable_count (); i++)
-      if (get_subtable (i).apply (context, lookup_type))
+      if (get_subtable (i).apply (c, lookup_type))
 	return true;
 
     return false;
@@ -1564,11 +1564,11 @@
     return ret;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (unlikely (!Lookup::sanitize (context))) return false;
+    if (unlikely (!Lookup::sanitize (c))) return false;
     OffsetArrayOf<PosLookupSubTable> &list = CastR<OffsetArrayOf<PosLookupSubTable> > (subTable);
-    return list.sanitize (context, this, get_type ());
+    return list.sanitize (c, this, get_type ());
   }
 };
 
@@ -1591,11 +1591,11 @@
 			       hb_mask_t     mask) const
   { return get_lookup (lookup_index).apply_string (layout, buffer, mask); }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (unlikely (!GSUBGPOS::sanitize (context))) return false;
+    if (unlikely (!GSUBGPOS::sanitize (c))) return false;
     OffsetTo<PosLookupList> &list = CastR<OffsetTo<PosLookupList> > (lookupList);
-    return list.sanitize (context, this);
+    return list.sanitize (c, this);
   }
   public:
   DEFINE_SIZE_STATIC (10);
@@ -1604,33 +1604,33 @@
 
 /* Out-of-class implementation for methods recursing */
 
-inline bool ExtensionPos::apply (hb_apply_context_t *context) const
+inline bool ExtensionPos::apply (hb_apply_context_t *c) const
 {
   TRACE_APPLY ();
-  return get_subtable ().apply (context, get_type ());
+  return get_subtable ().apply (c, get_type ());
 }
 
-inline bool ExtensionPos::sanitize (hb_sanitize_context_t *context)
+inline bool ExtensionPos::sanitize (hb_sanitize_context_t *c)
 {
   TRACE_SANITIZE ();
-  if (unlikely (!Extension::sanitize (context))) return false;
+  if (unlikely (!Extension::sanitize (c))) return false;
   unsigned int offset = get_offset ();
   if (unlikely (!offset)) return true;
-  return StructAtOffset<PosLookupSubTable> (this, offset).sanitize (context, get_type ());
+  return StructAtOffset<PosLookupSubTable> (this, offset).sanitize (c, get_type ());
 }
 
-static inline bool position_lookup (hb_apply_context_t *context, unsigned int lookup_index)
+static inline bool position_lookup (hb_apply_context_t *c, unsigned int lookup_index)
 {
-  const GPOS &gpos = *(context->layout->face->ot_layout.gpos);
+  const GPOS &gpos = *(c->layout->face->ot_layout.gpos);
   const PosLookup &l = gpos.get_lookup (lookup_index);
 
-  if (unlikely (context->nesting_level_left == 0))
+  if (unlikely (c->nesting_level_left == 0))
     return false;
 
-  if (unlikely (context->context_length < 1))
+  if (unlikely (c->context_length < 1))
     return false;
 
-  return l.apply_once (context->layout, context->buffer, context->context_length, context->nesting_level_left - 1);
+  return l.apply_once (c->layout, c->buffer, c->context_length, c->nesting_level_left - 1);
 }
 
 
diff --git a/src/hb-ot-layout-gsub-private.hh b/src/hb-ot-layout-gsub-private.hh
index 2b5919e..766bae9 100644
--- a/src/hb-ot-layout-gsub-private.hh
+++ b/src/hb-ot-layout-gsub-private.hh
@@ -31,7 +31,7 @@
 
 
 #undef BUFFER
-#define BUFFER context->buffer
+#define BUFFER c->buffer
 
 
 struct SingleSubstFormat1
@@ -40,7 +40,7 @@
 
   private:
 
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     hb_codepoint_t glyph_id = IN_CURGLYPH ();
@@ -49,19 +49,19 @@
       return false;
 
     glyph_id += deltaGlyphID;
-    context->buffer->replace_glyph (glyph_id);
+    c->buffer->replace_glyph (glyph_id);
 
     /* We inherit the old glyph class to the substituted glyph */
-    if (_hb_ot_layout_has_new_glyph_classes (context->layout->face))
-      _hb_ot_layout_set_glyph_property (context->layout->face, glyph_id, context->property);
+    if (_hb_ot_layout_has_new_glyph_classes (c->layout->face))
+      _hb_ot_layout_set_glyph_property (c->layout->face, glyph_id, c->property);
 
     return true;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return coverage.sanitize (context, this)
-	&& deltaGlyphID.sanitize (context);
+    return coverage.sanitize (c, this)
+	&& deltaGlyphID.sanitize (c);
   }
 
   private:
@@ -81,7 +81,7 @@
 
   private:
 
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     hb_codepoint_t glyph_id = IN_CURGLYPH ();
@@ -93,19 +93,19 @@
       return false;
 
     glyph_id = substitute[index];
-    context->buffer->replace_glyph (glyph_id);
+    c->buffer->replace_glyph (glyph_id);
 
     /* We inherit the old glyph class to the substituted glyph */
-    if (_hb_ot_layout_has_new_glyph_classes (context->layout->face))
-      _hb_ot_layout_set_glyph_property (context->layout->face, glyph_id, context->property);
+    if (_hb_ot_layout_has_new_glyph_classes (c->layout->face))
+      _hb_ot_layout_set_glyph_property (c->layout->face, glyph_id, c->property);
 
     return true;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return coverage.sanitize (context, this)
-	&& substitute.sanitize (context);
+    return coverage.sanitize (c, this)
+	&& substitute.sanitize (c);
   }
 
   private:
@@ -126,22 +126,22 @@
 
   private:
 
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     switch (u.format) {
-    case 1: return u.format1.apply (context);
-    case 2: return u.format2.apply (context);
+    case 1: return u.format1.apply (c);
+    case 2: return u.format2.apply (c);
     default:return false;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
-    case 2: return u.format2.sanitize (context);
+    case 1: return u.format1.sanitize (c);
+    case 2: return u.format2.sanitize (c);
     default:return true;
     }
   }
@@ -160,35 +160,35 @@
   friend struct MultipleSubstFormat1;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     if (unlikely (!substitute.len))
       return false;
 
-    context->buffer->add_output_glyphs_be16 (1,
+    c->buffer->add_output_glyphs_be16 (1,
 					     substitute.len, (const uint16_t *) substitute.array,
 					     0xFFFF, 0xFFFF);
 
     /* This is a guess only ... */
-    if (_hb_ot_layout_has_new_glyph_classes (context->layout->face))
+    if (_hb_ot_layout_has_new_glyph_classes (c->layout->face))
     {
-      unsigned int property = context->property;
+      unsigned int property = c->property;
       if (property == HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE)
         property = HB_OT_LAYOUT_GLYPH_CLASS_BASE_GLYPH;
 
       unsigned int count = substitute.len;
       for (unsigned int n = 0; n < count; n++)
-	_hb_ot_layout_set_glyph_property (context->layout->face, substitute[n], property);
+	_hb_ot_layout_set_glyph_property (c->layout->face, substitute[n], property);
     }
 
     return true;
   }
 
   public:
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return substitute.sanitize (context);
+    return substitute.sanitize (c);
   }
 
   private:
@@ -204,7 +204,7 @@
 
   private:
 
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
 
@@ -212,13 +212,13 @@
     if (likely (index == NOT_COVERED))
       return false;
 
-    return (this+sequence[index]).apply (context);
+    return (this+sequence[index]).apply (c);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return coverage.sanitize (context, this)
-	&& sequence.sanitize (context, this);
+    return coverage.sanitize (c, this)
+	&& sequence.sanitize (c, this);
   }
 
   private:
@@ -239,20 +239,20 @@
 
   private:
 
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     switch (u.format) {
-    case 1: return u.format1.apply (context);
+    case 1: return u.format1.apply (c);
     default:return false;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
+    case 1: return u.format1.sanitize (c);
     default:return true;
     }
   }
@@ -274,7 +274,7 @@
 
   private:
 
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     hb_codepoint_t glyph_id = IN_CURGLYPH ();
@@ -291,9 +291,9 @@
     unsigned int alt_index = 0;
 
     /* XXX callback to user to choose alternate
-    if (context->layout->face->altfunc)
-      alt_index = (context->layout->face->altfunc)(context->layout->layout, context->buffer,
-				    context->buffer->out_pos, glyph_id,
+    if (c->layout->face->altfunc)
+      alt_index = (c->layout->face->altfunc)(c->layout->layout, c->buffer,
+				    c->buffer->out_pos, glyph_id,
 				    alt_set.len, alt_set.array);
 				   */
 
@@ -302,19 +302,19 @@
 
     glyph_id = alt_set[alt_index];
 
-    context->buffer->replace_glyph (glyph_id);
+    c->buffer->replace_glyph (glyph_id);
 
     /* We inherit the old glyph class to the substituted glyph */
-    if (_hb_ot_layout_has_new_glyph_classes (context->layout->face))
-      _hb_ot_layout_set_glyph_property (context->layout->face, glyph_id, context->property);
+    if (_hb_ot_layout_has_new_glyph_classes (c->layout->face))
+      _hb_ot_layout_set_glyph_property (c->layout->face, glyph_id, c->property);
 
     return true;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return coverage.sanitize (context, this)
-	&& alternateSet.sanitize (context, this);
+    return coverage.sanitize (c, this)
+	&& alternateSet.sanitize (c, this);
   }
 
   private:
@@ -335,20 +335,20 @@
 
   private:
 
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     switch (u.format) {
-    case 1: return u.format1.apply (context);
+    case 1: return u.format1.apply (c);
     default:return false;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
+    case 1: return u.format1.sanitize (c);
     default:return true;
     }
   }
@@ -366,19 +366,19 @@
   friend struct LigatureSet;
 
   private:
-  inline bool apply (hb_apply_context_t *context, bool is_mark) const
+  inline bool apply (hb_apply_context_t *c, bool is_mark) const
   {
     TRACE_APPLY ();
     unsigned int i, j;
     unsigned int count = component.len;
-    unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length);
-    if (unlikely (context->buffer->in_pos + count > end))
+    unsigned int end = MIN (c->buffer->in_length, c->buffer->in_pos + c->context_length);
+    if (unlikely (c->buffer->in_pos + count > end))
       return false;
 
-    for (i = 1, j = context->buffer->in_pos + 1; i < count; i++, j++)
+    for (i = 1, j = c->buffer->in_pos + 1; i < count; i++, j++)
     {
       unsigned int property;
-      while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), context->lookup_flag, &property))
+      while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), c->lookup_flag, &property))
       {
 	if (unlikely (j + count - i == end))
 	  return false;
@@ -392,23 +392,23 @@
         return false;
     }
     /* This is just a guess ... */
-    if (_hb_ot_layout_has_new_glyph_classes (context->layout->face))
-      _hb_ot_layout_set_glyph_class (context->layout->face, ligGlyph,
+    if (_hb_ot_layout_has_new_glyph_classes (c->layout->face))
+      _hb_ot_layout_set_glyph_class (c->layout->face, ligGlyph,
 				     is_mark ? HB_OT_LAYOUT_GLYPH_CLASS_MARK
 					     : HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE);
 
-    if (j == context->buffer->in_pos + i) /* No input glyphs skipped */
+    if (j == c->buffer->in_pos + i) /* No input glyphs skipped */
       /* We don't use a new ligature ID if there are no skipped
 	 glyphs and the ligature already has an ID. */
-      context->buffer->add_output_glyphs_be16 (i,
+      c->buffer->add_output_glyphs_be16 (i,
 					       1, (const uint16_t *) &ligGlyph,
 					       0,
-					       IN_LIGID (context->buffer->in_pos) && !IN_COMPONENT (context->buffer->in_pos) ?
-					       0xFFFF : context->buffer->allocate_lig_id ());
+					       IN_LIGID (c->buffer->in_pos) && !IN_COMPONENT (c->buffer->in_pos) ?
+					       0xFFFF : c->buffer->allocate_lig_id ());
     else
     {
-      unsigned int lig_id = context->buffer->allocate_lig_id ();
-      context->buffer->add_output_glyph (ligGlyph, 0xFFFF, lig_id);
+      unsigned int lig_id = c->buffer->allocate_lig_id ();
+      c->buffer->add_output_glyph (ligGlyph, 0xFFFF, lig_id);
 
       /* Now we must do a second loop to copy the skipped glyphs to
 	 `out' and assign component values to it.  We start with the
@@ -419,10 +419,10 @@
 
       for ( i = 1; i < count; i++ )
       {
-	while (_hb_ot_layout_skip_mark (context->layout->face, IN_CURINFO (), context->lookup_flag, NULL))
-	  context->buffer->add_output_glyph (IN_CURGLYPH (), i, lig_id);
+	while (_hb_ot_layout_skip_mark (c->layout->face, IN_CURINFO (), c->lookup_flag, NULL))
+	  c->buffer->add_output_glyph (IN_CURGLYPH (), i, lig_id);
 
-	(context->buffer->in_pos)++;
+	(c->buffer->in_pos)++;
       }
     }
 
@@ -430,10 +430,10 @@
   }
 
   public:
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return ligGlyph.sanitize (context)
-        && component.sanitize (context);
+    return ligGlyph.sanitize (c)
+        && component.sanitize (c);
   }
 
   private:
@@ -451,14 +451,14 @@
   friend struct LigatureSubstFormat1;
 
   private:
-  inline bool apply (hb_apply_context_t *context, bool is_mark) const
+  inline bool apply (hb_apply_context_t *c, bool is_mark) const
   {
     TRACE_APPLY ();
     unsigned int num_ligs = ligature.len;
     for (unsigned int i = 0; i < num_ligs; i++)
     {
       const Ligature &lig = this+ligature[i];
-      if (lig.apply (context, is_mark))
+      if (lig.apply (c, is_mark))
         return true;
     }
 
@@ -466,9 +466,9 @@
   }
 
   public:
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return ligature.sanitize (context, this);
+    return ligature.sanitize (c, this);
   }
 
   private:
@@ -484,25 +484,25 @@
   friend struct LigatureSubst;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     hb_codepoint_t glyph_id = IN_CURGLYPH ();
 
-    bool first_is_mark = !!(context->property & HB_OT_LAYOUT_GLYPH_CLASS_MARK);
+    bool first_is_mark = !!(c->property & HB_OT_LAYOUT_GLYPH_CLASS_MARK);
 
     unsigned int index = (this+coverage) (glyph_id);
     if (likely (index == NOT_COVERED))
       return false;
 
     const LigatureSet &lig_set = this+ligatureSet[index];
-    return lig_set.apply (context, first_is_mark);
+    return lig_set.apply (c, first_is_mark);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return coverage.sanitize (context, this)
-	&& ligatureSet.sanitize (context, this);
+    return coverage.sanitize (c, this)
+	&& ligatureSet.sanitize (c, this);
   }
 
   private:
@@ -522,20 +522,20 @@
   friend struct SubstLookupSubTable;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     switch (u.format) {
-    case 1: return u.format1.apply (context);
+    case 1: return u.format1.apply (c);
     default:return false;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
+    case 1: return u.format1.sanitize (c);
     default:return true;
     }
   }
@@ -549,17 +549,17 @@
 
 
 
-static inline bool substitute_lookup (hb_apply_context_t *context, unsigned int lookup_index);
+static inline bool substitute_lookup (hb_apply_context_t *c, unsigned int lookup_index);
 
 struct ContextSubst : Context
 {
   friend struct SubstLookupSubTable;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    return Context::apply (context, substitute_lookup);
+    return Context::apply (c, substitute_lookup);
   }
 };
 
@@ -568,10 +568,10 @@
   friend struct SubstLookupSubTable;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    return ChainContext::apply (context, substitute_lookup);
+    return ChainContext::apply (c, substitute_lookup);
   }
 };
 
@@ -589,9 +589,9 @@
     return StructAtOffset<SubstLookupSubTable> (this, offset);
   }
 
-  inline bool apply (hb_apply_context_t *context) const;
+  inline bool apply (hb_apply_context_t *c) const;
 
-  inline bool sanitize (hb_sanitize_context_t *context);
+  inline bool sanitize (hb_sanitize_context_t *c);
 
   inline bool is_reverse (void) const;
 };
@@ -602,10 +602,10 @@
   friend struct ReverseChainSingleSubst;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
-    if (unlikely (context->context_length != NO_CONTEXT))
+    if (unlikely (c->context_length != NO_CONTEXT))
       return false; /* No chaining to this type */
 
     unsigned int index = (this+coverage) (IN_CURGLYPH ());
@@ -615,32 +615,32 @@
     const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
     const ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID> > (lookahead);
 
-    if (match_backtrack (context,
+    if (match_backtrack (c,
 			 backtrack.len, (USHORT *) backtrack.array,
 			 match_coverage, this) &&
-        match_lookahead (context,
+        match_lookahead (c,
 			 lookahead.len, (USHORT *) lookahead.array,
 			 match_coverage, this,
 			 1))
     {
       IN_CURGLYPH () = substitute[index];
-      context->buffer->in_pos--; /* Reverse! */
+      c->buffer->in_pos--; /* Reverse! */
       return true;
     }
 
     return false;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!(coverage.sanitize (context, this)
-       && backtrack.sanitize (context, this)))
+    if (!(coverage.sanitize (c, this)
+       && backtrack.sanitize (c, this)))
       return false;
     OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
-    if (!lookahead.sanitize (context, this))
+    if (!lookahead.sanitize (c, this))
       return false;
     ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID> > (lookahead);
-    return substitute.sanitize (context);
+    return substitute.sanitize (c);
   }
 
   private:
@@ -668,20 +668,20 @@
   friend struct SubstLookupSubTable;
 
   private:
-  inline bool apply (hb_apply_context_t *context) const
+  inline bool apply (hb_apply_context_t *c) const
   {
     TRACE_APPLY ();
     switch (u.format) {
-    case 1: return u.format1.apply (context);
+    case 1: return u.format1.apply (c);
     default:return false;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
+    case 1: return u.format1.sanitize (c);
     default:return true;
     }
   }
@@ -714,33 +714,33 @@
     ReverseChainSingle	= 8
   };
 
-  inline bool apply (hb_apply_context_t *context, unsigned int lookup_type) const
+  inline bool apply (hb_apply_context_t *c, unsigned int lookup_type) const
   {
     TRACE_APPLY ();
     switch (lookup_type) {
-    case Single:		return u.single.apply (context);
-    case Multiple:		return u.multiple.apply (context);
-    case Alternate:		return u.alternate.apply (context);
-    case Ligature:		return u.ligature.apply (context);
-    case Context:		return u.context.apply (context);
-    case ChainContext:		return u.chainContext.apply (context);
-    case Extension:		return u.extension.apply (context);
-    case ReverseChainSingle:	return u.reverseChainContextSingle.apply (context);
+    case Single:		return u.single.apply (c);
+    case Multiple:		return u.multiple.apply (c);
+    case Alternate:		return u.alternate.apply (c);
+    case Ligature:		return u.ligature.apply (c);
+    case Context:		return u.c.apply (c);
+    case ChainContext:		return u.chainContext.apply (c);
+    case Extension:		return u.extension.apply (c);
+    case ReverseChainSingle:	return u.reverseChainContextSingle.apply (c);
     default:return false;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context, unsigned int lookup_type) {
+  inline bool sanitize (hb_sanitize_context_t *c, unsigned int lookup_type) {
     TRACE_SANITIZE ();
     switch (lookup_type) {
-    case Single:		return u.single.sanitize (context);
-    case Multiple:		return u.multiple.sanitize (context);
-    case Alternate:		return u.alternate.sanitize (context);
-    case Ligature:		return u.ligature.sanitize (context);
-    case Context:		return u.context.sanitize (context);
-    case ChainContext:		return u.chainContext.sanitize (context);
-    case Extension:		return u.extension.sanitize (context);
-    case ReverseChainSingle:	return u.reverseChainContextSingle.sanitize (context);
+    case Single:		return u.single.sanitize (c);
+    case Multiple:		return u.multiple.sanitize (c);
+    case Alternate:		return u.alternate.sanitize (c);
+    case Ligature:		return u.ligature.sanitize (c);
+    case Context:		return u.c.sanitize (c);
+    case ChainContext:		return u.chainContext.sanitize (c);
+    case Extension:		return u.extension.sanitize (c);
+    case ReverseChainSingle:	return u.reverseChainContextSingle.sanitize (c);
     default:return true;
     }
   }
@@ -752,7 +752,7 @@
   MultipleSubst			multiple;
   AlternateSubst		alternate;
   LigatureSubst			ligature;
-  ContextSubst			context;
+  ContextSubst			c;
   ChainContextSubst		chainContext;
   ExtensionSubst		extension;
   ReverseChainSingleSubst	reverseChainContextSingle;
@@ -785,15 +785,15 @@
 			  unsigned int nesting_level_left) const
   {
     unsigned int lookup_type = get_type ();
-    hb_apply_context_t context[1] = {{0}};
+    hb_apply_context_t c[1] = {{0}};
 
-    context->layout = layout;
-    context->buffer = buffer;
-    context->context_length = context_length;
-    context->nesting_level_left = nesting_level_left;
-    context->lookup_flag = get_flag ();
+    c->layout = layout;
+    c->buffer = buffer;
+    c->context_length = context_length;
+    c->nesting_level_left = nesting_level_left;
+    c->lookup_flag = get_flag ();
 
-    if (!_hb_ot_layout_check_glyph_property (context->layout->face, IN_CURINFO (), context->lookup_flag, &context->property))
+    if (!_hb_ot_layout_check_glyph_property (c->layout->face, IN_CURINFO (), c->lookup_flag, &c->property))
       return false;
 
     if (unlikely (lookup_type == SubstLookupSubTable::Extension))
@@ -812,7 +812,7 @@
 
     unsigned int count = get_subtable_count ();
     for (unsigned int i = 0; i < count; i++)
-      if (get_subtable (i).apply (context, lookup_type))
+      if (get_subtable (i).apply (c, lookup_type))
 	return true;
 
     return false;
@@ -865,11 +865,11 @@
     return ret;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (unlikely (!Lookup::sanitize (context))) return false;
+    if (unlikely (!Lookup::sanitize (c))) return false;
     OffsetArrayOf<SubstLookupSubTable> &list = CastR<OffsetArrayOf<SubstLookupSubTable> > (subTable);
-    return list.sanitize (context, this, get_type ());
+    return list.sanitize (c, this, get_type ());
   }
 };
 
@@ -892,11 +892,11 @@
 				 hb_mask_t     mask) const
   { return get_lookup (lookup_index).apply_string (layout, buffer, mask); }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (unlikely (!GSUBGPOS::sanitize (context))) return false;
+    if (unlikely (!GSUBGPOS::sanitize (c))) return false;
     OffsetTo<SubstLookupList> &list = CastR<OffsetTo<SubstLookupList> > (lookupList);
-    return list.sanitize (context, this);
+    return list.sanitize (c, this);
   }
   public:
   DEFINE_SIZE_STATIC (10);
@@ -905,19 +905,19 @@
 
 /* Out-of-class implementation for methods recursing */
 
-inline bool ExtensionSubst::apply (hb_apply_context_t *context) const
+inline bool ExtensionSubst::apply (hb_apply_context_t *c) const
 {
   TRACE_APPLY ();
-  return get_subtable ().apply (context, get_type ());
+  return get_subtable ().apply (c, get_type ());
 }
 
-inline bool ExtensionSubst::sanitize (hb_sanitize_context_t *context)
+inline bool ExtensionSubst::sanitize (hb_sanitize_context_t *c)
 {
   TRACE_SANITIZE ();
-  if (unlikely (!Extension::sanitize (context))) return false;
+  if (unlikely (!Extension::sanitize (c))) return false;
   unsigned int offset = get_offset ();
   if (unlikely (!offset)) return true;
-  return StructAtOffset<SubstLookupSubTable> (this, offset).sanitize (context, get_type ());
+  return StructAtOffset<SubstLookupSubTable> (this, offset).sanitize (c, get_type ());
 }
 
 inline bool ExtensionSubst::is_reverse (void) const
@@ -928,18 +928,18 @@
   return SubstLookup::lookup_type_is_reverse (type);
 }
 
-static inline bool substitute_lookup (hb_apply_context_t *context, unsigned int lookup_index)
+static inline bool substitute_lookup (hb_apply_context_t *c, unsigned int lookup_index)
 {
-  const GSUB &gsub = *(context->layout->face->ot_layout.gsub);
+  const GSUB &gsub = *(c->layout->face->ot_layout.gsub);
   const SubstLookup &l = gsub.get_lookup (lookup_index);
 
-  if (unlikely (context->nesting_level_left == 0))
+  if (unlikely (c->nesting_level_left == 0))
     return false;
 
-  if (unlikely (context->context_length < 1))
+  if (unlikely (c->context_length < 1))
     return false;
 
-  return l.apply_once (context->layout, context->buffer, context->context_length, context->nesting_level_left - 1);
+  return l.apply_once (c->layout, c->buffer, c->context_length, c->nesting_level_left - 1);
 }
 
 
diff --git a/src/hb-ot-layout-gsubgpos-private.hh b/src/hb-ot-layout-gsubgpos-private.hh
index cefde13..71c2975 100644
--- a/src/hb-ot-layout-gsubgpos-private.hh
+++ b/src/hb-ot-layout-gsubgpos-private.hh
@@ -36,7 +36,7 @@
 #endif
 
 #define TRACE_APPLY() \
-	hb_trace_t<HB_DEBUG_APPLY> trace (&context->debug_depth, "APPLY", HB_FUNC, this); \
+	hb_trace_t<HB_DEBUG_APPLY> trace (&c->debug_depth, "APPLY", HB_FUNC, this); \
 
 
 struct hb_apply_context_t
@@ -54,11 +54,11 @@
 
 
 #undef BUFFER
-#define BUFFER context->buffer
+#define BUFFER c->buffer
 
 
 typedef bool (*match_func_t) (hb_codepoint_t glyph_id, const USHORT &value, const void *data);
-typedef bool (*apply_lookup_func_t) (hb_apply_context_t *context, unsigned int lookup_index);
+typedef bool (*apply_lookup_func_t) (hb_apply_context_t *c, unsigned int lookup_index);
 
 struct ContextFuncs
 {
@@ -85,7 +85,7 @@
 }
 
 
-static inline bool match_input (hb_apply_context_t *context,
+static inline bool match_input (hb_apply_context_t *c,
 				unsigned int count, /* Including the first glyph (not matched) */
 				const USHORT input[], /* Array of input values--start with second glyph */
 				match_func_t match_func,
@@ -93,13 +93,13 @@
 				unsigned int *context_length_out)
 {
   unsigned int i, j;
-  unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length);
-  if (unlikely (context->buffer->in_pos + count > end))
+  unsigned int end = MIN (c->buffer->in_length, c->buffer->in_pos + c->context_length);
+  if (unlikely (c->buffer->in_pos + count > end))
     return false;
 
-  for (i = 1, j = context->buffer->in_pos + 1; i < count; i++, j++)
+  for (i = 1, j = c->buffer->in_pos + 1; i < count; i++, j++)
   {
-    while (_hb_ot_layout_skip_mark (context->layout->face, IN_INFO (j), context->lookup_flag, NULL))
+    while (_hb_ot_layout_skip_mark (c->layout->face, IN_INFO (j), c->lookup_flag, NULL))
     {
       if (unlikely (j + count - i == end))
 	return false;
@@ -110,23 +110,23 @@
       return false;
   }
 
-  *context_length_out = j - context->buffer->in_pos;
+  *context_length_out = j - c->buffer->in_pos;
 
   return true;
 }
 
-static inline bool match_backtrack (hb_apply_context_t *context,
+static inline bool match_backtrack (hb_apply_context_t *c,
 				    unsigned int count,
 				    const USHORT backtrack[],
 				    match_func_t match_func,
 				    const void *match_data)
 {
-  if (unlikely (context->buffer->out_pos < count))
+  if (unlikely (c->buffer->out_pos < count))
     return false;
 
-  for (unsigned int i = 0, j = context->buffer->out_pos - 1; i < count; i++, j--)
+  for (unsigned int i = 0, j = c->buffer->out_pos - 1; i < count; i++, j--)
   {
-    while (_hb_ot_layout_skip_mark (context->layout->face, OUT_INFO (j), context->lookup_flag, NULL))
+    while (_hb_ot_layout_skip_mark (c->layout->face, OUT_INFO (j), c->lookup_flag, NULL))
     {
       if (unlikely (j + 1 == count - i))
 	return false;
@@ -140,7 +140,7 @@
   return true;
 }
 
-static inline bool match_lookahead (hb_apply_context_t *context,
+static inline bool match_lookahead (hb_apply_context_t *c,
 				    unsigned int count,
 				    const USHORT lookahead[],
 				    match_func_t match_func,
@@ -148,13 +148,13 @@
 				    unsigned int offset)
 {
   unsigned int i, j;
-  unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length);
-  if (unlikely (context->buffer->in_pos + offset + count > end))
+  unsigned int end = MIN (c->buffer->in_length, c->buffer->in_pos + c->context_length);
+  if (unlikely (c->buffer->in_pos + offset + count > end))
     return false;
 
-  for (i = 0, j = context->buffer->in_pos + offset; i < count; i++, j++)
+  for (i = 0, j = c->buffer->in_pos + offset; i < count; i++, j++)
   {
-    while (_hb_ot_layout_skip_mark (context->layout->face, OUT_INFO (j), context->lookup_flag, NULL))
+    while (_hb_ot_layout_skip_mark (c->layout->face, OUT_INFO (j), c->lookup_flag, NULL))
     {
       if (unlikely (j + count - i == end))
 	return false;
@@ -171,9 +171,9 @@
 
 struct LookupRecord
 {
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this);
+    return c->check_struct (this);
   }
 
   USHORT	sequenceIndex;		/* Index into current glyph
@@ -184,14 +184,14 @@
   DEFINE_SIZE_STATIC (4);
 };
 
-static inline bool apply_lookup (hb_apply_context_t *context,
+static inline bool apply_lookup (hb_apply_context_t *c,
 				 unsigned int count, /* Including the first glyph */
 				 unsigned int lookupCount,
 				 const LookupRecord lookupRecord[], /* Array of LookupRecords--in design order */
 				 apply_lookup_func_t apply_func)
 {
-  unsigned int end = MIN (context->buffer->in_length, context->buffer->in_pos + context->context_length);
-  if (unlikely (context->buffer->in_pos + count > end))
+  unsigned int end = MIN (c->buffer->in_length, c->buffer->in_pos + c->context_length);
+  if (unlikely (c->buffer->in_pos + count > end))
     return false;
 
   /* TODO We don't support lookupRecord arrays that are not increasing:
@@ -203,26 +203,26 @@
    */
   for (unsigned int i = 0; i < count; /* NOP */)
   {
-    while (_hb_ot_layout_skip_mark (context->layout->face, IN_CURINFO (), context->lookup_flag, NULL))
+    while (_hb_ot_layout_skip_mark (c->layout->face, IN_CURINFO (), c->lookup_flag, NULL))
     {
-      if (unlikely (context->buffer->in_pos == end))
+      if (unlikely (c->buffer->in_pos == end))
 	return true;
       /* No lookup applied for this index */
-      context->buffer->next_glyph ();
+      c->buffer->next_glyph ();
     }
 
     if (lookupCount && i == lookupRecord->sequenceIndex)
     {
-      unsigned int old_pos = context->buffer->in_pos;
+      unsigned int old_pos = c->buffer->in_pos;
 
       /* Apply a lookup */
-      bool done = apply_func (context, lookupRecord->lookupListIndex);
+      bool done = apply_func (c, lookupRecord->lookupListIndex);
 
       lookupRecord++;
       lookupCount--;
       /* Err, this is wrong if the lookup jumped over some glyphs */
-      i += context->buffer->in_pos - old_pos;
-      if (unlikely (context->buffer->in_pos == end))
+      i += c->buffer->in_pos - old_pos;
+      if (unlikely (c->buffer->in_pos == end))
 	return true;
 
       if (!done)
@@ -232,7 +232,7 @@
     {
     not_applied:
       /* No lookup applied for this index */
-      context->buffer->next_glyph ();
+      c->buffer->next_glyph ();
       i++;
     }
   }
@@ -249,15 +249,15 @@
   const void *match_data;
 };
 
-static inline bool context_lookup (hb_apply_context_t *context,
+static inline bool context_lookup (hb_apply_context_t *c,
 				   unsigned int inputCount, /* Including the first glyph (not matched) */
 				   const USHORT input[], /* Array of input values--start with second glyph */
 				   unsigned int lookupCount,
 				   const LookupRecord lookupRecord[],
 				   ContextLookupContext &lookup_context)
 {
-  hb_apply_context_t new_context = *context;
-  return match_input (context,
+  hb_apply_context_t new_context = *c;
+  return match_input (c,
 		      inputCount, input,
 		      lookup_context.funcs.match, lookup_context.match_data,
 		      &new_context.context_length)
@@ -272,22 +272,22 @@
   friend struct RuleSet;
 
   private:
-  inline bool apply (hb_apply_context_t *context, ContextLookupContext &lookup_context) const
+  inline bool apply (hb_apply_context_t *c, ContextLookupContext &lookup_context) const
   {
     TRACE_APPLY ();
     const LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (input, input[0].static_size * (inputCount ? inputCount - 1 : 0));
-    return context_lookup (context,
+    return context_lookup (c,
 			   inputCount, input,
 			   lookupCount, lookupRecord,
 			   lookup_context);
   }
 
   public:
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return inputCount.sanitize (context)
-	&& lookupCount.sanitize (context)
-	&& context->check_range (input,
+    return inputCount.sanitize (c)
+	&& lookupCount.sanitize (c)
+	&& c->check_range (input,
 				 input[0].static_size * inputCount
 				 + lookupRecordX[0].static_size * lookupCount);
   }
@@ -307,22 +307,22 @@
 
 struct RuleSet
 {
-  inline bool apply (hb_apply_context_t *context, ContextLookupContext &lookup_context) const
+  inline bool apply (hb_apply_context_t *c, ContextLookupContext &lookup_context) const
   {
     TRACE_APPLY ();
     unsigned int num_rules = rule.len;
     for (unsigned int i = 0; i < num_rules; i++)
     {
-      if ((this+rule[i]).apply (context, lookup_context))
+      if ((this+rule[i]).apply (c, lookup_context))
         return true;
     }
 
     return false;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return rule.sanitize (context, this);
+    return rule.sanitize (c, this);
   }
 
   private:
@@ -339,7 +339,7 @@
   friend struct Context;
 
   private:
-  inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const
+  inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) const
   {
     TRACE_APPLY ();
     unsigned int index = (this+coverage) (IN_CURGLYPH ());
@@ -351,13 +351,13 @@
       {match_glyph, apply_func},
       NULL
     };
-    return rule_set.apply (context, lookup_context);
+    return rule_set.apply (c, lookup_context);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return coverage.sanitize (context, this)
-	&& ruleSet.sanitize (context, this);
+    return coverage.sanitize (c, this)
+	&& ruleSet.sanitize (c, this);
   }
 
   private:
@@ -378,7 +378,7 @@
   friend struct Context;
 
   private:
-  inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const
+  inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) const
   {
     TRACE_APPLY ();
     unsigned int index = (this+coverage) (IN_CURGLYPH ());
@@ -395,14 +395,14 @@
       {match_class, apply_func},
       &class_def
     };
-    return rule_set.apply (context, lookup_context);
+    return rule_set.apply (c, lookup_context);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return coverage.sanitize (context, this)
-        && classDef.sanitize (context, this)
-	&& ruleSet.sanitize (context, this);
+    return coverage.sanitize (c, this)
+        && classDef.sanitize (c, this)
+	&& ruleSet.sanitize (c, this);
   }
 
   private:
@@ -426,7 +426,7 @@
   friend struct Context;
 
   private:
-  inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const
+  inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) const
   {
     TRACE_APPLY ();
     unsigned int index = (this+coverage[0]) (IN_CURGLYPH ());
@@ -438,21 +438,21 @@
       {match_coverage, apply_func},
       this
     };
-    return context_lookup (context,
+    return context_lookup (c,
 			   glyphCount, (const USHORT *) (coverage + 1),
 			   lookupCount, lookupRecord,
 			   lookup_context);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!context->check_struct (this)) return false;
+    if (!c->check_struct (this)) return false;
     unsigned int count = glyphCount;
-    if (!context->check_array (coverage, coverage[0].static_size, count)) return false;
+    if (!c->check_array (coverage, coverage[0].static_size, count)) return false;
     for (unsigned int i = 0; i < count; i++)
-      if (!coverage[i].sanitize (context, this)) return false;
+      if (!coverage[i].sanitize (c, this)) return false;
     LookupRecord *lookupRecord = &StructAtOffset<LookupRecord> (coverage, coverage[0].static_size * count);
-    return context->check_array (lookupRecord, lookupRecord[0].static_size, lookupCount);
+    return c->check_array (lookupRecord, lookupRecord[0].static_size, lookupCount);
   }
 
   private:
@@ -472,24 +472,24 @@
 struct Context
 {
   protected:
-  inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const
+  inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) const
   {
     TRACE_APPLY ();
     switch (u.format) {
-    case 1: return u.format1.apply (context, apply_func);
-    case 2: return u.format2.apply (context, apply_func);
-    case 3: return u.format3.apply (context, apply_func);
+    case 1: return u.format1.apply (c, apply_func);
+    case 2: return u.format2.apply (c, apply_func);
+    case 3: return u.format3.apply (c, apply_func);
     default:return false;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
-    case 2: return u.format2.sanitize (context);
-    case 3: return u.format3.sanitize (context);
+    case 1: return u.format1.sanitize (c);
+    case 2: return u.format2.sanitize (c);
+    case 3: return u.format3.sanitize (c);
     default:return true;
     }
   }
@@ -512,7 +512,7 @@
   const void *match_data[3];
 };
 
-static inline bool chain_context_lookup (hb_apply_context_t *context,
+static inline bool chain_context_lookup (hb_apply_context_t *c,
 					 unsigned int backtrackCount,
 					 const USHORT backtrack[],
 					 unsigned int inputCount, /* Including the first glyph (not matched) */
@@ -524,20 +524,20 @@
 					 ChainContextLookupContext &lookup_context)
 {
   /* First guess */
-  if (unlikely (context->buffer->out_pos < backtrackCount ||
-		context->buffer->in_pos + inputCount + lookaheadCount > context->buffer->in_length ||
-		inputCount + lookaheadCount > context->context_length))
+  if (unlikely (c->buffer->out_pos < backtrackCount ||
+		c->buffer->in_pos + inputCount + lookaheadCount > c->buffer->in_length ||
+		inputCount + lookaheadCount > c->context_length))
     return false;
 
-  hb_apply_context_t new_context = *context;
-  return match_backtrack (context,
+  hb_apply_context_t new_context = *c;
+  return match_backtrack (c,
 			  backtrackCount, backtrack,
 			  lookup_context.funcs.match, lookup_context.match_data[0])
-      && match_input (context,
+      && match_input (c,
 		      inputCount, input,
 		      lookup_context.funcs.match, lookup_context.match_data[1],
 		      &new_context.context_length)
-      && match_lookahead (context,
+      && match_lookahead (c,
 			  lookaheadCount, lookahead,
 			  lookup_context.funcs.match, lookup_context.match_data[2],
 			  new_context.context_length)
@@ -552,13 +552,13 @@
   friend struct ChainRuleSet;
 
   private:
-  inline bool apply (hb_apply_context_t *context, ChainContextLookupContext &lookup_context) const
+  inline bool apply (hb_apply_context_t *c, ChainContextLookupContext &lookup_context) const
   {
     TRACE_APPLY ();
     const HeadlessArrayOf<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
     const ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
     const ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
-    return chain_context_lookup (context,
+    return chain_context_lookup (c,
 				 backtrack.len, backtrack.array,
 				 input.len, input.array,
 				 lookahead.len, lookahead.array,
@@ -568,15 +568,15 @@
   }
 
   public:
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!backtrack.sanitize (context)) return false;
+    if (!backtrack.sanitize (c)) return false;
     HeadlessArrayOf<USHORT> &input = StructAfter<HeadlessArrayOf<USHORT> > (backtrack);
-    if (!input.sanitize (context)) return false;
+    if (!input.sanitize (c)) return false;
     ArrayOf<USHORT> &lookahead = StructAfter<ArrayOf<USHORT> > (input);
-    if (!lookahead.sanitize (context)) return false;
+    if (!lookahead.sanitize (c)) return false;
     ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
-    return lookup.sanitize (context);
+    return lookup.sanitize (c);
   }
 
   private:
@@ -599,22 +599,22 @@
 
 struct ChainRuleSet
 {
-  inline bool apply (hb_apply_context_t *context, ChainContextLookupContext &lookup_context) const
+  inline bool apply (hb_apply_context_t *c, ChainContextLookupContext &lookup_context) const
   {
     TRACE_APPLY ();
     unsigned int num_rules = rule.len;
     for (unsigned int i = 0; i < num_rules; i++)
     {
-      if ((this+rule[i]).apply (context, lookup_context))
+      if ((this+rule[i]).apply (c, lookup_context))
         return true;
     }
 
     return false;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return rule.sanitize (context, this);
+    return rule.sanitize (c, this);
   }
 
   private:
@@ -630,7 +630,7 @@
   friend struct ChainContext;
 
   private:
-  inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const
+  inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) const
   {
     TRACE_APPLY ();
     unsigned int index = (this+coverage) (IN_CURGLYPH ());
@@ -642,13 +642,13 @@
       {match_glyph, apply_func},
       {NULL, NULL, NULL}
     };
-    return rule_set.apply (context, lookup_context);
+    return rule_set.apply (c, lookup_context);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return coverage.sanitize (context, this)
-	&& ruleSet.sanitize (context, this);
+    return coverage.sanitize (c, this)
+	&& ruleSet.sanitize (c, this);
   }
 
   private:
@@ -668,7 +668,7 @@
   friend struct ChainContext;
 
   private:
-  inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const
+  inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) const
   {
     TRACE_APPLY ();
     unsigned int index = (this+coverage) (IN_CURGLYPH ());
@@ -690,16 +690,16 @@
        &input_class_def,
        &lookahead_class_def}
     };
-    return rule_set.apply (context, lookup_context);
+    return rule_set.apply (c, lookup_context);
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return coverage.sanitize (context, this)
-	&& backtrackClassDef.sanitize (context, this)
-	&& inputClassDef.sanitize (context, this)
-	&& lookaheadClassDef.sanitize (context, this)
-	&& ruleSet.sanitize (context, this);
+    return coverage.sanitize (c, this)
+	&& backtrackClassDef.sanitize (c, this)
+	&& inputClassDef.sanitize (c, this)
+	&& lookaheadClassDef.sanitize (c, this)
+	&& ruleSet.sanitize (c, this);
   }
 
   private:
@@ -732,7 +732,7 @@
 
   private:
 
-  inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const
+  inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) const
   {
     TRACE_APPLY ();
     const OffsetArrayOf<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
@@ -747,7 +747,7 @@
       {match_coverage, apply_func},
       {this, this, this}
     };
-    return chain_context_lookup (context,
+    return chain_context_lookup (c,
 				 backtrack.len, (const USHORT *) backtrack.array,
 				 input.len, (const USHORT *) input.array + 1,
 				 lookahead.len, (const USHORT *) lookahead.array,
@@ -756,15 +756,15 @@
     return false;
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!backtrack.sanitize (context, this)) return false;
+    if (!backtrack.sanitize (c, this)) return false;
     OffsetArrayOf<Coverage> &input = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
-    if (!input.sanitize (context, this)) return false;
+    if (!input.sanitize (c, this)) return false;
     OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (input);
-    if (!lookahead.sanitize (context, this)) return false;
+    if (!lookahead.sanitize (c, this)) return false;
     ArrayOf<LookupRecord> &lookup = StructAfter<ArrayOf<LookupRecord> > (lookahead);
-    return lookup.sanitize (context);
+    return lookup.sanitize (c);
   }
 
   private:
@@ -791,24 +791,24 @@
 struct ChainContext
 {
   protected:
-  inline bool apply (hb_apply_context_t *context, apply_lookup_func_t apply_func) const
+  inline bool apply (hb_apply_context_t *c, apply_lookup_func_t apply_func) const
   {
     TRACE_APPLY ();
     switch (u.format) {
-    case 1: return u.format1.apply (context, apply_func);
-    case 2: return u.format2.apply (context, apply_func);
-    case 3: return u.format3.apply (context, apply_func);
+    case 1: return u.format1.apply (c, apply_func);
+    case 2: return u.format2.apply (c, apply_func);
+    case 3: return u.format3.apply (c, apply_func);
     default:return false;
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
-    case 2: return u.format2.sanitize (context);
-    case 3: return u.format3.sanitize (context);
+    case 1: return u.format1.sanitize (c);
+    case 2: return u.format2.sanitize (c);
+    case 3: return u.format3.sanitize (c);
     default:return true;
     }
   }
@@ -831,9 +831,9 @@
   inline unsigned int get_type (void) const { return extensionLookupType; }
   inline unsigned int get_offset (void) const { return extensionOffset; }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return context->check_struct (this);
+    return c->check_struct (this);
   }
 
   private:
@@ -864,11 +864,11 @@
     }
   }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!u.format.sanitize (context)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1.sanitize (context);
+    case 1: return u.format1.sanitize (c);
     default:return true;
     }
   }
@@ -921,12 +921,12 @@
   inline const Lookup& get_lookup (unsigned int i) const
   { return (this+lookupList)[i]; }
 
-  inline bool sanitize (hb_sanitize_context_t *context) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return version.sanitize (context) && likely (version.major == 1)
-	&& scriptList.sanitize (context, this)
-	&& featureList.sanitize (context, this)
-	&& lookupList.sanitize (context, this);
+    return version.sanitize (c) && likely (version.major == 1)
+	&& scriptList.sanitize (c, this)
+	&& featureList.sanitize (c, this)
+	&& lookupList.sanitize (c, this);
   }
 
   protected:
diff --git a/src/hb-ot-layout.cc b/src/hb-ot-layout.cc
index 63186a3..2965384 100644
--- a/src/hb-ot-layout.cc
+++ b/src/hb-ot-layout.cc
@@ -320,10 +320,10 @@
 			     unsigned int   *caret_count /* IN/OUT */,
 			     int            *caret_array /* OUT */)
 {
-  hb_ot_layout_context_t context;
-  context.font = font;
-  context.face = face;
-  return _get_gdef (face).get_lig_carets (&context, glyph, start_offset, caret_count, caret_array);
+  hb_ot_layout_context_t c;
+  c.font = font;
+  c.face = face;
+  return _get_gdef (face).get_lig_carets (&c, glyph, start_offset, caret_count, caret_array);
 }
 
 /*
@@ -564,10 +564,10 @@
 				unsigned int  lookup_index,
 				hb_mask_t     mask)
 {
-  hb_ot_layout_context_t context;
-  context.font = NULL;
-  context.face = face;
-  return _get_gsub (face).substitute_lookup (&context, buffer, lookup_index, mask);
+  hb_ot_layout_context_t c;
+  c.font = NULL;
+  c.face = face;
+  return _get_gsub (face).substitute_lookup (&c, buffer, lookup_index, mask);
 }
 
 
@@ -588,10 +588,10 @@
 				unsigned int  lookup_index,
 				hb_mask_t     mask)
 {
-  hb_ot_layout_context_t context;
-  context.font = font;
-  context.face = face;
-  return _get_gpos (face).position_lookup (&context, buffer, lookup_index, mask);
+  hb_ot_layout_context_t c;
+  c.font = font;
+  c.face = face;
+  return _get_gpos (face).position_lookup (&c, buffer, lookup_index, mask);
 }
 
 void