Merge remote-tracking branch 'eroux/add-base'

src/Makefile.sources

@@ -87,8 +87,10 @@ HB_OT_sources = \
 	hb-aat-layout-kerx-table.hh \
 	hb-aat-layout-trak-table.hh \
 	hb-aat-layout-private.hh \
+	hb-ot-base.cc \
 	hb-ot-font.cc \
 	hb-ot-layout.cc \
+	hb-ot-layout-base-table.hh \
 	hb-ot-layout-common-private.hh \
 	hb-ot-layout-gdef-table.hh \
 	hb-ot-layout-gpos-table.hh \
@@ -152,6 +154,7 @@ HB_OT_headers = \
 	hb-ot-font.h \
 	hb-ot-layout.h \
 	hb-ot-math.h \
+	hb-ot-base.h \
 	hb-ot-shape.h \
 	hb-ot-tag.h \
 	hb-ot-var.h \

src/hb-ot-base.cc

+/*
+ * Copyright © 2017 Elie Roux<elie.roux@telecom-bretagne.eu>
+ *
+ *  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
+ * software and its documentation for any purpose, provided that the
+ * above copyright notice and the following two paragraphs appear in
+ * all copies of this software.
+ *
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
+ * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
+ * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
+ * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
+ * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ *
+ */
+
+#include "hb-open-type-private.hh"
+
+#include "hb-ot-layout-private.hh"
+#include "hb-ot-layout-base-table.hh"
+
+static inline const OT::BASE&
+_get_base (hb_face_t *face)
+{
+  if (unlikely (!hb_ot_shaper_face_data_ensure (face))) return OT::Null(OT::BASE);
+  hb_ot_layout_t * layout = hb_ot_layout_from_face (face);
+  return *(layout->base.get ());
+}
+
+/*
+ * OT::BASE
+ */
+
+/**
+ * hb_ot_base_has_data:
+ * @face: #hb_face_t to test
+ *
+ * This function allows to verify the presence of an OpenType BASE table on the
+ * face.
+ *
+ * Return value: true if face has a BASE table, false otherwise
+ *
+ * Since: XXX
+ **/
+hb_bool_t
+hb_ot_base_has_data (hb_face_t *face)
+{
+  return &_get_base (face) != &OT::Null(OT::BASE);
+}

src/hb-ot-base.h

+/*
+ * Copyright © 2017 Elie Roux<elie.roux@telecom-bretagne.eu>
+ *
+ *  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
+ * software and its documentation for any purpose, provided that the
+ * above copyright notice and the following two paragraphs appear in
+ * all copies of this software.
+ *
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
+ * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
+ * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
+ * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
+ * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ *
+ */
+
+#ifndef HB_OT_H_IN
+#error "Include <hb-ot.h> instead."
+#endif
+
+#ifndef HB_OT_BASE_H
+#define HB_OT_BASE_H
+
+#include "hb.h"
+
+HB_BEGIN_DECLS
+
+#define HB_OT_TAG_BASE      HB_TAG('B','A','S','E')
+
+// https://www.microsoft.com/typography/otspec/baselinetags.htm
+
+#define HB_OT_TAG_BASE_HANG HB_TAG('h','a','n','g')
+#define HB_OT_TAG_BASE_ICFB HB_TAG('i','c','f','b')
+#define HB_OT_TAG_BASE_ICFT HB_TAG('i','c','f','t')
+#define HB_OT_TAG_BASE_IDEO HB_TAG('i','d','e','o')
+#define HB_OT_TAG_BASE_IDTB HB_TAG('i','d','t','b')
+#define HB_OT_TAG_BASE_MATH HB_TAG('m','a','t','h')
+#define HB_OT_TAG_BASE_ROMN HB_TAG('r','o','m','n')
+
+/* Methods */
+
+HB_EXTERN hb_bool_t
+hb_ot_base_has_data (hb_face_t *face);
+
+HB_END_DECLS
+
+#endif /* HB_OT_BASE_H */

src/hb-ot-layout-base-table.hh

