X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fhb-ot-layout-common-private.hh;h=ce47e22a065e86c715c26e9cc64f9bc469d2a0df;hb=743807a3ce1b2229e5307a8aea074a7544623d8d;hp=a4032d9a9e220cdd4ea09fb8055838bd100fad16;hpb=284899ccbe79fda7405ab09d3092fc25fd89e810;p=framework%2Fuifw%2Fharfbuzz.git

diff --git a/src/hb-ot-layout-common-private.hh b/src/hb-ot-layout-common-private.hh
index a4032d9..ce47e22 100644
--- a/src/hb-ot-layout-common-private.hh
+++ b/src/hb-ot-layout-common-private.hh
@@ -1,7 +1,8 @@
 /*
- * Copyright (C) 2007,2008,2009  Red Hat, Inc.
+ * Copyright © 2007,2008,2009  Red Hat, Inc.
+ * Copyright © 2010  Google, Inc.
  *
- *  This is part of HarfBuzz, an OpenType Layout engine library.
+ *  This is part of HarfBuzz, a text shaping library.
  *
  * Permission is hereby granted, without written agreement and without
  * license or royalty fees, to use, copy, modify, and distribute this
@@ -22,16 +23,25 @@
  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  *
  * Red Hat Author(s): Behdad Esfahbod
+ * Google Author(s): Behdad Esfahbod
  */
 
 #ifndef HB_OT_LAYOUT_COMMON_PRIVATE_HH
 #define HB_OT_LAYOUT_COMMON_PRIVATE_HH
 
-#include "hb-ot-layout-private.h"
+#include "hb-ot-layout-private.hh"
 
 #include "hb-open-type-private.hh"
 
 
+#define NO_CONTEXT		((unsigned int) 0x110000)
+#define NOT_COVERED		((unsigned int) 0x110000)
+#define MAX_NESTING_LEVEL	8
+
+HB_BEGIN_DECLS
+HB_END_DECLS
+
+
 /*
  *
  * OpenType Layout Common Table Formats
@@ -46,49 +56,56 @@
 template <typename Type>
 struct Record
 {
-  inline bool sanitize (SANITIZE_ARG_DEF, const void *base) {
-    SANITIZE_DEBUG ();
-    return SANITIZE (tag) && SANITIZE_BASE (offset, base);
+  inline int cmp (hb_tag_t a) const {
+    return tag.cmp (a);
+  }
+
+  inline bool sanitize (hb_sanitize_context_t *c, void *base) {
+    TRACE_SANITIZE ();
+    return c->check_struct (this)
+	&& offset.sanitize (c, base);
   }
 
   Tag		tag;		/* 4-byte Tag identifier */
   OffsetTo<Type>
 		offset;		/* Offset from beginning of object holding
 				 * the Record */
+  public:
+  DEFINE_SIZE_STATIC (6);
 };
 
 template <typename Type>
