Merge remote-tracking branch 'eroux/add-base'
diff --git a/src/Makefile.sources b/src/Makefile.sources
index 2bb56b4..cecd644 100644
--- a/src/Makefile.sources
+++ b/src/Makefile.sources
@@ -87,8 +87,10 @@
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-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 \
diff --git a/src/hb-ot-base.cc b/src/hb-ot-base.cc
new file mode 100644
index 0000000..27e0b20
--- /dev/null
+++ b/src/hb-ot-base.cc
@@ -0,0 +1,58 @@
+/*
+ * 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);
+}
diff --git a/src/hb-ot-base.h b/src/hb-ot-base.h
new file mode 100644
index 0000000..9d82d22
--- /dev/null
+++ b/src/hb-ot-base.h
@@ -0,0 +1,56 @@
+/*
+ * 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 */
diff --git a/src/hb-ot-layout-base-table.hh b/src/hb-ot-layout-base-table.hh
new file mode 100644
index 0000000..7801860
--- /dev/null
+++ b/src/hb-ot-layout-base-table.hh
@@ -0,0 +1,762 @@
+/*
+ * 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 */
diff --git a/src/hb-ot-layout-private.hh b/src/hb-ot-layout-private.hh
index 0c3bcbc..b8860a7 100644
--- a/src/hb-ot-layout-private.hh
+++ b/src/hb-ot-layout-private.hh
@@ -122,6 +122,7 @@
*/
namespace OT {
+ struct BASE;
struct GDEF;
struct GSUB;
struct GPOS;
@@ -168,6 +169,7 @@
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;
diff --git a/src/hb-ot-layout.cc b/src/hb-ot-layout.cc
index 4cf6c72..68eb125 100644
--- a/src/hb-ot-layout.cc
+++ b/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 @@
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_blob_destroy (layout->gpos_blob);
layout->math.fini ();
+ layout->base.fini ();
layout->fvar.fini ();
layout->avar.fini ();
layout->morx.fini ();
diff --git a/src/hb-ot.h b/src/hb-ot.h
index 2120a3e..272208e 100644
--- a/src/hb-ot.h
+++ b/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"
