SkOTTableName::Iterator Class Reference

#include <SkOTTable_name.h>

Classes
struct	Record

Public Member Functions
	Iterator (const uint8_t *nameTable, size_t size)
	Iterator (const uint8_t *nameTable, size_t size, SK_OT_USHORT type)
void	reset (SK_OT_USHORT type)
bool	next (Record &)

Detailed Description

Definition at line 544 of file SkOTTable_name.h.

Constructor & Destructor Documentation

Iterator() [1/2]

SkOTTableName::Iterator::Iterator ( const uint8_t *  nameTable, size_t  size  )

inline

Definition at line 546 of file SkOTTable_name.h.

            : fNameTable(nameTable), fNameTableSize(size), fIndex(0), fType(-1) { }

Iterator() [2/2]

SkOTTableName::Iterator::Iterator ( const uint8_t *  nameTable, size_t  size, SK_OT_USHORT  type  )

inline

Definition at line 548 of file SkOTTable_name.h.

            : fNameTable(nameTable), fNameTableSize(size), fIndex(0), fType(type)
        { }

Member Function Documentation

next()

bool SkOTTableName::Iterator::next

(

Record &

record

)

Definition at line 457 of file SkOTTable_name.cpp.

                                                                    {
    SkOTTableName nameTable;
    if (fNameTableSize < sizeof(nameTable)) {
        return false;
    }
    memcpy(&nameTable, fNameTable, sizeof(nameTable));
 
    const uint8_t* nameRecords = fNameTable + sizeof(nameTable);
    const size_t nameRecordsSize = fNameTableSize - sizeof(nameTable);
 
    const size_t stringTableOffset = SkEndian_SwapBE16(nameTable.stringOffset);
    if (fNameTableSize < stringTableOffset) {
        return false;
    }
    const uint8_t* stringTable = fNameTable + stringTableOffset;
    const size_t stringTableSize = fNameTableSize - stringTableOffset;
 
    // Find the next record which matches the requested type.
    SkOTTableName::Record nameRecord;
    const size_t nameRecordsCount = SkEndian_SwapBE16(nameTable.count);
    const size_t nameRecordsMax = std::min(nameRecordsCount, nameRecordsSize / sizeof(nameRecord));
    do {
        if (fIndex >= nameRecordsMax) {
            return false;
        }
 
        memcpy(&nameRecord, nameRecords + sizeof(nameRecord)*fIndex, sizeof(nameRecord));
        ++fIndex;
    } while (fType != -1 && nameRecord.nameID.fontSpecific != fType);
 
    record.type = nameRecord.nameID.fontSpecific;
 
    // Decode the name into UTF-8.
    const size_t nameOffset = SkEndian_SwapBE16(nameRecord.offset);
    const size_t nameLength = SkEndian_SwapBE16(nameRecord.length);
    if (stringTableSize < nameOffset + nameLength) {
        return false; // continue?
    }
    const uint8_t* nameString = stringTable + nameOffset;
    switch (nameRecord.platformID.value) {
        case SkOTTableName::Record::PlatformID::Windows:
            if (SkOTTableName::Record::EncodingID::Windows::UnicodeBMPUCS2
                   != nameRecord.encodingID.windows.value
                && SkOTTableName::Record::EncodingID::Windows::UnicodeUCS4
                   != nameRecord.encodingID.windows.value
                && SkOTTableName::Record::EncodingID::Windows::Symbol
                   != nameRecord.encodingID.windows.value)
            {
                record.name.reset();
                break; // continue?
            }
            [[fallthrough]];
        case SkOTTableName::Record::PlatformID::Unicode:
        case SkOTTableName::Record::PlatformID::ISO:
            SkString_from_UTF16BE(nameString, nameLength, record.name);
            break;
 
        case SkOTTableName::Record::PlatformID::Macintosh:
            // TODO: need better decoding, especially on Mac.
            if (SkOTTableName::Record::EncodingID::Macintosh::Roman
                != nameRecord.encodingID.macintosh.value)
            {
                record.name.reset();
                break;  // continue?
            }
            SkStringFromMacRoman(nameString, nameLength, record.name);
            break;
 
        case SkOTTableName::Record::PlatformID::Custom:
            // These should never appear in a 'name' table.
        default:
            SkASSERT(false);
            record.name.reset();
            break;  // continue?
    }
 
    // Determine the language.
    const uint16_t languageID = SkEndian_SwapBE16(nameRecord.languageID.languageTagID);
 
    // Handle format 1 languages.
    if (SkOTTableName::format_1 == nameTable.format && languageID >= 0x8000) {
        const uint16_t languageTagRecordIndex = languageID - 0x8000;
 
        if (nameRecordsSize < sizeof(nameRecord)*nameRecordsCount) {
            return false; //"und" or break?
        }
        const uint8_t* format1extData = nameRecords + sizeof(nameRecord)*nameRecordsCount;
        size_t format1extSize = nameRecordsSize - sizeof(nameRecord)*nameRecordsCount;
        SkOTTableName::Format1Ext format1ext;
        if (format1extSize < sizeof(format1ext)) {
            return false; // "und" or break?
        }
        memcpy(&format1ext, format1extData, sizeof(format1ext));
 
        const uint8_t* languageTagRecords = format1extData + sizeof(format1ext);
        size_t languageTagRecordsSize = format1extSize - sizeof(format1ext);
        if (languageTagRecordIndex < SkEndian_SwapBE16(format1ext.langTagCount)) {
            SkOTTableName::Format1Ext::LangTagRecord languageTagRecord;
            if (languageTagRecordsSize < sizeof(languageTagRecord)*(languageTagRecordIndex+1)) {
                return false; // "und"?
            }
            const uint8_t* languageTagData = languageTagRecords
                                           + sizeof(languageTagRecord)*languageTagRecordIndex;
            memcpy(&languageTagRecord, languageTagData, sizeof(languageTagRecord));
 
            uint16_t languageOffset = SkEndian_SwapBE16(languageTagRecord.offset);
            uint16_t languageLength = SkEndian_SwapBE16(languageTagRecord.length);
 
            if (fNameTableSize < stringTableOffset + languageOffset + languageLength) {
                return false; // "und"?
            }
            const uint8_t* languageString = stringTable + languageOffset;
            SkString_from_UTF16BE(languageString, languageLength, record.language);
            return true;
        }
    }
 
    // Handle format 0 languages, translating them into BCP 47.
    const BCP47FromLanguageId target = { languageID, "" };
    int languageIndex = SkTSearch<BCP47FromLanguageId, BCP47FromLanguageIdLess>(
        BCP47FromLanguageID, std::size(BCP47FromLanguageID), target, sizeof(target));
    if (languageIndex >= 0) {
        record.language = BCP47FromLanguageID[languageIndex].bcp47;
        return true;
    }
 
    // Unknown language, return the BCP 47 code 'und' for 'undetermined'.
    record.language = "und";
    return true;
}

reset()

void SkOTTableName::Iterator::reset ( SK_OT_USHORT  type )

inline

Definition at line 552 of file SkOTTable_name.h.

                                      {
            fIndex = 0;
            fType = type;
        }

---

The documentation for this class was generated from the following files:

• third_party/skia/src/sfnt/SkOTTable_name.h
• third_party/skia/src/sfnt/SkOTTable_name.cpp