+/*
+ * Copyright © 2016 Elie Roux <elie.roux@telecom-bretagne.eu>
+ *
+ *  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
+ * software and its documentation for any purpose, provided that the
+ * above copyright notice and the following two paragraphs appear in
+ * all copies of this software.
+ *
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
+ * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
+ * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
+ * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
+ * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
+ * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
+ * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ *
+ */
+
+#ifndef HB_OT_BASE_TABLE_HH
+#define HB_OT_BASE_TABLE_HH
+
+#include "hb-open-type-private.hh"
+#include "hb-ot-layout-common-private.hh"
+#include "hb-ot-base.h"
+
+namespace OT {
+
+#define NO_COORD Null(HBINT16)//HBINT16((short int) -32767)
+
+#define NOT_INDEXED   ((unsigned int) -1)
+
+/*
+ * BASE -- The BASE Table
+ */
+
+struct BaseCoordFormat1 {
+
+  inline HBINT16 get_coord (void) const
+  { return coordinate; }
+
+  inline bool sanitize (hb_sanitize_context_t *c) const
+  {
+    TRACE_SANITIZE (this);
+    return_trace (c->check_struct (this));
+  }
+
+  protected:
+  HBUINT16    baseCoordFormat;
+  HBINT16     coordinate;
+
+  public:
+  DEFINE_SIZE_STATIC (4);
+};
+
+struct BaseCoordFormat2 {
+
+  inline HBINT16 get_coord (void) const
+  { return coordinate; }
+
+  inline bool sanitize (hb_sanitize_context_t *c) const
+  {
+    TRACE_SANITIZE (this);
+    return_trace (c->check_struct (this));
+  }
+
+  protected:
+  HBUINT16    baseCoordFormat;
+  HBINT16     coordinate;
+  HBUINT16    referenceGlyph;
+  HBUINT16    baseCoordPoint;
+
+  public:
+  DEFINE_SIZE_STATIC (8);
+};
+
+struct BaseCoordFormat3 {
+
+  inline HBINT16 get_coord (void) const
+  { return coordinate; }
+
+  inline bool sanitize (hb_sanitize_context_t *c) const
+  {
+    TRACE_SANITIZE (this);
+    return_trace (c->check_struct (this) && deviceTable.sanitize (c, this));
+  }
+
+  protected:
+  HBUINT16           baseCoordFormat;
+  HBINT16            coordinate;
+  OffsetTo<Device> deviceTable;
+
+  public:
+  DEFINE_SIZE_STATIC (6);
+};
+
+struct BaseCoord {
+
+  inline HBINT16 get_coord (void) const
+  { return u.format1.get_coord(); }
+
+  inline bool sanitize (hb_sanitize_context_t *c) const
+  {
+    TRACE_SANITIZE (this);
+    if (!u.baseCoordFormat.sanitize (c)) return_trace (false);
+    switch (u.baseCoordFormat) {
+    case 1: return_trace (u.format1.sanitize (c));
+    case 2: return_trace (u.format2.sanitize (c));
+    case 3: return_trace (u.format3.sanitize (c));
+    default:return_trace (false);
+    }
+  }
+
+  protected:
+  union {
+    HBUINT16            baseCoordFormat;
+    BaseCoordFormat1  format1;
+    BaseCoordFormat2  format2;
+    BaseCoordFormat3  format3;
+  } u;
+
+  public:
+  DEFINE_SIZE_MIN (4);
+};
+
+struct FeatMinMaxRecord {
+
+  inline HBINT16 get_min_value (void) const
+  {
+    if (minCoord == Null(OffsetTo<BaseCoord>)) return NO_COORD;
+      return (this+minCoord).get_coord();
+  }
+
+  inline HBINT16 get_max_value (void) const
+  {
+    if (minCoord == Null(OffsetTo<BaseCoord>)) return NO_COORD;
+      return (this+maxCoord).get_coord();
+  }
+
+  inline Tag get_tag () const
+  { return featureTableTag; }
+
+  inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
+  {
+    TRACE_SANITIZE (this);
+    return_trace (c->check_struct (this) &&
+      minCoord.sanitize (c, base) &&
+      maxCoord.sanitize (c, base));
+  }
+
+  protected:
+  Tag                   featureTableTag;
+  OffsetTo<BaseCoord>   minCoord;
+  OffsetTo<BaseCoord>   maxCoord;
+
+  public:
+  DEFINE_SIZE_STATIC (8);
+
+};
+
+struct MinMax {
+
+  inline unsigned int get_feature_tag_index (Tag featureTableTag) const
+  {
+    Tag tag;
+    int cmp;
+    // taking advantage of alphabetical order
+    for (unsigned int i = 0; i < featMinMaxCount; i++) {
+      tag = featMinMaxRecords[i].get_tag();
+      cmp = tag.cmp(featureTableTag);
+      if (cmp == 0) return i;
+      if (cmp > 0)  return NOT_INDEXED;
+    }
+    return NOT_INDEXED;
+  }
+
+  inline HBINT16 get_min_value (unsigned int featureTableTagIndex) const
+  {
+    if (featureTableTagIndex == NOT_INDEXED) {
+      if (minCoord == Null(OffsetTo<BaseCoord>)) return NO_COORD;
+      return (this+minCoord).get_coord();
+    }
+    if (unlikely(featureTableTagIndex >= featMinMaxCount)) return NO_COORD;
+    return featMinMaxRecords[featureTableTagIndex].get_min_value();
+  }
+
+  inline HBINT16 get_max_value (unsigned int featureTableTagIndex) const
+  {
+    if (featureTableTagIndex == NOT_INDEXED) {
+      if (minCoord == Null(OffsetTo<BaseCoord>)) return NO_COORD;
+      return (this+maxCoord).get_coord();
+    }
+    if (unlikely(featureTableTagIndex >= featMinMaxCount)) return NO_COORD;
+    return featMinMaxRecords[featureTableTagIndex].get_max_value();
+  }
+
+  inline bool sanitize (hb_sanitize_context_t *c) const
+  {
+    TRACE_SANITIZE (this);
+    return_trace (c->check_struct (this) &&
+      minCoord.sanitize (c, this) &&
+      maxCoord.sanitize (c, this) &&
+      featMinMaxRecords.sanitize (c, this));
+    // TODO: test alphabetical order?
+  }
+
+  protected:
+  OffsetTo<BaseCoord>       minCoord;
+  OffsetTo<BaseCoord>       maxCoord;
+  HBUINT16                    featMinMaxCount;
+  ArrayOf<FeatMinMaxRecord> featMinMaxRecords;
+
+  public:
+  DEFINE_SIZE_ARRAY (8, featMinMaxRecords);
+
+};
+
+struct BaseLangSysRecord {
+
+  inline Tag get_tag(void) const
+  { return baseLangSysTag; }
+
+  inline unsigned int get_feature_tag_index (Tag featureTableTag) const
+  { (this+minMax).get_feature_tag_index(featureTableTag); }
+
+  inline HBINT16 get_min_value (unsigned int featureTableTagIndex) const
+  { (this+minMax).get_min_value(featureTableTagIndex); }
+
+  inline HBINT16 get_max_value (unsigned int featureTableTagIndex) const
+  { (this+minMax).get_max_value(featureTableTagIndex); }
+
+  inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
+  {
+    TRACE_SANITIZE (this);
+    return_trace (c->check_struct (this) &&
+      minMax != Null(OffsetTo<MinMax>) &&
+      minMax.sanitize (c, base));
+  }
+
+  protected:
+  Tag               baseLangSysTag;
+  OffsetTo<MinMax>  minMax; // not supposed to be NULL
+
+  public:
+  DEFINE_SIZE_STATIC (6); 
+
+};
+
+struct BaseValues {
+
+  inline const unsigned int get_default_base_tag_index (void) const
+  { return defaultIndex; }
+
+  inline HBINT16 get_base_coord (unsigned int baselineTagIndex) const
+  {
+    if (unlikely(baselineTagIndex >= baseCoordCount)) return NO_COORD;
+    return (this+baseCoords[baselineTagIndex]).get_coord();
+  }
+
+  inline bool sanitize (hb_sanitize_context_t *c) const
+  {
+    TRACE_SANITIZE (this);
+    return_trace (c->check_struct (this) &&
+      defaultIndex <= baseCoordCount &&
+      baseCoords.sanitize (c, this));
+  }
+
+  protected:
+  Index                     defaultIndex;
+  HBUINT16                    baseCoordCount;
+  OffsetArrayOf<BaseCoord>  baseCoords;
+
+  public:
+  DEFINE_SIZE_ARRAY (6, baseCoords);
+
+};
+
+struct BaseScript {
+
+  inline unsigned int get_lang_tag_index (Tag baseLangSysTag) const
+  {
+    Tag tag;
+    int cmp;
+    for (unsigned int i = 0; i < baseLangSysCount; i++) {
+      tag = baseLangSysRecords[i].get_tag();
+      // taking advantage of alphabetical order
+      cmp = tag.cmp(baseLangSysTag);
+      if (cmp == 0) return i;
+      if (cmp > 0)  return NOT_INDEXED;
+    }
+    return NOT_INDEXED;
+  }
+
+  inline unsigned int get_feature_tag_index (unsigned int baseLangSysIndex, Tag featureTableTag) const
+  {
+    if (baseLangSysIndex == NOT_INDEXED) {
+      if (unlikely(defaultMinMax)) return NOT_INDEXED;
+      return (this+defaultMinMax).get_feature_tag_index(featureTableTag);
+    }
+    if (unlikely(baseLangSysIndex >= baseLangSysCount)) return NOT_INDEXED;
+    return baseLangSysRecords[baseLangSysIndex].get_feature_tag_index(featureTableTag);
+  }
+
+  inline HBINT16 get_min_value (unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  {
+    if (baseLangSysIndex == NOT_INDEXED) {
+      if (unlikely(defaultMinMax == Null(OffsetTo<MinMax>))) return NO_COORD;
+      return (this+defaultMinMax).get_min_value(featureTableTagIndex);
+    }
+    if (unlikely(baseLangSysIndex >= baseLangSysCount)) return NO_COORD;
+    return baseLangSysRecords[baseLangSysIndex].get_max_value(featureTableTagIndex); 
+  }
+
+  inline HBINT16 get_max_value (unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  {
+    if (baseLangSysIndex == NOT_INDEXED) {
+      if (unlikely(defaultMinMax == Null(OffsetTo<MinMax>))) return NO_COORD;
+      return (this+defaultMinMax).get_min_value(featureTableTagIndex);
+    }
+    if (unlikely(baseLangSysIndex >= baseLangSysCount)) return NO_COORD;
+    return baseLangSysRecords[baseLangSysIndex].get_max_value(featureTableTagIndex);
+  }
+
+  inline unsigned int get_default_base_tag_index (void) const
+  { return (this+baseValues).get_default_base_tag_index(); }
+
+  inline HBINT16 get_base_coord (unsigned int baselineTagIndex) const
+  { return (this+baseValues).get_base_coord(baselineTagIndex); }
+
+  inline bool sanitize (hb_sanitize_context_t *c) const
+  {
+    TRACE_SANITIZE (this);
+    return_trace (c->check_struct (this) &&
+      baseValues.sanitize (c, this) &&
+      defaultMinMax.sanitize (c, this) &&
+      baseLangSysRecords.sanitize (c, this));
+  }
+
+  protected:
+  OffsetTo<BaseValues>        baseValues;
+  OffsetTo<MinMax>            defaultMinMax;
+  HBUINT16                      baseLangSysCount;
+  ArrayOf<BaseLangSysRecord>  baseLangSysRecords;
+
+  public:
+    DEFINE_SIZE_ARRAY (8, baseLangSysRecords);
+};
+
+
+struct BaseScriptRecord {
+
+  inline bool get_tag (void) const
+  { return baseScriptTag; }
+
+  inline unsigned int get_default_base_tag_index(void) const
+  { return (this+baseScript).get_default_base_tag_index(); }
+
+  inline HBINT16 get_base_coord(unsigned int baselineTagIndex) const
+  { return (this+baseScript).get_base_coord(baselineTagIndex); }
+
+  inline unsigned int get_lang_tag_index (Tag baseLangSysTag) const
+  { return (this+baseScript).get_lang_tag_index(baseLangSysTag); }
+
+  inline unsigned int get_feature_tag_index (unsigned int baseLangSysIndex, Tag featureTableTag) const
+  { return (this+baseScript).get_feature_tag_index(baseLangSysIndex, featureTableTag); }
+
+  inline HBINT16 get_max_value (unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  { return (this+baseScript).get_max_value(baseLangSysIndex, featureTableTagIndex); }
+
+  inline HBINT16 get_min_value (unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  { return (this+baseScript).get_min_value(baseLangSysIndex, featureTableTagIndex); }
+
+  inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
+  {
+    TRACE_SANITIZE (this);
+    return_trace (c->check_struct (this) &&
+      baseScript != Null(OffsetTo<BaseScript>) &&
+      baseScript.sanitize (c, base));
+  }
+
+  protected:
+  Tag                   baseScriptTag;
+  OffsetTo<BaseScript>  baseScript;
+
+  public:
+    DEFINE_SIZE_STATIC (6);
+};
+
+struct BaseScriptList {
+
+  inline unsigned int get_base_script_index (Tag baseScriptTag) const
+  {
+    for (unsigned int i = 0; i < baseScriptCount; i++)
+      if (baseScriptRecords[i].get_tag() == baseScriptTag)
+        return i;
+    return NOT_INDEXED;
+  }
+
+  inline unsigned int get_default_base_tag_index (unsigned int baseScriptIndex) const
+  { 
+    if (unlikely(baseScriptIndex >= baseScriptCount)) return NOT_INDEXED;
+    return baseScriptRecords[baseScriptIndex].get_default_base_tag_index();
+  }
+
+  inline HBINT16 get_base_coord(unsigned int baseScriptIndex, unsigned int baselineTagIndex) const
+  {
+    if (unlikely(baseScriptIndex >= baseScriptCount)) return NO_COORD;
+    return baseScriptRecords[baseScriptIndex].get_base_coord(baselineTagIndex);
+  }
+
+  inline unsigned int get_lang_tag_index (unsigned int baseScriptIndex, Tag baseLangSysTag) const
+  {
+    if (unlikely(baseScriptIndex >= baseScriptCount)) return NOT_INDEXED;
+    return baseScriptRecords[baseScriptIndex].get_lang_tag_index(baseLangSysTag);
+  }
+
+  inline unsigned int get_feature_tag_index (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, Tag featureTableTag) const
+  {
+    if (unlikely(baseScriptIndex >= baseScriptCount)) return NOT_INDEXED;
+    return baseScriptRecords[baseScriptIndex].get_feature_tag_index(baseLangSysIndex, featureTableTag);
+  }
+
+  inline HBINT16 get_max_value (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  {
+    if (unlikely(baseScriptIndex >= baseScriptCount)) return NO_COORD;
+    return baseScriptRecords[baseScriptIndex].get_max_value(baseLangSysIndex, featureTableTagIndex);
+  }
+
+  inline HBINT16 get_min_value (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  {
+    if (unlikely(baseScriptIndex >= baseScriptCount)) return NO_COORD;
+    return baseScriptRecords[baseScriptIndex].get_min_value(baseLangSysIndex, featureTableTagIndex);
+  }
+
+  inline bool sanitize (hb_sanitize_context_t *c) const
+  {
+    TRACE_SANITIZE (this);
+    return_trace (c->check_struct (this) &&
+      baseScriptRecords.sanitize (c, this));
+  }
+
+  protected:
+  HBUINT16                    baseScriptCount;
+  ArrayOf<BaseScriptRecord> baseScriptRecords;
+
+  public:
+  DEFINE_SIZE_ARRAY (4, baseScriptRecords);
+  
+};
+
+struct BaseTagList
+{
+
+  inline unsigned int get_tag_index(Tag baselineTag) const
+  {
+    for (unsigned int i = 0; i < baseTagCount; i++)
+      if (baselineTags[i] == baselineTag)
+        return i;
+    return NOT_INDEXED;
+  }
+
+  inline bool sanitize (hb_sanitize_context_t *c) const
+  {
+    TRACE_SANITIZE (this);
+    return_trace (c->check_struct (this));
+  }
+
+  protected:
+  HBUINT16        baseTagCount;
+  SortedArrayOf<Tag>  baselineTags;
+
+  public:
+  DEFINE_SIZE_ARRAY (4, baselineTags);
+};
+
+struct Axis
+{
+
+  inline unsigned int get_base_tag_index(Tag baselineTag) const
+  {
+    if (unlikely(baseTagList == Null(OffsetTo<BaseTagList>))) return NOT_INDEXED;
+    return (this+baseTagList).get_tag_index(baselineTag);
+  }
+
+  inline unsigned int get_default_base_tag_index_for_script_index (unsigned int baseScriptIndex) const
+  { 
+    if (unlikely(baseScriptList == Null(OffsetTo<BaseScriptList>))) return NOT_INDEXED;
+    return (this+baseScriptList).get_default_base_tag_index(baseScriptIndex);
+  }
+
+  inline HBINT16 get_base_coord(unsigned int baseScriptIndex, unsigned int baselineTagIndex) const
+  {
+    if (unlikely(baseScriptList == Null(OffsetTo<BaseScriptList>))) return NO_COORD;
+    return (this+baseScriptList).get_base_coord(baseScriptIndex, baselineTagIndex);
+  }
+
+  inline unsigned int get_lang_tag_index (unsigned int baseScriptIndex, Tag baseLangSysTag) const
+  {
+    if (unlikely(baseScriptList == Null(OffsetTo<BaseScriptList>))) return NOT_INDEXED;
+    return (this+baseScriptList).get_lang_tag_index(baseScriptIndex, baseLangSysTag);
+  }
+
+  inline unsigned int get_feature_tag_index (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, Tag featureTableTag) const
+  {
+    if (unlikely(baseScriptList == Null(OffsetTo<BaseScriptList>))) return NOT_INDEXED;
+    return (this+baseScriptList).get_feature_tag_index(baseScriptIndex, baseLangSysIndex, featureTableTag);
+  }
+
+  inline HBINT16 get_max_value (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  {
+    if (unlikely(baseScriptList == Null(OffsetTo<BaseScriptList>))) return NO_COORD;
+    return (this+baseScriptList).get_max_value(baseScriptIndex, baseLangSysIndex, featureTableTagIndex);
+  }
+
+  inline HBINT16 get_min_value (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  {
+    if (unlikely(baseScriptList == Null(OffsetTo<BaseScriptList>))) return NO_COORD;
+    return (this+baseScriptList).get_min_value(baseScriptIndex, baseLangSysIndex, featureTableTagIndex);
+  }
+
+  inline bool sanitize (hb_sanitize_context_t *c) const
+  {
+    TRACE_SANITIZE (this);
+    return_trace (c->check_struct (this) &&
+      baseTagList.sanitize (c, this) &&
+      baseScriptList.sanitize (c, this));
+  }
+
+  protected:
+  OffsetTo<BaseTagList>     baseTagList;
+  OffsetTo<BaseScriptList>  baseScriptList;
+
+  public:
+  DEFINE_SIZE_STATIC (4);
+};
+
+struct BASEFormat1_1
+{
+
+  inline bool sanitize (hb_sanitize_context_t *c) const
+  {
+    TRACE_SANITIZE (this);
+    return_trace (c->check_struct (this) &&
+      horizAxis.sanitize (c, this) &&
+      vertAxis.sanitize (c, this) && 
+      itemVarStore.sanitize (c, this));
+  }
+
+  protected:
+  FixedVersion<>            version;
+  OffsetTo<Axis>            horizAxis;
+  OffsetTo<Axis>            vertAxis;
+  LOffsetTo<VariationStore> itemVarStore;
+
+  public:
+  DEFINE_SIZE_STATIC (12);
+};
+
+struct BASEFormat1_0
+{
+
+  inline bool has_vert_axis(void)
+  { return vertAxis != Null(OffsetTo<Axis>); }
+
+  inline bool has_horiz_axis(void)
+  { return horizAxis != Null(OffsetTo<Axis>); }
+
+  // horizontal axis base coords:
+
+  inline unsigned int get_horiz_base_tag_index(Tag baselineTag) const
+  {
+    if (unlikely(horizAxis == Null(OffsetTo<Axis>))) return NOT_INDEXED;
+    return (this+horizAxis).get_base_tag_index(baselineTag);
+  }
+
+  inline unsigned int get_horiz_default_base_tag_index_for_script_index (unsigned int baseScriptIndex) const
+  { 
+    if (unlikely(horizAxis == Null(OffsetTo<Axis>))) return NOT_INDEXED;
+    return (this+horizAxis).get_default_base_tag_index_for_script_index(baseScriptIndex);
+  }
+
+  inline HBINT16 get_horiz_base_coord(unsigned int baseScriptIndex, unsigned int baselineTagIndex) const
+  {
+    if (unlikely(horizAxis == Null(OffsetTo<Axis>))) return NO_COORD;
+    return (this+horizAxis).get_base_coord(baseScriptIndex, baselineTagIndex);
+  }
+
+  // vertical axis base coords:
+
+  inline unsigned int get_vert_base_tag_index(Tag baselineTag) const
+  {
+    if (unlikely(vertAxis == Null(OffsetTo<Axis>))) return NOT_INDEXED;
+    return (this+vertAxis).get_base_tag_index(baselineTag);
+  }
+
+  inline unsigned int get_vert_default_base_tag_index_for_script_index (unsigned int baseScriptIndex) const
+  { 
+    if (unlikely(vertAxis == Null(OffsetTo<Axis>))) return NOT_INDEXED;
+    return (this+vertAxis).get_default_base_tag_index_for_script_index(baseScriptIndex);
+  }
+
+  inline HBINT16 get_vert_base_coord(unsigned int baseScriptIndex, unsigned int baselineTagIndex) const
+  {
+    if (vertAxis == Null(OffsetTo<Axis>)) return NO_COORD;
+    return (this+vertAxis).get_base_coord(baseScriptIndex, baselineTagIndex);
+  }
+
+  // horizontal axis min/max coords:
+
+  inline unsigned int get_horiz_lang_tag_index (unsigned int baseScriptIndex, Tag baseLangSysTag) const
+  {
+    if (unlikely(horizAxis == Null(OffsetTo<Axis>))) return NOT_INDEXED;
+    return (this+horizAxis).get_lang_tag_index (baseScriptIndex, baseLangSysTag);
+  }
+
+  inline unsigned int get_horiz_feature_tag_index (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, Tag featureTableTag) const
+  {
+    if (unlikely(horizAxis == Null(OffsetTo<Axis>))) return NOT_INDEXED;
+    return (this+horizAxis).get_feature_tag_index (baseScriptIndex, baseLangSysIndex, featureTableTag);
+  }
+
+  inline HBINT16 get_horiz_max_value (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  {
+    if (unlikely(horizAxis == Null(OffsetTo<Axis>))) return NO_COORD;
+    return (this+horizAxis).get_max_value (baseScriptIndex, baseLangSysIndex, featureTableTagIndex);
+  }
+
+  inline HBINT16 get_horiz_min_value (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  {
+    if (unlikely(horizAxis == Null(OffsetTo<Axis>))) return NO_COORD;
+    return (this+horizAxis).get_min_value (baseScriptIndex, baseLangSysIndex, featureTableTagIndex);
+  }
+
+    // vertical axis min/max coords:
+
+  inline unsigned int get_vert_lang_tag_index (unsigned int baseScriptIndex, Tag baseLangSysTag) const
+  {
+    if (unlikely(vertAxis == Null(OffsetTo<Axis>))) return NOT_INDEXED;
+    return (this+vertAxis).get_lang_tag_index (baseScriptIndex, baseLangSysTag);
+  }
+
+  inline unsigned int get_vert_feature_tag_index (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, Tag featureTableTag) const
+  {
+    if (unlikely(vertAxis == Null(OffsetTo<Axis>))) return NOT_INDEXED;
+    return (this+vertAxis).get_feature_tag_index (baseScriptIndex, baseLangSysIndex, featureTableTag);
+  }
+
+  inline HBINT16 get_vert_max_value (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  {
+    if (unlikely(vertAxis == Null(OffsetTo<Axis>))) return NO_COORD;
+    return (this+vertAxis).get_max_value (baseScriptIndex, baseLangSysIndex, featureTableTagIndex);
+  }
+
+  inline HBINT16 get_vert_min_value (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  {
+    if (unlikely(vertAxis == Null(OffsetTo<Axis>))) return NO_COORD;
+    return (this+vertAxis).get_min_value (baseScriptIndex, baseLangSysIndex, featureTableTagIndex);
+  }
+
+  inline bool sanitize (hb_sanitize_context_t *c) const
+  {
+    TRACE_SANITIZE (this);
+    return_trace (c->check_struct (this) &&
+      horizAxis.sanitize (c, this) &&
+      vertAxis.sanitize (c, this));
+  }
+
+  protected:
+  FixedVersion<>  version;
+  OffsetTo<Axis>  horizAxis;
+  OffsetTo<Axis>  vertAxis;
+
+  public:
+  DEFINE_SIZE_STATIC (8);
+};
+
+struct BASE
+{
+  static const hb_tag_t tableTag = HB_OT_TAG_BASE;
+
+  inline bool has_vert_axis(void)
+  { return u.format1_0.has_vert_axis(); }
+
+  inline bool has_horiz_axis(void)
+  { return u.format1_0.has_horiz_axis(); }
+
+  inline unsigned int get_horiz_base_tag_index(Tag baselineTag) const
+  { return u.format1_0.get_horiz_base_tag_index(baselineTag); }
+
+  inline unsigned int get_horiz_default_base_tag_index_for_script_index (unsigned int baseScriptIndex) const
+  { return u.format1_0.get_horiz_default_base_tag_index_for_script_index(baseScriptIndex); }
+
+  inline HBINT16 get_horiz_base_coord(unsigned int baseScriptIndex, unsigned int baselineTagIndex) const
+  { return u.format1_0.get_horiz_base_coord(baseScriptIndex, baselineTagIndex); }
+
+  inline unsigned int get_vert_base_tag_index(Tag baselineTag) const
+  { return u.format1_0.get_vert_base_tag_index(baselineTag); }
+
+  inline unsigned int get_vert_default_base_tag_index_for_script_index (unsigned int baseScriptIndex) const
+  { return u.format1_0.get_vert_default_base_tag_index_for_script_index(baseScriptIndex); }
+
+  inline HBINT16 get_vert_base_coord(unsigned int baseScriptIndex, unsigned int baselineTagIndex) const
+  { return u.format1_0.get_vert_base_coord(baseScriptIndex, baselineTagIndex); }
+
+  inline unsigned int get_horiz_lang_tag_index (unsigned int baseScriptIndex, Tag baseLangSysTag) const
+  { return u.format1_0.get_horiz_lang_tag_index(baseScriptIndex, baseLangSysTag); }
+
+  inline unsigned int get_horiz_feature_tag_index (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, Tag featureTableTag) const
+  { return u.format1_0.get_horiz_feature_tag_index(baseScriptIndex, baseLangSysIndex, featureTableTag); }
+
+  inline HBINT16 get_horiz_max_value (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  { return u.format1_0.get_horiz_max_value(baseScriptIndex, baseLangSysIndex, featureTableTagIndex); }
+
+  inline HBINT16 get_horiz_min_value (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  { return u.format1_0.get_horiz_min_value(baseScriptIndex, baseLangSysIndex, featureTableTagIndex); }
+
+  inline unsigned int get_vert_lang_tag_index (unsigned int baseScriptIndex, Tag baseLangSysTag) const
+  { return u.format1_0.get_vert_lang_tag_index(baseScriptIndex, baseLangSysTag); }
+
+  inline unsigned int get_vert_feature_tag_index (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, Tag featureTableTag) const
+  { return u.format1_0.get_vert_feature_tag_index(baseScriptIndex, baseLangSysIndex, featureTableTag); }
+
+  inline HBINT16 get_vert_max_value (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  { return u.format1_0.get_vert_max_value(baseScriptIndex, baseLangSysIndex, featureTableTagIndex); }
+
+  inline HBINT16 get_vert_min_value (unsigned int baseScriptIndex, unsigned int baseLangSysIndex, unsigned int featureTableTagIndex) const
+  { return u.format1_0.get_vert_min_value(baseScriptIndex, baseLangSysIndex, featureTableTagIndex); }
+
+  inline bool sanitize (hb_sanitize_context_t *c) const
+  {
+    TRACE_SANITIZE (this);
+    if (!u.version.sanitize (c)) return_trace (false);
+    if (!likely(u.version.major == 1)) return_trace (false);
+    switch (u.version.minor) {
+    case 0: return_trace (u.format1_0.sanitize (c));
+    case 1: return_trace (u.format1_1.sanitize (c));
+    default:return_trace (false);
+    }
+  }
+
+  protected:
+  union {
+    FixedVersion<>  version;    /* Version of the BASE table: 1.0 or 1.1 */
+    BASEFormat1_0   format1_0;
+    BASEFormat1_1   format1_1;
+  } u;
+
+  public:
+  DEFINE_SIZE_UNION (4, version);
+};
+
+
+} /* namespace OT */
+
+
+#endif /* HB_OT_BASE_TABLE_HH */

src/hb-ot-layout-private.hh

@@ -122,6 +122,7 @@ hb_ot_layout_position_finish_offsets (hb_font_t    *font,
  */
 
 namespace OT {
+  struct BASE;
   struct GDEF;
   struct GSUB;
   struct GPOS;
@@ -168,6 +169,7 @@ struct hb_ot_layout_t
   const struct OT::GPOS *gpos;
 
   /* TODO Move the following out of this struct. */
+  OT::hb_lazy_table_loader_t<struct OT::BASE> base;
   OT::hb_lazy_table_loader_t<struct OT::MATH> math;
   OT::hb_lazy_table_loader_t<struct OT::fvar> fvar;
   OT::hb_lazy_table_loader_t<struct OT::avar> avar;

src/hb-ot-layout.cc

@@ -31,6 +31,7 @@
 #include "hb-open-type-private.hh"
 #include "hb-ot-layout-private.hh"
 
+#include "hb-ot-layout-base-table.hh"
 #include "hb-ot-layout-gdef-table.hh"
 #include "hb-ot-layout-gsub-table.hh"
 #include "hb-ot-layout-gpos-table.hh"
@@ -62,6 +63,7 @@ _hb_ot_layout_create (hb_face_t *face)
   layout->gpos = OT::Sanitizer<OT::GPOS>::lock_instance (layout->gpos_blob);
 
   layout->math.init (face);
+  layout->base.init (face);
   layout->fvar.init (face);
   layout->avar.init (face);
   layout->morx.init (face);
@@ -212,6 +214,7 @@ _hb_ot_layout_destroy (hb_ot_layout_t *layout)
   hb_blob_destroy (layout->gpos_blob);
 
   layout->math.fini ();
+  layout->base.fini ();
   layout->fvar.fini ();
   layout->avar.fini ();
   layout->morx.fini ();

src/hb-ot.h

@@ -33,6 +33,7 @@
 #include "hb-ot-font.h"
 #include "hb-ot-layout.h"
 #include "hb-ot-math.h"
+#include "hb-ot-base.h"
 #include "hb-ot-tag.h"
 #include "hb-ot-shape.h"
 #include "hb-ot-var.h"