-struct RecordArrayOf : ArrayOf<Record<Type> > {
+struct RecordArrayOf : SortedArrayOf<Record<Type> > {
   inline const Tag& get_tag (unsigned int i) const
   {
-    if (HB_UNLIKELY (i >= this->len)) return Null(Tag);
-    return this->array[i].tag;
-  }
-  inline bool get_tags (unsigned int *record_count /* IN/OUT */,
-			hb_tag_t     *record_tags /* OUT */) const
+    /* We cheat slightly and don't define separate Null objects
+     * for Record types.  Instead, we return the correct Null(Tag)
+     * here. */
+    if (unlikely (i >= this->len)) return Null(Tag);
+    return (*this)[i].tag;
+  }
+  inline unsigned int get_tags (unsigned int start_offset,
+				unsigned int *record_count /* IN/OUT */,
+				hb_tag_t     *record_tags /* OUT */) const
   {
-    unsigned int count = MIN (this->len, *record_count);
-    for (unsigned int i = 0; i < count; i++)
-      record_tags[i] = this->array[i].tag;
-
-    *record_count = this->len;
-    return !!this->len;
+    if (record_count) {
+      const Record<Type> *arr = this->sub_array (start_offset, record_count);
+      unsigned int count = *record_count;
+      for (unsigned int i = 0; i < count; i++)
+	record_tags[i] = arr[i].tag;
+    }
+    return this->len;
   }
   inline bool find_index (hb_tag_t tag, unsigned int *index) const
   {
-    const Tag t = tag;
-    // TODO bsearch
-    unsigned int count = this->len;
-    for (unsigned int i = 0; i < count; i++)
-    {
-      if (t == this->array[i].tag)
-      {
+    int i = this->search (tag);
+    if (i != -1) {
         if (index) *index = i;
         return true;
-      }
+    } else {
+      if (index) *index = Index::NOT_FOUND_INDEX;
+      return false;
     }
-    if (index) *index = NO_INDEX;
-    return false;
   }
 };
 
@@ -96,32 +113,49 @@ template <typename Type>
 struct RecordListOf : RecordArrayOf<Type>
 {
   inline const Type& operator [] (unsigned int i) const
-  { return this+RecordArrayOf<Type>::operator[](i).offset; }
+  { return this+RecordArrayOf<Type>::operator [](i).offset; }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    return RecordArrayOf<Type>::sanitize (SANITIZE_ARG, CONST_CHARP(this));
+  inline bool sanitize (hb_sanitize_context_t *c) {
+    TRACE_SANITIZE ();
+    return RecordArrayOf<Type>::sanitize (c, this);
   }
 };
 
 
-struct IndexArray : ArrayOf<USHORT>
+struct RangeRecord
 {
-  inline unsigned int operator [] (unsigned int i) const
-  {
-    if (HB_UNLIKELY (i >= this->len))
-      return NO_INDEX;
-    return this->array[i];
+  inline int cmp (hb_codepoint_t g) const {
+    hb_codepoint_t a = start, b = end;
+    return g < a ? -1 : g <= b ? 0 : +1 ;
   }
-  inline bool get_indexes (unsigned int *_count /* IN/OUT */,
-			   unsigned int *_indexes /* OUT */) const
-  {
-    unsigned int count = MIN (this->len, *_count);
-    for (unsigned int i = 0; i < count; i++)
-      _indexes[i] = this->array[i];
 
-    *_count = this->len;
-    return !!this->len;
+  inline bool sanitize (hb_sanitize_context_t *c) {
+    TRACE_SANITIZE ();
+    return c->check_struct (this);
+  }
+
+  GlyphID	start;		/* First GlyphID in the range */
+  GlyphID	end;		/* Last GlyphID in the range */
+  USHORT	value;		/* Value */
+  public:
+  DEFINE_SIZE_STATIC (6);
+};
+DEFINE_NULL_DATA (RangeRecord, "\000\001");
+
+
+struct IndexArray : ArrayOf<Index>
+{
+  inline unsigned int get_indexes (unsigned int start_offset,
+				   unsigned int *_count /* IN/OUT */,
+				   unsigned int *_indexes /* OUT */) const
+  {
+    if (_count) {
+      const USHORT *arr = this->sub_array (start_offset, _count);
+      unsigned int count = *_count;
+      for (unsigned int i = 0; i < count; i++)
+	_indexes[i] = arr[i];
+    }
+    return this->len;
   }
 };
 
@@ -137,21 +171,23 @@ struct LangSys
   { return featureIndex.len; }
   inline hb_tag_t get_feature_index (unsigned int i) const
   { return featureIndex[i]; }
-  inline bool get_feature_indexes (unsigned int *feature_count /* IN/OUT */,
-				   hb_tag_t     *feature_tags /* OUT */) const
-  { return featureIndex.get_indexes (feature_count, feature_tags); }
+  inline unsigned int get_feature_indexes (unsigned int start_offset,
+					   unsigned int *feature_count /* IN/OUT */,
+					   unsigned int *feature_indexes /* OUT */) const
+  { return featureIndex.get_indexes (start_offset, feature_count, feature_indexes); }
 
   inline bool has_required_feature (void) const { return reqFeatureIndex != 0xffff; }
-  inline int get_required_feature_index (void) const
+  inline unsigned int get_required_feature_index (void) const
   {
     if (reqFeatureIndex == 0xffff)
-      return NO_INDEX;
+      return Index::NOT_FOUND_INDEX;
    return reqFeatureIndex;;
   }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    return SANITIZE_SELF () && SANITIZE (featureIndex);
+  inline bool sanitize (hb_sanitize_context_t *c) {
+    TRACE_SANITIZE ();
+    return c->check_struct (this)
+	&& featureIndex.sanitize (c);
   }
 
   Offset	lookupOrder;	/* = Null (reserved for an offset to a
@@ -160,8 +196,10 @@ struct LangSys
 				 * language system--if no required features
 				 * = 0xFFFF */
   IndexArray	featureIndex;	/* Array of indices into the FeatureList */
+  public:
+  DEFINE_SIZE_ARRAY (6, featureIndex);
 };
-ASSERT_SIZE_DATA (LangSys, 6, "\0\0\xFF\xFF");
+DEFINE_NULL_DATA (LangSys, "\0\0\xFF\xFF");
 
 
 struct Script
@@ -170,12 +208,13 @@ struct Script
   { return langSys.len; }
   inline const Tag& get_lang_sys_tag (unsigned int i) const
   { return langSys.get_tag (i); }
-  inline bool get_lang_sys_tags (unsigned int *lang_sys_count /* IN/OUT */,
-				 hb_tag_t     *lang_sys_tags /* OUT */) const
-  { return langSys.get_tags (lang_sys_count, lang_sys_tags); }
+  inline unsigned int get_lang_sys_tags (unsigned int start_offset,
+					 unsigned int *lang_sys_count /* IN/OUT */,
+					 hb_tag_t     *lang_sys_tags /* OUT */) const
+  { return langSys.get_tags (start_offset, lang_sys_count, lang_sys_tags); }
   inline const LangSys& get_lang_sys (unsigned int i) const
   {
-    if (i == NO_INDEX) return get_default_lang_sys ();
+    if (i == Index::NOT_FOUND_INDEX) return get_default_lang_sys ();
     return this+langSys[i].offset;
   }
   inline bool find_lang_sys_index (hb_tag_t tag, unsigned int *index) const
@@ -184,9 +223,10 @@ struct Script
   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 (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    return SANITIZE_THIS (defaultLangSys) && SANITIZE_THIS (langSys);
+  inline bool sanitize (hb_sanitize_context_t *c) {
+    TRACE_SANITIZE ();
+    return defaultLangSys.sanitize (c, this)
+	&& langSys.sanitize (c, this);
   }
 
   private:
@@ -196,11 +236,11 @@ struct Script
   RecordArrayOf<LangSys>
 		langSys;	/* Array of LangSysRecords--listed
 				 * alphabetically by LangSysTag */
+  public:
+  DEFINE_SIZE_ARRAY (4, langSys);
 };
-ASSERT_SIZE (Script, 4);
 
 typedef RecordListOf<Script> ScriptList;
-ASSERT_SIZE (ScriptList, 2);
 
 
 struct Feature
@@ -209,27 +249,27 @@ struct Feature
   { return lookupIndex.len; }
   inline hb_tag_t get_lookup_index (unsigned int i) const
   { return lookupIndex[i]; }
-  inline bool get_lookup_indexes (unsigned int *lookup_count /* IN/OUT */,
-				  hb_tag_t     *lookup_tags /* OUT */) const
-  { return lookupIndex.get_indexes (lookup_count, lookup_tags); }
+  inline unsigned int get_lookup_indexes (unsigned int start_index,
+					  unsigned int *lookup_count /* IN/OUT */,
+					  unsigned int *lookup_tags /* OUT */) const
+  { return lookupIndex.get_indexes (start_index, lookup_count, lookup_tags); }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    return SANITIZE_SELF () && SANITIZE (lookupIndex);
+  inline bool sanitize (hb_sanitize_context_t *c) {
+    TRACE_SANITIZE ();
+    return c->check_struct (this)
+	&& lookupIndex.sanitize (c);
   }
 
-  /* TODO: implement get_feature_parameters() */
-  /* TODO: implement FeatureSize and other special features? */
   Offset	featureParams;	/* Offset to Feature Parameters table (if one
 				 * has been defined for the feature), relative
 				 * to the beginning of the Feature Table; = Null
 				 * if not required */
   IndexArray	 lookupIndex;	/* Array of LookupList indices */
+  public:
+  DEFINE_SIZE_ARRAY (4, lookupIndex);
 };
-ASSERT_SIZE (Feature, 4);
 
 typedef RecordListOf<Feature> FeatureList;
-ASSERT_SIZE (FeatureList, 2);
 
 
 struct LookupFlag : USHORT
@@ -239,80 +279,60 @@ struct LookupFlag : USHORT
     IgnoreBaseGlyphs	= 0x0002u,
     IgnoreLigatures	= 0x0004u,
     IgnoreMarks		= 0x0008u,
+    IgnoreFlags		= 0x000Eu,
     UseMarkFilteringSet	= 0x0010u,
     Reserved		= 0x00E0u,
-    MarkAttachmentType	= 0xFF00u,
+    MarkAttachmentType	= 0xFF00u
   };
