From 4ada364e183e05479bc45d2ce41700ae18b7f6a3 Mon Sep 17 00:00:00 2001 From: Tom Sepez Date: Mon, 30 Jan 2017 09:56:43 -0800 Subject: Cleanup memory allocations in ttgsubtable.cpp Rename array members to plurals. Use std::vectors rather than native arrays and counts. Use std::set instead of map of key to itself. Use unique_ptr inside vector to clean subtables. Mark non-existent constructors() = delete. Change-Id: Ifde189157e8affb5de654a44fac8b9358de7079b Reviewed-on: https://pdfium-review.googlesource.com/2452 Commit-Queue: Tom Sepez Reviewed-by: dsinclair --- core/fpdfapi/font/ttgsubtable.cpp | 278 ++++++++++++++------------------------ core/fpdfapi/font/ttgsubtable.h | 126 +++++++++-------- 2 files changed, 169 insertions(+), 235 deletions(-) (limited to 'core/fpdfapi') diff --git a/core/fpdfapi/font/ttgsubtable.cpp b/core/fpdfapi/font/ttgsubtable.cpp index c037746c1e..51e8e9cc20 100644 --- a/core/fpdfapi/font/ttgsubtable.cpp +++ b/core/fpdfapi/font/ttgsubtable.cpp @@ -7,6 +7,7 @@ #include "core/fpdfapi/font/ttgsubtable.h" #include "core/fxge/fx_freetype.h" +#include "third_party/base/ptr_util.h" #include "third_party/base/stl_util.h" CFX_GlyphMap::CFX_GlyphMap() {} @@ -93,33 +94,29 @@ bool CFX_CTTGSUBTable::GetVerticalGlyph(uint32_t glyphnum, (uint8_t)'t', }; if (!m_bFeautureMapLoad) { - for (int i = 0; i < ScriptList.ScriptCount; i++) { - for (int j = 0; j < ScriptList.ScriptRecord[i].Script.LangSysCount; ++j) { - const auto& record = ScriptList.ScriptRecord[i].Script.LangSysRecord[j]; - for (int k = 0; k < record.LangSys.FeatureCount; ++k) { - uint32_t index = record.LangSys.FeatureIndex[k]; - if (FeatureList.FeatureRecord[index].FeatureTag == tag[0] || - FeatureList.FeatureRecord[index].FeatureTag == tag[1]) { - if (!pdfium::ContainsKey(m_featureMap, index)) { - m_featureMap[index] = index; - } + for (const auto& script : ScriptList.ScriptRecords) { + for (const auto& record : script.Script.LangSysRecords) { + for (const auto& index : record.LangSys.FeatureIndices) { + if (FeatureList.FeatureRecords[index].FeatureTag == tag[0] || + FeatureList.FeatureRecords[index].FeatureTag == tag[1]) { + m_featureSet.insert(index); } } } } - if (m_featureMap.empty()) { - for (int i = 0; i < FeatureList.FeatureCount; i++) { - if (FeatureList.FeatureRecord[i].FeatureTag == tag[0] || - FeatureList.FeatureRecord[i].FeatureTag == tag[1]) { - m_featureMap[i] = i; - } + if (m_featureSet.empty()) { + int i = 0; + for (const auto& feature : FeatureList.FeatureRecords) { + if (feature.FeatureTag == tag[0] || feature.FeatureTag == tag[1]) + m_featureSet.insert(i); + ++i; } } m_bFeautureMapLoad = true; } - for (const auto& pair : m_featureMap) { + for (const auto& item : m_featureSet) { if (GetVerticalGlyphSub(glyphnum, vglyphnum, - &FeatureList.FeatureRecord[pair.second].Feature)) { + &FeatureList.FeatureRecords[item].Feature)) { return true; } } @@ -128,17 +125,14 @@ bool CFX_CTTGSUBTable::GetVerticalGlyph(uint32_t glyphnum, bool CFX_CTTGSUBTable::GetVerticalGlyphSub(uint32_t glyphnum, uint32_t* vglyphnum, - TFeature* Feature) const { - for (int i = 0; i < Feature->LookupCount; i++) { - int index = Feature->LookupListIndex[i]; - if (index < 0 || LookupList.LookupCount < index) { + TFeature* Feature) { + for (int index : Feature->LookupListIndices) { + if (index < 0 || index >= pdfium::CollectionSize(LookupList.Lookups)) continue; - } - if (LookupList.Lookup[index].LookupType == 1) { - if (GetVerticalGlyphSub2(glyphnum, vglyphnum, - &LookupList.Lookup[index])) { - return true; - } + + if (LookupList.Lookups[index].LookupType == 1 && + GetVerticalGlyphSub2(glyphnum, vglyphnum, &LookupList.Lookups[index])) { + return true; } } return false; @@ -146,11 +140,11 @@ bool CFX_CTTGSUBTable::GetVerticalGlyphSub(uint32_t glyphnum, bool CFX_CTTGSUBTable::GetVerticalGlyphSub2(uint32_t glyphnum, uint32_t* vglyphnum, - TLookup* Lookup) const { - for (int i = 0; i < Lookup->SubTableCount; i++) { - switch (Lookup->SubTable[i]->SubstFormat) { + TLookup* Lookup) { + for (const auto& subTable : Lookup->SubTables) { + switch (subTable->SubstFormat) { case 1: { - TSingleSubstFormat1* tbl1 = (TSingleSubstFormat1*)Lookup->SubTable[i]; + auto tbl1 = static_cast(subTable.get()); if (GetCoverageIndex(tbl1->Coverage.get(), glyphnum) >= 0) { *vglyphnum = glyphnum + tbl1->DeltaGlyphID; return true; @@ -158,11 +152,11 @@ bool CFX_CTTGSUBTable::GetVerticalGlyphSub2(uint32_t glyphnum, break; } case 2: { - TSingleSubstFormat2* tbl2 = (TSingleSubstFormat2*)Lookup->SubTable[i]; - int index = -1; - index = GetCoverageIndex(tbl2->Coverage.get(), glyphnum); - if (0 <= index && index < tbl2->GlyphCount) { - *vglyphnum = tbl2->Substitute[index]; + auto tbl2 = static_cast(subTable.get()); + int index = GetCoverageIndex(tbl2->Coverage.get(), glyphnum); + if (index >= 0 && + index < pdfium::CollectionSize(tbl2->Substitutes)) { + *vglyphnum = tbl2->Substitutes[index]; return true; } break; @@ -174,29 +168,28 @@ bool CFX_CTTGSUBTable::GetVerticalGlyphSub2(uint32_t glyphnum, int CFX_CTTGSUBTable::GetCoverageIndex(TCoverageFormatBase* Coverage, uint32_t g) const { - int i = 0; - if (!Coverage) { + if (!Coverage) return -1; - } + switch (Coverage->CoverageFormat) { case 1: { + int i = 0; TCoverageFormat1* c1 = (TCoverageFormat1*)Coverage; - for (i = 0; i < c1->GlyphCount; i++) { - if ((uint32_t)c1->GlyphArray[i] == g) { + for (const auto& glyph : c1->GlyphArray) { + if (static_cast(glyph) == g) return i; - } + ++i; } return -1; } case 2: { TCoverageFormat2* c2 = (TCoverageFormat2*)Coverage; - for (i = 0; i < c2->RangeCount; i++) { - uint32_t s = c2->RangeRecord[i].Start; - uint32_t e = c2->RangeRecord[i].End; - uint32_t si = c2->RangeRecord[i].StartCoverageIndex; - if (s <= g && g <= e) { + for (const auto& rangeRec : c2->RangeRecords) { + uint32_t s = rangeRec.Start; + uint32_t e = rangeRec.End; + uint32_t si = rangeRec.StartCoverageIndex; + if (s <= g && g <= e) return si + g - s; - } } return -1; } @@ -244,33 +237,21 @@ bool CFX_CTTGSUBTable::Parse(FT_Bytes scriptlist, } void CFX_CTTGSUBTable::ParseScriptList(FT_Bytes raw, TScriptList* rec) { - int i; FT_Bytes sp = raw; - rec->ScriptCount = GetUInt16(sp); - if (rec->ScriptCount <= 0) { - return; - } - rec->ScriptRecord.reset(new TScriptRecord[rec->ScriptCount]); - for (i = 0; i < rec->ScriptCount; i++) { - rec->ScriptRecord[i].ScriptTag = GetUInt32(sp); - uint16_t offset = GetUInt16(sp); - ParseScript(&raw[offset], &rec->ScriptRecord[i].Script); + rec->ScriptRecords = std::vector(GetUInt16(sp)); + for (auto& scriptRec : rec->ScriptRecords) { + scriptRec.ScriptTag = GetUInt32(sp); + ParseScript(&raw[GetUInt16(sp)], &scriptRec.Script); } } void CFX_CTTGSUBTable::ParseScript(FT_Bytes raw, TScript* rec) { - int i; FT_Bytes sp = raw; rec->DefaultLangSys = GetUInt16(sp); - rec->LangSysCount = GetUInt16(sp); - if (rec->LangSysCount <= 0) { - return; - } - rec->LangSysRecord.reset(new TLangSysRecord[rec->LangSysCount]); - for (i = 0; i < rec->LangSysCount; i++) { - rec->LangSysRecord[i].LangSysTag = GetUInt32(sp); - uint16_t offset = GetUInt16(sp); - ParseLangSys(&raw[offset], &rec->LangSysRecord[i].LangSys); + rec->LangSysRecords = std::vector(GetUInt16(sp)); + for (auto& sysRecord : rec->LangSysRecords) { + sysRecord.LangSysTag = GetUInt32(sp); + ParseLangSys(&raw[GetUInt16(sp)], &sysRecord.LangSys); } } @@ -278,81 +259,45 @@ void CFX_CTTGSUBTable::ParseLangSys(FT_Bytes raw, TLangSys* rec) { FT_Bytes sp = raw; rec->LookupOrder = GetUInt16(sp); rec->ReqFeatureIndex = GetUInt16(sp); - rec->FeatureCount = GetUInt16(sp); - if (rec->FeatureCount <= 0) { - return; - } - rec->FeatureIndex.reset(new uint16_t[rec->FeatureCount]); - FXSYS_memset(rec->FeatureIndex.get(), 0, - sizeof(uint16_t) * rec->FeatureCount); - for (int i = 0; i < rec->FeatureCount; ++i) { - rec->FeatureIndex[i] = GetUInt16(sp); - } + rec->FeatureIndices = std::vector(GetUInt16(sp)); + for (auto& element : rec->FeatureIndices) + element = GetUInt16(sp); } void CFX_CTTGSUBTable::ParseFeatureList(FT_Bytes raw, TFeatureList* rec) { - int i; FT_Bytes sp = raw; - rec->FeatureCount = GetUInt16(sp); - if (rec->FeatureCount <= 0) { - return; - } - rec->FeatureRecord.reset(new TFeatureRecord[rec->FeatureCount]); - for (i = 0; i < rec->FeatureCount; i++) { - rec->FeatureRecord[i].FeatureTag = GetUInt32(sp); - uint16_t offset = GetUInt16(sp); - ParseFeature(&raw[offset], &rec->FeatureRecord[i].Feature); + rec->FeatureRecords = std::vector(GetUInt16(sp)); + for (auto& featureRec : rec->FeatureRecords) { + featureRec.FeatureTag = GetUInt32(sp); + ParseFeature(&raw[GetUInt16(sp)], &featureRec.Feature); } } void CFX_CTTGSUBTable::ParseFeature(FT_Bytes raw, TFeature* rec) { - int i; FT_Bytes sp = raw; rec->FeatureParams = GetUInt16(sp); - rec->LookupCount = GetUInt16(sp); - if (rec->LookupCount <= 0) { - return; - } - rec->LookupListIndex.reset(new uint16_t[rec->LookupCount]); - for (i = 0; i < rec->LookupCount; i++) { - rec->LookupListIndex[i] = GetUInt16(sp); - } + rec->LookupListIndices = std::vector(GetUInt16(sp)); + for (auto& listIndex : rec->LookupListIndices) + listIndex = GetUInt16(sp); } void CFX_CTTGSUBTable::ParseLookupList(FT_Bytes raw, TLookupList* rec) { - int i; FT_Bytes sp = raw; - rec->LookupCount = GetUInt16(sp); - if (rec->LookupCount <= 0) { - return; - } - rec->Lookup.reset(new TLookup[rec->LookupCount]); - for (i = 0; i < rec->LookupCount; i++) { - uint16_t offset = GetUInt16(sp); - ParseLookup(&raw[offset], &rec->Lookup[i]); - } + rec->Lookups = std::vector(GetUInt16(sp)); + for (auto& lookup : rec->Lookups) + ParseLookup(&raw[GetUInt16(sp)], &lookup); } void CFX_CTTGSUBTable::ParseLookup(FT_Bytes raw, TLookup* rec) { - int i; FT_Bytes sp = raw; rec->LookupType = GetUInt16(sp); rec->LookupFlag = GetUInt16(sp); - rec->SubTableCount = GetUInt16(sp); - if (rec->SubTableCount <= 0) { - return; - } - rec->SubTable.reset(new TSubTableBase*[rec->SubTableCount]); - for (i = 0; i < rec->SubTableCount; i++) { - rec->SubTable[i] = nullptr; - } - if (rec->LookupType != 1) { + rec->SubTables = std::vector>(GetUInt16(sp)); + if (rec->LookupType != 1) return; - } - for (i = 0; i < rec->SubTableCount; i++) { - uint16_t offset = GetUInt16(sp); - ParseSingleSubst(&raw[offset], &rec->SubTable[i]); - } + + for (auto& subTable : rec->SubTables) + ParseSingleSubst(&raw[GetUInt16(sp)], &subTable); } CFX_CTTGSUBTable::TCoverageFormatBase* CFX_CTTGSUBTable::ParseCoverage( @@ -372,47 +317,39 @@ CFX_CTTGSUBTable::TCoverageFormatBase* CFX_CTTGSUBTable::ParseCoverage( void CFX_CTTGSUBTable::ParseCoverageFormat1(FT_Bytes raw, TCoverageFormat1* rec) { - int i; FT_Bytes sp = raw; - GetUInt16(sp); - rec->GlyphCount = GetUInt16(sp); - if (rec->GlyphCount <= 0) { - return; - } - rec->GlyphArray.reset(new uint16_t[rec->GlyphCount]); - for (i = 0; i < rec->GlyphCount; i++) { - rec->GlyphArray[i] = GetUInt16(sp); - } + (void)GetUInt16(sp); + rec->GlyphArray = std::vector(GetUInt16(sp)); + for (auto& glyph : rec->GlyphArray) + glyph = GetUInt16(sp); } void CFX_CTTGSUBTable::ParseCoverageFormat2(FT_Bytes raw, TCoverageFormat2* rec) { - int i; FT_Bytes sp = raw; - GetUInt16(sp); - rec->RangeCount = GetUInt16(sp); - if (rec->RangeCount <= 0) { - return; - } - rec->RangeRecord.reset(new TRangeRecord[rec->RangeCount]); - for (i = 0; i < rec->RangeCount; i++) { - rec->RangeRecord[i].Start = GetUInt16(sp); - rec->RangeRecord[i].End = GetUInt16(sp); - rec->RangeRecord[i].StartCoverageIndex = GetUInt16(sp); + (void)GetUInt16(sp); + rec->RangeRecords = std::vector(GetUInt16(sp)); + for (auto& rangeRec : rec->RangeRecords) { + rangeRec.Start = GetUInt16(sp); + rangeRec.End = GetUInt16(sp); + rangeRec.StartCoverageIndex = GetUInt16(sp); } } -void CFX_CTTGSUBTable::ParseSingleSubst(FT_Bytes raw, TSubTableBase** rec) { +void CFX_CTTGSUBTable::ParseSingleSubst(FT_Bytes raw, + std::unique_ptr* rec) { FT_Bytes sp = raw; uint16_t Format = GetUInt16(sp); switch (Format) { case 1: - *rec = new TSingleSubstFormat1(); - ParseSingleSubstFormat1(raw, (TSingleSubstFormat1*)*rec); + *rec = pdfium::MakeUnique(); + ParseSingleSubstFormat1(raw, + static_cast(rec->get())); break; case 2: - *rec = new TSingleSubstFormat2(); - ParseSingleSubstFormat2(raw, (TSingleSubstFormat2*)*rec); + *rec = pdfium::MakeUnique(); + ParseSingleSubstFormat2(raw, + static_cast(rec->get())); break; } } @@ -428,23 +365,17 @@ void CFX_CTTGSUBTable::ParseSingleSubstFormat1(FT_Bytes raw, void CFX_CTTGSUBTable::ParseSingleSubstFormat2(FT_Bytes raw, TSingleSubstFormat2* rec) { - int i; FT_Bytes sp = raw; - GetUInt16(sp); + (void)GetUInt16(sp); uint16_t offset = GetUInt16(sp); rec->Coverage.reset(ParseCoverage(&raw[offset])); - rec->GlyphCount = GetUInt16(sp); - if (rec->GlyphCount <= 0) { - return; - } - rec->Substitute.reset(new uint16_t[rec->GlyphCount]); - for (i = 0; i < rec->GlyphCount; i++) { - rec->Substitute[i] = GetUInt16(sp); - } + rec->Substitutes = std::vector(GetUInt16(sp)); + for (auto& substitute : rec->Substitutes) + substitute = GetUInt16(sp); } CFX_CTTGSUBTable::TCoverageFormat1::TCoverageFormat1() - : TCoverageFormatBase(1), GlyphCount(0) {} + : TCoverageFormatBase(1) {} CFX_CTTGSUBTable::TCoverageFormat1::~TCoverageFormat1() {} @@ -452,7 +383,7 @@ CFX_CTTGSUBTable::TRangeRecord::TRangeRecord() : Start(0), End(0), StartCoverageIndex(0) {} CFX_CTTGSUBTable::TCoverageFormat2::TCoverageFormat2() - : TCoverageFormatBase(2), RangeCount(0) {} + : TCoverageFormatBase(2) {} CFX_CTTGSUBTable::TCoverageFormat2::~TCoverageFormat2() {} @@ -462,41 +393,34 @@ CFX_CTTGSUBTable::TSingleSubstFormat1::TSingleSubstFormat1() CFX_CTTGSUBTable::TSingleSubstFormat1::~TSingleSubstFormat1() {} CFX_CTTGSUBTable::TSingleSubstFormat2::TSingleSubstFormat2() - : TSubTableBase(2), GlyphCount(0) {} + : TSubTableBase(2) {} CFX_CTTGSUBTable::TSingleSubstFormat2::~TSingleSubstFormat2() {} -CFX_CTTGSUBTable::TLookup::TLookup() - : LookupType(0), LookupFlag(0), SubTableCount(0) {} +CFX_CTTGSUBTable::TLookup::TLookup() : LookupType(0), LookupFlag(0) {} -CFX_CTTGSUBTable::TLookup::~TLookup() { - if (SubTable) { - for (int i = 0; i < SubTableCount; ++i) - delete SubTable[i]; - } -} +CFX_CTTGSUBTable::TLookup::~TLookup() {} -CFX_CTTGSUBTable::TScript::TScript() : DefaultLangSys(0), LangSysCount(0) {} +CFX_CTTGSUBTable::TScript::TScript() : DefaultLangSys(0) {} CFX_CTTGSUBTable::TScript::~TScript() {} -CFX_CTTGSUBTable::TScriptList::TScriptList() : ScriptCount(0) {} +CFX_CTTGSUBTable::TScriptList::TScriptList() {} CFX_CTTGSUBTable::TScriptList::~TScriptList() {} -CFX_CTTGSUBTable::TFeature::TFeature() : FeatureParams(0), LookupCount(0) {} +CFX_CTTGSUBTable::TFeature::TFeature() : FeatureParams(0) {} CFX_CTTGSUBTable::TFeature::~TFeature() {} -CFX_CTTGSUBTable::TFeatureList::TFeatureList() : FeatureCount(0) {} +CFX_CTTGSUBTable::TFeatureList::TFeatureList() {} CFX_CTTGSUBTable::TFeatureList::~TFeatureList() {} -CFX_CTTGSUBTable::TLookupList::TLookupList() : LookupCount(0) {} +CFX_CTTGSUBTable::TLookupList::TLookupList() {} CFX_CTTGSUBTable::TLookupList::~TLookupList() {} -CFX_CTTGSUBTable::TLangSys::TLangSys() - : LookupOrder(0), ReqFeatureIndex(0), FeatureCount(0) {} +CFX_CTTGSUBTable::TLangSys::TLangSys() : LookupOrder(0), ReqFeatureIndex(0) {} CFX_CTTGSUBTable::TLangSys::~TLangSys() {} diff --git a/core/fpdfapi/font/ttgsubtable.h b/core/fpdfapi/font/ttgsubtable.h index e0e4bbbd05..f927269540 100644 --- a/core/fpdfapi/font/ttgsubtable.h +++ b/core/fpdfapi/font/ttgsubtable.h @@ -9,8 +9,9 @@ #include -#include #include +#include +#include #include "core/fxcrt/fx_basic.h" #include "core/fxge/fx_font.h" @@ -45,19 +46,20 @@ class CFX_CTTGSUBTable { uint16_t FeatureList; uint16_t LookupList; }; + struct TLangSys { TLangSys(); ~TLangSys(); uint16_t LookupOrder; uint16_t ReqFeatureIndex; - uint16_t FeatureCount; - std::unique_ptr FeatureIndex; + std::vector FeatureIndices; private: - TLangSys(const TLangSys&); - TLangSys& operator=(const TLangSys&); + TLangSys(const TLangSys&) = delete; + TLangSys& operator=(const TLangSys&) = delete; }; + struct TLangSysRecord { TLangSysRecord() : LangSysTag(0) {} @@ -65,21 +67,22 @@ class CFX_CTTGSUBTable { TLangSys LangSys; private: - TLangSysRecord(const TLangSysRecord&); - TLangSysRecord& operator=(const TLangSysRecord&); + TLangSysRecord(const TLangSysRecord&) = delete; + TLangSysRecord& operator=(const TLangSysRecord&) = delete; }; + struct TScript { TScript(); ~TScript(); uint16_t DefaultLangSys; - uint16_t LangSysCount; - std::unique_ptr LangSysRecord; + std::vector LangSysRecords; private: - TScript(const TScript&); - TScript& operator=(const TScript&); + TScript(const TScript&) = delete; + TScript& operator=(const TScript&) = delete; }; + struct TScriptRecord { TScriptRecord() : ScriptTag(0) {} @@ -87,32 +90,33 @@ class CFX_CTTGSUBTable { TScript Script; private: - TScriptRecord(const TScriptRecord&); - TScriptRecord& operator=(const TScriptRecord&); + TScriptRecord(const TScriptRecord&) = delete; + TScriptRecord& operator=(const TScriptRecord&) = delete; }; + struct TScriptList { TScriptList(); ~TScriptList(); - uint16_t ScriptCount; - std::unique_ptr ScriptRecord; + std::vector ScriptRecords; private: - TScriptList(const TScriptList&); - TScriptList& operator=(const TScriptList&); + TScriptList(const TScriptList&) = delete; + TScriptList& operator=(const TScriptList&) = delete; }; + struct TFeature { TFeature(); ~TFeature(); uint16_t FeatureParams; - int LookupCount; - std::unique_ptr LookupListIndex; + std::vector LookupListIndices; private: - TFeature(const TFeature&); - TFeature& operator=(const TFeature&); + TFeature(const TFeature&) = delete; + TFeature& operator=(const TFeature&) = delete; }; + struct TFeatureRecord { TFeatureRecord() : FeatureTag(0) {} @@ -120,20 +124,21 @@ class CFX_CTTGSUBTable { TFeature Feature; private: - TFeatureRecord(const TFeatureRecord&); - TFeatureRecord& operator=(const TFeatureRecord&); + TFeatureRecord(const TFeatureRecord&) = delete; + TFeatureRecord& operator=(const TFeatureRecord&) = delete; }; + struct TFeatureList { TFeatureList(); ~TFeatureList(); - int FeatureCount; - std::unique_ptr FeatureRecord; + std::vector FeatureRecords; private: - TFeatureList(const TFeatureList&); - TFeatureList& operator=(const TFeatureList&); + TFeatureList(const TFeatureList&) = delete; + TFeatureList& operator=(const TFeatureList&) = delete; }; + enum TLookupFlag { LOOKUPFLAG_RightToLeft = 0x0001, LOOKUPFLAG_IgnoreBaseGlyphs = 0x0002, @@ -142,6 +147,7 @@ class CFX_CTTGSUBTable { LOOKUPFLAG_Reserved = 0x00F0, LOOKUPFLAG_MarkAttachmentType = 0xFF00, }; + struct TCoverageFormatBase { TCoverageFormatBase() : CoverageFormat(0) {} explicit TCoverageFormatBase(uint16_t format) : CoverageFormat(format) {} @@ -154,17 +160,18 @@ class CFX_CTTGSUBTable { TCoverageFormatBase(const TCoverageFormatBase&); TCoverageFormatBase& operator=(const TCoverageFormatBase&); }; + struct TCoverageFormat1 : public TCoverageFormatBase { TCoverageFormat1(); ~TCoverageFormat1() override; - uint16_t GlyphCount; - std::unique_ptr GlyphArray; + std::vector GlyphArray; private: - TCoverageFormat1(const TCoverageFormat1&); - TCoverageFormat1& operator=(const TCoverageFormat1&); + TCoverageFormat1(const TCoverageFormat1&) = delete; + TCoverageFormat1& operator=(const TCoverageFormat1&) = delete; }; + struct TRangeRecord { TRangeRecord(); @@ -177,19 +184,20 @@ class CFX_CTTGSUBTable { uint16_t StartCoverageIndex; private: - TRangeRecord(const TRangeRecord&); + TRangeRecord(const TRangeRecord&) = delete; }; + struct TCoverageFormat2 : public TCoverageFormatBase { TCoverageFormat2(); ~TCoverageFormat2() override; - uint16_t RangeCount; - std::unique_ptr RangeRecord; + std::vector RangeRecords; private: - TCoverageFormat2(const TCoverageFormat2&); - TCoverageFormat2& operator=(const TCoverageFormat2&); + TCoverageFormat2(const TCoverageFormat2&) = delete; + TCoverageFormat2& operator=(const TCoverageFormat2&) = delete; }; + struct TDevice { TDevice() : StartSize(0), EndSize(0), DeltaFormat(0) {} @@ -198,9 +206,10 @@ class CFX_CTTGSUBTable { uint16_t DeltaFormat; private: - TDevice(const TDevice&); - TDevice& operator=(const TDevice&); + TDevice(const TDevice&) = delete; + TDevice& operator=(const TDevice&) = delete; }; + struct TSubTableBase { TSubTableBase() : SubstFormat(0) {} explicit TSubTableBase(uint16_t format) : SubstFormat(format) {} @@ -209,9 +218,10 @@ class CFX_CTTGSUBTable { uint16_t SubstFormat; private: - TSubTableBase(const TSubTableBase&); - TSubTableBase& operator=(const TSubTableBase&); + TSubTableBase(const TSubTableBase&) = delete; + TSubTableBase& operator=(const TSubTableBase&) = delete; }; + struct TSingleSubstFormat1 : public TSubTableBase { TSingleSubstFormat1(); ~TSingleSubstFormat1() override; @@ -220,44 +230,44 @@ class CFX_CTTGSUBTable { int16_t DeltaGlyphID; private: - TSingleSubstFormat1(const TSingleSubstFormat1&); - TSingleSubstFormat1& operator=(const TSingleSubstFormat1&); + TSingleSubstFormat1(const TSingleSubstFormat1&) = delete; + TSingleSubstFormat1& operator=(const TSingleSubstFormat1&) = delete; }; + struct TSingleSubstFormat2 : public TSubTableBase { TSingleSubstFormat2(); ~TSingleSubstFormat2() override; std::unique_ptr Coverage; - uint16_t GlyphCount; - std::unique_ptr Substitute; + std::vector Substitutes; private: - TSingleSubstFormat2(const TSingleSubstFormat2&); - TSingleSubstFormat2& operator=(const TSingleSubstFormat2&); + TSingleSubstFormat2(const TSingleSubstFormat2&) = delete; + TSingleSubstFormat2& operator=(const TSingleSubstFormat2&) = delete; }; + struct TLookup { TLookup(); ~TLookup(); uint16_t LookupType; uint16_t LookupFlag; - uint16_t SubTableCount; - std::unique_ptr SubTable; + std::vector> SubTables; private: - TLookup(const TLookup&); - TLookup& operator=(const TLookup&); + TLookup(const TLookup&) = delete; + TLookup& operator=(const TLookup&) = delete; }; + struct TLookupList { TLookupList(); ~TLookupList(); - int LookupCount; - std::unique_ptr Lookup; + std::vector Lookups; private: - TLookupList(const TLookupList&); - TLookupList& operator=(const TLookupList&); + TLookupList(const TLookupList&) = delete; + TLookupList& operator=(const TLookupList&) = delete; }; bool Parse(FT_Bytes scriptlist, FT_Bytes featurelist, FT_Bytes lookuplist); @@ -271,16 +281,16 @@ class CFX_CTTGSUBTable { TCoverageFormatBase* ParseCoverage(FT_Bytes raw); void ParseCoverageFormat1(FT_Bytes raw, TCoverageFormat1* rec); void ParseCoverageFormat2(FT_Bytes raw, TCoverageFormat2* rec); - void ParseSingleSubst(FT_Bytes raw, TSubTableBase** rec); + void ParseSingleSubst(FT_Bytes raw, std::unique_ptr* rec); void ParseSingleSubstFormat1(FT_Bytes raw, TSingleSubstFormat1* rec); void ParseSingleSubstFormat2(FT_Bytes raw, TSingleSubstFormat2* rec); bool GetVerticalGlyphSub(uint32_t glyphnum, uint32_t* vglyphnum, - TFeature* Feature) const; + TFeature* Feature); bool GetVerticalGlyphSub2(uint32_t glyphnum, uint32_t* vglyphnum, - TLookup* Lookup) const; + TLookup* Lookup); int GetCoverageIndex(TCoverageFormatBase* Coverage, uint32_t g) const; uint8_t GetUInt8(FT_Bytes& p) const; @@ -289,7 +299,7 @@ class CFX_CTTGSUBTable { int32_t GetInt32(FT_Bytes& p) const; uint32_t GetUInt32(FT_Bytes& p) const; - std::map m_featureMap; + std::set m_featureSet; bool m_bFeautureMapLoad; bool loaded; tt_gsub_header header; -- cgit v1.2.3