#include "otf.h"
#include "otferror.h"
+/* Return nonzero (-1 if ID is zero, 1 otherwise) if OTF_Glyph *G
+ should be ignored according to LookupFlag FLAG. */
+#define IGNORED_GLYPH(g, flag) \
+ ((g)->glyph_id == 0 ? -1 \
+ : (((flag) & (1 << (g)->GlyphClass)) \
+ || (((flag) & OTF_MarkAttachmentType) \
+ && (g)->GlyphClass == OTF_GlyphClassMark \
+ && ((flag) >> 8) != (g)->MarkAttachClass)))
+
#define GSTRING_DELETE(gstring, from, len) \
do { \
memmove (gstring->glyphs + from, gstring->glyphs + from + len, \
char *errfmt = "GSTRING%s"; \
\
gstring->size = gstring->used + len; \
- gstring->glyphs = (OTF_Glyph *) realloc (gstring->glyphs, \
- gstring->size); \
+ gstring->glyphs \
+ = (OTF_Glyph *) realloc (gstring->glyphs, \
+ sizeof (OTF_Glyph) * gstring->size); \
if (! gstring->glyphs) \
OTF_ERROR (OTF_ERROR_MEMORY, ""); \
} \
} while (0)
+static unsigned get_class_def (OTF_ClassDef *, OTF_GlyphID);
+
static int
-gstring_subst (OTF_GlyphString *gstring, int from, int to, int flag,
+gstring_subst (OTF *otf, OTF_GlyphString *gstring, int from, int to, int flag,
OTF_GlyphID *ids, int num)
{
int errret = -1;
int len = to - from;
int i;
- int c = gstring->glyphs[from].c;
int from_idx = gstring->glyphs[from].f.index.from;
int to_idx = gstring->glyphs[to - 1].f.index.to;
int non_ignored_idx;
for (i = non_ignored_idx = to - 1; i >= from; i--)
- if (flag & (1 << gstring->glyphs[i].GlyphClass))
- {
- OTF_Glyph temp = gstring->glyphs[i];
+ {
+ OTF_Glyph *g = gstring->glyphs + i;
- memmove (gstring->glyphs + i, gstring->glyphs + i + 1,
- sizeof (OTF_Glyph) * (non_ignored_idx - i));
- non_ignored_idx--;
- len--;
- }
+ if (IGNORED_GLYPH (g, flag) == 1)
+ {
+ /* Move this glyph to the next of the current target of
+ substitution. */
+ OTF_Glyph temp = *g;
+
+ memmove (g, g + 1, sizeof (OTF_Glyph) * (non_ignored_idx - i));
+ temp.f.index.from = from_idx;
+ temp.f.index.to = to_idx;
+ gstring->glyphs[non_ignored_idx--] = temp;
+ len--;
+ }
+ }
if (len < num)
GSTRING_INSERT (gstring, from, (num - len));
GSTRING_DELETE (gstring, from, (len - num));
for (i = 0; i < num; i++)
{
- gstring->glyphs[from + i].c = c;
+ if (gstring->glyphs[from + i].glyph_id != ids[i])
+ {
+ gstring->glyphs[from + i].c = 0;
+ if (otf->gdef)
+ gstring->glyphs[from + i].GlyphClass
+ = get_class_def (&otf->gdef->glyph_class_def, ids[i]);
+ else
+ gstring->glyphs[from + i].GlyphClass = 0;
+ }
gstring->glyphs[from + i].glyph_id = ids[i];
+ gstring->glyphs[from + i].positioning_type = 0;
gstring->glyphs[from + i].f.index.from = from_idx;
gstring->glyphs[from + i].f.index.to = to_idx;
}
}
static OTF_LangSys *
-get_langsys (OTF_ScriptList *script_list, char *script, char *language)
+get_langsys (OTF_ScriptList *script_list,
+ const char *script, const char *language)
{
OTF_Tag script_tag = OTF_tag (script);
static int
setup_lookup_indices (OTF_LookupList *LookupList, OTF_FeatureList *FeatureList,
- char *features, int *lookup_indices)
+ const char *features, int *lookup_indices)
{
int i, j, n = 0;
OTF_Feature *feature;
{
char tagname[4];
OTF_Tag tag;
- int negate = 0;
+ int use_it = 1;
if (*features == '*')
{
/* Consume all remaining features. */
- /* We are sure that the last LookupCount elements of
- lookup_indices are free to be used for this work. */
- int *free_table = (lookup_indices + (LookupList->LookupCount
- * FeatureList->FeatureCount));
-
- for (i = 0; i < LookupList->LookupCount; i++)
- free_table[i] = 0;
for (i = 0; i < FeatureList->FeatureCount; i++)
if (! feature_table[i])
{
feature = FeatureList->Feature + i;
for (j = 0; j < feature->LookupCount; j++)
- free_table[feature->LookupListIndex[j]] = 1;
+ lookup_indices[n++] = feature->LookupListIndex[j];
}
- for (i = 0; i < LookupList->LookupCount; i++)
- if (free_table[i])
- lookup_indices[n++] = i;
break;
}
if (*features == '~')
- negate = 1, features++;
+ use_it = -1, features++;
for (i = 0; *features && *features != ','; i++, features++)
tagname[i] = *features;
if (*features)
feature = FeatureList->Feature + i;
if (tag == feature->FeatureTag)
{
- if (! negate)
+ if (feature_table[i])
+ break;
+ if (use_it > 0)
for (j = 0; j < feature->LookupCount; j++)
lookup_indices[n++] = feature->LookupListIndex[j];
- feature_table[i] = 1;
+ feature_table[i] = use_it;
break;
}
}
int i;
for (g = gbeg, i = 0; g < gend && i < count; g++)
- if (g->glyph_id && ! (flag & (1 << g->GlyphClass))
- && g->glyph_id != ids[i++])
+ if (! IGNORED_GLYPH (g, flag) && g->glyph_id != ids[i++])
return -1;
return (i < count ? -1 : g - gbeg);
}
if (i > 0)
{
int j;
+ OTF_Glyph *g;
- for (j = gidx - 1; j >= 0; j--)
- if (gstring->glyphs[j].glyph_id
- && --i == 0)
+ for (j = gidx - 1, g = gstring->glyphs + j; j >= 0; j--, g--)
+ if (! IGNORED_GLYPH (g, flag) && --i == 0)
break;
if (i > 0)
return -1;
int i;
for (g = gbeg, i = 0; g < gend && i < count; g++)
- if (g->glyph_id && ! (flag & (1 << g->GlyphClass))
+ if (! IGNORED_GLYPH (g, flag)
&& get_class_def (class_def, g->glyph_id) != classes[i++])
return -1;
return (i < count ? -1 : g - gbeg);
if (i > 0)
{
int j;
+ OTF_Glyph *g;
- for (j = gidx - 1; j >= 0 && i > 0; j--)
- if (gstring->glyphs[j].glyph_id
- && i-- == 0)
+ for (j = gidx - 1, g = gstring->glyphs + j; j >= 0; j--, g--)
+ if (! IGNORED_GLYPH (g, flag) && i-- == 0)
break;
if (i > 0)
return -1;
int i;
for (g = gbeg, i = 0; g < gend && i < count; g++)
- if (g->glyph_id && ! (flag & (1 << g->GlyphClass))
+ if (! IGNORED_GLYPH (g, flag)
&& get_coverage_index (coverages + i++, g->glyph_id) < 0)
return -1;
return (i < count ? -1 : g - gbeg);
if (i > 0)
{
int j;
+ OTF_Glyph *g;
- for (j = gidx - 1; j >= 0; j--)
- if (gstring->glyphs[j].glyph_id
- && --i == 0)
+ for (j = gidx - 1, g= gstring->glyphs +j; j >= 0; j--, g--)
+ if (! IGNORED_GLYPH (g, flag) && --i == 0)
break;
if (i > 0)
return -1;
}
static int
-lookup_gsub (OTF_LookupList *lookup_list, unsigned lookup_list_index,
- OTF_GlyphString *gstring, int gidx)
+lookup_gsub (OTF *otf, OTF_LookupList *lookup_list, unsigned lookup_list_index,
+ OTF_GlyphString *gstring, int gidx, int alternate_subst)
{
char *errfmt = "GSUB Looking up%s";
int errret = -1;
OTF_Lookup *lookup = lookup_list->Lookup + lookup_list_index;
- unsigned int flag = lookup->LookupFlag & OTF_LookupFlagIgnoreMask;
+ unsigned int flag = (lookup->LookupFlag
+ & (OTF_LookupFlagIgnoreMask | OTF_MarkAttachmentType));
int orig_gidx = gidx;
OTF_Glyph *g = gstring->glyphs + gidx;
int i;
- if (! g->glyph_id
- || (g->GlyphClass
- && (flag & (1 << g->GlyphClass))))
+ if (IGNORED_GLYPH (g, flag))
return (gidx + 1);
/* Try all subtables until one of them handles the current glyph. */
subtable = extension1->ExtensionSubtable;
}
+ if (alternate_subst
+ ? (lookup_type != 3 && lookup_type != 5 && lookup_type != 6)
+ : (lookup_type == 3))
+ continue;
+
if (subtable->Coverage.offset)
{
coverage_idx = get_coverage_index (&subtable->Coverage,
continue;
}
- switch (lookup->LookupType)
+ switch (lookup_type)
{
case 1:
if (subtable->Format == 1)
break;
case 2:
- {
- OTF_GSUB_Multiple1 *multiple1 = &subtable->u.multiple1;
- OTF_Sequence *seq = multiple1->Sequence + coverage_idx;
+ if (subtable->Format == 1)
+ {
+ OTF_GSUB_Multiple1 *multiple1 = &subtable->u.multiple1;
+ OTF_Sequence *seq = multiple1->Sequence + coverage_idx;
- gstring_subst (gstring, gidx, gidx + 1, flag,
- seq->Substitute, seq->GlyphCount);
- gidx += seq->GlyphCount;
- }
+ gstring_subst (otf, gstring, gidx, gidx + 1, flag,
+ seq->Substitute, seq->GlyphCount);
+ gidx += seq->GlyphCount;
+ }
+ else
+ OTF_ERROR (OTF_ERROR_GSUB_DRIVE, " (invalid SubFormat)");
break;
case 3:
- /* For the moment, we always ignore this feature. */
- break;
if (subtable->Format == 1)
{
OTF_GSUB_Alternate1 *alt1 = &subtable->u.alternate1;
OTF_AlternateSet *altset = alt1->AlternateSet + coverage_idx;
- g->glyph_id = altset->Alternate[0];
- gidx++;
+ gstring_subst (otf, gstring, gidx, gidx + 1, flag,
+ altset->Alternate, altset->GlyphCount);
+ gidx += altset->GlyphCount;;
}
else
OTF_ERROR (OTF_ERROR_GSUB_DRIVE, " (invalid SubFormat)");
lig->CompCount - 1, lig->Component);
if (n < 0)
continue;
- gstring_subst (gstring, gidx, gidx + 1 + n, flag,
+ gstring_subst (otf, gstring, gidx, gidx + 1 + n, flag,
&lig->LigGlyph, 1);
gidx++;
break;
continue;
orig_used = gstring->used;
for (k = 0; k < rule->LookupCount; k++)
- lookup_gsub (lookup_list,
+ lookup_gsub (otf, lookup_list,
rule->LookupRecord[k].LookupListIndex,
gstring,
- gidx + rule->LookupRecord[k].SequenceIndex);
+ gidx + rule->LookupRecord[k].SequenceIndex,
+ alternate_subst);
gidx += rule->GlyphCount + (gstring->used - orig_used);
break;
}
continue;
orig_used = gstring->used;
for (k = 0; k < rule->LookupCount; k++)
- lookup_gsub (lookup_list,
+ lookup_gsub (otf, lookup_list,
rule->LookupRecord[k].LookupListIndex,
gstring,
- gidx + rule->LookupRecord[k].SequenceIndex);
+ gidx + rule->LookupRecord[k].SequenceIndex,
+ alternate_subst);
gidx += rule->GlyphCount + (gstring->used - orig_used);
break;
}
continue;
orig_used = gstring->used;
for (j = 0; j < context3->LookupCount; j++)
- lookup_gsub (lookup_list,
+ lookup_gsub (otf, lookup_list,
context3->LookupRecord[j].LookupListIndex,
gstring,
- gidx + context3->LookupRecord[j].SequenceIndex);
+ gidx + context3->LookupRecord[j].SequenceIndex,
+ alternate_subst);
gidx += context3->GlyphCount + (gstring->used - orig_used);
}
break;
continue;
orig_used = gstring->used;
for (k = 0; k < rule->LookupCount; k++)
- lookup_gsub (lookup_list,
+ lookup_gsub (otf, lookup_list,
rule->LookupRecord[k].LookupListIndex,
gstring,
- gidx + rule->LookupRecord[k].SequenceIndex);
+ gidx + rule->LookupRecord[k].SequenceIndex,
+ alternate_subst);
gidx += rule->InputGlyphCount + (gstring->used - orig_used);
break;
}
continue;
orig_used = gstring->used;
for (k = 0; k < rule->LookupCount; k++)
- lookup_gsub (lookup_list,
+ lookup_gsub (otf, lookup_list,
rule->LookupRecord[k].LookupListIndex,
gstring,
- gidx + rule->LookupRecord[k].SequenceIndex);
+ gidx + rule->LookupRecord[k].SequenceIndex,
+ alternate_subst);
gidx += rule->InputGlyphCount + (gstring->used - orig_used);
break;
}
continue;
orig_used = gstring->used;
for (j = 0; j < context3->LookupCount; j++)
- lookup_gsub (lookup_list,
+ lookup_gsub (otf, lookup_list,
context3->LookupRecord[j].LookupListIndex,
gstring,
- gidx + context3->LookupRecord[j].SequenceIndex);
+ gidx + context3->LookupRecord[j].SequenceIndex,
+ alternate_subst);
gidx += context3->InputGlyphCount + (gstring->used - orig_used);
}
break;
char *errfmt = "GPOS Looking up%s";
int errret = -1;
OTF_Lookup *lookup = lookup_list->Lookup + lookup_list_index;
- unsigned int flag = lookup->LookupFlag & OTF_LookupFlagIgnoreMask;
+ unsigned int flag = (lookup->LookupFlag
+ & (OTF_LookupFlagIgnoreMask | OTF_MarkAttachmentType));
int orig_gidx = gidx;
OTF_Glyph *g = gstring->glyphs + gidx;
int i;
- if (! g->glyph_id
- || g->positioning_type
- || (g->GlyphClass
- && (flag & (1 << g->GlyphClass))))
+ if (IGNORED_GLYPH (g, flag)
+ || (0 & g->positioning_type))
return (gidx + 1);
/* Try all subtables until one of them handles the current glyph. */
for (i = 0; i < lookup->SubTableCount && gidx == orig_gidx; i++)
{
+ unsigned lookup_type = lookup->LookupType;
OTF_LookupSubTableGPOS *subtable = lookup->SubTable.gpos + i;
int coverage_idx;
+ if (lookup_type == 9)
+ {
+ OTF_GPOS_Extension1 *extension1 = &subtable->u.extension1;
+
+ lookup_type = extension1->ExtensionLookupType;
+ subtable = extension1->ExtensionSubtable;
+ }
+
if (subtable->Coverage.offset)
{
coverage_idx = get_coverage_index (&subtable->Coverage,
continue;
}
- switch (lookup->LookupType)
+ switch (lookup_type)
{
case 1:
- g->positioning_type = lookup->LookupType;
+ g->positioning_type = lookup_type;
if (subtable->Format == 1)
{
OTF_GPOS_Single1 *single1 = &subtable->u.single1;
case 2:
{
- int next_gidx = gidx + 1;
+ int next_gidx;
OTF_Glyph *nextg;
- while (next_gidx < gstring->used
- && (! gstring->glyphs[next_gidx].glyph_id
- || ! (flag
- & (1 << gstring->glyphs[next_gidx].GlyphClass))))
- next_gidx++;
+ for (next_gidx = gidx + 1, nextg = gstring->glyphs + next_gidx;
+ next_gidx < gstring->used && IGNORED_GLYPH (nextg, flag);
+ next_gidx++, nextg++);
- if (next_gidx >= gstring->used)
- continue;
- nextg = gstring->glyphs + next_gidx;
- if (nextg->positioning_type)
+ if (next_gidx >= gstring->used
+ || nextg->positioning_type)
continue;
if (subtable->Format == 1)
{
{
if (pair1->ValueFormat1)
{
- g->positioning_type = lookup->LookupType;
+ g->positioning_type = lookup_type;
g->f.f2.format = pair1->ValueFormat1;
g->f.f2.value = &set->PairValueRecord[j].Value1;
}
gidx = next_gidx;
if (pair1->ValueFormat2)
{
- nextg->positioning_type = lookup->LookupType;
+ nextg->positioning_type = lookup_type;
nextg->f.f2.format = pair1->ValueFormat2;
nextg->f.f2.value = &set->PairValueRecord[j].Value2;
gidx++;
class2 = get_class_def (&pair2->ClassDef2, nextg->glyph_id);
if (pair2->ValueFormat1)
{
- g->positioning_type = lookup->LookupType;
+ g->positioning_type = lookup_type;
g->f.f2.format = pair2->ValueFormat1;
g->f.f2.value
= &pair2->Class1Record[class1].Class2Record[class2].Value1;
gidx = next_gidx;
if (pair2->ValueFormat2)
{
- nextg->positioning_type = lookup->LookupType;
+ nextg->positioning_type = lookup_type;
nextg->f.f2.format = pair2->ValueFormat2;
nextg->f.f2.value
= &pair2->Class1Record[class1].Class2Record[class2].Value2;
{
OTF_GPOS_Cursive1 *cursive1 = &subtable->u.cursive1;
- g->positioning_type = lookup->LookupType;
+ g->positioning_type = lookup_type;
g->f.f3.entry_anchor
= &cursive1->EntryExitRecord[coverage_idx].EntryAnchor;
g->f.f3.exit_anchor
OTF_GPOS_MarkBase1 *mark_base1 = &subtable->u.mark_base1;
OTF_MarkRecord *mark_record;
OTF_AnchorRecord *base_record;
- OTF_Glyph *baseg = g - 1;
+ OTF_Glyph *baseg;
int coverage_idx_base;
+ unsigned int this_flag = flag | OTF_IgnoreMarks;
- while (baseg >= gstring->glyphs
- && (! baseg->glyph_id
- || (baseg->GlyphClass
- && (flag & (1 << baseg->GlyphClass)))))
- baseg--;
+ for (baseg = g - 1;
+ baseg >= gstring->glyphs && IGNORED_GLYPH (baseg, this_flag);
+ baseg--);
+ if (baseg < gstring->glyphs)
+ continue;
coverage_idx_base
= get_coverage_index (&mark_base1->BaseCoverage,
baseg->glyph_id);
-
if (coverage_idx_base < 0)
continue;
mark_record = mark_base1->MarkArray.MarkRecord + coverage_idx;
g->f.f4.mark_anchor = &mark_record->MarkAnchor;
g->f.f4.base_anchor
= &base_record->Anchor[mark_record->Class];
- g->positioning_type = lookup->LookupType;
+ g->positioning_type = lookup_type;
}
break;
if (subtable->Format == 1)
{
OTF_GPOS_MarkLig1 *mark_lig1 = &subtable->u.mark_lig1;
- unsigned class = g->MarkAttachClass;
- OTF_Glyph *ligg = g - 1;
+ OTF_Glyph *ligg;
int coverage_idx_lig;
OTF_MarkRecord *mark_record;
- OTF_ComponentRecord *cmp_record;
OTF_LigatureAttach *attach;
int *num_class = alloca (sizeof (int) * mark_lig1->ClassCount);
int j;
for (j = 0; j < mark_lig1->ClassCount; j++)
num_class[j] = 0;
- while (ligg >= gstring->glyphs
- && (! ligg->glyph_id
- || (ligg->GlyphClass
- && (flag & (1 << ligg->GlyphClass)))))
- {
- if (ligg->positioning_type == 5
- && ligg->MarkAttachClass < mark_lig1->ClassCount)
- num_class[ligg->MarkAttachClass]++;
- ligg--;
- }
+ for (ligg = g - 1;
+ (ligg >= gstring->glyphs
+ && (IGNORED_GLYPH (ligg, flag)
+ || ligg->GlyphClass > OTF_GlyphClassLigature));
+ ligg--)
+ if (ligg->positioning_type == 5
+ && ligg->MarkAttachClass < mark_lig1->ClassCount)
+ num_class[ligg->MarkAttachClass]++;
+ if (ligg < gstring->glyphs)
+ continue;
coverage_idx_lig
= get_coverage_index (&mark_lig1->LigatureCoverage,
ligg->glyph_id);
= attach->ComponentRecord[j].LigatureAnchor;
if (lig_anchor[mark_record->Class].AnchorFormat
- && num_class[mark_record->Class]-- < 0)
+ && num_class[mark_record->Class]-- == 0)
{
- g->positioning_type = lookup->LookupType;
+ g->positioning_type = lookup_type;
g->f.f5.mark_anchor = &mark_record->MarkAnchor;
g->f.f5.ligature_anchor = lig_anchor + mark_record->Class;
break;
OTF_GPOS_MarkMark1 *mark_mark1 = &subtable->u.mark_mark1;
OTF_MarkRecord *mark1_record;
OTF_AnchorRecord *mark2_record;
- OTF_Glyph *prevg = g - 1;
+ OTF_Glyph *prevg;
int coverage_idx_base;
- while (prevg >= gstring->glyphs
- && (! prevg->glyph_id
- || (prevg->GlyphClass
- && (flag & (1 << prevg->GlyphClass)))))
- prevg--;
+ for (prevg = g - 1;
+ prevg >= gstring->glyphs && IGNORED_GLYPH (prevg, flag);
+ prevg--);
if (prevg < gstring->glyphs)
continue;
coverage_idx_base
g->f.f6.mark1_anchor = &mark1_record->MarkAnchor;
g->f.f6.mark2_anchor
= &mark2_record->Anchor[mark1_record->Class];
- g->positioning_type = lookup->LookupType;
+ g->positioning_type = lookup_type;
break;
}
break;
OTF_ERROR (OTF_ERROR_GPOS_DRIVE, " (invalid subformat)");
break;
- case 9:
- OTF_ERROR (OTF_ERROR_GPOS_DRIVE, " (not yet supported)");
- break;
-
default:
continue;
}
return 0;
}
-
-int
-OTF_drive_gsub (OTF *otf, OTF_GlyphString *gstring,
- char *script, char *language, char *features)
+static int
+OTF_drive_gsub_internal (OTF *otf, OTF_GlyphString *gstring,
+ const char *script, const char *language,
+ const char *features,
+ int alternate_subst)
{
char *errfmt = "GSUB driving%s";
int errret = -1;
int i, n;
for (i = 0; i < gstring->used; i++)
- gstring->glyphs[i].f.index.from = gstring->glyphs[i].f.index.to = i;
+ {
+ gstring->glyphs[i].positioning_type = 0;
+ gstring->glyphs[i].f.index.from = gstring->glyphs[i].f.index.to = i;
+ }
- if (! otf->gsub
- && OTF_get_table (otf, "GSUB") < 0)
+ if (OTF_get_table (otf, "GSUB") < 0)
return errret;
gsub = otf->gsub;
if (gsub->FeatureList.FeatureCount == 0
gidx = 0;
while (gidx < gstring->used)
{
- gidx = lookup_gsub (&gsub->LookupList, index, gstring, gidx);
+ gidx = lookup_gsub (otf, &gsub->LookupList, index, gstring, gidx,
+ alternate_subst);
if (gidx < 0)
return errret;
}
gidx = gstring->used - 1;
while (gidx >= 0)
{
- gidx = lookup_gsub (&gsub->LookupList, index, gstring, gidx);
+ gidx = lookup_gsub (otf, &gsub->LookupList, index, gstring, gidx,
+ alternate_subst);
if (gidx < 0)
return errret;
}
}
int
+OTF_drive_gsub (OTF *otf, OTF_GlyphString *gstring,
+ const char *script, const char *language, const char *features)
+{
+ if (! otf->cmap)
+ OTF_get_table (otf, "cmap");
+ return OTF_drive_gsub_internal (otf, gstring, script, language, features, 0);
+}
+
+int
OTF_drive_gpos (OTF *otf, OTF_GlyphString *gstring,
- char *script, char *language, char *features)
+ const char *script, const char *language, const char *features)
{
char *errfmt = "GPOS driving%s";
int errret = -1;
int *lookup_indices;
int i, n;
- if (! otf->gpos
- && OTF_get_table (otf, "GPOS") < 0)
+ for (i = 0; i < gstring->used; i++)
+ gstring->glyphs[i].positioning_type = 0;
+
+ if (OTF_get_table (otf, "GPOS") < 0)
return errret;
gpos = otf->gpos;
if (gpos->FeatureList.FeatureCount == 0
if (n < 0)
return errret;
- for (i = 0; i < gstring->used; i++)
- gstring->glyphs[i].positioning_type = 0;
-
for (i = 0; i < n; i++)
{
int index = lookup_indices[i];
int
OTF_drive_tables (OTF *otf, OTF_GlyphString *gstring,
- char *script, char *language,
- char *gsub_features, char *gpos_features)
+ const char *script, const char *language,
+ const char *gsub_features, const char *gpos_features)
{
if (OTF_drive_cmap (otf, gstring) < 0)
return -1;
return -1;
return 0;
}
+
+int
+OTF_drive_gsub_alternate (OTF *otf, OTF_GlyphString *gstring,
+ const char *script, const char *language,
+ const char *features)
+{
+ return OTF_drive_gsub_internal (otf, gstring, script, language, features, 1);
+}