+  public:
+  DEFINE_SIZE_STATIC (2);
 };
-ASSERT_SIZE (LookupFlag, 2);
-
-struct LookupSubTable
-{
-  inline bool sanitize (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    return SANITIZE_SELF ();
-  }
-
-  private:
-  USHORT	format;		/* Subtable format.  Different for GSUB and GPOS */
-};
-ASSERT_SIZE (LookupSubTable, 2);
 
 struct Lookup
 {
-  inline const LookupSubTable& get_subtable (unsigned int i) const { return this+subTable[i]; }
   inline unsigned int get_subtable_count (void) const { return subTable.len; }
 
   inline unsigned int get_type (void) const { return lookupType; }
-  inline unsigned int get_flag (void) const
+
+  /* lookup_props is a 32-bit integer where the lower 16-bit is LookupFlag and
+   * higher 16-bit is mark-filtering-set if the lookup uses one.
+   * Not to be confused with glyph_props which is very similar. */
+  inline uint32_t get_props (void) const
   {
     unsigned int flag = lookupFlag;
-    if (HB_UNLIKELY (flag & LookupFlag::UseMarkFilteringSet))
+    if (unlikely (flag & LookupFlag::UseMarkFilteringSet))
     {
-      const USHORT &markFilteringSet = CONST_NEXT (USHORT, subTable);
+      const USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
       flag += (markFilteringSet << 16);
     }
     return flag;
   }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    if (!(SANITIZE_SELF () && SANITIZE_THIS (subTable))) return false;
-    if (HB_UNLIKELY (lookupFlag & LookupFlag::UseMarkFilteringSet))
+  inline bool sanitize (hb_sanitize_context_t *c) {
+    TRACE_SANITIZE ();
+    /* Real sanitize of the subtables is done by GSUB/GPOS/... */
+    if (!(c->check_struct (this)
+       && subTable.sanitize (c))) return false;
+    if (unlikely (lookupFlag & LookupFlag::UseMarkFilteringSet))
     {
-      USHORT &markFilteringSet = NEXT (USHORT, subTable);
-      if (!SANITIZE (markFilteringSet)) return false;
+      USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
+      if (!markFilteringSet.sanitize (c)) return false;
     }
     return true;
   }
 
   USHORT	lookupType;		/* Different enumerations for GSUB and GPOS */
   USHORT	lookupFlag;		/* Lookup qualifiers */
-  OffsetArrayOf<LookupSubTable>
+  ArrayOf<Offset>
 		subTable;		/* Array of SubTables */
-  USHORT	markFilteringSetX[0];	/* Index (base 0) into GDEF mark glyph sets
+  USHORT	markFilteringSetX[VAR];	/* Index (base 0) into GDEF mark glyph sets
 					 * structure. This field is only present if bit
 					 * UseMarkFilteringSet of lookup flags is set. */
-};
-ASSERT_SIZE (Lookup, 6);
-
-template <typename Type>
-struct OffsetListOf : OffsetArrayOf<Type>
-{
-  inline const Type& operator [] (unsigned int i) const
-  {
-    if (HB_UNLIKELY (i >= this->len)) return Null(Type);
-    return this+this->array[i];
-  }
-
-  inline bool sanitize (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    return OffsetArrayOf<Type>::sanitize (SANITIZE_ARG, CONST_CHARP(this));
-  }
+  public:
+  DEFINE_SIZE_ARRAY2 (6, subTable, markFilteringSetX);
 };
 
 typedef OffsetListOf<Lookup> LookupList;
