From b986c6a321f7d997eba0a9308b651966644bf336 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Fri, 29 Mar 2019 20:17:46 -0700 Subject: [PATCH] [C++11] Remove IntType::set() in favor of operator= --- src/hb-cff-interp-common.hh | 4 +- src/hb-ft.cc | 2 +- src/hb-null.hh | 6 -- src/hb-open-file.hh | 14 ++-- src/hb-open-type.hh | 43 +++++++----- src/hb-ot-cff-common.hh | 24 +++---- src/hb-ot-cff1-table.hh | 32 ++++----- src/hb-ot-cmap-table.hh | 77 +++++++++++----------- src/hb-ot-glyf-table.hh | 2 +- src/hb-ot-hdmx-table.hh | 12 ++-- src/hb-ot-hmtx-table.hh | 8 +-- src/hb-ot-layout-common.hh | 44 ++++++------- src/hb-ot-layout-gdef-table.hh | 8 +-- src/hb-ot-layout-gsub-table.hh | 18 ++--- src/hb-ot-maxp-table.hh | 16 ++--- src/hb-ot-os2-table.hh | 10 +-- src/hb-ot-post-table.hh | 2 +- src/hb-ot-shape-complex-arabic-fallback.hh | 10 +-- src/hb-ot-vorg-table.hh | 12 ++-- src/hb-subset-cff-common.cc | 12 ++-- src/hb-subset-cff-common.hh | 2 +- src/hb-subset-cff1.cc | 10 +-- src/hb-subset-cff2.cc | 8 +-- src/hb-subset-glyf.cc | 8 +-- src/hb-uniscribe.cc | 22 +++---- 25 files changed, 206 insertions(+), 200 deletions(-) diff --git a/src/hb-cff-interp-common.hh b/src/hb-cff-interp-common.hh index 72e9e06c8..78ef997b1 100644 --- a/src/hb-cff-interp-common.hh +++ b/src/hb-cff-interp-common.hh @@ -272,11 +272,11 @@ struct UnsizedByteStr : UnsizedArrayOf HBUINT8 *p = c->allocate_size (1); if (unlikely (p == nullptr)) return_trace (false); - p->set (intOp); + *p = intOp; INTTYPE *ip = c->allocate_size (INTTYPE::static_size); if (unlikely (ip == nullptr)) return_trace (false); - ip->set ((unsigned int)value); + *ip = (unsigned int) value; return_trace (true); } diff --git a/src/hb-ft.cc b/src/hb-ft.cc index 1900f30bc..48434dc8c 100644 --- a/src/hb-ft.cc +++ b/src/hb-ft.cc @@ -96,7 +96,7 @@ _hb_ft_font_create (FT_Face ft_face, bool symbol, bool unref) ft_font->load_flags = FT_LOAD_DEFAULT | FT_LOAD_NO_HINTING; - ft_font->cached_x_scale.set (0); + ft_font->cached_x_scale.set_relaxed (0); ft_font->advance_cache.init (); return ft_font; diff --git a/src/hb-null.hh b/src/hb-null.hh index c1e4a634d..21810b210 100644 --- a/src/hb-null.hh +++ b/src/hb-null.hh @@ -83,12 +83,6 @@ struct hb_static_size template struct _hb_assign { static inline void value (T &o, const V v) { o = v; } }; -template -struct _hb_assign > -{ static inline void value (T &o, const V v) { o.set (v); } }; -template -struct _hb_assign > -{ static inline void value (T &o, const T v) { o = v; } }; template static inline void hb_assign (T &o, const V v) diff --git a/src/hb-open-file.hh b/src/hb-open-file.hh index 32a223cdf..03d27c118 100644 --- a/src/hb-open-file.hh +++ b/src/hb-open-file.hh @@ -106,7 +106,7 @@ typedef struct OffsetTable bool find_table_index (hb_tag_t tag, unsigned int *table_index) const { Tag t; - t.set (tag); + t = tag; return tables.bfind (t, table_index, HB_BFIND_NOT_FOUND_STORE, Index::NOT_FOUND_INDEX); } const TableRecord& get_table_by_tag (hb_tag_t tag) const @@ -127,7 +127,7 @@ typedef struct OffsetTable /* Alloc 12 for the OTHeader. */ if (unlikely (!c->extend_min (*this))) return_trace (false); /* Write sfntVersion (bytes 0..3). */ - sfnt_version.set (sfnt_tag); + sfnt_version = sfnt_tag; /* Take space for numTables, searchRange, entrySelector, RangeShift * and the TableRecords themselves. */ if (unlikely (!tables.serialize (c, items.length))) return_trace (false); @@ -140,8 +140,8 @@ typedef struct OffsetTable { TableRecord &rec = tables.arrayZ[i]; hb_blob_t *blob = items[i].blob; - rec.tag.set (items[i].tag); - rec.length.set (hb_blob_get_length (blob)); + rec.tag = items[i].tag; + rec.length = hb_blob_get_length (blob); rec.offset.serialize (c, this); /* Allocate room for the table and copy it. */ @@ -159,7 +159,7 @@ typedef struct OffsetTable { head *h = (head *) start; checksum_adjustment = &h->checkSumAdjustment; - checksum_adjustment->set (0); + *checksum_adjustment = 0; } rec.checkSum.set_for_data (start, end - start); @@ -177,10 +177,10 @@ typedef struct OffsetTable for (unsigned int i = 0; i < items.length; i++) { TableRecord &rec = tables.arrayZ[i]; - checksum.set (checksum + rec.checkSum); + checksum = checksum + rec.checkSum; } - checksum_adjustment->set (0xB1B0AFBAu - checksum); + *checksum_adjustment = 0xB1B0AFBAu - checksum; } return_trace (true); diff --git a/src/hb-open-type.hh b/src/hb-open-type.hh index d7e6182f4..5756a9b0f 100644 --- a/src/hb-open-type.hh +++ b/src/hb-open-type.hh @@ -60,7 +60,6 @@ struct IntType typedef typename hb_signedness_int (hb_is_signed (Type)) wide_type; IntType& operator = (wide_type i) { v = i; return *this; } - void set (wide_type i) { v = i; } operator wide_type () const { return v; } bool operator == (const IntType &o) const { return (Type) v == (Type) o.v; } bool operator != (const IntType &o) const { return !(*this == o); } @@ -107,6 +106,7 @@ typedef HBUINT16 UFWORD; /* 16-bit signed fixed number with the low 14 bits of fraction (2.14). */ struct F2DOT14 : HBINT16 { + F2DOT14& operator = (uint16_t i ) { HBINT16::operator= (i); return *this; } // 16384 means 1<<14 float to_float () const { return ((int32_t) v) / 16384.f; } void set_float (float f) { v = round (f * 16384.f); } @@ -117,6 +117,7 @@ struct F2DOT14 : HBINT16 /* 32-bit signed fixed-point number (16.16). */ struct Fixed : HBINT32 { + Fixed& operator = (uint32_t i) { HBINT32::operator= (i); return *this; } // 65536 means 1<<16 float to_float () const { return ((int32_t) v) / 65536.f; } void set_float (float f) { v = round (f * 65536.f); } @@ -144,6 +145,7 @@ struct LONGDATETIME * system, feature, or baseline */ struct Tag : HBUINT32 { + Tag& operator = (uint32_t i) { HBUINT32::operator= (i); return *this; } /* What the char* converters return is NOT nul-terminated. Print using "%.4s" */ operator const char* () const { return reinterpret_cast (&this->v); } operator char* () { return reinterpret_cast (&this->v); } @@ -152,11 +154,15 @@ struct Tag : HBUINT32 }; /* Glyph index number, same as uint16 (length = 16 bits) */ -struct GlyphID : HBUINT16 {}; +struct GlyphID : HBUINT16 +{ + GlyphID& operator = (uint16_t i) { HBUINT16::operator= (i); return *this; } +}; /* Script/language-system/feature index */ struct Index : HBUINT16 { static constexpr unsigned NOT_FOUND_INDEX = 0xFFFFu; + Index& operator = (uint16_t i) { HBUINT16::operator= (i); return *this; } }; DECLARE_NULL_NAMESPACE_BYTES (OT, Index); @@ -166,6 +172,8 @@ typedef Index NameID; template struct Offset : Type { + Offset& operator = (typename Type::type i) { Type::operator= (i); return *this; } + typedef Type type; bool is_null () const { return has_null && 0 == *this; } @@ -173,7 +181,7 @@ struct Offset : Type void *serialize (hb_serialize_context_t *c, const void *base) { void *t = c->start_embed (); - this->set ((char *) t - (char *) base); /* TODO(serialize) Overflow? */ + *this = (char *) t - (char *) base; /* TODO(serialize) Overflow? */ return t; } @@ -188,6 +196,8 @@ typedef Offset Offset32; /* CheckSum */ struct CheckSum : HBUINT32 { + CheckSum& operator = (uint32_t i) { HBUINT32::operator= (i); return *this; } + /* This is reference implementation from the spec. */ static uint32_t CalcTableChecksum (const HBUINT32 *Table, uint32_t Length) { @@ -202,7 +212,7 @@ struct CheckSum : HBUINT32 /* Note: data should be 4byte aligned and have 4byte padding at the end. */ void set_for_data (const void *data, unsigned int length) - { set (CalcTableChecksum ((const HBUINT32 *) data, length)); } + { *this = CalcTableChecksum ((const HBUINT32 *) data, length); } public: DEFINE_SIZE_STATIC (4); @@ -252,6 +262,8 @@ struct _hb_has_null template struct OffsetTo : Offset { + OffsetTo& operator = (typename OffsetType::type i) { OffsetType::operator= (i); return *this; } + const Type& operator () (const void *base) const { if (unlikely (this->is_null ())) return *_hb_has_null::get_null (); @@ -273,12 +285,12 @@ struct OffsetTo : Offset { if (&src == &Null (T)) { - this->set (0); + *this = 0; return; } serialize (c->serializer, base); if (!src.subset (c)) - this->set (0); + *this = 0; } bool sanitize_shallow (hb_sanitize_context_t *c, const void *base) const @@ -558,7 +570,7 @@ struct ArrayOf { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (*this))) return_trace (false); - len.set (items_len); /* TODO(serialize) Overflow? */ + len = items_len; /* TODO(serialize) Overflow? */ if (unlikely (!c->extend (*this))) return_trace (false); return_trace (true); } @@ -717,7 +729,7 @@ struct HeadlessArrayOf { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (*this))) return_trace (false); - lenP1.set (items.length + 1); /* TODO(serialize) Overflow? */ + lenP1 = items.length + 1; /* TODO(serialize) Overflow? */ if (unlikely (!c->extend (*this))) return_trace (false); for (unsigned int i = 0; i < items.length; i++) arrayZ[i] = items[i]; @@ -872,15 +884,16 @@ struct BinSearchHeader return_trace (c->check_struct (this)); } - void set (unsigned int v) + BinSearchHeader& operator = (unsigned int v) { - len.set (v); + len = v; assert (len == v); - entrySelector.set (MAX (1u, hb_bit_storage (v)) - 1); - searchRange.set (16 * (1u << entrySelector)); - rangeShift.set (v * 16 > searchRange - ? 16 * v - searchRange - : 0); + entrySelector = MAX (1u, hb_bit_storage (v)) - 1; + searchRange = 16 * (1u << entrySelector); + rangeShift = v * 16 > searchRange + ? 16 * v - searchRange + : 0; + return *this; } protected: diff --git a/src/hb-ot-cff-common.hh b/src/hb-ot-cff-common.hh index 61e615cf0..0cd05d0e2 100644 --- a/src/hb-ot-cff-common.hh +++ b/src/hb-ot-cff-common.hh @@ -124,14 +124,14 @@ struct CFFIndex { COUNT *dest = c->allocate_min (); if (unlikely (dest == nullptr)) return_trace (false); - dest->set (0); + *dest = 0; } else { /* serialize CFFIndex header */ if (unlikely (!c->extend_min (*this))) return_trace (false); - this->count.set (byteArray.length); - this->offSize.set (offSize_); + this->count = byteArray.length; + this->offSize = offSize_; if (!unlikely (c->allocate_size (offSize_ * (byteArray.length + 1)))) return_trace (false); @@ -181,7 +181,7 @@ struct CFFIndex for (; size; size--) { --p; - p->set (offset & 0xFF); + *p = offset & 0xFF; offset >>= 8; } } @@ -275,8 +275,8 @@ struct CFFIndexOf : CFFIndex TRACE_SERIALIZE (this); /* serialize CFFIndex header */ if (unlikely (!c->extend_min (*this))) return_trace (false); - this->count.set (dataArrayLen); - this->offSize.set (offSize_); + this->count = dataArrayLen; + this->offSize = offSize_; if (!unlikely (c->allocate_size (offSize_ * (dataArrayLen + 1)))) return_trace (false); @@ -376,11 +376,11 @@ struct Dict : UnsizedByteStr if (unlikely (p == nullptr)) return_trace (false); if (Is_OpCode_ESC (op)) { - p->set (OpCode_escape); + *p = OpCode_escape; op = Unmake_OpCode_ESC (op); p++; } - p->set (op); + *p = op; return_trace (true); } @@ -477,8 +477,8 @@ struct FDArray : CFFIndexOf { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (*this))) return_trace (false); - this->count.set (fontDicts.length); - this->offSize.set (offSize_); + this->count = fontDicts.length; + this->offSize = offSize_; if (!unlikely (c->allocate_size (offSize_ * (fontDicts.length + 1)))) return_trace (false); @@ -514,8 +514,8 @@ struct FDArray : CFFIndexOf { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (*this))) return_trace (false); - this->count.set (fdCount); - this->offSize.set (offSize_); + this->count = fdCount; + this->offSize = offSize_; if (!unlikely (c->allocate_size (offSize_ * (fdCount + 1)))) return_trace (false); diff --git a/src/hb-ot-cff1-table.hh b/src/hb-ot-cff1-table.hh index 9d39242cf..7fbda905e 100644 --- a/src/hb-ot-cff1-table.hh +++ b/src/hb-ot-cff1-table.hh @@ -196,18 +196,18 @@ struct Encoding { TRACE_SERIALIZE (this); Encoding *dest = c->extend_min (*this); if (unlikely (dest == nullptr)) return_trace (false); - dest->format.set (format | ((supp_codes.length > 0)? 0x80: 0)); + dest->format = format | ((supp_codes.length > 0)? 0x80: 0); if (format == 0) { Encoding0 *fmt0 = c->allocate_size (Encoding0::min_size + HBUINT8::static_size * enc_count); if (unlikely (fmt0 == nullptr)) return_trace (false); - fmt0->nCodes ().set (enc_count); + fmt0->nCodes () = enc_count; unsigned int glyph = 0; for (unsigned int i = 0; i < code_ranges.length; i++) { hb_codepoint_t code = code_ranges[i].code; for (int left = (int)code_ranges[i].glyph; left >= 0; left--) - fmt0->codes[glyph++].set (code++); + fmt0->codes[glyph++] = code++; if (unlikely (!((glyph <= 0x100) && (code <= 0x100)))) return_trace (false); } @@ -216,24 +216,24 @@ struct Encoding { { Encoding1 *fmt1 = c->allocate_size (Encoding1::min_size + Encoding1_Range::static_size * code_ranges.length); if (unlikely (fmt1 == nullptr)) return_trace (false); - fmt1->nRanges ().set (code_ranges.length); + fmt1->nRanges () = code_ranges.length; for (unsigned int i = 0; i < code_ranges.length; i++) { if (unlikely (!((code_ranges[i].code <= 0xFF) && (code_ranges[i].glyph <= 0xFF)))) return_trace (false); - fmt1->ranges[i].first.set (code_ranges[i].code); - fmt1->ranges[i].nLeft.set (code_ranges[i].glyph); + fmt1->ranges[i].first = code_ranges[i].code; + fmt1->ranges[i].nLeft = code_ranges[i].glyph; } } if (supp_codes.length > 0) { CFF1SuppEncData *suppData = c->allocate_size (CFF1SuppEncData::min_size + SuppEncoding::static_size * supp_codes.length); if (unlikely (suppData == nullptr)) return_trace (false); - suppData->nSups ().set (supp_codes.length); + suppData->nSups () = supp_codes.length; for (unsigned int i = 0; i < supp_codes.length; i++) { - suppData->supps[i].code.set (supp_codes[i].code); - suppData->supps[i].glyph.set (supp_codes[i].glyph); /* actually SID */ + suppData->supps[i].code = supp_codes[i].code; + suppData->supps[i].glyph = supp_codes[i].glyph; /* actually SID */ } } return_trace (true); @@ -469,7 +469,7 @@ struct Charset { TRACE_SERIALIZE (this); Charset *dest = c->extend_min (*this); if (unlikely (dest == nullptr)) return_trace (false); - dest->format.set (format); + dest->format = format; if (format == 0) { Charset0 *fmt0 = c->allocate_size (Charset0::min_size + HBUINT16::static_size * (num_glyphs - 1)); @@ -479,7 +479,7 @@ struct Charset { { hb_codepoint_t sid = sid_ranges[i].code; for (int left = (int)sid_ranges[i].glyph; left >= 0; left--) - fmt0->sids[glyph++].set (sid++); + fmt0->sids[glyph++] = sid++; } } else if (format == 1) @@ -490,8 +490,8 @@ struct Charset { { if (unlikely (!(sid_ranges[i].glyph <= 0xFF))) return_trace (false); - fmt1->ranges[i].first.set (sid_ranges[i].code); - fmt1->ranges[i].nLeft.set (sid_ranges[i].glyph); + fmt1->ranges[i].first = sid_ranges[i].code; + fmt1->ranges[i].nLeft = sid_ranges[i].glyph; } } else /* format 2 */ @@ -502,8 +502,8 @@ struct Charset { { if (unlikely (!(sid_ranges[i].glyph <= 0xFFFF))) return_trace (false); - fmt2->ranges[i].first.set (sid_ranges[i].code); - fmt2->ranges[i].nLeft.set (sid_ranges[i].glyph); + fmt2->ranges[i].first = sid_ranges[i].code; + fmt2->ranges[i].nLeft = sid_ranges[i].glyph; } } return_trace (true); @@ -577,7 +577,7 @@ struct CFF1StringIndex : CFF1Index { if (!unlikely (c->extend_min (this->count))) return_trace (false); - count.set (0); + count = 0; return_trace (true); } diff --git a/src/hb-ot-cmap-table.hh b/src/hb-ot-cmap-table.hh index 3846d46c1..53b914a17 100644 --- a/src/hb-ot-cmap-table.hh +++ b/src/hb-ot-cmap-table.hh @@ -89,15 +89,15 @@ struct CmapSubtableFormat4 if (unlikely (!c->extend_min (*this))) return_trace (false); - this->format.set (4); - this->length.set (get_sub_table_size (segments)); + this->format = 4; + this->length = get_sub_table_size (segments); - this->segCountX2.set (segments.length * 2); - this->entrySelector.set (MAX (1u, hb_bit_storage (segments.length)) - 1); - this->searchRange.set (2 * (1u << this->entrySelector)); - this->rangeShift.set (segments.length * 2 > this->searchRange - ? 2 * segments.length - this->searchRange - : 0); + this->segCountX2 = segments.length * 2; + this->entrySelector = MAX (1u, hb_bit_storage (segments.length)) - 1; + this->searchRange = 2 * (1u << this->entrySelector); + this->rangeShift = segments.length * 2 > this->searchRange + ? 2 * segments.length - this->searchRange + : 0; HBUINT16 *end_count = c->allocate_size (HBUINT16::static_size * segments.length); c->allocate_size (HBUINT16::static_size); // 2 bytes of padding. @@ -110,17 +110,17 @@ struct CmapSubtableFormat4 for (unsigned int i = 0; i < segments.length; i++) { - end_count[i].set (segments[i].end_code); - start_count[i].set (segments[i].start_code); + end_count[i] = segments[i].end_code; + start_count[i] = segments[i].start_code; if (segments[i].use_delta) { hb_codepoint_t cp = segments[i].start_code; hb_codepoint_t start_gid = 0; if (unlikely (!plan->new_gid_for_codepoint (cp, &start_gid) && cp != 0xFFFF)) return_trace (false); - id_delta[i].set (start_gid - segments[i].start_code); + id_delta[i] = start_gid - segments[i].start_code; } else { - id_delta[i].set (0); + id_delta[i] = 0; unsigned int num_codepoints = segments[i].end_code - segments[i].start_code + 1; HBUINT16 *glyph_id_array = c->allocate_size (HBUINT16::static_size * num_codepoints); if (glyph_id_array == nullptr) @@ -138,15 +138,14 @@ struct CmapSubtableFormat4 // id_range_offset[i] // = // 2 * (glyph_id_array - id_range_offset - i) - id_range_offset[i].set (2 * ( - glyph_id_array - id_range_offset - i)); + id_range_offset[i] = 2 * (glyph_id_array - id_range_offset - i); for (unsigned int j = 0; j < num_codepoints; j++) { hb_codepoint_t cp = segments[i].start_code + j; hb_codepoint_t new_gid; if (unlikely (!plan->new_gid_for_codepoint (cp, &new_gid))) return_trace (false); - glyph_id_array[j].set (new_gid); + glyph_id_array[j] = new_gid; } } } @@ -198,11 +197,11 @@ struct CmapSubtableFormat4 cp != segment->end_code + 1u) { segment = segments->push (); - segment->start_code.set (cp); - segment->end_code.set (cp); + segment->start_code = cp; + segment->end_code = cp; segment->use_delta = true; } else { - segment->end_code.set (cp); + segment->end_code = cp; if (last_gid + 1u != new_gid) // gid's are not consecutive in this segment so delta // cannot be used. @@ -216,8 +215,8 @@ struct CmapSubtableFormat4 if (segment == nullptr || segment->end_code != 0xFFFF) { segment = segments->push (); - segment->start_code.set (0xFFFF); - segment->end_code.set (0xFFFF); + segment->start_code = 0xFFFF; + segment->end_code = 0xFFFF; segment->use_delta = true; } @@ -523,9 +522,9 @@ struct CmapSubtableFormat12 : CmapSubtableLongSegmented { if (unlikely (!c->extend_min (*this))) return false; - this->format.set (12); - this->reserved.set (0); - this->length.set (get_sub_table_size (groups)); + this->format = 12; + this->reserved = 0; + this->length = get_sub_table_size (groups); return CmapSubtableLongSegmented::serialize (c, groups); } @@ -552,11 +551,11 @@ struct CmapSubtableFormat12 : CmapSubtableLongSegmented if (!group || !_is_gid_consecutive (group, cp, new_gid)) { group = groups->push (); - group->startCharCode.set (cp); - group->endCharCode.set (cp); - group->glyphID.set (new_gid); + group->startCharCode = cp; + group->endCharCode = cp; + group->glyphID = new_gid; } - else group->endCharCode.set (cp); + else group->endCharCode = cp; } DEBUG_MSG(SUBSET, nullptr, "cmap"); @@ -879,7 +878,7 @@ struct cmap return false; } - table->version.set (0); + table->version = 0; if (unlikely (!table->encodingRecord.serialize (&c, /* numTables */ 3))) return false; @@ -888,24 +887,24 @@ struct cmap // Format 4, Plat 0 Encoding Record EncodingRecord &format4_plat0_rec = table->encodingRecord[0]; - format4_plat0_rec.platformID.set (0); // Unicode - format4_plat0_rec.encodingID.set (3); + format4_plat0_rec.platformID = 0; // Unicode + format4_plat0_rec.encodingID = 3; // Format 4, Plat 3 Encoding Record EncodingRecord &format4_plat3_rec = table->encodingRecord[1]; - format4_plat3_rec.platformID.set (3); // Windows - format4_plat3_rec.encodingID.set (1); // Unicode BMP + format4_plat3_rec.platformID = 3; // Windows + format4_plat3_rec.encodingID = 1; // Unicode BMP // Format 12 Encoding Record EncodingRecord &format12_rec = table->encodingRecord[2]; - format12_rec.platformID.set (3); // Windows - format12_rec.encodingID.set (10); // Unicode UCS-4 + format12_rec.platformID = 3; // Windows + format12_rec.encodingID = 10; // Unicode UCS-4 // Write out format 4 sub table { CmapSubtable &subtable = format4_plat0_rec.subtable.serialize (&c, table); - format4_plat3_rec.subtable.set (format4_plat0_rec.subtable); - subtable.u.format.set (4); + format4_plat3_rec.subtable = format4_plat0_rec.subtable; + subtable.u.format = 4; CmapSubtableFormat4 &format4 = subtable.u.format4; if (unlikely (!format4.serialize (&c, plan, cmap_subset_plan.format4_segments))) @@ -915,7 +914,7 @@ struct cmap // Write out format 12 sub table. { CmapSubtable &subtable = format12_rec.subtable.serialize (&c, table); - subtable.u.format.set (12); + subtable.u.format = 12; CmapSubtableFormat12 &format12 = subtable.u.format12; if (unlikely (!format12.serialize (&c, cmap_subset_plan.format12_groups))) @@ -1144,8 +1143,8 @@ struct cmap unsigned int encoding_id) const { EncodingRecord key; - key.platformID.set (platform_id); - key.encodingID.set (encoding_id); + key.platformID = platform_id; + key.encodingID = encoding_id; const EncodingRecord &result = encodingRecord.bsearch (key); if (!result.subtable) diff --git a/src/hb-ot-glyf-table.hh b/src/hb-ot-glyf-table.hh index c2b38b05b..b595e5efe 100644 --- a/src/hb-ot-glyf-table.hh +++ b/src/hb-ot-glyf-table.hh @@ -112,7 +112,7 @@ struct glyf return false; head *head_prime = (head *) hb_blob_get_data_writable (head_prime_blob, nullptr); - head_prime->indexToLocFormat.set (use_short_loca ? 0 : 1); + head_prime->indexToLocFormat = use_short_loca ? 0 : 1; bool success = plan->add_table (HB_OT_TAG_head, head_prime_blob); hb_blob_destroy (head_prime_blob); diff --git a/src/hb-ot-hdmx-table.hh b/src/hb-ot-hdmx-table.hh index 953ccab80..847b32657 100644 --- a/src/hb-ot-hdmx-table.hh +++ b/src/hb-ot-hdmx-table.hh @@ -88,8 +88,8 @@ struct DeviceRecord return_trace (false); } - this->pixelSize.set (subset_view.source_device_record->pixelSize); - this->maxWidth.set (subset_view.source_device_record->maxWidth); + this->pixelSize = subset_view.source_device_record->pixelSize; + this->maxWidth = subset_view.source_device_record->maxWidth; for (unsigned int i = 0; i < subset_view.len (); i++) { @@ -99,7 +99,7 @@ struct DeviceRecord DEBUG_MSG(SUBSET, nullptr, "HDMX width for new gid %d is missing.", i); return_trace (false); } - widthsZ[i].set (*width); + widthsZ[i] = *width; } return_trace (true); @@ -141,9 +141,9 @@ struct hdmx if (unlikely (!c->extend_min ((*this)))) return_trace (false); - this->version.set (source_hdmx->version); - this->numRecords.set (source_hdmx->numRecords); - this->sizeDeviceRecord.set (DeviceRecord::get_size (plan->num_output_glyphs ())); + this->version = source_hdmx->version; + this->numRecords = source_hdmx->numRecords; + this->sizeDeviceRecord = DeviceRecord::get_size (plan->num_output_glyphs ()); for (unsigned int i = 0; i < source_hdmx->numRecords; i++) { diff --git a/src/hb-ot-hmtx-table.hh b/src/hb-ot-hmtx-table.hh index 9ef1f5716..5dff981ef 100644 --- a/src/hb-ot-hmtx-table.hh +++ b/src/hb-ot-hmtx-table.hh @@ -78,7 +78,7 @@ struct hmtxvmtx unsigned int length; H *table = (H *) hb_blob_get_data (dest_blob, &length); - table->numberOfLongMetrics.set (num_hmetrics); + table->numberOfLongMetrics = num_hmetrics; bool result = plan->add_table (H::tableTag, dest_blob); hb_blob_destroy (dest_blob); @@ -128,12 +128,12 @@ struct hmtxvmtx bool has_advance = i < num_advances; if (has_advance) { - ((LongMetric *) dest_pos)->advance.set (advance); - ((LongMetric *) dest_pos)->sb.set (side_bearing); + ((LongMetric *) dest_pos)->advance = advance; + ((LongMetric *) dest_pos)->sb = side_bearing; } else { - ((FWORD *) dest_pos)->set (side_bearing); + *((FWORD *) dest_pos) = side_bearing; } dest_pos += (has_advance ? 4 : 2); } diff --git a/src/hb-ot-layout-common.hh b/src/hb-ot-layout-common.hh index 9991af139..e2ba28a24 100644 --- a/src/hb-ot-layout-common.hh +++ b/src/hb-ot-layout-common.hh @@ -561,7 +561,7 @@ struct Feature TRACE_SUBSET (this); struct Feature *out = c->serializer->embed (*this); if (unlikely (!out)) return_trace (false); - out->featureParams.set (0); /* TODO(subset) FeatureParams. */ + out->featureParams = 0; /* TODO(subset) FeatureParams. */ return_trace (true); } @@ -599,7 +599,7 @@ struct Feature OffsetTo new_offset; /* Check that it did not overflow. */ - new_offset.set (new_offset_int); + new_offset = new_offset_int; if (new_offset == new_offset_int && c->try_set (&featureParams, new_offset) && !featureParams.sanitize (c, this, closure ? closure->tag : HB_TAG_NONE)) @@ -703,14 +703,14 @@ struct Lookup { TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (*this))) return_trace (false); - lookupType.set (lookup_type); - lookupFlag.set (lookup_props & 0xFFFFu); + lookupType = lookup_type; + lookupFlag = lookup_props & 0xFFFFu; if (unlikely (!subTable.serialize (c, num_subtables))) return_trace (false); if (lookupFlag & LookupFlag::UseMarkFilteringSet) { if (unlikely (!c->extend (*this))) return_trace (false); HBUINT16 &markFilteringSet = StructAfter (subTable); - markFilteringSet.set (lookup_props >> 16); + markFilteringSet = lookup_props >> 16; } return_trace (true); } @@ -901,7 +901,7 @@ struct CoverageFormat2 if (unlikely (!glyphs)) { - rangeRecord.len.set (0); + rangeRecord.len = 0; return_trace (true); } /* TODO(iter) Port to non-random-access iterator interface. */ @@ -911,19 +911,19 @@ struct CoverageFormat2 for (unsigned int i = 1; i < count; i++) if (glyphs[i - 1] + 1 != glyphs[i]) num_ranges++; - rangeRecord.len.set (num_ranges); + rangeRecord.len = num_ranges; if (unlikely (!c->extend (rangeRecord))) return_trace (false); unsigned int range = 0; rangeRecord[range].start = glyphs[0]; - rangeRecord[range].value.set (0); + rangeRecord[range].value = 0; for (unsigned int i = 1; i < count; i++) { if (glyphs[i - 1] + 1 != glyphs[i]) { range++; rangeRecord[range].start = glyphs[i]; - rangeRecord[range].value.set (i); + rangeRecord[range].value = i; } rangeRecord[range].end = glyphs[i]; } @@ -1066,7 +1066,7 @@ struct Coverage for (unsigned int i = 1; i < count; i++) if (glyphs[i - 1] + 1 != glyphs[i]) num_ranges++; - u.format.set (count * 2 < num_ranges * 3 ? 1 : 2); + u.format = count * 2 < num_ranges * 3 ? 1 : 2; switch (u.format) { @@ -1212,16 +1212,16 @@ struct ClassDefFormat1 if (unlikely (!glyphs)) { - startGlyph.set (0); - classValue.len.set (0); + startGlyph = 0; + classValue.len = 0; return_trace (true); } hb_codepoint_t glyph_min = glyphs[0]; hb_codepoint_t glyph_max = glyphs[glyphs.length - 1]; - startGlyph.set (glyph_min); - classValue.len.set (glyph_max - glyph_min + 1); + startGlyph = glyph_min; + classValue.len = glyph_max - glyph_min + 1; if (unlikely (!c->extend (classValue))) return_trace (false); for (unsigned int i = 0; i < glyphs.length; i++) @@ -1245,8 +1245,8 @@ struct ClassDefFormat1 if (!glyphset.has (g)) continue; unsigned int value = classValue[g - start]; if (!value) continue; - glyphs.push()->set (glyph_map[g]); - klasses.push()->set (value); + glyphs.push(glyph_map[g]); + klasses.push(value); } c->serializer->propagate_error (glyphs, klasses); ClassDef_serialize (c->serializer, glyphs, klasses); @@ -1348,7 +1348,7 @@ struct ClassDefFormat2 if (unlikely (!glyphs)) { - rangeRecord.len.set (0); + rangeRecord.len = 0; return_trace (true); } @@ -1357,12 +1357,12 @@ struct ClassDefFormat2 if (glyphs[i - 1] + 1 != glyphs[i] || klasses[i - 1] != klasses[i]) num_ranges++; - rangeRecord.len.set (num_ranges); + rangeRecord.len = num_ranges; if (unlikely (!c->extend (rangeRecord))) return_trace (false); unsigned int range = 0; rangeRecord[range].start = glyphs[0]; - rangeRecord[range].value.set (klasses[0]); + rangeRecord[range].value = klasses[0]; for (unsigned int i = 1; i < glyphs.length; i++) { if (glyphs[i - 1] + 1 != glyphs[i] || @@ -1395,8 +1395,8 @@ struct ClassDefFormat2 for (hb_codepoint_t g = start; g < end; g++) { if (!glyphset.has (g)) continue; - glyphs.push ()->set (glyph_map[g]); - klasses.push ()->set (value); + glyphs.push (glyph_map[g]); + klasses.push (value); } } c->serializer->propagate_error (glyphs, klasses); @@ -1519,7 +1519,7 @@ struct ClassDef if (1 + (glyph_max - glyph_min + 1) < num_ranges * 3) format = 1; } - u.format.set (format); + u.format = format; switch (u.format) { diff --git a/src/hb-ot-layout-gdef-table.hh b/src/hb-ot-layout-gdef-table.hh index 06c26fbb4..dc8b9b847 100644 --- a/src/hb-ot-layout-gdef-table.hh +++ b/src/hb-ot-layout-gdef-table.hh @@ -443,15 +443,15 @@ struct GDEF if (unlikely (!out)) return_trace (false); out->glyphClassDef.serialize_subset (c, this+glyphClassDef, out); - out->attachList.set (0);//TODO(subset) serialize_subset (c, this+attachList, out); - out->ligCaretList.set (0);//TODO(subset) serialize_subset (c, this+ligCaretList, out); + out->attachList = 0;//TODO(subset) serialize_subset (c, this+attachList, out); + out->ligCaretList = 0;//TODO(subset) serialize_subset (c, this+ligCaretList, out); out->markAttachClassDef.serialize_subset (c, this+markAttachClassDef, out); if (version.to_int () >= 0x00010002u) - out->markGlyphSetsDef.set (0);// TODO(subset) serialize_subset (c, this+markGlyphSetsDef, out); + out->markGlyphSetsDef = 0;// TODO(subset) serialize_subset (c, this+markGlyphSetsDef, out); if (version.to_int () >= 0x00010003u) - out->varStore.set (0);// TODO(subset) serialize_subset (c, this+varStore, out); + out->varStore = 0;// TODO(subset) serialize_subset (c, this+varStore, out); return_trace (true); } diff --git a/src/hb-ot-layout-gsub-table.hh b/src/hb-ot-layout-gsub-table.hh index 9b672bafe..3ed9ee2b8 100644 --- a/src/hb-ot-layout-gsub-table.hh +++ b/src/hb-ot-layout-gsub-table.hh @@ -88,7 +88,7 @@ struct SingleSubstFormat1 TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (*this))) return_trace (false); if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs))) return_trace (false); - deltaGlyphID.set (delta); /* TODO(serialize) overflow? */ + deltaGlyphID = delta; /* TODO(serialize) overflow? */ return_trace (true); } @@ -103,8 +103,8 @@ struct SingleSubstFormat1 for (auto it = hb_iter (this+coverage) | hb_filter (glyphset); it; ++it) { - from.push ()->set (glyph_map[*it]); - to.push ()->set (glyph_map[(*it + delta) & 0xFFFF]); + from.push (glyph_map[*it]); + to.push (glyph_map[(*it + delta) & 0xFFFF]); } c->serializer->propagate_error (from, to); SingleSubst_serialize (c->serializer, from, to); @@ -193,8 +193,8 @@ struct SingleSubstFormat2 for (auto it = hb_zip (this+coverage, substitute) | hb_filter (glyphset, hb_first); it; ++it) { - from.push ()->set (glyph_map[(*it).first]); - to.push ()->set (glyph_map[(*it).second]); + from.push (glyph_map[(*it).first]); + to.push (glyph_map[(*it).second]); } c->serializer->propagate_error (from, to); SingleSubst_serialize (c->serializer, from, to); @@ -240,7 +240,7 @@ struct SingleSubst break; } } - u.format.set (format); + u.format = format; switch (u.format) { case 1: return_trace (u.format1.serialize (c, glyphs, delta)); case 2: return_trace (u.format2.serialize (c, glyphs, substitutes)); @@ -433,7 +433,7 @@ struct MultipleSubst TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (u.format))) return_trace (false); unsigned int format = 1; - u.format.set (format); + u.format = format; switch (u.format) { case 1: return_trace (u.format1.serialize (c, glyphs, substitute_len_list, substitute_glyphs_list)); default:return_trace (false); @@ -610,7 +610,7 @@ struct AlternateSubst TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (u.format))) return_trace (false); unsigned int format = 1; - u.format.set (format); + u.format = format; switch (u.format) { case 1: return_trace (u.format1.serialize (c, glyphs, alternate_len_list, alternate_glyphs_list)); default:return_trace (false); @@ -942,7 +942,7 @@ struct LigatureSubst TRACE_SERIALIZE (this); if (unlikely (!c->extend_min (u.format))) return_trace (false); unsigned int format = 1; - u.format.set (format); + u.format = format; switch (u.format) { case 1: return_trace (u.format1.serialize (c, first_glyphs, diff --git a/src/hb-ot-maxp-table.hh b/src/hb-ot-maxp-table.hh index 10bd592e8..a2d9167c5 100644 --- a/src/hb-ot-maxp-table.hh +++ b/src/hb-ot-maxp-table.hh @@ -77,7 +77,7 @@ struct maxp void set_num_glyphs (unsigned int count) { - numGlyphs.set (count); + numGlyphs = count; } bool sanitize (hb_sanitize_context_t *c) const @@ -119,13 +119,13 @@ struct maxp if (maxp_prime->version.major == 1) { maxpV1Tail &v1 = StructAfter (*maxp_prime); - v1.maxZones.set (1); - v1.maxTwilightPoints.set (0); - v1.maxStorage.set (0); - v1.maxFunctionDefs.set (0); - v1.maxInstructionDefs.set (0); - v1.maxStackElements.set (0); - v1.maxSizeOfInstructions.set (0); + v1.maxZones = 1; + v1.maxTwilightPoints = 0; + v1.maxStorage = 0; + v1.maxFunctionDefs = 0; + v1.maxInstructionDefs = 0; + v1.maxStackElements = 0; + v1.maxSizeOfInstructions = 0; } } diff --git a/src/hb-ot-os2-table.hh b/src/hb-ot-os2-table.hh index 68dd63e01..3b6a3727a 100644 --- a/src/hb-ot-os2-table.hh +++ b/src/hb-ot-os2-table.hh @@ -160,8 +160,8 @@ struct OS2 uint16_t min_cp, max_cp; find_min_and_max_codepoint (plan->unicodes, &min_cp, &max_cp); - os2_prime->usFirstCharIndex.set (min_cp); - os2_prime->usLastCharIndex.set (max_cp); + os2_prime->usFirstCharIndex = min_cp; + os2_prime->usLastCharIndex = max_cp; _update_unicode_ranges (plan->unicodes, os2_prime->ulUnicodeRange); bool result = plan->add_table (HB_OT_TAG_OS2, os2_prime_blob); @@ -174,7 +174,7 @@ struct OS2 HBUINT32 ulUnicodeRange[4]) const { for (unsigned int i = 0; i < 4; i++) - ulUnicodeRange[i].set (0); + ulUnicodeRange[i] = 0; hb_codepoint_t cp = HB_SET_VALUE_INVALID; while (codepoints->next (&cp)) { @@ -184,14 +184,14 @@ struct OS2 unsigned int block = bit / 32; unsigned int bit_in_block = bit % 32; unsigned int mask = 1 << bit_in_block; - ulUnicodeRange[block].set (ulUnicodeRange[block] | mask); + ulUnicodeRange[block] = ulUnicodeRange[block] | mask; } if (cp >= 0x10000 && cp <= 0x110000) { /* the spec says that bit 57 ("Non Plane 0") implies that there's at least one codepoint beyond the BMP; so I also include all the non-BMP codepoints here */ - ulUnicodeRange[1].set (ulUnicodeRange[1] | (1 << 25)); + ulUnicodeRange[1] = ulUnicodeRange[1] | (1 << 25); } } } diff --git a/src/hb-ot-post-table.hh b/src/hb-ot-post-table.hh index 43c1143cf..21aa94dad 100644 --- a/src/hb-ot-post-table.hh +++ b/src/hb-ot-post-table.hh @@ -88,7 +88,7 @@ struct post return false; } - post_prime->version.major.set (3); // Version 3 does not have any glyph names. + post_prime->version.major = 3; // Version 3 does not have any glyph names. bool result = plan->add_table (HB_OT_TAG_post, post_prime_blob); hb_blob_destroy (post_prime_blob); diff --git a/src/hb-ot-shape-complex-arabic-fallback.hh b/src/hb-ot-shape-complex-arabic-fallback.hh index 471a2014e..dad5100ca 100644 --- a/src/hb-ot-shape-complex-arabic-fallback.hh +++ b/src/hb-ot-shape-complex-arabic-fallback.hh @@ -66,8 +66,8 @@ arabic_fallback_synthesize_lookup_single (const hb_ot_shape_plan_t *plan HB_UNUS u_glyph > 0xFFFFu || s_glyph > 0xFFFFu) continue; - glyphs[num_glyphs].set (u_glyph); - substitutes[num_glyphs].set (s_glyph); + glyphs[num_glyphs] = u_glyph; + substitutes[num_glyphs] = s_glyph; num_glyphs++; } @@ -120,7 +120,7 @@ arabic_fallback_synthesize_lookup_ligature (const hb_ot_shape_plan_t *plan HB_UN hb_codepoint_t first_glyph; if (!hb_font_get_glyph (font, first_u, 0, &first_glyph)) continue; - first_glyphs[num_first_glyphs].set (first_glyph); + first_glyphs[num_first_glyphs] = first_glyph; ligature_per_first_glyph_count_list[num_first_glyphs] = 0; first_glyphs_indirection[num_first_glyphs] = first_glyph_idx; num_first_glyphs++; @@ -146,9 +146,9 @@ arabic_fallback_synthesize_lookup_ligature (const hb_ot_shape_plan_t *plan HB_UN ligature_per_first_glyph_count_list[i]++; - ligature_list[num_ligatures].set (ligature_glyph); + ligature_list[num_ligatures] = ligature_glyph; component_count_list[num_ligatures] = 2; - component_list[num_ligatures].set (second_glyph); + component_list[num_ligatures] = second_glyph; num_ligatures++; } } diff --git a/src/hb-ot-vorg-table.hh b/src/hb-ot-vorg-table.hh index 39073db8f..b2059e86e 100644 --- a/src/hb-ot-vorg-table.hh +++ b/src/hb-ot-vorg-table.hh @@ -81,11 +81,11 @@ struct VORG if (unlikely (!c.extend_min (*subset_table))) return false; - subset_table->version.major.set (1); - subset_table->version.minor.set (0); + subset_table->version.major = 1; + subset_table->version.minor = 0; - subset_table->defaultVertOriginY.set (vorg_table->defaultVertOriginY); - subset_table->vertYOrigins.len.set (subset_metrics.length); + subset_table->defaultVertOriginY = vorg_table->defaultVertOriginY; + subset_table->vertYOrigins.len = subset_metrics.length; bool success = true; if (subset_metrics.length > 0) @@ -130,8 +130,8 @@ struct VORG if (plan->new_gid_for_old_gid (old_glyph, &new_glyph)) { VertOriginMetric *metrics = subset_metrics.push (); - metrics->glyph.set (new_glyph); - metrics->vertOriginY.set (vertYOrigins[i].vertOriginY); + metrics->glyph = new_glyph; + metrics->vertOriginY = vertYOrigins[i].vertOriginY; } } } diff --git a/src/hb-subset-cff-common.cc b/src/hb-subset-cff-common.cc index f29937a22..aa5d27b36 100644 --- a/src/hb-subset-cff-common.cc +++ b/src/hb-subset-cff-common.cc @@ -160,13 +160,13 @@ serialize_fdselect_3_4 (hb_serialize_context_t *c, TRACE_SERIALIZE (this); FDSELECT3_4 *p = c->allocate_size (size); if (unlikely (p == nullptr)) return_trace (false); - p->nRanges ().set (fdselect_ranges.length); + p->nRanges () = fdselect_ranges.length; for (unsigned int i = 0; i < fdselect_ranges.length; i++) { - p->ranges[i].first.set (fdselect_ranges[i].glyph); - p->ranges[i].fd.set (fdselect_ranges[i].code); + p->ranges[i].first = fdselect_ranges[i].glyph; + p->ranges[i].fd = fdselect_ranges[i].code; } - p->sentinel().set (num_glyphs); + p->sentinel() = num_glyphs; return_trace (true); } @@ -186,7 +186,7 @@ hb_serialize_cff_fdselect (hb_serialize_context_t *c, TRACE_SERIALIZE (this); FDSelect *p = c->allocate_min (); if (unlikely (p == nullptr)) return_trace (false); - p->format.set (fdselect_format); + p->format = fdselect_format; size -= FDSelect::min_size; switch (fdselect_format) @@ -205,7 +205,7 @@ hb_serialize_cff_fdselect (hb_serialize_context_t *c, { fd = fdselect_ranges[range_index++].code; } - p->fds[i].set (fd); + p->fds[i] = fd; } break; } diff --git a/src/hb-subset-cff-common.hh b/src/hb-subset-cff-common.hh index 81368ee4c..921b0253d 100644 --- a/src/hb-subset-cff-common.hh +++ b/src/hb-subset-cff-common.hh @@ -209,7 +209,7 @@ struct cff_font_dict_op_serializer_t : op_serializer_t /* serialize the opcode */ HBUINT8 *p = c->allocate_size (1); if (unlikely (p == nullptr)) return_trace (false); - p->set (OpCode_Private); + *p = OpCode_Private; return_trace (true); } diff --git a/src/hb-subset-cff1.cc b/src/hb-subset-cff1.cc index 49ac0bf42..601cbe9a1 100644 --- a/src/hb-subset-cff1.cc +++ b/src/hb-subset-cff1.cc @@ -147,7 +147,7 @@ struct cff1_top_dict_op_serializer_t : cff_top_dict_op_serializer_tallocate_size (1); if (unlikely (p == nullptr)) return_trace (false); - p->set (OpCode_Private); + *p = OpCode_Private; } break; @@ -892,10 +892,10 @@ static inline bool _write_cff1 (const cff_subset_plan &plan, return false; /* header */ - cff->version.major.set (0x01); - cff->version.minor.set (0x00); - cff->nameIndex.set (cff->min_size); - cff->offSize.set (4); /* unused? */ + cff->version.major = 0x01; + cff->version.minor = 0x00; + cff->nameIndex = cff->min_size; + cff->offSize = 4; /* unused? */ /* name INDEX */ { diff --git a/src/hb-subset-cff2.cc b/src/hb-subset-cff2.cc index bf76a3ede..f033fbde1 100644 --- a/src/hb-subset-cff2.cc +++ b/src/hb-subset-cff2.cc @@ -451,14 +451,14 @@ static inline bool _write_cff2 (const cff2_subset_plan &plan, return false; /* header */ - cff2->version.major.set (0x02); - cff2->version.minor.set (0x00); - cff2->topDict.set (OT::cff2::static_size); + cff2->version.major = 0x02; + cff2->version.minor = 0x00; + cff2->topDict = OT::cff2::static_size; /* top dict */ { assert (cff2->topDict == (unsigned) (c.head - c.start)); - cff2->topDictSize.set (plan.offsets.topDictInfo.size); + cff2->topDictSize = plan.offsets.topDictInfo.size; TopDict &dict = cff2 + cff2->topDict; cff2_top_dict_op_serializer_t topSzr; if (unlikely (!dict.serialize (&c, acc.topDict, topSzr, plan.offsets))) diff --git a/src/hb-subset-glyf.cc b/src/hb-subset-glyf.cc index ee004eeb3..9095e9f76 100644 --- a/src/hb-subset-glyf.cc +++ b/src/hb-subset-glyf.cc @@ -43,9 +43,9 @@ struct loca_data_t if ((id + 1) * entry_size <= size) { if (is_short) { - ((OT::HBUINT16*) data) [id].set (offset / 2); + ((OT::HBUINT16*) data) [id] = offset / 2; } else { - ((OT::HBUINT32*) data) [id].set (offset); + ((OT::HBUINT32*) data) [id] = offset; } return true; } @@ -164,7 +164,7 @@ _update_components (const hb_subset_plan_t *plan, &new_gid)) continue; - ((OT::glyf::CompositeGlyphHeader *) iterator.current)->glyphIndex.set (new_gid); + ((OT::glyf::CompositeGlyphHeader *) iterator.current)->glyphIndex = new_gid; } while (iterator.move_to_next ()); } } @@ -178,7 +178,7 @@ static bool _remove_composite_instruction_flag (char *glyf_prime, unsigned int l do { glyph = composite_it.current; OT::HBUINT16 *flags = const_cast (&glyph->flags); - flags->set ( (uint16_t) *flags & ~OT::glyf::CompositeGlyphHeader::WE_HAVE_INSTRUCTIONS); + *flags = (uint16_t) *flags & ~OT::glyf::CompositeGlyphHeader::WE_HAVE_INSTRUCTIONS; } while (composite_it.move_to_next ()); return true; } diff --git a/src/hb-uniscribe.cc b/src/hb-uniscribe.cc index 31c50dfeb..f9d9f3d0f 100644 --- a/src/hb-uniscribe.cc +++ b/src/hb-uniscribe.cc @@ -396,18 +396,18 @@ _hb_rename_font (hb_blob_t *blob, wchar_t *new_name) memcpy(new_sfnt_data, orig_sfnt_data, length); OT::name &name = StructAtOffset (new_sfnt_data, name_table_offset); - name.format.set (0); - name.count.set (ARRAY_LENGTH (name_IDs)); - name.stringOffset.set (name.get_size ()); + name.format = 0; + name.count = ARRAY_LENGTH (name_IDs); + name.stringOffset = name.get_size (); for (unsigned int i = 0; i < ARRAY_LENGTH (name_IDs); i++) { OT::NameRecord &record = name.nameRecordZ[i]; - record.platformID.set (3); - record.encodingID.set (1); - record.languageID.set (0x0409u); /* English */ - record.nameID.set (name_IDs[i]); - record.length.set (name_str_len * 2); - record.offset.set (0); + record.platformID = 3; + record.encodingID = 1; + record.languageID = 0x0409u; /* English */ + record.nameID = name_IDs[i]; + record.length = name_str_len * 2; + record.offset = 0; } /* Copy string data from new_name, converting wchar_t to UTF16BE. */ @@ -431,8 +431,8 @@ _hb_rename_font (hb_blob_t *blob, wchar_t *new_name) { OT::TableRecord &record = const_cast (face.get_table (index)); record.checkSum.set_for_data (&name, padded_name_table_length); - record.offset.set (name_table_offset); - record.length.set (name_table_length); + record.offset = name_table_offset; + record.length = name_table_length; } else if (face_index == 0) /* Fail if first face doesn't have 'name' table. */ {