2009-05-18 02:28:01 +02:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2007,2008,2009 Red Hat, Inc.
|
|
|
|
*
|
2010-04-22 06:11:43 +02:00
|
|
|
* This is part of HarfBuzz, a text shaping library.
|
2009-05-18 02:28:01 +02:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* Red Hat Author(s): Behdad Esfahbod
|
|
|
|
*/
|
|
|
|
|
2009-08-03 02:03:12 +02:00
|
|
|
#ifndef HB_OT_LAYOUT_COMMON_PRIVATE_HH
|
|
|
|
#define HB_OT_LAYOUT_COMMON_PRIVATE_HH
|
2009-05-18 02:28:01 +02:00
|
|
|
|
2009-08-03 01:57:00 +02:00
|
|
|
#include "hb-ot-layout-private.h"
|
|
|
|
|
2009-08-05 04:06:57 +02:00
|
|
|
#include "hb-open-type-private.hh"
|
2009-05-18 02:28:01 +02:00
|
|
|
|
|
|
|
|
2009-08-15 00:42:42 +02:00
|
|
|
#define NO_CONTEXT ((unsigned int) 0x110000)
|
|
|
|
#define NOT_COVERED ((unsigned int) 0x110000)
|
|
|
|
#define MAX_NESTING_LEVEL 8
|
|
|
|
|
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
/*
|
|
|
|
*
|
|
|
|
* OpenType Layout Common Table Formats
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2009-05-18 10:37:37 +02:00
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
/*
|
|
|
|
* Script, ScriptList, LangSys, Feature, FeatureList, Lookup, LookupList
|
|
|
|
*/
|
|
|
|
|
|
|
|
template <typename Type>
|
2009-05-20 05:58:54 +02:00
|
|
|
struct Record
|
|
|
|
{
|
2010-03-16 08:46:17 +01:00
|
|
|
static inline unsigned int get_size () { return sizeof (Record<Type>); }
|
|
|
|
|
2010-04-22 05:30:48 +02:00
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF, void *base) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2010-04-22 19:22:41 +02:00
|
|
|
return SANITIZE_SELF () && SANITIZE_BASE (offset, base);
|
2009-08-04 08:09:34 +02:00
|
|
|
}
|
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
Tag tag; /* 4-byte Tag identifier */
|
|
|
|
OffsetTo<Type>
|
|
|
|
offset; /* Offset from beginning of object holding
|
|
|
|
* the Record */
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename Type>
|
2009-08-08 01:46:30 +02:00
|
|
|
struct RecordArrayOf : ArrayOf<Record<Type> > {
|
2009-05-20 05:58:54 +02:00
|
|
|
inline const Tag& get_tag (unsigned int i) const
|
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
if (HB_UNLIKELY (i >= this->len)) return Null(Tag);
|
2009-11-03 16:47:29 +01:00
|
|
|
return (*this)[i].tag;
|
2009-05-18 02:28:01 +02:00
|
|
|
}
|
2009-11-04 22:36:14 +01:00
|
|
|
inline unsigned int get_tags (unsigned int start_offset,
|
|
|
|
unsigned int *record_count /* IN/OUT */,
|
|
|
|
hb_tag_t *record_tags /* OUT */) const
|
2009-08-08 01:46:30 +02:00
|
|
|
{
|
2009-11-04 22:36:14 +01:00
|
|
|
if (record_count) {
|
2010-04-22 06:27:39 +02:00
|
|
|
const Record<Type> *array = this->sub_array (start_offset, record_count);
|
2009-11-04 22:59:50 +01:00
|
|
|
unsigned int count = *record_count;
|
2009-11-04 22:36:14 +01:00
|
|
|
for (unsigned int i = 0; i < count; i++)
|
|
|
|
record_tags[i] = array[i].tag;
|
|
|
|
}
|
|
|
|
return this->len;
|
2009-08-08 01:46:30 +02:00
|
|
|
}
|
|
|
|
inline bool find_index (hb_tag_t tag, unsigned int *index) const
|
|
|
|
{
|
2010-04-21 06:14:12 +02:00
|
|
|
Tag t;
|
|
|
|
t.set (tag);
|
2009-08-08 01:46:30 +02:00
|
|
|
// TODO bsearch
|
2010-04-22 04:37:31 +02:00
|
|
|
const Record<Type> *a = this->array();
|
2009-08-08 01:46:30 +02:00
|
|
|
unsigned int count = this->len;
|
|
|
|
for (unsigned int i = 0; i < count; i++)
|
|
|
|
{
|
2009-11-03 16:47:29 +01:00
|
|
|
if (t == a[i].tag)
|
2009-08-08 01:46:30 +02:00
|
|
|
{
|
|
|
|
if (index) *index = i;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (index) *index = NO_INDEX;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename Type>
|
|
|
|
struct RecordListOf : RecordArrayOf<Type>
|
|
|
|
{
|
|
|
|
inline const Type& operator [] (unsigned int i) const
|
2009-11-03 01:17:36 +01:00
|
|
|
{ return this+RecordArrayOf<Type>::operator [](i).offset; }
|
2009-08-04 08:09:34 +02:00
|
|
|
|
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2010-04-22 05:30:48 +02:00
|
|
|
return RecordArrayOf<Type>::sanitize (SANITIZE_ARG, CharP(this));
|
2009-08-04 08:09:34 +02:00
|
|
|
}
|
2009-05-18 02:28:01 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2009-08-08 01:46:30 +02:00
|
|
|
struct IndexArray : ArrayOf<USHORT>
|
|
|
|
{
|
|
|
|
inline unsigned int operator [] (unsigned int i) const
|
|
|
|
{
|
|
|
|
if (HB_UNLIKELY (i >= this->len))
|
|
|
|
return NO_INDEX;
|
2010-04-22 04:37:31 +02:00
|
|
|
return this->array()[i];
|
2009-08-08 01:46:30 +02:00
|
|
|
}
|
2009-11-04 22:36:14 +01:00
|
|
|
inline unsigned int get_indexes (unsigned int start_offset,
|
|
|
|
unsigned int *_count /* IN/OUT */,
|
|
|
|
unsigned int *_indexes /* OUT */) const
|
2009-08-08 01:46:30 +02:00
|
|
|
{
|
2009-11-04 22:36:14 +01:00
|
|
|
if (_count) {
|
2010-04-22 06:27:39 +02:00
|
|
|
const USHORT *array = this->sub_array (start_offset, _count);
|
2009-11-04 22:59:50 +01:00
|
|
|
unsigned int count = *_count;
|
2009-11-04 22:36:14 +01:00
|
|
|
for (unsigned int i = 0; i < count; i++)
|
|
|
|
_indexes[i] = array[i];
|
|
|
|
}
|
|
|
|
return this->len;
|
2009-08-08 01:46:30 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
struct Script;
|
|
|
|
struct LangSys;
|
|
|
|
struct Feature;
|
|
|
|
|
|
|
|
|
2009-05-20 05:58:54 +02:00
|
|
|
struct LangSys
|
|
|
|
{
|
2009-08-08 01:46:30 +02:00
|
|
|
inline unsigned int get_feature_count (void) const
|
|
|
|
{ return featureIndex.len; }
|
|
|
|
inline hb_tag_t get_feature_index (unsigned int i) const
|
|
|
|
{ return featureIndex[i]; }
|
2009-11-04 22:36:14 +01:00
|
|
|
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); }
|
2009-05-18 02:28:01 +02:00
|
|
|
|
2009-05-25 09:10:06 +02:00
|
|
|
inline bool has_required_feature (void) const { return reqFeatureIndex != 0xffff; }
|
2009-05-20 05:58:54 +02:00
|
|
|
inline int get_required_feature_index (void) const
|
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
if (reqFeatureIndex == 0xffff)
|
|
|
|
return NO_INDEX;
|
|
|
|
return reqFeatureIndex;;
|
|
|
|
}
|
|
|
|
|
2009-08-04 08:09:34 +02:00
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2009-08-04 08:09:34 +02:00
|
|
|
return SANITIZE_SELF () && SANITIZE (featureIndex);
|
|
|
|
}
|
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
Offset lookupOrder; /* = Null (reserved for an offset to a
|
|
|
|
* reordering table) */
|
|
|
|
USHORT reqFeatureIndex;/* Index of a feature required for this
|
|
|
|
* language system--if no required features
|
|
|
|
* = 0xFFFF */
|
2009-08-08 01:46:30 +02:00
|
|
|
IndexArray featureIndex; /* Array of indices into the FeatureList */
|
2009-05-18 02:28:01 +02:00
|
|
|
};
|
2010-04-20 21:25:27 +02:00
|
|
|
ASSERT_SIZE (LangSys, 6);
|
|
|
|
DEFINE_NULL_DATA (LangSys, 6, "\0\0\xFF\xFF");
|
2009-05-18 02:28:01 +02:00
|
|
|
|
|
|
|
|
2009-05-20 05:58:54 +02:00
|
|
|
struct Script
|
|
|
|
{
|
2009-08-08 01:46:30 +02:00
|
|
|
inline unsigned int get_lang_sys_count (void) const
|
|
|
|
{ return langSys.len; }
|
|
|
|
inline const Tag& get_lang_sys_tag (unsigned int i) const
|
|
|
|
{ return langSys.get_tag (i); }
|
2009-11-04 22:36:14 +01:00
|
|
|
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); }
|
2009-05-20 05:58:54 +02:00
|
|
|
inline const LangSys& get_lang_sys (unsigned int i) const
|
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
if (i == NO_INDEX) return get_default_lang_sys ();
|
|
|
|
return this+langSys[i].offset;
|
|
|
|
}
|
2009-08-08 01:46:30 +02:00
|
|
|
inline bool find_lang_sys_index (hb_tag_t tag, unsigned int *index) const
|
|
|
|
{ return langSys.find_index (tag, index); }
|
2009-05-18 02:28:01 +02:00
|
|
|
|
2009-05-25 09:10:06 +02:00
|
|
|
inline bool has_default_lang_sys (void) const { return defaultLangSys != 0; }
|
2009-05-20 05:58:54 +02:00
|
|
|
inline const LangSys& get_default_lang_sys (void) const { return this+defaultLangSys; }
|
2009-05-18 02:28:01 +02:00
|
|
|
|
2009-08-04 08:09:34 +02:00
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2010-04-22 19:26:21 +02:00
|
|
|
return SANITIZE_THIS2 (defaultLangSys, langSys);
|
2009-08-04 08:09:34 +02:00
|
|
|
}
|
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
private:
|
|
|
|
OffsetTo<LangSys>
|
|
|
|
defaultLangSys; /* Offset to DefaultLangSys table--from
|
|
|
|
* beginning of Script table--may be Null */
|
2009-08-04 08:09:34 +02:00
|
|
|
RecordArrayOf<LangSys>
|
2009-05-18 02:28:01 +02:00
|
|
|
langSys; /* Array of LangSysRecords--listed
|
|
|
|
* alphabetically by LangSysTag */
|
|
|
|
};
|
|
|
|
ASSERT_SIZE (Script, 4);
|
|
|
|
|
|
|
|
typedef RecordListOf<Script> ScriptList;
|
|
|
|
ASSERT_SIZE (ScriptList, 2);
|
|
|
|
|
|
|
|
|
2009-05-20 05:58:54 +02:00
|
|
|
struct Feature
|
|
|
|
{
|
2009-08-08 01:46:30 +02:00
|
|
|
inline unsigned int get_lookup_count (void) const
|
|
|
|
{ return lookupIndex.len; }
|
|
|
|
inline hb_tag_t get_lookup_index (unsigned int i) const
|
|
|
|
{ return lookupIndex[i]; }
|
2009-11-04 22:36:14 +01:00
|
|
|
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); }
|
2009-05-18 02:28:01 +02:00
|
|
|
|
2009-08-04 08:09:34 +02:00
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2009-08-04 08:09:34 +02:00
|
|
|
return SANITIZE_SELF () && SANITIZE (lookupIndex);
|
|
|
|
}
|
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
/* 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 */
|
2009-08-08 01:46:30 +02:00
|
|
|
IndexArray lookupIndex; /* Array of LookupList indices */
|
2009-05-18 02:28:01 +02:00
|
|
|
};
|
|
|
|
ASSERT_SIZE (Feature, 4);
|
|
|
|
|
|
|
|
typedef RecordListOf<Feature> FeatureList;
|
|
|
|
ASSERT_SIZE (FeatureList, 2);
|
|
|
|
|
|
|
|
|
2009-05-20 05:58:54 +02:00
|
|
|
struct LookupFlag : USHORT
|
|
|
|
{
|
2009-05-19 00:44:54 +02:00
|
|
|
enum {
|
|
|
|
RightToLeft = 0x0001u,
|
|
|
|
IgnoreBaseGlyphs = 0x0002u,
|
|
|
|
IgnoreLigatures = 0x0004u,
|
|
|
|
IgnoreMarks = 0x0008u,
|
2009-10-29 08:00:44 +01:00
|
|
|
IgnoreFlags = 0x000Eu,
|
2009-05-26 19:04:59 +02:00
|
|
|
UseMarkFilteringSet = 0x0010u,
|
|
|
|
Reserved = 0x00E0u,
|
2009-08-18 22:41:59 +02:00
|
|
|
MarkAttachmentType = 0xFF00u
|
2009-05-19 00:44:54 +02:00
|
|
|
};
|
2009-05-18 02:28:01 +02:00
|
|
|
};
|
|
|
|
ASSERT_SIZE (LookupFlag, 2);
|
|
|
|
|
2009-05-20 05:58:54 +02:00
|
|
|
struct LookupSubTable
|
|
|
|
{
|
2009-08-04 08:09:34 +02:00
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2009-08-04 08:09:34 +02:00
|
|
|
return SANITIZE_SELF ();
|
|
|
|
}
|
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
private:
|
|
|
|
USHORT format; /* Subtable format. Different for GSUB and GPOS */
|
|
|
|
};
|
|
|
|
ASSERT_SIZE (LookupSubTable, 2);
|
|
|
|
|
2009-05-20 05:58:54 +02:00
|
|
|
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; }
|
2009-05-18 02:28:01 +02:00
|
|
|
|
|
|
|
inline unsigned int get_type (void) const { return lookupType; }
|
2009-05-26 19:04:59 +02:00
|
|
|
inline unsigned int get_flag (void) const
|
|
|
|
{
|
|
|
|
unsigned int flag = lookupFlag;
|
|
|
|
if (HB_UNLIKELY (flag & LookupFlag::UseMarkFilteringSet))
|
|
|
|
{
|
2010-04-21 21:56:11 +02:00
|
|
|
const USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
|
2009-05-27 01:48:16 +02:00
|
|
|
flag += (markFilteringSet << 16);
|
2009-05-26 19:04:59 +02:00
|
|
|
}
|
|
|
|
return flag;
|
|
|
|
}
|
2009-05-18 02:28:01 +02:00
|
|
|
|
2009-08-04 08:09:34 +02:00
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2010-04-22 06:49:16 +02:00
|
|
|
if (!(SANITIZE_SELF () && HB_LIKELY ((subTable).sanitize_shallow (SANITIZE_ARG)))) return false;
|
2009-08-04 08:09:34 +02:00
|
|
|
if (HB_UNLIKELY (lookupFlag & LookupFlag::UseMarkFilteringSet))
|
|
|
|
{
|
2010-04-21 21:56:11 +02:00
|
|
|
USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
|
2009-08-04 08:09:34 +02:00
|
|
|
if (!SANITIZE (markFilteringSet)) return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-05-26 19:04:59 +02:00
|
|
|
USHORT lookupType; /* Different enumerations for GSUB and GPOS */
|
|
|
|
USHORT lookupFlag; /* Lookup qualifiers */
|
2009-05-18 02:28:01 +02:00
|
|
|
OffsetArrayOf<LookupSubTable>
|
2009-05-26 19:04:59 +02:00
|
|
|
subTable; /* Array of SubTables */
|
2009-11-03 16:47:29 +01:00
|
|
|
USHORT markFilteringSetX[VAR]; /* Index (base 0) into GDEF mark glyph sets
|
2009-05-26 19:04:59 +02:00
|
|
|
* structure. This field is only present if bit
|
|
|
|
* UseMarkFilteringSet of lookup flags is set. */
|
2009-05-18 02:28:01 +02:00
|
|
|
};
|
2009-11-03 16:47:29 +01:00
|
|
|
ASSERT_SIZE_VAR (Lookup, 6, USHORT);
|
2009-05-18 02:28:01 +02:00
|
|
|
|
|
|
|
typedef OffsetListOf<Lookup> LookupList;
|
|
|
|
ASSERT_SIZE (LookupList, 2);
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Coverage Table
|
|
|
|
*/
|
|
|
|
|
2009-05-20 05:58:54 +02:00
|
|
|
struct CoverageFormat1
|
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
friend struct Coverage;
|
|
|
|
|
|
|
|
private:
|
2009-05-20 05:58:54 +02:00
|
|
|
inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
|
|
|
|
{
|
2009-05-18 10:37:37 +02:00
|
|
|
if (HB_UNLIKELY (glyph_id > 0xFFFF))
|
2009-05-18 02:28:01 +02:00
|
|
|
return NOT_COVERED;
|
2009-05-18 10:37:37 +02:00
|
|
|
GlyphID gid;
|
2009-11-20 02:28:03 +01:00
|
|
|
gid.set (glyph_id);
|
2009-05-18 02:28:01 +02:00
|
|
|
// TODO: bsearch
|
|
|
|
unsigned int num_glyphs = glyphArray.len;
|
|
|
|
for (unsigned int i = 0; i < num_glyphs; i++)
|
|
|
|
if (gid == glyphArray[i])
|
|
|
|
return i;
|
|
|
|
return NOT_COVERED;
|
|
|
|
}
|
|
|
|
|
2009-08-04 06:58:28 +02:00
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2009-08-04 06:58:28 +02:00
|
|
|
return SANITIZE (glyphArray);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2009-05-18 02:28:01 +02:00
|
|
|
USHORT coverageFormat; /* Format identifier--format = 1 */
|
|
|
|
ArrayOf<GlyphID>
|
|
|
|
glyphArray; /* Array of GlyphIDs--in numerical order */
|
|
|
|
};
|
|
|
|
ASSERT_SIZE (CoverageFormat1, 4);
|
|
|
|
|
2009-05-20 05:58:54 +02:00
|
|
|
struct CoverageRangeRecord
|
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
friend struct CoverageFormat2;
|
|
|
|
|
2010-03-16 08:46:17 +01:00
|
|
|
static inline unsigned int get_size () { return sizeof (CoverageRangeRecord); }
|
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
private:
|
2009-05-20 05:58:54 +02:00
|
|
|
inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
|
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
if (glyph_id >= start && glyph_id <= end)
|
2009-05-18 10:37:37 +02:00
|
|
|
return (unsigned int) startCoverageIndex + (glyph_id - start);
|
2009-05-18 02:28:01 +02:00
|
|
|
return NOT_COVERED;
|
|
|
|
}
|
|
|
|
|
2009-08-04 08:09:34 +02:00
|
|
|
public:
|
2009-08-04 06:58:28 +02:00
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2009-08-04 06:58:28 +02:00
|
|
|
return SANITIZE_SELF ();
|
|
|
|
}
|
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
private:
|
|
|
|
GlyphID start; /* First GlyphID in the range */
|
|
|
|
GlyphID end; /* Last GlyphID in the range */
|
|
|
|
USHORT startCoverageIndex; /* Coverage Index of first GlyphID in
|
|
|
|
* range */
|
|
|
|
};
|
2010-04-20 21:25:27 +02:00
|
|
|
ASSERT_SIZE (CoverageRangeRecord, 6);
|
|
|
|
DEFINE_NULL_DATA (CoverageRangeRecord, 6, "\000\001");
|
2009-05-18 02:28:01 +02:00
|
|
|
|
2009-05-20 05:58:54 +02:00
|
|
|
struct CoverageFormat2
|
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
friend struct Coverage;
|
|
|
|
|
|
|
|
private:
|
2009-05-20 05:58:54 +02:00
|
|
|
inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
|
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
// TODO: bsearch
|
|
|
|
unsigned int count = rangeRecord.len;
|
2009-05-20 05:58:54 +02:00
|
|
|
for (unsigned int i = 0; i < count; i++)
|
|
|
|
{
|
2009-05-18 10:37:37 +02:00
|
|
|
unsigned int coverage = rangeRecord[i].get_coverage (glyph_id);
|
|
|
|
if (coverage != NOT_COVERED)
|
2009-05-18 02:28:01 +02:00
|
|
|
return coverage;
|
|
|
|
}
|
|
|
|
return NOT_COVERED;
|
|
|
|
}
|
|
|
|
|
2009-08-04 06:58:28 +02:00
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2009-08-04 06:58:28 +02:00
|
|
|
return SANITIZE (rangeRecord);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2009-05-18 02:28:01 +02:00
|
|
|
USHORT coverageFormat; /* Format identifier--format = 2 */
|
|
|
|
ArrayOf<CoverageRangeRecord>
|
|
|
|
rangeRecord; /* Array of glyph ranges--ordered by
|
|
|
|
* Start GlyphID. rangeCount entries
|
|
|
|
* long */
|
|
|
|
};
|
|
|
|
ASSERT_SIZE (CoverageFormat2, 4);
|
|
|
|
|
2009-05-20 05:58:54 +02:00
|
|
|
struct Coverage
|
|
|
|
{
|
2010-04-21 05:50:45 +02:00
|
|
|
inline unsigned int operator () (hb_codepoint_t glyph_id) const { return get_coverage (glyph_id); }
|
2009-08-04 06:58:28 +02:00
|
|
|
|
2009-08-11 01:00:36 +02:00
|
|
|
inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
|
2009-05-20 05:58:54 +02:00
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
switch (u.format) {
|
|
|
|
case 1: return u.format1->get_coverage(glyph_id);
|
|
|
|
case 2: return u.format2->get_coverage(glyph_id);
|
|
|
|
default:return NOT_COVERED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-11 01:00:36 +02:00
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2009-08-04 06:58:28 +02:00
|
|
|
if (!SANITIZE (u.format)) return false;
|
|
|
|
switch (u.format) {
|
|
|
|
case 1: return u.format1->sanitize (SANITIZE_ARG);
|
|
|
|
case 2: return u.format2->sanitize (SANITIZE_ARG);
|
|
|
|
default:return true;
|
|
|
|
}
|
|
|
|
}
|
2009-05-18 02:28:01 +02:00
|
|
|
|
|
|
|
private:
|
|
|
|
union {
|
|
|
|
USHORT format; /* Format identifier */
|
2009-11-03 16:47:29 +01:00
|
|
|
CoverageFormat1 format1[VAR];
|
|
|
|
CoverageFormat2 format2[VAR];
|
2009-05-18 02:28:01 +02:00
|
|
|
} u;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Class Definition Table
|
|
|
|
*/
|
|
|
|
|
2009-05-20 05:58:54 +02:00
|
|
|
struct ClassDefFormat1
|
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
friend struct ClassDef;
|
|
|
|
|
|
|
|
private:
|
2009-05-20 05:58:54 +02:00
|
|
|
inline hb_ot_layout_class_t get_class (hb_codepoint_t glyph_id) const
|
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
if ((unsigned int) (glyph_id - startGlyph) < classValue.len)
|
|
|
|
return classValue[glyph_id - startGlyph];
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-04 06:58:28 +02:00
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2009-08-04 06:58:28 +02:00
|
|
|
return SANITIZE_SELF () && SANITIZE (classValue);
|
|
|
|
}
|
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
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);
|
|
|
|
|
2009-05-20 05:58:54 +02:00
|
|
|
struct ClassRangeRecord
|
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
friend struct ClassDefFormat2;
|
|
|
|
|
2010-03-16 08:46:17 +01:00
|
|
|
static inline unsigned int get_size () { return sizeof (ClassRangeRecord); }
|
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
private:
|
2009-05-20 05:58:54 +02:00
|
|
|
inline hb_ot_layout_class_t get_class (hb_codepoint_t glyph_id) const
|
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
if (glyph_id >= start && glyph_id <= end)
|
|
|
|
return classValue;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-04 08:09:34 +02:00
|
|
|
public:
|
2009-08-04 06:58:28 +02:00
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2009-08-04 06:58:28 +02:00
|
|
|
return SANITIZE_SELF ();
|
|
|
|
}
|
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
private:
|
|
|
|
GlyphID start; /* First GlyphID in the range */
|
|
|
|
GlyphID end; /* Last GlyphID in the range */
|
|
|
|
USHORT classValue; /* Applied to all glyphs in the range */
|
|
|
|
};
|
2010-04-20 21:25:27 +02:00
|
|
|
ASSERT_SIZE (ClassRangeRecord, 6);
|
|
|
|
DEFINE_NULL_DATA (ClassRangeRecord, 6, "\000\001");
|
2009-05-18 02:28:01 +02:00
|
|
|
|
2009-05-20 05:58:54 +02:00
|
|
|
struct ClassDefFormat2
|
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
friend struct ClassDef;
|
|
|
|
|
|
|
|
private:
|
2009-05-20 05:58:54 +02:00
|
|
|
inline hb_ot_layout_class_t get_class (hb_codepoint_t glyph_id) const
|
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
// TODO: bsearch
|
|
|
|
unsigned int count = rangeRecord.len;
|
2009-05-20 05:58:54 +02:00
|
|
|
for (unsigned int i = 0; i < count; i++)
|
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
int classValue = rangeRecord[i].get_class (glyph_id);
|
|
|
|
if (classValue > 0)
|
|
|
|
return classValue;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-04 06:58:28 +02:00
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2009-08-04 06:58:28 +02:00
|
|
|
return SANITIZE (rangeRecord);
|
|
|
|
}
|
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
USHORT classFormat; /* Format identifier--format = 2 */
|
|
|
|
ArrayOf<ClassRangeRecord>
|
|
|
|
rangeRecord; /* Array of glyph ranges--ordered by
|
|
|
|
* Start GlyphID */
|
|
|
|
};
|
|
|
|
ASSERT_SIZE (ClassDefFormat2, 4);
|
|
|
|
|
2009-05-20 05:58:54 +02:00
|
|
|
struct ClassDef
|
|
|
|
{
|
2010-04-21 05:50:45 +02:00
|
|
|
inline hb_ot_layout_class_t operator () (hb_codepoint_t glyph_id) const { return get_class (glyph_id); }
|
2009-08-04 06:58:28 +02:00
|
|
|
|
2009-08-11 01:00:36 +02:00
|
|
|
inline hb_ot_layout_class_t get_class (hb_codepoint_t glyph_id) const
|
2009-05-20 05:58:54 +02:00
|
|
|
{
|
2009-05-18 02:28:01 +02:00
|
|
|
switch (u.format) {
|
|
|
|
case 1: return u.format1->get_class(glyph_id);
|
|
|
|
case 2: return u.format2->get_class(glyph_id);
|
|
|
|
default:return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-11 01:00:36 +02:00
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2009-08-04 06:58:28 +02:00
|
|
|
if (!SANITIZE (u.format)) return false;
|
|
|
|
switch (u.format) {
|
|
|
|
case 1: return u.format1->sanitize (SANITIZE_ARG);
|
|
|
|
case 2: return u.format2->sanitize (SANITIZE_ARG);
|
|
|
|
default:return true;
|
|
|
|
}
|
|
|
|
}
|
2009-05-18 05:17:56 +02:00
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
private:
|
|
|
|
union {
|
|
|
|
USHORT format; /* Format identifier */
|
2009-11-03 16:47:29 +01:00
|
|
|
ClassDefFormat1 format1[VAR];
|
|
|
|
ClassDefFormat2 format2[VAR];
|
2009-05-18 02:28:01 +02:00
|
|
|
} u;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Device Tables
|
|
|
|
*/
|
|
|
|
|
2009-05-20 05:58:54 +02:00
|
|
|
struct Device
|
|
|
|
{
|
2010-04-21 05:50:45 +02:00
|
|
|
inline int operator () (unsigned int ppem_size) const { return get_delta (ppem_size); }
|
2009-08-04 18:26:26 +02:00
|
|
|
|
2009-08-11 01:00:36 +02:00
|
|
|
inline int get_delta (unsigned int ppem_size) const
|
2009-05-20 05:58:54 +02:00
|
|
|
{
|
2009-05-19 01:47:52 +02:00
|
|
|
unsigned int f = deltaFormat;
|
|
|
|
if (HB_UNLIKELY (f < 1 || f > 3))
|
|
|
|
return 0;
|
2009-05-18 02:28:01 +02:00
|
|
|
|
2009-05-19 01:47:52 +02:00
|
|
|
if (ppem_size < startSize || ppem_size > endSize)
|
|
|
|
return 0;
|
2009-05-18 02:28:01 +02:00
|
|
|
|
2009-05-19 01:47:52 +02:00
|
|
|
unsigned int s = ppem_size - startSize;
|
2009-05-18 02:28:01 +02:00
|
|
|
|
2009-05-19 01:47:52 +02:00
|
|
|
unsigned int byte = deltaValue[s >> (4 - f)];
|
2009-05-27 01:48:16 +02:00
|
|
|
unsigned int bits = (byte >> (16 - (((s & ((1 << (4 - f)) - 1)) + 1) << f)));
|
|
|
|
unsigned int mask = (0xFFFF >> (16 - (1 << f)));
|
2009-05-19 01:47:52 +02:00
|
|
|
|
|
|
|
int delta = bits & mask;
|
|
|
|
|
2009-08-04 19:57:41 +02:00
|
|
|
if ((unsigned int) delta >= ((mask + 1) >> 1))
|
2009-05-19 01:47:52 +02:00
|
|
|
delta -= mask + 1;
|
|
|
|
|
|
|
|
return delta;
|
|
|
|
}
|
|
|
|
|
2009-08-04 18:26:26 +02:00
|
|
|
inline unsigned int get_size () const
|
|
|
|
{
|
|
|
|
unsigned int f = deltaFormat;
|
2010-03-16 08:46:17 +01:00
|
|
|
if (HB_UNLIKELY (f < 1 || f > 3 || startSize > endSize)) return 3 * USHORT::get_size ();
|
|
|
|
return 3 * USHORT::get_size () + ((endSize - startSize + (1 << (4 - f)) - 1) >> (4 - f));
|
2009-08-04 18:26:26 +02:00
|
|
|
}
|
|
|
|
|
2009-08-11 01:00:36 +02:00
|
|
|
inline bool sanitize (SANITIZE_ARG_DEF) {
|
2009-08-28 23:17:11 +02:00
|
|
|
TRACE_SANITIZE ();
|
2010-04-22 06:45:42 +02:00
|
|
|
return SANITIZE_SELF() && SANITIZE_MEM (this, this->get_size ());
|
2009-08-04 18:26:26 +02:00
|
|
|
}
|
2009-05-18 02:28:01 +02:00
|
|
|
|
|
|
|
private:
|
2010-04-22 06:23:14 +02:00
|
|
|
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 */
|
2009-11-03 16:47:29 +01:00
|
|
|
USHORT deltaValue[VAR]; /* Array of compressed data */
|
2009-05-18 02:28:01 +02:00
|
|
|
};
|
2009-11-03 16:47:29 +01:00
|
|
|
ASSERT_SIZE_VAR (Device, 6, USHORT);
|
2009-05-18 02:28:01 +02:00
|
|
|
|
|
|
|
|
2009-08-03 02:03:12 +02:00
|
|
|
#endif /* HB_OT_LAYOUT_COMMON_PRIVATE_HH */
|