-ASSERT_SIZE (LookupList, 2);
 
 
 /*
@@ -326,55 +346,24 @@ struct CoverageFormat1
   private:
   inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
   {
-    if (HB_UNLIKELY (glyph_id > 0xFFFF))
-      return NOT_COVERED;
-    GlyphID gid;
-    gid = glyph_id;
-    // TODO: bsearch
-    unsigned int num_glyphs = glyphArray.len;
-    for (unsigned int i = 0; i < num_glyphs; i++)
-      if (gid == glyphArray[i])
+    int i = glyphArray.search (glyph_id);
+    if (i != -1)
         return i;
     return NOT_COVERED;
   }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    return SANITIZE (glyphArray);
+  inline bool sanitize (hb_sanitize_context_t *c) {
+    TRACE_SANITIZE ();
+    return glyphArray.sanitize (c);
   }
 
   private:
   USHORT	coverageFormat;	/* Format identifier--format = 1 */
-  ArrayOf<GlyphID>
+  SortedArrayOf<GlyphID>
 		glyphArray;	/* Array of GlyphIDs--in numerical order */
-};
-ASSERT_SIZE (CoverageFormat1, 4);
-
-struct CoverageRangeRecord
-{
-  friend struct CoverageFormat2;
-
-  private:
-  inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
-  {
-    if (glyph_id >= start && glyph_id <= end)
-      return (unsigned int) startCoverageIndex + (glyph_id - start);
-    return NOT_COVERED;
-  }
-
   public:
-  inline bool sanitize (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    return SANITIZE_SELF ();
-  }
-
-  private:
-  GlyphID	start;			/* First GlyphID in the range */
-  GlyphID	end;			/* Last GlyphID in the range */
-  USHORT	startCoverageIndex;	/* Coverage Index of first GlyphID in
-					 * range */
+  DEFINE_SIZE_ARRAY (4, glyphArray);
 };
