void Target::trace() const {
_definition->mark();
markArray(ArrayRef<Target *>(_depends));
markArray(ArrayRef<Target *>(_dependents));
markArray(ArrayRef<File *>(_sources));
markArray(ArrayRef<File *>(_outputs));
}
void CallCandidate::trace() const {
safeMark(callExpr_);
safeMark(base_);
safeMark(method_);
safeMark(method_);
safeMark(fnType_);
safeMark(resultType_.unqualified());
safeMark(typeParams_);
safeMark(spCandidate_);
markArray(llvm::ArrayRef<QualifiedType>(paramTypes_));
}
le_int32 MarkToBasePositioningSubtable::process(const LETableReference &base, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode &success) const
{
LEGlyphID markGlyph = glyphIterator->getCurrGlyphID();
le_int32 markCoverage = getGlyphCoverage(base, (LEGlyphID) markGlyph, success);
if (LE_FAILURE(success)) {
return 0;
}
if (markCoverage < 0) {
// markGlyph isn't a covered mark glyph
return 0;
}
LEPoint markAnchor;
LEReferenceTo<MarkArray> markArray(base, success, (const MarkArray *) ((char *) this + SWAPW(markArrayOffset)));
if(LE_FAILURE(success)) return 0;
le_int32 markClass = markArray->getMarkClass(markArray, markGlyph, markCoverage, fontInstance, markAnchor, success);
le_uint16 mcCount = SWAPW(classCount);
if (markClass < 0 || markClass >= mcCount || LE_FAILURE(success)) {
// markGlyph isn't in the mark array or its
// mark class is too big. The table is mal-formed!
return 0;
}
// FIXME: We probably don't want to find a base glyph before a previous ligature...
GlyphIterator baseIterator(*glyphIterator, (le_uint16) (lfIgnoreMarks /*| lfIgnoreLigatures*/));
LEGlyphID baseGlyph = findBaseGlyph(&baseIterator);
le_int32 baseCoverage = getBaseCoverage(base, (LEGlyphID) baseGlyph, success);
LEReferenceTo<BaseArray> baseArray(base, success, (const BaseArray *) ((char *) this + SWAPW(baseArrayOffset)));
if(LE_FAILURE(success)) return 0;
le_uint16 baseCount = SWAPW(baseArray->baseRecordCount);
if (baseCoverage < 0 || baseCoverage >= baseCount) {
// The base glyph isn't covered, or the coverage
// index is too big. The latter means that the
// table is mal-formed...
return 0;
}
LEReferenceTo<BaseRecord> baseRecord(base, success, &baseArray->baseRecordArray[baseCoverage * mcCount]);
if( LE_FAILURE(success) ) { return 0; }
LEReferenceToArrayOf<Offset> baseAnchorTableOffsetArray(base, success, &(baseRecord->baseAnchorTableOffsetArray[0]), markClass+1);
if( LE_FAILURE(success) ) { return 0; }
Offset anchorTableOffset = SWAPW(baseRecord->baseAnchorTableOffsetArray[markClass]);
if (anchorTableOffset <= 0) {
// this means the table is mal-formed...
glyphIterator->setCurrGlyphBaseOffset(baseIterator.getCurrStreamPosition());
return 0;
}
LEReferenceTo<AnchorTable> anchorTable(baseArray, success, anchorTableOffset);
LEPoint baseAnchor, markAdvance, pixels;
anchorTable->getAnchor(anchorTable, baseGlyph, fontInstance, baseAnchor, success);
fontInstance->getGlyphAdvance(markGlyph, pixels);
fontInstance->pixelsToUnits(pixels, markAdvance);
float anchorDiffX = baseAnchor.fX - markAnchor.fX;
float anchorDiffY = baseAnchor.fY - markAnchor.fY;
_LETRACE("Offset: (%.2f, %.2f) glyph 0x%X", anchorDiffX, anchorDiffY, markGlyph);
glyphIterator->setCurrGlyphBaseOffset(baseIterator.getCurrStreamPosition());
if (glyphIterator->isRightToLeft()) {
// FIXME: need similar patch to below; also in MarkToLigature and MarkToMark
// (is there a better way to approach this for all the cases?)
glyphIterator->setCurrGlyphPositionAdjustment(anchorDiffX, anchorDiffY, -markAdvance.fX, -markAdvance.fY);
} else {
LEPoint baseAdvance;
fontInstance->getGlyphAdvance(baseGlyph, pixels);
//JK: adjustment needs to account for non-zero advance of any marks between base glyph and current mark
GlyphIterator gi(baseIterator, (le_uint16)0); // copy of baseIterator that won't ignore marks
gi.next(); // point beyond the base glyph
while (gi.getCurrStreamPosition() < glyphIterator->getCurrStreamPosition()) { // for all intervening glyphs (marks)...
LEGlyphID otherMark = gi.getCurrGlyphID();
LEPoint px;
fontInstance->getGlyphAdvance(otherMark, px); // get advance, in case it's non-zero
pixels.fX += px.fX; // and add that to the base glyph's advance
pixels.fY += px.fY;
gi.next();
}
// end of JK patch
fontInstance->pixelsToUnits(pixels, baseAdvance);
glyphIterator->setCurrGlyphPositionAdjustment(anchorDiffX - baseAdvance.fX, anchorDiffY - baseAdvance.fY, -markAdvance.fX, -markAdvance.fY);
}
return 1;
}
le_int32 MarkToLigaturePositioningSubtable::process(const LETableReference &base, GlyphIterator *glyphIterator, const LEFontInstance *fontInstance, LEErrorCode &success) const
{
LEGlyphID markGlyph = glyphIterator->getCurrGlyphID();
le_int32 markCoverage = getGlyphCoverage(base, (LEGlyphID) markGlyph, success);
if (LE_FAILURE(success)) {
return 0;
}
if (markCoverage < 0) {
// markGlyph isn't a covered mark glyph
return 0;
}
LEPoint markAnchor;
LEReferenceTo<MarkArray> markArray(base, success, SWAPW(markArrayOffset));
if( LE_FAILURE(success) ) {
return 0;
}
le_int32 markClass = markArray->getMarkClass(markArray, markGlyph, markCoverage, fontInstance, markAnchor, success);
le_uint16 mcCount = SWAPW(classCount);
if (markClass < 0 || markClass >= mcCount) {
// markGlyph isn't in the mark array or its
// mark class is too big. The table is mal-formed!
return 0;
}
// FIXME: we probably don't want to find a ligature before a previous base glyph...
GlyphIterator ligatureIterator(*glyphIterator, (le_uint16) (lfIgnoreMarks /*| lfIgnoreBaseGlyphs*/));
LEGlyphID ligatureGlyph = findLigatureGlyph(&ligatureIterator);
le_int32 ligatureCoverage = getBaseCoverage(base, (LEGlyphID) ligatureGlyph, success);
LEReferenceTo<LigatureArray> ligatureArray(base, success, SWAPW(baseArrayOffset));
if (LE_FAILURE(success)) { return 0; }
le_uint16 ligatureCount = SWAPW(ligatureArray->ligatureCount);
if (ligatureCoverage < 0 || ligatureCoverage >= ligatureCount) {
// The ligature glyph isn't covered, or the coverage
// index is too big. The latter means that the
// table is mal-formed...
return 0;
}
le_int32 markPosition = glyphIterator->getCurrStreamPosition();
Offset ligatureAttachOffset = SWAPW(ligatureArray->ligatureAttachTableOffsetArray[ligatureCoverage]);
LEReferenceTo<LigatureAttachTable> ligatureAttachTable(ligatureArray, success, ligatureAttachOffset);
if (LE_FAILURE(success)) { return 0; }
le_int32 componentCount = SWAPW(ligatureAttachTable->componentCount);
le_int32 component = ligatureIterator.getMarkComponent(markPosition);
if (component >= componentCount) {
// should really just bail at this point...
component = componentCount - 1;
}
LEReferenceTo<ComponentRecord> componentRecord(base, success, &ligatureAttachTable->componentRecordArray[component * mcCount]);
if (LE_FAILURE(success)) { return 0; }
LEReferenceToArrayOf<Offset> ligatureAnchorTableOffsetArray(base, success, &(componentRecord->ligatureAnchorTableOffsetArray[0]), mcCount);
if( LE_FAILURE(success) ) { return 0; }
Offset anchorTableOffset = SWAPW(componentRecord->ligatureAnchorTableOffsetArray[markClass]);
LEReferenceTo<AnchorTable> anchorTable(ligatureAttachTable, success, anchorTableOffset);
if (LE_FAILURE(success)) { return 0; }
LEPoint ligatureAnchor, markAdvance, pixels;
anchorTable->getAnchor(anchorTable, ligatureGlyph, fontInstance, ligatureAnchor, success);
fontInstance->getGlyphAdvance(markGlyph, pixels);
fontInstance->pixelsToUnits(pixels, markAdvance);
float anchorDiffX = ligatureAnchor.fX - markAnchor.fX;
float anchorDiffY = ligatureAnchor.fY - markAnchor.fY;
glyphIterator->setCurrGlyphBaseOffset(ligatureIterator.getCurrStreamPosition());
if (glyphIterator->isRightToLeft()) {
glyphIterator->setCurrGlyphPositionAdjustment(anchorDiffX, anchorDiffY, -markAdvance.fX, -markAdvance.fY);
} else {
LEPoint ligatureAdvance;
fontInstance->getGlyphAdvance(ligatureGlyph, pixels);
fontInstance->pixelsToUnits(pixels, ligatureAdvance);
glyphIterator->setCurrGlyphPositionAdjustment(anchorDiffX - ligatureAdvance.fX, anchorDiffY - ligatureAdvance.fY, -markAdvance.fX, -markAdvance.fY);
}
return 1;
}