-ASSERT_SIZE_DATA (CoverageRangeRecord, 6, "\000\001");
 
 struct CoverageFormat2
 {
@@ -383,50 +372,48 @@ struct CoverageFormat2
   private:
   inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
   {
-    // TODO: bsearch
-    unsigned int count = rangeRecord.len;
-    for (unsigned int i = 0; i < count; i++)
-    {
-      unsigned int coverage = rangeRecord[i].get_coverage (glyph_id);
-      if (coverage != NOT_COVERED)
-        return coverage;
+    int i = rangeRecord.search (glyph_id);
+    if (i != -1) {
+      const RangeRecord &range = rangeRecord[i];
+      return (unsigned int) range.value + (glyph_id - range.start);
     }
     return NOT_COVERED;
   }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    return SANITIZE (rangeRecord);
+  inline bool sanitize (hb_sanitize_context_t *c) {
+    TRACE_SANITIZE ();
+    return rangeRecord.sanitize (c);
   }
 
   private:
   USHORT	coverageFormat;	/* Format identifier--format = 2 */
-  ArrayOf<CoverageRangeRecord>
+  SortedArrayOf<RangeRecord>
 		rangeRecord;	/* Array of glyph ranges--ordered by
 				 * Start GlyphID. rangeCount entries
 				 * long */
+  public:
+  DEFINE_SIZE_ARRAY (4, rangeRecord);
 };
-ASSERT_SIZE (CoverageFormat2, 4);
 
 struct Coverage
 {
-  inline unsigned int operator() (hb_codepoint_t glyph_id) const { return get_coverage (glyph_id); }
+  inline unsigned int operator () (hb_codepoint_t glyph_id) const { return get_coverage (glyph_id); }
 
-  unsigned int get_coverage (hb_codepoint_t glyph_id) const
+  inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
   {
     switch (u.format) {
-    case 1: return u.format1->get_coverage(glyph_id);
-    case 2: return u.format2->get_coverage(glyph_id);
+    case 1: return u.format1.get_coverage(glyph_id);
+    case 2: return u.format2.get_coverage(glyph_id);
     default:return NOT_COVERED;
     }
   }
 
-  bool sanitize (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    if (!SANITIZE (u.format)) return false;
+  inline bool sanitize (hb_sanitize_context_t *c) {
+    TRACE_SANITIZE ();
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1->sanitize (SANITIZE_ARG);
-    case 2: return u.format2->sanitize (SANITIZE_ARG);
+    case 1: return u.format1.sanitize (c);
+    case 2: return u.format2.sanitize (c);
     default:return true;
     }
   }
@@ -434,11 +421,12 @@ struct Coverage
   private:
   union {
   USHORT		format;		/* Format identifier */
-  CoverageFormat1	format1[];
-  CoverageFormat2	format2[];
+  CoverageFormat1	format1;
+  CoverageFormat2	format2;
   } u;
+  public:
+  DEFINE_SIZE_UNION (2, format);
 };
-ASSERT_SIZE (Coverage, 2);
 
 
 /*
@@ -450,99 +438,72 @@ struct ClassDefFormat1
   friend struct ClassDef;
 
   private:
-  inline hb_ot_layout_class_t get_class (hb_codepoint_t glyph_id) const
+  inline unsigned int get_class (hb_codepoint_t glyph_id) const
   {
     if ((unsigned int) (glyph_id - startGlyph) < classValue.len)
       return classValue[glyph_id - startGlyph];
     return 0;
   }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    return SANITIZE_SELF () && SANITIZE (classValue);
+  inline bool sanitize (hb_sanitize_context_t *c) {
+    TRACE_SANITIZE ();
+    return c->check_struct (this)
+	&& classValue.sanitize (c);
   }
 
   USHORT	classFormat;		/* Format identifier--format = 1 */
   GlyphID	startGlyph;		/* First GlyphID of the classValueArray */
   ArrayOf<USHORT>
 		classValue;		/* Array of Class Values--one per GlyphID */
-};
-ASSERT_SIZE (ClassDefFormat1, 6);
-
-struct ClassRangeRecord
-{
-  friend struct ClassDefFormat2;
-
-  private:
-  inline hb_ot_layout_class_t get_class (hb_codepoint_t glyph_id) const
-  {
-    if (glyph_id >= start && glyph_id <= end)
-      return classValue;
-    return 0;
-  }
-
   public:
-  inline bool sanitize (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    return SANITIZE_SELF ();
-  }
-
-  private:
-  GlyphID	start;		/* First GlyphID in the range */
-  GlyphID	end;		/* Last GlyphID in the range */
-  USHORT	classValue;	/* Applied to all glyphs in the range */
+  DEFINE_SIZE_ARRAY (6, classValue);
 };
-ASSERT_SIZE_DATA (ClassRangeRecord, 6, "\000\001");
 
 struct ClassDefFormat2
 {
   friend struct ClassDef;
 
   private:
-  inline hb_ot_layout_class_t get_class (hb_codepoint_t glyph_id) const
+  inline unsigned int get_class (hb_codepoint_t glyph_id) const
   {
-    // TODO: bsearch
-    unsigned int count = rangeRecord.len;
-    for (unsigned int i = 0; i < count; i++)
-    {
-      int classValue = rangeRecord[i].get_class (glyph_id);
-      if (classValue > 0)
-        return classValue;
-    }
+    int i = rangeRecord.search (glyph_id);
+    if (i != -1)
+      return rangeRecord[i].value;
     return 0;
   }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    return SANITIZE (rangeRecord);
+  inline bool sanitize (hb_sanitize_context_t *c) {
+    TRACE_SANITIZE ();
+    return rangeRecord.sanitize (c);
   }
 
   USHORT	classFormat;	/* Format identifier--format = 2 */
-  ArrayOf<ClassRangeRecord>
+  SortedArrayOf<RangeRecord>
 		rangeRecord;	/* Array of glyph ranges--ordered by
 				 * Start GlyphID */
+  public:
+  DEFINE_SIZE_ARRAY (4, rangeRecord);
 };
-ASSERT_SIZE (ClassDefFormat2, 4);
 
 struct ClassDef
 {
-  inline unsigned int operator() (hb_codepoint_t glyph_id) const { return get_class (glyph_id); }
+  inline unsigned int operator () (hb_codepoint_t glyph_id) const { return get_class (glyph_id); }
 
-  hb_ot_layout_class_t get_class (hb_codepoint_t glyph_id) const
+  inline unsigned int get_class (hb_codepoint_t glyph_id) const
   {
     switch (u.format) {
-    case 1: return u.format1->get_class(glyph_id);
-    case 2: return u.format2->get_class(glyph_id);
+    case 1: return u.format1.get_class(glyph_id);
+    case 2: return u.format2.get_class(glyph_id);
     default:return 0;
     }
   }
 
-  bool sanitize (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    if (!SANITIZE (u.format)) return false;
+  inline bool sanitize (hb_sanitize_context_t *c) {
+    TRACE_SANITIZE ();
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1->sanitize (SANITIZE_ARG);
-    case 2: return u.format2->sanitize (SANITIZE_ARG);
+    case 1: return u.format1.sanitize (c);
+    case 2: return u.format2.sanitize (c);
     default:return true;
     }
   }
@@ -550,11 +511,12 @@ struct ClassDef
   private:
   union {
   USHORT		format;		/* Format identifier */
-  ClassDefFormat1	format1[];
-  ClassDefFormat2	format2[];
+  ClassDefFormat1	format1;
+  ClassDefFormat2	format2;
   } u;
+  public:
+  DEFINE_SIZE_UNION (2, format);
 };
-ASSERT_SIZE (ClassDef, 2);
 
 
 /*
@@ -563,12 +525,29 @@ ASSERT_SIZE (ClassDef, 2);
 
 struct Device
 {
-  inline int operator() (unsigned int ppem_size) const { return get_delta (ppem_size); }
 
-  int get_delta (unsigned int ppem_size) const
+  inline hb_position_t get_x_delta (hb_font_t *font) const
+  { return get_delta (font->x_ppem, font->x_scale); }
+
+  inline hb_position_t get_y_delta (hb_font_t *font) const
+  { return get_delta (font->y_ppem, font->y_scale); }
+
+  inline int get_delta (unsigned int ppem, int scale) const
+  {
+    if (!ppem) return 0;
+
+    int pixels = get_delta_pixels (ppem);
+
+    if (!pixels) return 0;
+
+    return pixels * (int64_t) scale / ppem;
+  }
+
+
+  inline int get_delta_pixels (unsigned int ppem_size) const
   {
     unsigned int f = deltaFormat;
-    if (HB_UNLIKELY (f < 1 || f > 3))
+    if (unlikely (f < 1 || f > 3))
       return 0;
 
     if (ppem_size < startSize || ppem_size > endSize)
@@ -588,25 +567,34 @@ struct Device
     return delta;
   }
 
-  inline unsigned int get_size () const
+  inline unsigned int get_size (void) const
   {
     unsigned int f = deltaFormat;
-    if (HB_UNLIKELY (f < 1 || f > 3 || startSize > endSize)) return sizeof (*this);
-    return sizeof (*this) + ((endSize - startSize + (1 << (4 - f)) - 1) >> (4 - f));
+    if (unlikely (f < 1 || f > 3 || startSize > endSize)) return 3 * USHORT::static_size;
+    return USHORT::static_size * (4 + ((endSize - startSize) >> (4 - f)));
   }
 
-  bool sanitize (SANITIZE_ARG_DEF) {
-    SANITIZE_DEBUG ();
-    return SANITIZE_GET_SIZE ();
+  inline bool sanitize (hb_sanitize_context_t *c) {
+    TRACE_SANITIZE ();
+    return c->check_struct (this)
+	&& c->check_range (this, this->get_size ());
   }
 
   private:
-  USHORT	startSize;	/* Smallest size to correct--in ppem */
-  USHORT	endSize;	/* Largest size to correct--in ppem */
-  USHORT	deltaFormat;	/* Format of DeltaValue array data: 1, 2, or 3 */
-  USHORT	deltaValue[];	/* Array of compressed data */
+  USHORT	startSize;		/* Smallest size to correct--in ppem */
+  USHORT	endSize;		/* Largest size to correct--in ppem */
+  USHORT	deltaFormat;		/* Format of DeltaValue array data: 1, 2, or 3
+					 * 1	Signed 2-bit value, 8 values per uint16
+					 * 2	Signed 4-bit value, 4 values per uint16
+					 * 3	Signed 8-bit value, 2 values per uint16
+					 */
+  USHORT	deltaValue[VAR];	/* Array of compressed data */
+  public:
+  DEFINE_SIZE_ARRAY (6, deltaValue);
 };
-ASSERT_SIZE (Device, 6);
 
 
+HB_BEGIN_DECLS
+HB_END_DECLS
+
 #endif /* HB_OT_LAYOUT_COMMON_PRIVATE_HH */