diff options
Diffstat (limited to 'Build')
24 files changed, 6902 insertions, 6926 deletions
diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontInst.cpp b/Build/source/texk/web2c/xetexdir/XeTeXFontInst.cpp index a6cd3785c4c..cc8267b91bf 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeXFontInst.cpp +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontInst.cpp @@ -35,8 +35,8 @@ authorization from the copyright holders. * * created on: 2005-10-22 * created by: Jonathan Kew - * - * originally based on PortableFontInstance.cpp from ICU + * + * originally based on PortableFontInstance.cpp from ICU */ #ifdef __cplusplus @@ -57,6 +57,8 @@ extern "C" { FT_Library gFreeTypeLibrary = 0; +static hb_font_funcs_t* hbFontFuncs = NULL; + XeTeXFontInst::XeTeXFontInst(const char* pathname, int index, float pointSize, int &status) : fPointSize(pointSize) , fUnitsPerEM(0) @@ -71,17 +73,19 @@ XeTeXFontInst::XeTeXFontInst(const char* pathname, int index, float pointSize, i , hbFont(NULL) , fMath(NULL) { - if (pathname != NULL) - initialize(pathname, index, status); + if (pathname != NULL) + initialize(pathname, index, status); } XeTeXFontInst::~XeTeXFontInst() { - if (ftFace != 0) { - FT_Done_Face(ftFace); - ftFace = 0; - } - hb_font_destroy(hbFont); + if (ftFace != 0) { + FT_Done_Face(ftFace); + ftFace = 0; + } + hb_font_destroy(hbFont); + delete[] fFilename; + free((void*) fMath); } /* HarfBuzz font functions */ @@ -89,198 +93,198 @@ XeTeXFontInst::~XeTeXFontInst() static hb_bool_t _get_glyph(hb_font_t*, void *font_data, hb_codepoint_t ch, hb_codepoint_t vs, hb_codepoint_t *gid, void*) { - FT_Face face = (FT_Face) font_data; - *gid = 0; + FT_Face face = (FT_Face) font_data; + *gid = 0; - if (vs) - *gid = FT_Face_GetCharVariantIndex (face, ch, vs); + if (vs) + *gid = FT_Face_GetCharVariantIndex (face, ch, vs); - if (*gid == 0) - *gid = FT_Get_Char_Index (face, ch); + if (*gid == 0) + *gid = FT_Get_Char_Index (face, ch); - return *gid != 0; + return *gid != 0; } static FT_Fixed _get_glyph_advance(FT_Face face, FT_UInt gid, bool vertical) { - FT_Error error; - FT_Fixed advance; - int flags = FT_LOAD_NO_SCALE; + FT_Error error; + FT_Fixed advance; + int flags = FT_LOAD_NO_SCALE; - if (vertical) - flags |= FT_LOAD_VERTICAL_LAYOUT; + if (vertical) + flags |= FT_LOAD_VERTICAL_LAYOUT; - error = FT_Get_Advance(face, gid, flags, &advance); - if (error) - advance = 0; - else - advance = advance; + error = FT_Get_Advance(face, gid, flags, &advance); + if (error) + advance = 0; + else + advance = advance; - /* FreeType's vertical metrics grows downward */ - if (vertical) - advance = -advance; + /* FreeType's vertical metrics grows downward */ + if (vertical) + advance = -advance; - return advance; + return advance; } static hb_position_t _get_glyph_h_advance(hb_font_t*, void *font_data, hb_codepoint_t gid, void*) { - return _get_glyph_advance((FT_Face) font_data, gid, false); + return _get_glyph_advance((FT_Face) font_data, gid, false); } static hb_position_t _get_glyph_v_advance(hb_font_t*, void *font_data, hb_codepoint_t gid, void*) { - return _get_glyph_advance((FT_Face) font_data, gid, true); + return _get_glyph_advance((FT_Face) font_data, gid, true); } static hb_bool_t _get_glyph_h_origin(hb_font_t*, void *font_data, hb_codepoint_t gid, hb_position_t *x, hb_position_t *y, void*) { - // horizontal origin is (0, 0) - return true; + // horizontal origin is (0, 0) + return true; } static hb_bool_t _get_glyph_v_origin(hb_font_t*, void *font_data, hb_codepoint_t gid, hb_position_t *x, hb_position_t *y, void*) { - // vertical origin is (0, 0) for now - return true; - - // TODO - // Keep the code below for reference, for now we want to keep vertical - // origin at (0, 0) for compatibility with pre-0.9999. - // Reconsider this (e.g. using BASE table) when we get around overhauling - // the text directionality model and implementing real vertical typesetting. - - FT_Face face = (FT_Face) font_data; - FT_Error error; - - error = FT_Load_Glyph (face, gid, FT_LOAD_NO_SCALE); - if (!error) { - *x = face->glyph->metrics.horiBearingX - face->glyph->metrics.vertBearingX; - *y = face->glyph->metrics.horiBearingY - (-face->glyph->metrics.vertBearingY); - } + // vertical origin is (0, 0) for now + return true; + + // TODO + // Keep the code below for reference, for now we want to keep vertical + // origin at (0, 0) for compatibility with pre-0.9999. + // Reconsider this (e.g. using BASE table) when we get around overhauling + // the text directionality model and implementing real vertical typesetting. + + FT_Face face = (FT_Face) font_data; + FT_Error error; + + error = FT_Load_Glyph (face, gid, FT_LOAD_NO_SCALE); + if (!error) { + *x = face->glyph->metrics.horiBearingX - face->glyph->metrics.vertBearingX; + *y = face->glyph->metrics.horiBearingY - (-face->glyph->metrics.vertBearingY); + } - return !error; + return !error; } static hb_position_t _get_glyph_h_kerning(hb_font_t*, void *font_data, hb_codepoint_t gid1, hb_codepoint_t gid2, void*) { - FT_Face face = (FT_Face) font_data; - FT_Error error; - FT_Vector kerning; - hb_position_t ret; + FT_Face face = (FT_Face) font_data; + FT_Error error; + FT_Vector kerning; + hb_position_t ret; - error = FT_Get_Kerning (face, gid1, gid2, FT_KERNING_UNFITTED, &kerning); - if (error) - ret = 0; - else - ret = kerning.x; - return ret; + error = FT_Get_Kerning (face, gid1, gid2, FT_KERNING_UNFITTED, &kerning); + if (error) + ret = 0; + else + ret = kerning.x; + return ret; } static hb_position_t _get_glyph_v_kerning(hb_font_t*, void *font_data, hb_codepoint_t gid1, hb_codepoint_t gid2, void*) { - /* FreeType does not support vertical kerning */ - return 0; + /* FreeType does not support vertical kerning */ + return 0; } static hb_bool_t _get_glyph_extents(hb_font_t*, void *font_data, hb_codepoint_t gid, hb_glyph_extents_t *extents, void*) { - FT_Face face = (FT_Face) font_data; - FT_Error error; - - error = FT_Load_Glyph (face, gid, FT_LOAD_NO_SCALE); - if (!error) { - extents->x_bearing = face->glyph->metrics.horiBearingX; - extents->y_bearing = face->glyph->metrics.horiBearingY; - extents->width = face->glyph->metrics.width; - extents->height = -face->glyph->metrics.height; - } + FT_Face face = (FT_Face) font_data; + FT_Error error; + + error = FT_Load_Glyph (face, gid, FT_LOAD_NO_SCALE); + if (!error) { + extents->x_bearing = face->glyph->metrics.horiBearingX; + extents->y_bearing = face->glyph->metrics.horiBearingY; + extents->width = face->glyph->metrics.width; + extents->height = -face->glyph->metrics.height; + } - return !error; + return !error; } static hb_bool_t _get_glyph_contour_point(hb_font_t*, void *font_data, hb_codepoint_t gid, unsigned int point_index, hb_position_t *x, hb_position_t *y, void*) { - FT_Face face = (FT_Face) font_data; - FT_Error error; - bool ret = false; - - error = FT_Load_Glyph (face, gid, FT_LOAD_NO_SCALE); - if (!error) { - if (face->glyph->format == FT_GLYPH_FORMAT_OUTLINE) { - if (point_index < (unsigned int) face->glyph->outline.n_points) { - *x = face->glyph->outline.points[point_index].x; - *y = face->glyph->outline.points[point_index].y; - ret = true; - } - } - } + FT_Face face = (FT_Face) font_data; + FT_Error error; + bool ret = false; + + error = FT_Load_Glyph (face, gid, FT_LOAD_NO_SCALE); + if (!error) { + if (face->glyph->format == FT_GLYPH_FORMAT_OUTLINE) { + if (point_index < (unsigned int) face->glyph->outline.n_points) { + *x = face->glyph->outline.points[point_index].x; + *y = face->glyph->outline.points[point_index].y; + ret = true; + } + } + } - return ret; + return ret; } static hb_bool_t _get_glyph_name(hb_font_t *, void *font_data, hb_codepoint_t gid, char *name, unsigned int size, void *) { - FT_Face face = (FT_Face) font_data; - bool ret = false; + FT_Face face = (FT_Face) font_data; + bool ret = false; - ret = !FT_Get_Glyph_Name (face, gid, name, size); - if (ret && (size && !*name)) - ret = false; + ret = !FT_Get_Glyph_Name (face, gid, name, size); + if (ret && (size && !*name)) + ret = false; - return ret; + return ret; } static hb_font_funcs_t * _get_font_funcs(void) { - static hb_font_funcs_t* funcs = hb_font_funcs_create(); + static hb_font_funcs_t* funcs = hb_font_funcs_create(); - hb_font_funcs_set_glyph_func (funcs, _get_glyph, NULL, NULL); - hb_font_funcs_set_glyph_h_advance_func (funcs, _get_glyph_h_advance, NULL, NULL); - hb_font_funcs_set_glyph_v_advance_func (funcs, _get_glyph_v_advance, NULL, NULL); - hb_font_funcs_set_glyph_h_origin_func (funcs, _get_glyph_h_origin, NULL, NULL); - hb_font_funcs_set_glyph_v_origin_func (funcs, _get_glyph_v_origin, NULL, NULL); - hb_font_funcs_set_glyph_h_kerning_func (funcs, _get_glyph_h_kerning, NULL, NULL); - hb_font_funcs_set_glyph_v_kerning_func (funcs, _get_glyph_v_kerning, NULL, NULL); - hb_font_funcs_set_glyph_extents_func (funcs, _get_glyph_extents, NULL, NULL); - hb_font_funcs_set_glyph_contour_point_func (funcs, _get_glyph_contour_point, NULL, NULL); - hb_font_funcs_set_glyph_name_func (funcs, _get_glyph_name, NULL, NULL); + hb_font_funcs_set_glyph_func (funcs, _get_glyph, NULL, NULL); + hb_font_funcs_set_glyph_h_advance_func (funcs, _get_glyph_h_advance, NULL, NULL); + hb_font_funcs_set_glyph_v_advance_func (funcs, _get_glyph_v_advance, NULL, NULL); + hb_font_funcs_set_glyph_h_origin_func (funcs, _get_glyph_h_origin, NULL, NULL); + hb_font_funcs_set_glyph_v_origin_func (funcs, _get_glyph_v_origin, NULL, NULL); + hb_font_funcs_set_glyph_h_kerning_func (funcs, _get_glyph_h_kerning, NULL, NULL); + hb_font_funcs_set_glyph_v_kerning_func (funcs, _get_glyph_v_kerning, NULL, NULL); + hb_font_funcs_set_glyph_extents_func (funcs, _get_glyph_extents, NULL, NULL); + hb_font_funcs_set_glyph_contour_point_func (funcs, _get_glyph_contour_point, NULL, NULL); + hb_font_funcs_set_glyph_name_func (funcs, _get_glyph_name, NULL, NULL); - return funcs; + return funcs; } static hb_blob_t * _get_table(hb_face_t *, hb_tag_t tag, void *user_data) { - FT_Face face = (FT_Face) user_data; - FT_ULong length = 0; - FT_Byte *table; - FT_Error error; - hb_blob_t* blob = NULL; - - error = FT_Load_Sfnt_Table(face, tag, 0, NULL, &length); - if (!error) { - table = (FT_Byte *) xmalloc(length * sizeof(char)); - if (table != NULL) { - error = FT_Load_Sfnt_Table(face, tag, 0, (FT_Byte*)table, &length); - if (!error) { - blob = hb_blob_create((const char*) table, length, HB_MEMORY_MODE_WRITABLE, table, free); - } else { - free(table); - } - } - } + FT_Face face = (FT_Face) user_data; + FT_ULong length = 0; + FT_Byte *table; + FT_Error error; + hb_blob_t* blob = NULL; + + error = FT_Load_Sfnt_Table(face, tag, 0, NULL, &length); + if (!error) { + table = (FT_Byte *) xmalloc(length * sizeof(char)); + if (table != NULL) { + error = FT_Load_Sfnt_Table(face, tag, 0, (FT_Byte*)table, &length); + if (!error) { + blob = hb_blob_create((const char*) table, length, HB_MEMORY_MODE_WRITABLE, table, free); + } else { + free(table); + } + } + } return blob; } @@ -288,76 +292,79 @@ _get_table(hb_face_t *, hb_tag_t tag, void *user_data) void XeTeXFontInst::initialize(const char* pathname, int index, int &status) { - TT_Postscript *postTable; - TT_OS2* os2Table; - FT_Error error; - hb_face_t *hbFace; - - if (!gFreeTypeLibrary) { - error = FT_Init_FreeType(&gFreeTypeLibrary); - if (error) { - fprintf(stderr, "FreeType initialization failed! (%d)\n", error); - exit(1); - } - } - - error = FT_New_Face(gFreeTypeLibrary, (char*)pathname, index, &ftFace); - if (error) { + TT_Postscript *postTable; + TT_OS2* os2Table; + FT_Error error; + hb_face_t *hbFace; + + if (!gFreeTypeLibrary) { + error = FT_Init_FreeType(&gFreeTypeLibrary); + if (error) { + fprintf(stderr, "FreeType initialization failed! (%d)\n", error); + exit(1); + } + } + + error = FT_New_Face(gFreeTypeLibrary, (char*)pathname, index, &ftFace); + if (error) { + status = 1; + return; + } + + if (!FT_IS_SCALABLE(ftFace)) { status = 1; return; } - if (!FT_IS_SCALABLE(ftFace)) { - status = 1; - return; - } - - /* for non-sfnt-packaged fonts (presumably Type 1), see if there is an AFM file we can attach */ - if (index == 0 && !FT_IS_SFNT(ftFace)) { - char* afm = new char[strlen((const char*)pathname) + 5]; // room to append ".afm" - strcpy(afm, (const char*)pathname); - char* p = strrchr(afm, '.'); - if (p == NULL || strlen(p) != 4 || tolower(*(p+1)) != 'p' || tolower(*(p+2)) != 'f') - strcat(afm, ".afm"); // append .afm if the extension didn't seem to be .pf[ab] - else - strcpy(p, ".afm"); // else replace extension with .afm - FT_Attach_File(ftFace, afm); // ignore error code; AFM might not exist - delete[] afm; - } - - char buf[20]; - if (index > 0) - sprintf(buf, ":%d", index); - else - buf[0] = 0; - fFilename = new char[strlen(pathname) + 2 + strlen(buf) + 1]; - sprintf(fFilename, "[%s%s]", pathname, buf); - fUnitsPerEM = ftFace->units_per_EM; - fAscent = unitsToPoints(ftFace->ascender); - fDescent = unitsToPoints(ftFace->descender); - - postTable = (TT_Postscript *) getFontTable(ft_sfnt_post); - if (postTable != NULL) { - fItalicAngle = Fix2D(postTable->italicAngle); - } - - os2Table = (TT_OS2*) getFontTable(ft_sfnt_os2); - if (os2Table) { - fCapHeight = unitsToPoints(os2Table->sCapHeight); - fXHeight = unitsToPoints(os2Table->sxHeight); - } - - // Set up HarfBuzz font - hbFace = hb_face_create_for_tables(_get_table, ftFace, NULL); - hb_face_set_index(hbFace, index); - hb_face_set_upem(hbFace, fUnitsPerEM); - hbFont = hb_font_create(hbFace); - hb_face_destroy(hbFace); - - hb_font_set_funcs(hbFont, _get_font_funcs(), ftFace, NULL); - hb_font_set_scale(hbFont, fUnitsPerEM, fUnitsPerEM); - // We don’t want device tables adjustments - hb_font_set_ppem(hbFont, 0, 0); + /* for non-sfnt-packaged fonts (presumably Type 1), see if there is an AFM file we can attach */ + if (index == 0 && !FT_IS_SFNT(ftFace)) { + char* afm = new char[strlen((const char*)pathname) + 5]; // room to append ".afm" + strcpy(afm, (const char*)pathname); + char* p = strrchr(afm, '.'); + if (p == NULL || strlen(p) != 4 || tolower(*(p+1)) != 'p' || tolower(*(p+2)) != 'f') + strcat(afm, ".afm"); // append .afm if the extension didn't seem to be .pf[ab] + else + strcpy(p, ".afm"); // else replace extension with .afm + FT_Attach_File(ftFace, afm); // ignore error code; AFM might not exist + delete[] afm; + } + + char buf[20]; + if (index > 0) + sprintf(buf, ":%d", index); + else + buf[0] = 0; + fFilename = new char[strlen(pathname) + 2 + strlen(buf) + 1]; + sprintf(fFilename, "[%s%s]", pathname, buf); + fUnitsPerEM = ftFace->units_per_EM; + fAscent = unitsToPoints(ftFace->ascender); + fDescent = unitsToPoints(ftFace->descender); + + postTable = (TT_Postscript *) getFontTable(ft_sfnt_post); + if (postTable != NULL) { + fItalicAngle = Fix2D(postTable->italicAngle); + } + + os2Table = (TT_OS2*) getFontTable(ft_sfnt_os2); + if (os2Table) { + fCapHeight = unitsToPoints(os2Table->sCapHeight); + fXHeight = unitsToPoints(os2Table->sxHeight); + } + + // Set up HarfBuzz font + hbFace = hb_face_create_for_tables(_get_table, ftFace, NULL); + hb_face_set_index(hbFace, index); + hb_face_set_upem(hbFace, fUnitsPerEM); + hbFont = hb_font_create(hbFace); + hb_face_destroy(hbFace); + + if (hbFontFuncs == NULL) + hbFontFuncs = _get_font_funcs(); + + hb_font_set_funcs(hbFont, hbFontFuncs, ftFace, NULL); + hb_font_set_scale(hbFont, fUnitsPerEM, fUnitsPerEM); + // We don’t want device tables adjustments + hb_font_set_ppem(hbFont, 0, 0); return; } @@ -365,25 +372,25 @@ XeTeXFontInst::initialize(const char* pathname, int index, int &status) void XeTeXFontInst::setLayoutDirVertical(bool vertical) { - fVertical = vertical; + fVertical = vertical; } const void * XeTeXFontInst::getFontTable(OTTag tag) const { - FT_ULong tmpLength = 0; - FT_Error error = FT_Load_Sfnt_Table(ftFace, tag, 0, NULL, &tmpLength); - if (error) - return NULL; - - void* table = xmalloc(tmpLength * sizeof(char)); - if (table != NULL) { - error = FT_Load_Sfnt_Table(ftFace, tag, 0, (FT_Byte*)table, &tmpLength); - if (error) { - free((void *) table); - return NULL; - } - } + FT_ULong tmpLength = 0; + FT_Error error = FT_Load_Sfnt_Table(ftFace, tag, 0, NULL, &tmpLength); + if (error) + return NULL; + + void* table = xmalloc(tmpLength * sizeof(char)); + if (table != NULL) { + error = FT_Load_Sfnt_Table(ftFace, tag, 0, (FT_Byte*)table, &tmpLength); + if (error) { + free((void *) table); + return NULL; + } + } return table; } @@ -391,136 +398,136 @@ XeTeXFontInst::getFontTable(OTTag tag) const const char * XeTeXFontInst::getMathTable() { - if (fMath == NULL) - fMath = (const char*) getFontTable(MATH_TAG); - return fMath; + if (fMath == NULL) + fMath = (const char*) getFontTable(MATH_TAG); + return fMath; } const void * XeTeXFontInst::getFontTable(FT_Sfnt_Tag tag) const { - return FT_Get_Sfnt_Table(ftFace, tag); + return FT_Get_Sfnt_Table(ftFace, tag); } void XeTeXFontInst::getGlyphBounds(GlyphID gid, GlyphBBox* bbox) { - bbox->xMin = bbox->yMin = bbox->xMax = bbox->yMax = 0.0; + bbox->xMin = bbox->yMin = bbox->xMax = bbox->yMax = 0.0; - FT_Error error = FT_Load_Glyph(ftFace, gid, FT_LOAD_NO_SCALE); - if (error) - return; + FT_Error error = FT_Load_Glyph(ftFace, gid, FT_LOAD_NO_SCALE); + if (error) + return; FT_Glyph glyph; error = FT_Get_Glyph(ftFace->glyph, &glyph); - if (error == 0) { - FT_BBox ft_bbox; - FT_Glyph_Get_CBox(glyph, FT_GLYPH_BBOX_UNSCALED, &ft_bbox); - bbox->xMin = unitsToPoints(ft_bbox.xMin); - bbox->yMin = unitsToPoints(ft_bbox.yMin); - bbox->xMax = unitsToPoints(ft_bbox.xMax); - bbox->yMax = unitsToPoints(ft_bbox.yMax); - FT_Done_Glyph(glyph); - } + if (error == 0) { + FT_BBox ft_bbox; + FT_Glyph_Get_CBox(glyph, FT_GLYPH_BBOX_UNSCALED, &ft_bbox); + bbox->xMin = unitsToPoints(ft_bbox.xMin); + bbox->yMin = unitsToPoints(ft_bbox.yMin); + bbox->xMax = unitsToPoints(ft_bbox.xMax); + bbox->yMax = unitsToPoints(ft_bbox.yMax); + FT_Done_Glyph(glyph); + } } GlyphID XeTeXFontInst::mapCharToGlyph(UChar32 ch) const { - return FT_Get_Char_Index(ftFace, ch); + return FT_Get_Char_Index(ftFace, ch); } uint16_t XeTeXFontInst::getNumGlyphs() const { - return ftFace->num_glyphs; + return ftFace->num_glyphs; } float XeTeXFontInst::getGlyphWidth(GlyphID gid) { - return unitsToPoints(_get_glyph_advance(ftFace, gid, false)); + return unitsToPoints(_get_glyph_advance(ftFace, gid, false)); } void XeTeXFontInst::getGlyphHeightDepth(GlyphID gid, float* ht, float* dp) { - GlyphBBox bbox; - getGlyphBounds(gid, &bbox); + GlyphBBox bbox; + getGlyphBounds(gid, &bbox); - if (ht) - *ht = bbox.yMax; - if (dp) - *dp = -bbox.yMin; + if (ht) + *ht = bbox.yMax; + if (dp) + *dp = -bbox.yMin; } void XeTeXFontInst::getGlyphSidebearings(GlyphID gid, float* lsb, float* rsb) { - float width = getGlyphWidth(gid); + float width = getGlyphWidth(gid); - GlyphBBox bbox; - getGlyphBounds(gid, &bbox); + GlyphBBox bbox; + getGlyphBounds(gid, &bbox); - if (lsb) - *lsb = bbox.xMin; - if (rsb) - *rsb = width - bbox.xMax; + if (lsb) + *lsb = bbox.xMin; + if (rsb) + *rsb = width - bbox.xMax; } float XeTeXFontInst::getGlyphItalCorr(GlyphID gid) { - float rval = 0.0; + float rval = 0.0; + + float width = getGlyphWidth(gid); - float width = getGlyphWidth(gid); + GlyphBBox bbox; + getGlyphBounds(gid, &bbox); - GlyphBBox bbox; - getGlyphBounds(gid, &bbox); - - if (bbox.xMax > width) - rval = bbox.xMax - width; - - return rval; + if (bbox.xMax > width) + rval = bbox.xMax - width; + + return rval; } GlyphID XeTeXFontInst::mapGlyphToIndex(const char* glyphName) const { - return FT_Get_Name_Index(ftFace, const_cast<char*>(glyphName)); + return FT_Get_Name_Index(ftFace, const_cast<char*>(glyphName)); } const char* XeTeXFontInst::getGlyphName(GlyphID gid, int& nameLen) { - if (FT_HAS_GLYPH_NAMES(ftFace)) { - static char buffer[256]; - FT_Get_Glyph_Name(ftFace, gid, buffer, 256); - nameLen = strlen(buffer); - return &buffer[0]; - } - else { - nameLen = 0; - return NULL; - } + if (FT_HAS_GLYPH_NAMES(ftFace)) { + static char buffer[256]; + FT_Get_Glyph_Name(ftFace, gid, buffer, 256); + nameLen = strlen(buffer); + return &buffer[0]; + } + else { + nameLen = 0; + return NULL; + } } UChar32 XeTeXFontInst::getFirstCharCode() { - FT_UInt gindex; - return FT_Get_First_Char(ftFace, &gindex); + FT_UInt gindex; + return FT_Get_First_Char(ftFace, &gindex); } UChar32 XeTeXFontInst::getLastCharCode() { - FT_UInt gindex; - UChar32 ch = FT_Get_First_Char(ftFace, &gindex); - UChar32 prev = ch; - while (gindex != 0) { - prev = ch; - ch = FT_Get_Next_Char(ftFace, ch, &gindex); - } - return prev; + FT_UInt gindex; + UChar32 ch = FT_Get_First_Char(ftFace, &gindex); + UChar32 prev = ch; + while (gindex != 0) { + prev = ch; + ch = FT_Get_Next_Char(ftFace, ch, &gindex); + } + return prev; } diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontInst.h b/Build/source/texk/web2c/xetexdir/XeTeXFontInst.h index 119f42808a9..49e0cbe58d9 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeXFontInst.h +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontInst.h @@ -35,8 +35,8 @@ authorization from the copyright holders. * * created on: 2005-10-22 * created by: Jonathan Kew - * - * originally based on PortableFontInstance.h from ICU + * + * originally based on PortableFontInstance.h from ICU */ @@ -57,72 +57,72 @@ authorization from the copyright holders. class XeTeXFontInst { protected: - unsigned short fUnitsPerEM; - float fPointSize; - float fAscent; - float fDescent; - float fCapHeight; - float fXHeight; - float fItalicAngle; + unsigned short fUnitsPerEM; + float fPointSize; + float fAscent; + float fDescent; + float fCapHeight; + float fXHeight; + float fItalicAngle; - bool fVertical; // false = horizontal, true = vertical + bool fVertical; // false = horizontal, true = vertical - char *fFilename; // actually holds [filename:index], as used in xetex + char *fFilename; // actually holds [filename:index], as used in xetex - FT_Face ftFace; - hb_font_t* hbFont; - const char *fMath; + FT_Face ftFace; + hb_font_t* hbFont; + const char *fMath; public: - XeTeXFontInst(float pointSize, int &status); - XeTeXFontInst(const char* filename, int index, float pointSize, int &status); + XeTeXFontInst(float pointSize, int &status); + XeTeXFontInst(const char* filename, int index, float pointSize, int &status); + + virtual ~XeTeXFontInst(); - virtual ~XeTeXFontInst(); + void initialize(const char* pathname, int index, int &status); - void initialize(const char* pathname, int index, int &status); + const void *getFontTable(OTTag tableTag) const; + const void *getFontTable(FT_Sfnt_Tag tableTag) const; + const char *getMathTable(); - const void *getFontTable(OTTag tableTag) const; - const void *getFontTable(FT_Sfnt_Tag tableTag) const; - const char *getMathTable(); + const char *getFilename() const { return fFilename; } + hb_font_t *getHbFont() const { return hbFont; } + void setLayoutDirVertical(bool vertical); + bool getLayoutDirVertical() const { return fVertical; }; - const char *getFilename() const { return fFilename; } - hb_font_t *getHbFont() const { return hbFont; } - void setLayoutDirVertical(bool vertical); - bool getLayoutDirVertical() const { return fVertical; }; + float getPointSize() const { return fPointSize; }; + float getAscent() const { return fAscent; } + float getDescent() const { return fDescent; } + float getCapHeight() const { return fCapHeight; } + float getXHeight() const { return fXHeight; } + float getItalicAngle() const { return fItalicAngle; } - float getPointSize() const { return fPointSize; }; - float getAscent() const { return fAscent; } - float getDescent() const { return fDescent; } - float getCapHeight() const { return fCapHeight; } - float getXHeight() const { return fXHeight; } - float getItalicAngle() const { return fItalicAngle; } + GlyphID mapCharToGlyph(UChar32 ch) const; + GlyphID mapGlyphToIndex(const char* glyphName) const; - GlyphID mapCharToGlyph(UChar32 ch) const; - GlyphID mapGlyphToIndex(const char* glyphName) const; + uint16_t getNumGlyphs() const; - uint16_t getNumGlyphs() const; + void getGlyphBounds(GlyphID glyph, GlyphBBox* bbox); - void getGlyphBounds(GlyphID glyph, GlyphBBox* bbox); + float getGlyphWidth(GlyphID glyph); + void getGlyphHeightDepth(GlyphID glyph, float *ht, float* dp); + void getGlyphSidebearings(GlyphID glyph, float* lsb, float* rsb); + float getGlyphItalCorr(GlyphID glyph); - float getGlyphWidth(GlyphID glyph); - void getGlyphHeightDepth(GlyphID glyph, float *ht, float* dp); - void getGlyphSidebearings(GlyphID glyph, float* lsb, float* rsb); - float getGlyphItalCorr(GlyphID glyph); + const char* getGlyphName(GlyphID gid, int& nameLen); - const char* getGlyphName(GlyphID gid, int& nameLen); - - UChar32 getFirstCharCode(); - UChar32 getLastCharCode(); + UChar32 getFirstCharCode(); + UChar32 getLastCharCode(); - float unitsToPoints(float units) const - { - return (units * fPointSize) / (float) fUnitsPerEM; - } + float unitsToPoints(float units) const + { + return (units * fPointSize) / (float) fUnitsPerEM; + } - float pointsToUnits(float points) const - { - return (points * (float) fUnitsPerEM) / fPointSize; - } + float pointsToUnits(float points) const + { + return (points * (float) fUnitsPerEM) / fPointSize; + } }; #endif diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.cpp b/Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.cpp index 895e5432f36..b79ba144dc7 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.cpp +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.cpp @@ -55,15 +55,15 @@ XeTeXFontInst_Mac::XeTeXFontInst_Mac(CTFontDescriptorRef descriptor, float point , fDescriptor(descriptor) , fFontRef(0) { - initialize(status); + initialize(status); } XeTeXFontInst_Mac::~XeTeXFontInst_Mac() { - if (fDescriptor != 0) - CFRelease(fDescriptor); - if (fFontRef != 0) - CFRelease(fFontRef); + if (fDescriptor != 0) + CFRelease(fDescriptor); + if (fFontRef != 0) + CFRelease(fFontRef); } void @@ -74,29 +74,29 @@ XeTeXFontInst_Mac::initialize(int &status) return; } - if (status != 0) - fDescriptor = 0; + if (status != 0) + fDescriptor = 0; - // Create a copy of original font descriptor with font cascading (fallback) disabled - CFArrayRef emptyCascadeList = CFArrayCreate(NULL, NULL, 0, &kCFTypeArrayCallBacks); - const void* values[] = { emptyCascadeList }; - static const void* attributeKeys[] = { kCTFontCascadeListAttribute }; - CFDictionaryRef attributes = CFDictionaryCreate(NULL, attributeKeys, values, 1, - &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); - CFRelease(emptyCascadeList); + // Create a copy of original font descriptor with font cascading (fallback) disabled + CFArrayRef emptyCascadeList = CFArrayCreate(NULL, NULL, 0, &kCFTypeArrayCallBacks); + const void* values[] = { emptyCascadeList }; + static const void* attributeKeys[] = { kCTFontCascadeListAttribute }; + CFDictionaryRef attributes = CFDictionaryCreate(NULL, attributeKeys, values, 1, + &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); + CFRelease(emptyCascadeList); - fDescriptor = CTFontDescriptorCreateCopyWithAttributes(fDescriptor, attributes); - CFRelease(attributes); - fFontRef = CTFontCreateWithFontDescriptor(fDescriptor, fPointSize * 72.0 / 72.27, NULL); - if (fFontRef) { - char *pathname; - int index; - pathname = getFileNameFromCTFont(fFontRef, &index); + fDescriptor = CTFontDescriptorCreateCopyWithAttributes(fDescriptor, attributes); + CFRelease(attributes); + fFontRef = CTFontCreateWithFontDescriptor(fDescriptor, fPointSize * 72.0 / 72.27, NULL); + if (fFontRef) { + char *pathname; + int index; + pathname = getFileNameFromCTFont(fFontRef, &index); - XeTeXFontInst::initialize(pathname, index, status); - } else { - status = 1; - CFRelease(fDescriptor); - fDescriptor = 0; - } + XeTeXFontInst::initialize(pathname, index, status); + } else { + status = 1; + CFRelease(fDescriptor); + fDescriptor = 0; + } } diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.h b/Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.h index 293613a517b..875414b942f 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.h +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.h @@ -49,15 +49,15 @@ authorization from the copyright holders. class XeTeXFontInst_Mac : public XeTeXFontInst { protected: - CTFontDescriptorRef fDescriptor; - CTFontRef fFontRef; + CTFontDescriptorRef fDescriptor; + CTFontRef fFontRef; public: - XeTeXFontInst_Mac(CTFontDescriptorRef descriptor, float pointSize, int &status); + XeTeXFontInst_Mac(CTFontDescriptorRef descriptor, float pointSize, int &status); - virtual ~XeTeXFontInst_Mac(); + virtual ~XeTeXFontInst_Mac(); - virtual void initialize(int &status); + virtual void initialize(int &status); }; #endif diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr.cpp b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr.cpp index 27eb5782d2e..dcc4a2fba46 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr.cpp +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr.cpp @@ -45,17 +45,19 @@ extern "C" { #endif #include "XeTeXFontInst.h" +#include <hb-ot.h> + extern "C" { extern Fixed loadedfontdesignsize; } // functions from the Pascal/WEB side extern "C" { - void zprintnl(int s); - void zprintchar(int c); - void begindiagnostic(); - void zenddiagnostic(int nl); - int gettracingfontsstate(); + void zprintnl(int s); + void zprintchar(int c); + void begindiagnostic(); + void zenddiagnostic(int nl); + int gettracingfontsstate(); }; // see cpascal.h @@ -66,7 +68,7 @@ extern "C" { zprintchar(*(ch_ptr++)); \ } while (0) -XeTeXFontMgr* XeTeXFontMgr::sFontManager = NULL; +XeTeXFontMgr* XeTeXFontMgr::sFontManager = NULL; char XeTeXFontMgr::sReqEngine = 0; /* use our own fmax function because it seems to be missing on certain platforms @@ -74,606 +76,607 @@ char XeTeXFontMgr::sReqEngine = 0; static inline double my_fmax(double x, double y) { - return (x > y) ? x : y; + return (x > y) ? x : y; } XeTeXFontMgr* XeTeXFontMgr::GetFontManager() { - if (sFontManager == NULL) { + if (sFontManager == NULL) { #ifdef XETEX_MAC - sFontManager = new XeTeXFontMgr_Mac; + sFontManager = new XeTeXFontMgr_Mac; #else - sFontManager = new XeTeXFontMgr_FC; + sFontManager = new XeTeXFontMgr_FC; #endif - sFontManager->initialize(); - } - - return sFontManager; + sFontManager->initialize(); + } + + return sFontManager; } void XeTeXFontMgr::Terminate() { - if (sFontManager != NULL) { - sFontManager->terminate(); - // we don't actually deallocate the manager, just ask it to clean up - // any auxiliary data such as the cocoa pool or freetype/fontconfig stuff - // as we still need to access font names after this is called - } + if (sFontManager != NULL) { + sFontManager->terminate(); + // we don't actually deallocate the manager, just ask it to clean up + // any auxiliary data such as the cocoa pool or freetype/fontconfig stuff + // as we still need to access font names after this is called + } } PlatformFontRef XeTeXFontMgr::findFont(const char* name, char* variant, double ptSize) - // ptSize is in TeX points, or negative for 'scaled' factor - // "variant" string will be shortened (in-place) by removal of /B and /I if present + // ptSize is in TeX points, or negative for 'scaled' factor + // "variant" string will be shortened (in-place) by removal of /B and /I if present { - std::string nameStr(name); - Font* font = NULL; - int dsize = 100; - loadedfontdesignsize = 655360L; - - for (int pass = 0; pass < 2; ++pass) { - // try full name as given - std::map<std::string,Font*>::iterator i = nameToFont.find(nameStr); - if (i != nameToFont.end()) { - font = i->second; - if (font->opSizeInfo.designSize != 0) - dsize = font->opSizeInfo.designSize; - break; - } - - // if there's a hyphen, split there and try Family-Style - int hyph = nameStr.find('-'); - if (hyph > 0 && hyph < nameStr.length() - 1) { - std::string family(nameStr.begin(), nameStr.begin() + hyph); - std::map<std::string,Family*>::iterator f = nameToFamily.find(family); - if (f != nameToFamily.end()) { - std::string style(nameStr.begin() + hyph + 1, nameStr.end()); - i = f->second->styles->find(style); - if (i != f->second->styles->end()) { - font = i->second; - if (font->opSizeInfo.designSize != 0) - dsize = font->opSizeInfo.designSize; - break; - } - } - } - - // try as PostScript name - i = psNameToFont.find(nameStr); - if (i != psNameToFont.end()) { - font = i->second; - if (font->opSizeInfo.designSize != 0) - dsize = font->opSizeInfo.designSize; - break; - } - - // try for the name as a family name - std::map<std::string,Family*>::iterator f = nameToFamily.find(nameStr); - - if (f != nameToFamily.end()) { - // look for a family member with the "regular" bit set in OS/2 - int regFonts = 0; - for (i = f->second->styles->begin(); i != f->second->styles->end(); ++i) - if (i->second->isReg) { - if (regFonts == 0) - font = i->second; - ++regFonts; - } - - // families with Ornament or similar fonts may flag those as Regular, - // which confuses the search above... so try some known names - if (font == NULL || regFonts > 1) { - // try for style "Regular", "Plain", "Normal", "Roman" - i = f->second->styles->find("Regular"); - if (i != f->second->styles->end()) - font = i->second; - else { - i = f->second->styles->find("Plain"); - if (i != f->second->styles->end()) - font = i->second; - else { - i = f->second->styles->find("Normal"); - if (i != f->second->styles->end()) - font = i->second; - else { - i = f->second->styles->find("Roman"); - if (i != f->second->styles->end()) - font = i->second; - } - } - } - } - - if (font == NULL) { - // look through the family for the (weight, width, slant) nearest to (80, 100, 0) - font = bestMatchFromFamily(f->second, 80, 100, 0); - } - - if (font != NULL) - break; - } - - if (pass == 0) { - // didn't find it in our caches, so do a platform search (may be relatively expensive); - // this will update the caches with any fonts that seem to match the name given, - // so that the second pass might find it - searchForHostPlatformFonts(nameStr); - } - } - - if (font == NULL) - return 0; - - Family* parent = font->parent; - - // if there are variant requests, try to apply them - // and delete B, I, and S=... codes from the string, just retain /engine option - sReqEngine = 0; - bool reqBold = false; - bool reqItal = false; - if (variant != NULL) { - std::string varString; - char* cp = variant; - while (*cp) { - if (strncmp(cp, "AAT", 3) == 0) { - sReqEngine = 'A'; - cp += 3; - if (varString.length() > 0 && *(varString.end() - 1) != '/') - varString.append("/"); - varString.append("AAT"); - goto skip_to_slash; - } - if (strncmp(cp, "ICU", 3) == 0) { // for backword compatability - sReqEngine = 'O'; - cp += 3; - if (varString.length() > 0 && *(varString.end() - 1) != '/') - varString.append("/"); - varString.append("OT"); - goto skip_to_slash; - } - if (strncmp(cp, "OT", 2) == 0) { - sReqEngine = 'O'; - cp += 2; - if (varString.length() > 0 && *(varString.end() - 1) != '/') - varString.append("/"); - varString.append("OT"); - goto skip_to_slash; - } - if (strncmp(cp, "GR", 2) == 0) { - sReqEngine = 'G'; - cp += 2; - if (varString.length() > 0 && *(varString.end() - 1) != '/') - varString.append("/"); - varString.append("GR"); - goto skip_to_slash; - } - if (*cp == 'S') { - char* start = cp; - ++cp; - if (*cp == '=') - ++cp; - ptSize = 0.0; - while (*cp >= '0' && *cp <= '9') { - ptSize = ptSize * 10 + *cp - '0'; - ++cp; - } - if (*cp == '.') { - double dec = 1.0; - ++cp; - while (*cp >= '0' && *cp <= '9') { - dec = dec * 10.0; - ptSize = ptSize + (*cp - '0') / dec; - ++cp; - } - } - goto skip_to_slash; - } - - /* if the code is "B" or "I", we skip putting it in varString */ - while (1) { - if (*cp == 'B') { - reqBold = true; - ++cp; - continue; - } - if (*cp == 'I') { - reqItal = true; - ++cp; - continue; - } - break; - } - - skip_to_slash: - while (*cp && *cp != '/') - ++cp; - if (*cp == '/') - ++cp; - } - strcpy(variant, varString.c_str()); - - std::map<std::string,Font*>::iterator i; - if (reqItal) { - Font* bestMatch = font; - if (font->slant < parent->maxSlant) - // try for a face with more slant - bestMatch = bestMatchFromFamily(parent, font->weight, font->width, parent->maxSlant); - - if (bestMatch == font && font->slant > parent->minSlant) - // maybe the slant is negated, or maybe this was something like "Times-Italic/I" - bestMatch = bestMatchFromFamily(parent, font->weight, font->width, parent->minSlant); - - if (parent->minWeight == parent->maxWeight && bestMatch->isBold != font->isBold) { - // try again using the bold flag, as we can't trust weight values - Font* newBest = NULL; - for (i = parent->styles->begin(); i != parent->styles->end(); ++i) { - if (i->second->isBold == font->isBold) { - if (newBest == NULL && i->second->isItalic != font->isItalic) { - newBest = i->second; - break; - } - } - } - if (newBest != NULL) - bestMatch = newBest; - } - - if (bestMatch == font) { - // maybe slant values weren't present; try the style bits as a fallback - bestMatch = NULL; - for (i = parent->styles->begin(); i != parent->styles->end(); ++i) - if (i->second->isItalic == !font->isItalic) - if (parent->minWeight != parent->maxWeight) { - // weight info was available, so try to match that - if (bestMatch == NULL || weightAndWidthDiff(i->second, font) < weightAndWidthDiff(bestMatch, font)) - bestMatch = i->second; - } - else { - // no weight info, so try matching style bits - if (bestMatch == NULL && i->second->isBold == font->isBold) { - bestMatch = i->second; - break; // found a match, no need to look further as we can't distinguish! - } - } - } - if (bestMatch != NULL) - font = bestMatch; - } - - if (reqBold) { - // try for more boldness, with the same width and slant - Font* bestMatch = font; - if (font->weight < parent->maxWeight) { - // try to increase weight by 1/2 x (max - min), rounding up - bestMatch = bestMatchFromFamily(parent, - font->weight + (parent->maxWeight - parent->minWeight) / 2 + 1, - font->width, font->slant); - if (parent->minSlant == parent->maxSlant) { - // double-check the italic flag, as we can't trust slant values - Font* newBest = NULL; - for (i = parent->styles->begin(); i != parent->styles->end(); ++i) { - if (i->second->isItalic == font->isItalic) { - if (newBest == NULL || weightAndWidthDiff(i->second, bestMatch) < weightAndWidthDiff(newBest, bestMatch)) - newBest = i->second; - } - } - if (newBest != NULL) - bestMatch = newBest; - } - } - if (bestMatch == font && !font->isBold) { - for (i = parent->styles->begin(); i != parent->styles->end(); ++i) { - if (i->second->isItalic == font->isItalic && i->second->isBold) { - bestMatch = i->second; - break; - } - } - } - font = bestMatch; - } - } - - // if there's optical size info, try to apply it - if (ptSize < 0.0) - ptSize = dsize / 10.0; - if (font != NULL && font->opSizeInfo.subFamilyID != 0 && ptSize > 0.0) { - ptSize = ptSize * 10.0; // convert to decipoints for comparison with the opSize values - double bestMismatch = my_fmax(font->opSizeInfo.minSize - ptSize, ptSize - font->opSizeInfo.maxSize); - if (bestMismatch > 0.0) { - Font* bestMatch = font; - for (std::map<std::string,Font*>::iterator i = parent->styles->begin(); i != parent->styles->end(); ++i) { - if (i->second->opSizeInfo.subFamilyID != font->opSizeInfo.subFamilyID) - continue; - double mismatch = my_fmax(i->second->opSizeInfo.minSize - ptSize, ptSize - i->second->opSizeInfo.maxSize); - if (mismatch < bestMismatch) { - bestMatch = i->second; - bestMismatch = mismatch; - } - if (bestMismatch <= 0.0) - break; - } - font = bestMatch; - } - } - - if (font != NULL && font->opSizeInfo.designSize != 0) - loadedfontdesignsize = (font->opSizeInfo.designSize << 16L) / 10; - - if (gettracingfontsstate() > 0) { - begindiagnostic(); - zprintnl(' '); - printcstring("-> "); - printcstring(getPlatformFontDesc(font->fontRef).c_str()); - zenddiagnostic(0); - } - - return font->fontRef; + std::string nameStr(name); + Font* font = NULL; + int dsize = 100; + loadedfontdesignsize = 655360L; + + for (int pass = 0; pass < 2; ++pass) { + // try full name as given + std::map<std::string,Font*>::iterator i = nameToFont.find(nameStr); + if (i != nameToFont.end()) { + font = i->second; + if (font->opSizeInfo.designSize != 0) + dsize = font->opSizeInfo.designSize; + break; + } + + // if there's a hyphen, split there and try Family-Style + int hyph = nameStr.find('-'); + if (hyph > 0 && hyph < nameStr.length() - 1) { + std::string family(nameStr.begin(), nameStr.begin() + hyph); + std::map<std::string,Family*>::iterator f = nameToFamily.find(family); + if (f != nameToFamily.end()) { + std::string style(nameStr.begin() + hyph + 1, nameStr.end()); + i = f->second->styles->find(style); + if (i != f->second->styles->end()) { + font = i->second; + if (font->opSizeInfo.designSize != 0) + dsize = font->opSizeInfo.designSize; + break; + } + } + } + + // try as PostScript name + i = psNameToFont.find(nameStr); + if (i != psNameToFont.end()) { + font = i->second; + if (font->opSizeInfo.designSize != 0) + dsize = font->opSizeInfo.designSize; + break; + } + + // try for the name as a family name + std::map<std::string,Family*>::iterator f = nameToFamily.find(nameStr); + + if (f != nameToFamily.end()) { + // look for a family member with the "regular" bit set in OS/2 + int regFonts = 0; + for (i = f->second->styles->begin(); i != f->second->styles->end(); ++i) + if (i->second->isReg) { + if (regFonts == 0) + font = i->second; + ++regFonts; + } + + // families with Ornament or similar fonts may flag those as Regular, + // which confuses the search above... so try some known names + if (font == NULL || regFonts > 1) { + // try for style "Regular", "Plain", "Normal", "Roman" + i = f->second->styles->find("Regular"); + if (i != f->second->styles->end()) + font = i->second; + else { + i = f->second->styles->find("Plain"); + if (i != f->second->styles->end()) + font = i->second; + else { + i = f->second->styles->find("Normal"); + if (i != f->second->styles->end()) + font = i->second; + else { + i = f->second->styles->find("Roman"); + if (i != f->second->styles->end()) + font = i->second; + } + } + } + } + + if (font == NULL) { + // look through the family for the (weight, width, slant) nearest to (80, 100, 0) + font = bestMatchFromFamily(f->second, 80, 100, 0); + } + + if (font != NULL) + break; + } + + if (pass == 0) { + // didn't find it in our caches, so do a platform search (may be relatively expensive); + // this will update the caches with any fonts that seem to match the name given, + // so that the second pass might find it + searchForHostPlatformFonts(nameStr); + } + } + + if (font == NULL) + return 0; + + Family* parent = font->parent; + + // if there are variant requests, try to apply them + // and delete B, I, and S=... codes from the string, just retain /engine option + sReqEngine = 0; + bool reqBold = false; + bool reqItal = false; + if (variant != NULL) { + std::string varString; + char* cp = variant; + while (*cp) { + if (strncmp(cp, "AAT", 3) == 0) { + sReqEngine = 'A'; + cp += 3; + if (varString.length() > 0 && *(varString.end() - 1) != '/') + varString.append("/"); + varString.append("AAT"); + goto skip_to_slash; + } + if (strncmp(cp, "ICU", 3) == 0) { // for backword compatability + sReqEngine = 'O'; + cp += 3; + if (varString.length() > 0 && *(varString.end() - 1) != '/') + varString.append("/"); + varString.append("OT"); + goto skip_to_slash; + } + if (strncmp(cp, "OT", 2) == 0) { + sReqEngine = 'O'; + cp += 2; + if (varString.length() > 0 && *(varString.end() - 1) != '/') + varString.append("/"); + varString.append("OT"); + goto skip_to_slash; + } + if (strncmp(cp, "GR", 2) == 0) { + sReqEngine = 'G'; + cp += 2; + if (varString.length() > 0 && *(varString.end() - 1) != '/') + varString.append("/"); + varString.append("GR"); + goto skip_to_slash; + } + if (*cp == 'S') { + char* start = cp; + ++cp; + if (*cp == '=') + ++cp; + ptSize = 0.0; + while (*cp >= '0' && *cp <= '9') { + ptSize = ptSize * 10 + *cp - '0'; + ++cp; + } + if (*cp == '.') { + double dec = 1.0; + ++cp; + while (*cp >= '0' && *cp <= '9') { + dec = dec * 10.0; + ptSize = ptSize + (*cp - '0') / dec; + ++cp; + } + } + goto skip_to_slash; + } + + /* if the code is "B" or "I", we skip putting it in varString */ + while (1) { + if (*cp == 'B') { + reqBold = true; + ++cp; + continue; + } + if (*cp == 'I') { + reqItal = true; + ++cp; + continue; + } + break; + } + + skip_to_slash: + while (*cp && *cp != '/') + ++cp; + if (*cp == '/') + ++cp; + } + strcpy(variant, varString.c_str()); + + std::map<std::string,Font*>::iterator i; + if (reqItal) { + Font* bestMatch = font; + if (font->slant < parent->maxSlant) + // try for a face with more slant + bestMatch = bestMatchFromFamily(parent, font->weight, font->width, parent->maxSlant); + + if (bestMatch == font && font->slant > parent->minSlant) + // maybe the slant is negated, or maybe this was something like "Times-Italic/I" + bestMatch = bestMatchFromFamily(parent, font->weight, font->width, parent->minSlant); + + if (parent->minWeight == parent->maxWeight && bestMatch->isBold != font->isBold) { + // try again using the bold flag, as we can't trust weight values + Font* newBest = NULL; + for (i = parent->styles->begin(); i != parent->styles->end(); ++i) { + if (i->second->isBold == font->isBold) { + if (newBest == NULL && i->second->isItalic != font->isItalic) { + newBest = i->second; + break; + } + } + } + if (newBest != NULL) + bestMatch = newBest; + } + + if (bestMatch == font) { + // maybe slant values weren't present; try the style bits as a fallback + bestMatch = NULL; + for (i = parent->styles->begin(); i != parent->styles->end(); ++i) { + if (i->second->isItalic == !font->isItalic) { + if (parent->minWeight != parent->maxWeight) { + // weight info was available, so try to match that + if (bestMatch == NULL || weightAndWidthDiff(i->second, font) < weightAndWidthDiff(bestMatch, font)) + bestMatch = i->second; + } else { + // no weight info, so try matching style bits + if (bestMatch == NULL && i->second->isBold == font->isBold) { + bestMatch = i->second; + break; // found a match, no need to look further as we can't distinguish! + } + } + } + } + } + if (bestMatch != NULL) + font = bestMatch; + } + + if (reqBold) { + // try for more boldness, with the same width and slant + Font* bestMatch = font; + if (font->weight < parent->maxWeight) { + // try to increase weight by 1/2 x (max - min), rounding up + bestMatch = bestMatchFromFamily(parent, + font->weight + (parent->maxWeight - parent->minWeight) / 2 + 1, + font->width, font->slant); + if (parent->minSlant == parent->maxSlant) { + // double-check the italic flag, as we can't trust slant values + Font* newBest = NULL; + for (i = parent->styles->begin(); i != parent->styles->end(); ++i) { + if (i->second->isItalic == font->isItalic) { + if (newBest == NULL || weightAndWidthDiff(i->second, bestMatch) < weightAndWidthDiff(newBest, bestMatch)) + newBest = i->second; + } + } + if (newBest != NULL) + bestMatch = newBest; + } + } + if (bestMatch == font && !font->isBold) { + for (i = parent->styles->begin(); i != parent->styles->end(); ++i) { + if (i->second->isItalic == font->isItalic && i->second->isBold) { + bestMatch = i->second; + break; + } + } + } + font = bestMatch; + } + } + + // if there's optical size info, try to apply it + if (ptSize < 0.0) + ptSize = dsize / 10.0; + if (font != NULL && font->opSizeInfo.subFamilyID != 0 && ptSize > 0.0) { + ptSize = ptSize * 10.0; // convert to decipoints for comparison with the opSize values + double bestMismatch = my_fmax(font->opSizeInfo.minSize - ptSize, ptSize - font->opSizeInfo.maxSize); + if (bestMismatch > 0.0) { + Font* bestMatch = font; + for (std::map<std::string,Font*>::iterator i = parent->styles->begin(); i != parent->styles->end(); ++i) { + if (i->second->opSizeInfo.subFamilyID != font->opSizeInfo.subFamilyID) + continue; + double mismatch = my_fmax(i->second->opSizeInfo.minSize - ptSize, ptSize - i->second->opSizeInfo.maxSize); + if (mismatch < bestMismatch) { + bestMatch = i->second; + bestMismatch = mismatch; + } + if (bestMismatch <= 0.0) + break; + } + font = bestMatch; + } + } + + if (font != NULL && font->opSizeInfo.designSize != 0) + loadedfontdesignsize = (font->opSizeInfo.designSize << 16L) / 10; + + if (gettracingfontsstate() > 0) { + begindiagnostic(); + zprintnl(' '); + printcstring("-> "); + printcstring(getPlatformFontDesc(font->fontRef).c_str()); + zenddiagnostic(0); + } + + return font->fontRef; } const char* XeTeXFontMgr::getFullName(PlatformFontRef font) const { - std::map<PlatformFontRef,Font*>::const_iterator i = platformRefToFont.find(font); - if (i == platformRefToFont.end()) - die("internal error %d in XeTeXFontMgr", 2); - if (i->second->fullName != NULL) - return i->second->fullName->c_str(); - else - return i->second->psName->c_str(); + std::map<PlatformFontRef,Font*>::const_iterator i = platformRefToFont.find(font); + if (i == platformRefToFont.end()) + die("internal error %d in XeTeXFontMgr", 2); + if (i->second->fullName != NULL) + return i->second->fullName->c_str(); + else + return i->second->psName->c_str(); } void XeTeXFontMgr::getNames(PlatformFontRef font, const char** psName, - const char** famName, const char** styName) const + const char** famName, const char** styName) const { - std::map<PlatformFontRef,Font*>::const_iterator i = platformRefToFont.find(font); - if (i == platformRefToFont.end()) - die("internal error %d in XeTeXFontMgr", 3); - *psName = i->second->psName->c_str(); - *famName = i->second->familyName->c_str(); - *styName = i->second->styleName->c_str(); + std::map<PlatformFontRef,Font*>::const_iterator i = platformRefToFont.find(font); + if (i == platformRefToFont.end()) + die("internal error %d in XeTeXFontMgr", 3); + *psName = xstrdup(i->second->psName->c_str()); + *famName = xstrdup(i->second->familyName->c_str()); + *styName = xstrdup(i->second->styleName->c_str()); } int XeTeXFontMgr::weightAndWidthDiff(const Font* a, const Font* b) const { - if (a->weight == 0 && a->width == 0) { - // assume there was no OS/2 info - if (a->isBold == b->isBold) - return 0; - else - return 10000; - } - - int widDiff = labs(a->width - b->width); - if (widDiff < 10) - widDiff *= 50; - - return labs(a->weight - b->weight) + widDiff; + if (a->weight == 0 && a->width == 0) { + // assume there was no OS/2 info + if (a->isBold == b->isBold) + return 0; + else + return 10000; + } + + int widDiff = labs(a->width - b->width); + if (widDiff < 10) + widDiff *= 50; + + return labs(a->weight - b->weight) + widDiff; } int XeTeXFontMgr::styleDiff(const Font* a, int wt, int wd, int slant) const { - int widDiff = labs(a->width - wd); - if (widDiff < 10) - widDiff *= 200; - - return labs(labs(a->slant) - labs(slant)) * 2 + labs(a->weight - wt) + widDiff; + int widDiff = labs(a->width - wd); + if (widDiff < 10) + widDiff *= 200; + + return labs(labs(a->slant) - labs(slant)) * 2 + labs(a->weight - wt) + widDiff; } XeTeXFontMgr::Font* XeTeXFontMgr::bestMatchFromFamily(const Family* fam, int wt, int wd, int slant) const { - Font* bestMatch = NULL; - for (std::map<std::string,Font*>::iterator s = fam->styles->begin(); s != fam->styles->end(); ++s) - if (bestMatch == NULL || styleDiff(s->second, wt, wd, slant) < styleDiff(bestMatch, wt, wd, slant)) - bestMatch = s->second; - return bestMatch; + Font* bestMatch = NULL; + for (std::map<std::string,Font*>::iterator s = fam->styles->begin(); s != fam->styles->end(); ++s) + if (bestMatch == NULL || styleDiff(s->second, wt, wd, slant) < styleDiff(bestMatch, wt, wd, slant)) + bestMatch = s->second; + return bestMatch; } const XeTeXFontMgr::OpSizeRec* XeTeXFontMgr::getOpSize(XeTeXFont font) { - hb_font_t* hbFont = ((XeTeXFontInst*)font)->getHbFont(); - if (hbFont != NULL) { - hb_face_t* face = hb_font_get_face(hbFont); - OpSizeRec* pSizeRec = (OpSizeRec*) xmalloc(sizeof(OpSizeRec)); - - bool ok = hb_ot_layout_get_size_params(face, - &pSizeRec->designSize, - &pSizeRec->subFamilyID, - &pSizeRec->nameCode, - &pSizeRec->minSize, - &pSizeRec->maxSize); - - if (ok) - return pSizeRec; - - free(pSizeRec); - return NULL; - } - - return NULL; + hb_font_t* hbFont = ((XeTeXFontInst*)font)->getHbFont(); + if (hbFont != NULL) { + hb_face_t* face = hb_font_get_face(hbFont); + OpSizeRec* pSizeRec = (OpSizeRec*) xmalloc(sizeof(OpSizeRec)); + + bool ok = hb_ot_layout_get_size_params(face, + &pSizeRec->designSize, + &pSizeRec->subFamilyID, + &pSizeRec->nameCode, + &pSizeRec->minSize, + &pSizeRec->maxSize); + + if (ok) + return pSizeRec; + + free(pSizeRec); + return NULL; + } + + return NULL; } double XeTeXFontMgr::getDesignSize(XeTeXFont font) { - const OpSizeRec* pSizeRec = getOpSize(font); - if (pSizeRec != NULL) - return pSizeRec->designSize / 10.0; - else - return 10.0; + const OpSizeRec* pSizeRec = getOpSize(font); + if (pSizeRec != NULL) + return pSizeRec->designSize / 10.0; + else + return 10.0; } void XeTeXFontMgr::getOpSizeRecAndStyleFlags(Font* theFont) { - XeTeXFont font = createFont(theFont->fontRef, 655360); - XeTeXFontInst* fontInst = (XeTeXFontInst*) font; - if (font != 0) { - const OpSizeRec* pSizeRec = getOpSize(font); - if (pSizeRec != NULL) { - theFont->opSizeInfo.designSize = pSizeRec->designSize; - if (pSizeRec->subFamilyID == 0 - && pSizeRec->nameCode == 0 - && pSizeRec->minSize == 0 - && pSizeRec->maxSize == 0) - goto done_size; // feature is valid, but no 'size' range - theFont->opSizeInfo.subFamilyID = pSizeRec->subFamilyID; - theFont->opSizeInfo.nameCode = pSizeRec->nameCode; - theFont->opSizeInfo.minSize = pSizeRec->minSize; - theFont->opSizeInfo.maxSize = pSizeRec->maxSize; - } - done_size: - - const TT_OS2* os2Table = (TT_OS2*) fontInst->getFontTable(ft_sfnt_os2); - if (os2Table != NULL) { - theFont->weight = os2Table->usWeightClass; - theFont->width = os2Table->usWidthClass; - uint16_t sel = os2Table->fsSelection; - theFont->isReg = (sel & (1 << 6)) != 0; - theFont->isBold = (sel & (1 << 5)) != 0; - theFont->isItalic = (sel & (1 << 0)) != 0; - } - - const TT_Header* headTable = (TT_Header*) fontInst->getFontTable(ft_sfnt_head); - if (headTable != NULL) { - uint16_t ms = headTable->Mac_Style; - if ((ms & (1 << 0)) != 0) - theFont->isBold = true; - if ((ms & (1 << 1)) != 0) - theFont->isItalic = true; - } - - const TT_Postscript* postTable = (const TT_Postscript*) fontInst->getFontTable(ft_sfnt_post); - if (postTable != NULL) { - theFont->slant = (int)(1000 * (tan(Fix2D(-postTable->italicAngle) * M_PI / 180.0))); - } - deleteFont(font); - } + XeTeXFont font = createFont(theFont->fontRef, 655360); + XeTeXFontInst* fontInst = (XeTeXFontInst*) font; + if (font != 0) { + const OpSizeRec* pSizeRec = getOpSize(font); + if (pSizeRec != NULL) { + theFont->opSizeInfo.designSize = pSizeRec->designSize; + if (pSizeRec->subFamilyID == 0 + && pSizeRec->nameCode == 0 + && pSizeRec->minSize == 0 + && pSizeRec->maxSize == 0) + goto done_size; // feature is valid, but no 'size' range + theFont->opSizeInfo.subFamilyID = pSizeRec->subFamilyID; + theFont->opSizeInfo.nameCode = pSizeRec->nameCode; + theFont->opSizeInfo.minSize = pSizeRec->minSize; + theFont->opSizeInfo.maxSize = pSizeRec->maxSize; + } + done_size: + + const TT_OS2* os2Table = (TT_OS2*) fontInst->getFontTable(ft_sfnt_os2); + if (os2Table != NULL) { + theFont->weight = os2Table->usWeightClass; + theFont->width = os2Table->usWidthClass; + uint16_t sel = os2Table->fsSelection; + theFont->isReg = (sel & (1 << 6)) != 0; + theFont->isBold = (sel & (1 << 5)) != 0; + theFont->isItalic = (sel & (1 << 0)) != 0; + } + + const TT_Header* headTable = (TT_Header*) fontInst->getFontTable(ft_sfnt_head); + if (headTable != NULL) { + uint16_t ms = headTable->Mac_Style; + if ((ms & (1 << 0)) != 0) + theFont->isBold = true; + if ((ms & (1 << 1)) != 0) + theFont->isItalic = true; + } + + const TT_Postscript* postTable = (const TT_Postscript*) fontInst->getFontTable(ft_sfnt_post); + if (postTable != NULL) { + theFont->slant = (int)(1000 * (tan(Fix2D(-postTable->italicAngle) * M_PI / 180.0))); + } + deleteFont(font); + } } // append a name but only if it's not already in the list void XeTeXFontMgr::appendToList(std::list<std::string>* list, const char* str) { - for (std::list<std::string>::const_iterator i = list->begin(); i != list->end(); ++i) - if (*i == str) - return; - list->push_back(str); + for (std::list<std::string>::const_iterator i = list->begin(); i != list->end(); ++i) + if (*i == str) + return; + list->push_back(str); } // prepend a name, removing it from later in the list if present void XeTeXFontMgr::prependToList(std::list<std::string>* list, const char* str) { - for (std::list<std::string>::iterator i = list->begin(); i != list->end(); ++i) - if (*i == str) { - list->erase(i); - break; - } - list->push_front(str); + for (std::list<std::string>::iterator i = list->begin(); i != list->end(); ++i) + if (*i == str) { + list->erase(i); + break; + } + list->push_front(str); } void XeTeXFontMgr::addToMaps(PlatformFontRef platformFont, const NameCollection* names) { - if (platformRefToFont.find(platformFont) != platformRefToFont.end()) - return; // this font has already been cached - - if (names->psName.length() == 0) - return; // can't use a font that lacks a PostScript name - - if (psNameToFont.find(names->psName) != psNameToFont.end()) - return; // duplicates an earlier PS name, so skip - - Font* thisFont = new Font(platformFont); - thisFont->psName = new std::string(names->psName); - getOpSizeRecAndStyleFlags(thisFont); - - psNameToFont[names->psName] = thisFont; - platformRefToFont[platformFont] = thisFont; - - if (names->fullNames.size() > 0) - thisFont->fullName = new std::string(*(names->fullNames.begin())); - - if (names->familyNames.size() > 0) - thisFont->familyName = new std::string(*(names->familyNames.begin())); - else - thisFont->familyName = new std::string(names->psName); - - if (names->styleNames.size() > 0) - thisFont->styleName = new std::string(*(names->styleNames.begin())); - else - thisFont->styleName = new std::string; - - std::list<std::string>::const_iterator i; - for (i = names->familyNames.begin(); i != names->familyNames.end(); ++i) { - std::map<std::string,Family*>::iterator iFam = nameToFamily.find(*i); - Family* family; - if (iFam == nameToFamily.end()) { - family = new Family; - nameToFamily[*i] = family; - family->minWeight = thisFont->weight; - family->maxWeight = thisFont->weight; - family->minWidth = thisFont->width; - family->maxWidth = thisFont->width; - family->minSlant = thisFont->slant; - family->maxSlant = thisFont->slant; - } else { - family = iFam->second; - if (thisFont->weight < family->minWeight) - family->minWeight = thisFont->weight; - if (thisFont->weight > family->maxWeight) - family->maxWeight = thisFont->weight; - if (thisFont->width < family->minWidth) - family->minWidth = thisFont->width; - if (thisFont->width > family->maxWidth) - family->maxWidth = thisFont->width; - if (thisFont->slant < family->minSlant) - family->minSlant = thisFont->slant; - if (thisFont->slant > family->maxSlant) - family->maxSlant = thisFont->slant; - } - - if (thisFont->parent == NULL) - thisFont->parent = family; - - // ensure all style names in the family point to thisFont - for (std::list<std::string>::const_iterator j = names->styleNames.begin(); j != names->styleNames.end(); ++j) { - std::map<std::string,Font*>::iterator iFont = family->styles->find(*j); - if (iFont == family->styles->end()) - (*family->styles)[*j] = thisFont; + if (platformRefToFont.find(platformFont) != platformRefToFont.end()) + return; // this font has already been cached + + if (names->psName.length() == 0) + return; // can't use a font that lacks a PostScript name + + if (psNameToFont.find(names->psName) != psNameToFont.end()) + return; // duplicates an earlier PS name, so skip + + Font* thisFont = new Font(platformFont); + thisFont->psName = new std::string(names->psName); + getOpSizeRecAndStyleFlags(thisFont); + + psNameToFont[names->psName] = thisFont; + platformRefToFont[platformFont] = thisFont; + + if (names->fullNames.size() > 0) + thisFont->fullName = new std::string(*(names->fullNames.begin())); + + if (names->familyNames.size() > 0) + thisFont->familyName = new std::string(*(names->familyNames.begin())); + else + thisFont->familyName = new std::string(names->psName); + + if (names->styleNames.size() > 0) + thisFont->styleName = new std::string(*(names->styleNames.begin())); + else + thisFont->styleName = new std::string; + + std::list<std::string>::const_iterator i; + for (i = names->familyNames.begin(); i != names->familyNames.end(); ++i) { + std::map<std::string,Family*>::iterator iFam = nameToFamily.find(*i); + Family* family; + if (iFam == nameToFamily.end()) { + family = new Family; + nameToFamily[*i] = family; + family->minWeight = thisFont->weight; + family->maxWeight = thisFont->weight; + family->minWidth = thisFont->width; + family->maxWidth = thisFont->width; + family->minSlant = thisFont->slant; + family->maxSlant = thisFont->slant; + } else { + family = iFam->second; + if (thisFont->weight < family->minWeight) + family->minWeight = thisFont->weight; + if (thisFont->weight > family->maxWeight) + family->maxWeight = thisFont->weight; + if (thisFont->width < family->minWidth) + family->minWidth = thisFont->width; + if (thisFont->width > family->maxWidth) + family->maxWidth = thisFont->width; + if (thisFont->slant < family->minSlant) + family->minSlant = thisFont->slant; + if (thisFont->slant > family->maxSlant) + family->maxSlant = thisFont->slant; + } + + if (thisFont->parent == NULL) + thisFont->parent = family; + + // ensure all style names in the family point to thisFont + for (std::list<std::string>::const_iterator j = names->styleNames.begin(); j != names->styleNames.end(); ++j) { + std::map<std::string,Font*>::iterator iFont = family->styles->find(*j); + if (iFont == family->styles->end()) + (*family->styles)[*j] = thisFont; /* - else if (iFont->second != thisFont) - fprintf(stderr, "# Font name warning: ambiguous Style \"%s\" in Family \"%s\" (PSNames \"%s\" and \"%s\")\n", - j->c_str(), i->c_str(), iFont->second->psName->c_str(), thisFont->psName->c_str()); + else if (iFont->second != thisFont) + fprintf(stderr, "# Font name warning: ambiguous Style \"%s\" in Family \"%s\" (PSNames \"%s\" and \"%s\")\n", + j->c_str(), i->c_str(), iFont->second->psName->c_str(), thisFont->psName->c_str()); */ - } - } - - for (i = names->fullNames.begin(); i != names->fullNames.end(); ++i) { - std::map<std::string,Font*>::iterator iFont = nameToFont.find(*i); - if (iFont == nameToFont.end()) - nameToFont[*i] = thisFont; + } + } + + for (i = names->fullNames.begin(); i != names->fullNames.end(); ++i) { + std::map<std::string,Font*>::iterator iFont = nameToFont.find(*i); + if (iFont == nameToFont.end()) + nameToFont[*i] = thisFont; /* - else if (iFont->second != thisFont) - fprintf(stderr, "# Font name warning: ambiguous FullName \"%s\" (PSNames \"%s\" and \"%s\")\n", - i->c_str(), iFont->second->psName->c_str(), thisFont->psName->c_str()); + else if (iFont->second != thisFont) + fprintf(stderr, "# Font name warning: ambiguous FullName \"%s\" (PSNames \"%s\" and \"%s\")\n", + i->c_str(), iFont->second->psName->c_str(), thisFont->psName->c_str()); */ - } + } } void XeTeXFontMgr::die(const char*s, int i) const { - fprintf(stderr, s, i); - fprintf(stderr, " - exiting\n"); - exit(3); + fprintf(stderr, s, i); + fprintf(stderr, " - exiting\n"); + exit(3); } void diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr.h b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr.h index 599fbe97d47..1535eff9db3 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr.h +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr.h @@ -41,14 +41,14 @@ typedef CTFontDescriptorRef PlatformFontRef; #include <fontconfig/fontconfig.h> #include <ft2build.h> #include FT_FREETYPE_H -typedef FcPattern* PlatformFontRef; +typedef FcPattern* PlatformFontRef; #endif #include "XeTeX_ext.h" #include "XeTeXLayoutInterface.h" -#ifdef __cplusplus /* allow inclusion in plain C files just to get the typedefs above */ +#ifdef __cplusplus /* allow inclusion in plain C files just to get the typedefs above */ #include <string> #include <map> @@ -58,151 +58,151 @@ typedef FcPattern* PlatformFontRef; class XeTeXFontMgr { public: - static XeTeXFontMgr* GetFontManager(); - // returns the global fontmanager (creating it if necessary) - static void Terminate(); - // clean up (may be required if using the cocoa implementation) + static XeTeXFontMgr* GetFontManager(); + // returns the global fontmanager (creating it if necessary) + static void Terminate(); + // clean up (may be required if using the cocoa implementation) - PlatformFontRef findFont(const char* name, char* variant, double ptSize); - // 1st arg is name as specified by user (C string, UTF-8) - // 2nd is /B/I/AAT/OT/ICU/GR/S=## qualifiers - // 1. try name given as "full name" - // 2. if there's a hyphen, split and try "family-style" - // 3. try as PostScript name - // 4. try name as family with "Regular/Plain/Normal" style - // apply style qualifiers and optical sizing if present + PlatformFontRef findFont(const char* name, char* variant, double ptSize); + // 1st arg is name as specified by user (C string, UTF-8) + // 2nd is /B/I/AAT/OT/ICU/GR/S=## qualifiers + // 1. try name given as "full name" + // 2. if there's a hyphen, split and try "family-style" + // 3. try as PostScript name + // 4. try name as family with "Regular/Plain/Normal" style + // apply style qualifiers and optical sizing if present - // SIDE EFFECT: sets sReqEngine to 'A' or 'O' or 'G' if appropriate, - // else clears it to 0 + // SIDE EFFECT: sets sReqEngine to 'A' or 'O' or 'G' if appropriate, + // else clears it to 0 - // SIDE EFFECT: updates TeX variables /nameoffile/ and /namelength/, - // to match the actual font found + // SIDE EFFECT: updates TeX variables /nameoffile/ and /namelength/, + // to match the actual font found - // SIDE EFFECT: edits /variant/ string in-place removing /B or /I - - const char* getFullName(PlatformFontRef font) const; - // return the full name of the font, suitable for use in XeTeX source - // without requiring style qualifiers + // SIDE EFFECT: edits /variant/ string in-place removing /B or /I - void getNames(PlatformFontRef font, const char** psName, - const char** famName, const char** styName) const; - // return Postscript, family, and style names, for use in .xdv + const char* getFullName(PlatformFontRef font) const; + // return the full name of the font, suitable for use in XeTeX source + // without requiring style qualifiers - double getDesignSize(XeTeXFont font); + void getNames(PlatformFontRef font, const char** psName, + const char** famName, const char** styName) const; + // return Postscript, family, and style names, for use in .xdv - char getReqEngine() const { return sReqEngine; }; - // return the requested rendering technology for the most recent findFont - // or 0 if no specific technology was requested + double getDesignSize(XeTeXFont font); - void setReqEngine(char reqEngine) const { sReqEngine = reqEngine; }; + char getReqEngine() const { return sReqEngine; }; + // return the requested rendering technology for the most recent findFont + // or 0 if no specific technology was requested + + void setReqEngine(char reqEngine) const { sReqEngine = reqEngine; }; protected: - static XeTeXFontMgr* sFontManager; - static char sReqEngine; - - XeTeXFontMgr() - { } - virtual ~XeTeXFontMgr() - { } - - virtual void initialize() = 0; - virtual void terminate(); - - virtual std::string getPlatformFontDesc(PlatformFontRef font) const = 0; - - class Font; - class Family; - - struct OpSizeRec { - unsigned int designSize; - unsigned int subFamilyID; - unsigned int nameCode; - unsigned int minSize; - unsigned int maxSize; - }; - - class Font { - public: - Font(PlatformFontRef ref) - : fullName(NULL), psName(NULL), familyName(NULL), styleName(NULL) - , parent(NULL) - , fontRef(ref), weight(0), width(0), slant(0) - , isReg(false), isBold(false), isItalic(false) - { opSizeInfo.subFamilyID = 0; - opSizeInfo.designSize = 100; } /* default to 10bp */ - ~Font() - { delete fullName; delete psName; } - - std::string* fullName; - std::string* psName; - std::string* familyName; // default family and style names that should locate this font - std::string* styleName; - Family* parent; - PlatformFontRef fontRef; - OpSizeRec opSizeInfo; - uint16_t weight; - uint16_t width; - int16_t slant; - bool isReg; - bool isBold; - bool isItalic; - }; - - class Family { - public: - Family() - : minWeight(0), maxWeight(0) - , minWidth(0), maxWidth(0) - , minSlant(0), maxSlant(0) - { - styles = new std::map<std::string,Font*>; - } - ~Family() - { - delete styles; - } - - std::map<std::string,Font*>* styles; - uint16_t minWeight; - uint16_t maxWeight; - uint16_t minWidth; - uint16_t maxWidth; - int16_t minSlant; - int16_t maxSlant; - }; - - class NameCollection { - public: - std::list<std::string> familyNames; - std::list<std::string> styleNames; - std::list<std::string> fullNames; - std::string psName; - std::string subFamily; - }; - - std::map<std::string,Font*> nameToFont; // maps full name (as used in TeX source) to font record - std::map<std::string,Family*> nameToFamily; - std::map<PlatformFontRef,Font*> platformRefToFont; - std::map<std::string,Font*> psNameToFont; // maps PS name (as used in .xdv) to font record - - int weightAndWidthDiff(const Font* a, const Font* b) const; - int styleDiff(const Font* a, int wt, int wd, int slant) const; - Font* bestMatchFromFamily(const Family* fam, int wt, int wd, int slant) const; - void appendToList(std::list<std::string>* list, const char* str); - void prependToList(std::list<std::string>* list, const char* str); - void addToMaps(PlatformFontRef platformFont, const NameCollection* names); - - const OpSizeRec* getOpSize(XeTeXFont font); - - virtual void getOpSizeRecAndStyleFlags(Font* theFont); - virtual void searchForHostPlatformFonts(const std::string& name) = 0; - - virtual NameCollection* readNames(PlatformFontRef fontRef) = 0; - - void die(const char*s, int i) const; /* for fatal internal errors! */ + static XeTeXFontMgr* sFontManager; + static char sReqEngine; + + XeTeXFontMgr() + { } + virtual ~XeTeXFontMgr() + { } + + virtual void initialize() = 0; + virtual void terminate(); + + virtual std::string getPlatformFontDesc(PlatformFontRef font) const = 0; + + class Font; + class Family; + + struct OpSizeRec { + unsigned int designSize; + unsigned int subFamilyID; + unsigned int nameCode; + unsigned int minSize; + unsigned int maxSize; + }; + + class Font { + public: + Font(PlatformFontRef ref) + : fullName(NULL), psName(NULL), familyName(NULL), styleName(NULL) + , parent(NULL) + , fontRef(ref), weight(0), width(0), slant(0) + , isReg(false), isBold(false), isItalic(false) + { opSizeInfo.subFamilyID = 0; + opSizeInfo.designSize = 100; } /* default to 10bp */ + ~Font() + { delete fullName; delete psName; } + + std::string* fullName; + std::string* psName; + std::string* familyName; // default family and style names that should locate this font + std::string* styleName; + Family* parent; + PlatformFontRef fontRef; + OpSizeRec opSizeInfo; + uint16_t weight; + uint16_t width; + int16_t slant; + bool isReg; + bool isBold; + bool isItalic; + }; + + class Family { + public: + Family() + : minWeight(0), maxWeight(0) + , minWidth(0), maxWidth(0) + , minSlant(0), maxSlant(0) + { + styles = new std::map<std::string,Font*>; + } + ~Family() + { + delete styles; + } + + std::map<std::string,Font*>* styles; + uint16_t minWeight; + uint16_t maxWeight; + uint16_t minWidth; + uint16_t maxWidth; + int16_t minSlant; + int16_t maxSlant; + }; + + class NameCollection { + public: + std::list<std::string> familyNames; + std::list<std::string> styleNames; + std::list<std::string> fullNames; + std::string psName; + std::string subFamily; + }; + + std::map<std::string,Font*> nameToFont; // maps full name (as used in TeX source) to font record + std::map<std::string,Family*> nameToFamily; + std::map<PlatformFontRef,Font*> platformRefToFont; + std::map<std::string,Font*> psNameToFont; // maps PS name (as used in .xdv) to font record + + int weightAndWidthDiff(const Font* a, const Font* b) const; + int styleDiff(const Font* a, int wt, int wd, int slant) const; + Font* bestMatchFromFamily(const Family* fam, int wt, int wd, int slant) const; + void appendToList(std::list<std::string>* list, const char* str); + void prependToList(std::list<std::string>* list, const char* str); + void addToMaps(PlatformFontRef platformFont, const NameCollection* names); + + const OpSizeRec* getOpSize(XeTeXFont font); + + virtual void getOpSizeRecAndStyleFlags(Font* theFont); + virtual void searchForHostPlatformFonts(const std::string& name) = 0; + + virtual NameCollection* readNames(PlatformFontRef fontRef) = 0; + + void die(const char*s, int i) const; /* for fatal internal errors! */ }; -#endif /* __cplusplus */ +#endif /* __cplusplus */ -#endif /* __XETEX_FONT_MANAGER_H */ +#endif /* __XETEX_FONT_MANAGER_H */ diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_FC.cpp b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_FC.cpp index f7c64d16f4b..f7253f1faa3 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_FC.cpp +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_FC.cpp @@ -50,318 +50,320 @@ extern "C" { #include <unicode/ucnv.h> -#define kFontFamilyName 1 -#define kFontStyleName 2 -#define kFontFullName 4 -#define kPreferredFamilyName 16 -#define kPreferredSubfamilyName 17 +#define kFontFamilyName 1 +#define kFontStyleName 2 +#define kFontFullName 4 +#define kPreferredFamilyName 16 +#define kPreferredSubfamilyName 17 -static UConverter* macRomanConv = NULL; -static UConverter* utf16beConv = NULL; -static UConverter* utf8Conv = NULL; +static UConverter* macRomanConv = NULL; +static UConverter* utf16beConv = NULL; +static UConverter* utf8Conv = NULL; static char* convertToUtf8(UConverter* conv, const unsigned char* name, int len) { - char* buffer1 = NULL; - char* buffer2 = NULL; - int bufSize = -1; - - if (2 * (len + 1) > bufSize) { - if (buffer1 != NULL) { - delete[] buffer1; - delete[] buffer2; - } - bufSize = 2 * len + 100; - buffer1 = new char[bufSize]; - buffer2 = new char[bufSize]; - } - - UErrorCode status = U_ZERO_ERROR; - len = ucnv_toUChars(conv, (UChar*)buffer1, bufSize, (const char*)name, len, &status); - len = ucnv_fromUChars(utf8Conv, buffer2, bufSize, (UChar*)buffer1, len, &status); - buffer2[len] = 0; - - return buffer2; + char* buffer1 = NULL; + char* buffer2 = NULL; + int bufSize = -1; + + if (2 * (len + 1) > bufSize) { + if (buffer1 != NULL) { + delete[] buffer1; + delete[] buffer2; + } + bufSize = 2 * len + 100; + buffer1 = new char[bufSize]; + buffer2 = new char[bufSize]; + } + + UErrorCode status = U_ZERO_ERROR; + len = ucnv_toUChars(conv, (UChar*)buffer1, bufSize, (const char*)name, len, &status); + len = ucnv_fromUChars(utf8Conv, buffer2, bufSize, (UChar*)buffer1, len, &status); + buffer2[len] = 0; + + delete[] buffer1; + return buffer2; } XeTeXFontMgr::NameCollection* XeTeXFontMgr_FC::readNames(FcPattern* pat) { - NameCollection* names = new NameCollection; - - char* pathname; - if (FcPatternGetString(pat, FC_FILE, 0, (FcChar8**)&pathname) != FcResultMatch) - return names; - int index; - if (FcPatternGetInteger(pat, FC_INDEX, 0, &index) != FcResultMatch) - return names; - - FT_Face face; - if (FT_New_Face(gFreeTypeLibrary, pathname, index, &face) != 0) - return names; - - const char* name = FT_Get_Postscript_Name(face); - if (name == NULL) - return names; - names->psName = name; - - // for sfnt containers, we'll read the name table ourselves, not rely on Fontconfig - if (FT_IS_SFNT(face)) { - std::list<std::string> familyNames; - std::list<std::string> subFamilyNames; - FT_SfntName nameRec; - for (index = 0; index < FT_Get_Sfnt_Name_Count(face); ++index) { - char* utf8name = NULL; - if (FT_Get_Sfnt_Name(face, index, &nameRec) != 0) - continue; - switch (nameRec.name_id) { - case kFontFullName: - case kFontFamilyName: - case kFontStyleName: - case kPreferredFamilyName: - case kPreferredSubfamilyName: - { - bool preferredName = false; - if (nameRec.platform_id == TT_PLATFORM_MACINTOSH - && nameRec.encoding_id == TT_MAC_ID_ROMAN && nameRec.language_id == 0) { - utf8name = convertToUtf8(macRomanConv, nameRec.string, nameRec.string_len); - preferredName = true; - } - else if ((nameRec.platform_id == TT_PLATFORM_APPLE_UNICODE) - || (nameRec.platform_id == TT_PLATFORM_MICROSOFT)) - utf8name = convertToUtf8(utf16beConv, nameRec.string, nameRec.string_len); - - if (utf8name != NULL) { - std::list<std::string>* nameList = NULL; - switch (nameRec.name_id) { - case kFontFullName: - nameList = &names->fullNames; - break; - case kFontFamilyName: - nameList = &names->familyNames; - break; - case kFontStyleName: - nameList = &names->styleNames; - break; - case kPreferredFamilyName: - nameList = &familyNames; - break; - case kPreferredSubfamilyName: - nameList = &subFamilyNames; - break; - } - if (preferredName) - prependToList(nameList, utf8name); - else - appendToList(nameList, utf8name); - } - } - break; - } - } - if (familyNames.size() > 0) - names->familyNames = familyNames; - if (subFamilyNames.size() > 0) - names->styleNames = subFamilyNames; - } else { - index = 0; - while (FcPatternGetString(pat, FC_FULLNAME, index++, (FcChar8**)&name) == FcResultMatch) - appendToList(&names->fullNames, name); - index = 0; - while (FcPatternGetString(pat, FC_FAMILY, index++, (FcChar8**)&name) == FcResultMatch) - appendToList(&names->familyNames, name); - index = 0; - while (FcPatternGetString(pat, FC_STYLE, index++, (FcChar8**)&name) == FcResultMatch) - appendToList(&names->styleNames, name); - - if (names->fullNames.size() == 0) { - std::string fullName(names->familyNames.front()); - if (names->styleNames.size() > 0) { - fullName += " "; - fullName += names->styleNames.front(); - } - names->fullNames.push_back(fullName); - } - } - - FT_Done_Face(face); - - return names; + NameCollection* names = new NameCollection; + + char* pathname; + if (FcPatternGetString(pat, FC_FILE, 0, (FcChar8**)&pathname) != FcResultMatch) + return names; + int index; + if (FcPatternGetInteger(pat, FC_INDEX, 0, &index) != FcResultMatch) + return names; + + FT_Face face; + if (FT_New_Face(gFreeTypeLibrary, pathname, index, &face) != 0) + return names; + + const char* name = FT_Get_Postscript_Name(face); + if (name == NULL) + return names; + names->psName = name; + + // for sfnt containers, we'll read the name table ourselves, not rely on Fontconfig + if (FT_IS_SFNT(face)) { + std::list<std::string> familyNames; + std::list<std::string> subFamilyNames; + FT_SfntName nameRec; + for (index = 0; index < FT_Get_Sfnt_Name_Count(face); ++index) { + char* utf8name = NULL; + if (FT_Get_Sfnt_Name(face, index, &nameRec) != 0) + continue; + switch (nameRec.name_id) { + case kFontFullName: + case kFontFamilyName: + case kFontStyleName: + case kPreferredFamilyName: + case kPreferredSubfamilyName: + { + bool preferredName = false; + if (nameRec.platform_id == TT_PLATFORM_MACINTOSH + && nameRec.encoding_id == TT_MAC_ID_ROMAN && nameRec.language_id == 0) { + utf8name = convertToUtf8(macRomanConv, nameRec.string, nameRec.string_len); + preferredName = true; + } + else if ((nameRec.platform_id == TT_PLATFORM_APPLE_UNICODE) + || (nameRec.platform_id == TT_PLATFORM_MICROSOFT)) + utf8name = convertToUtf8(utf16beConv, nameRec.string, nameRec.string_len); + + if (utf8name != NULL) { + std::list<std::string>* nameList = NULL; + switch (nameRec.name_id) { + case kFontFullName: + nameList = &names->fullNames; + break; + case kFontFamilyName: + nameList = &names->familyNames; + break; + case kFontStyleName: + nameList = &names->styleNames; + break; + case kPreferredFamilyName: + nameList = &familyNames; + break; + case kPreferredSubfamilyName: + nameList = &subFamilyNames; + break; + } + if (preferredName) + prependToList(nameList, utf8name); + else + appendToList(nameList, utf8name); + delete[] utf8name; + } + } + break; + } + } + if (familyNames.size() > 0) + names->familyNames = familyNames; + if (subFamilyNames.size() > 0) + names->styleNames = subFamilyNames; + } else { + index = 0; + while (FcPatternGetString(pat, FC_FULLNAME, index++, (FcChar8**)&name) == FcResultMatch) + appendToList(&names->fullNames, name); + index = 0; + while (FcPatternGetString(pat, FC_FAMILY, index++, (FcChar8**)&name) == FcResultMatch) + appendToList(&names->familyNames, name); + index = 0; + while (FcPatternGetString(pat, FC_STYLE, index++, (FcChar8**)&name) == FcResultMatch) + appendToList(&names->styleNames, name); + + if (names->fullNames.size() == 0) { + std::string fullName(names->familyNames.front()); + if (names->styleNames.size() > 0) { + fullName += " "; + fullName += names->styleNames.front(); + } + names->fullNames.push_back(fullName); + } + } + + FT_Done_Face(face); + + return names; } void XeTeXFontMgr_FC::getOpSizeRecAndStyleFlags(Font* theFont) { - XeTeXFontMgr::getOpSizeRecAndStyleFlags(theFont); - - if (theFont->weight == 0 && theFont->width == 0) { - // try to get values from FontConfig, as it apparently wasn't an sfnt - FcPattern* pat = theFont->fontRef; - int value; - if (FcPatternGetInteger(pat, FC_WEIGHT, 0, &value) == FcResultMatch) - theFont->weight = value; - if (FcPatternGetInteger(pat, FC_WIDTH, 0, &value) == FcResultMatch) - theFont->width = value; - if (FcPatternGetInteger(pat, FC_SLANT, 0, &value) == FcResultMatch) - theFont->slant = value; - } + XeTeXFontMgr::getOpSizeRecAndStyleFlags(theFont); + + if (theFont->weight == 0 && theFont->width == 0) { + // try to get values from FontConfig, as it apparently wasn't an sfnt + FcPattern* pat = theFont->fontRef; + int value; + if (FcPatternGetInteger(pat, FC_WEIGHT, 0, &value) == FcResultMatch) + theFont->weight = value; + if (FcPatternGetInteger(pat, FC_WIDTH, 0, &value) == FcResultMatch) + theFont->width = value; + if (FcPatternGetInteger(pat, FC_SLANT, 0, &value) == FcResultMatch) + theFont->slant = value; + } } void XeTeXFontMgr_FC::cacheFamilyMembers(const std::list<std::string>& familyNames) { - if (familyNames.size() == 0) - return; - for (int f = 0; f < allFonts->nfont; ++f) { - FcPattern* pat = allFonts->fonts[f]; - if (platformRefToFont.find(pat) != platformRefToFont.end()) - continue; - char* s; - for (int i = 0; FcPatternGetString(pat, FC_FAMILY, i, (FcChar8**)&s) == FcResultMatch; ++i) { - for (std::list<std::string>::const_iterator j = familyNames.begin(); j != familyNames.end(); ++j) { - if (*j == s) { - NameCollection* names = readNames(pat); - addToMaps(pat, names); - delete names; - goto cached; - } - } - } - cached: - ; - } + if (familyNames.size() == 0) + return; + for (int f = 0; f < allFonts->nfont; ++f) { + FcPattern* pat = allFonts->fonts[f]; + if (platformRefToFont.find(pat) != platformRefToFont.end()) + continue; + char* s; + for (int i = 0; FcPatternGetString(pat, FC_FAMILY, i, (FcChar8**)&s) == FcResultMatch; ++i) { + for (std::list<std::string>::const_iterator j = familyNames.begin(); j != familyNames.end(); ++j) { + if (*j == s) { + NameCollection* names = readNames(pat); + addToMaps(pat, names); + delete names; + goto cached; + } + } + } + cached: + ; + } } void XeTeXFontMgr_FC::searchForHostPlatformFonts(const std::string& name) { - if (cachedAll) // we've already loaded everything on an earlier search - return; - - std::string famName; - int hyph = name.find('-'); - if (hyph > 0 && hyph < name.length() - 1) - famName.assign(name.begin(), name.begin() + hyph); - else - hyph = 0; - - bool found = false; - while (1) { - for (int f = 0; f < allFonts->nfont; ++f) { - restart: - FcPattern* pat = allFonts->fonts[f]; - if (platformRefToFont.find(pat) != platformRefToFont.end()) - continue; - - if (cachedAll) { - // failed to find it via FC; add everything to our maps (potentially slow) as a last resort - NameCollection* names = readNames(pat); - addToMaps(pat, names); - delete names; - continue; - } - - char* s; - int i; - for (i = 0; FcPatternGetString(pat, FC_FULLNAME, i, (FcChar8**)&s) == FcResultMatch; ++i) { - if (name == s) { - NameCollection* names = readNames(pat); - addToMaps(pat, names); - cacheFamilyMembers(names->familyNames); - delete names; - found = true; - goto next_font; - } - } - - for (i = 0; FcPatternGetString(pat, FC_FAMILY, i, (FcChar8**)&s) == FcResultMatch; ++i) { - if (name == s || (hyph && famName == s)) { - NameCollection* names = readNames(pat); - addToMaps(pat, names); - cacheFamilyMembers(names->familyNames); - delete names; - found = true; - goto next_font; - } - char* t; - for (int j = 0; FcPatternGetString(pat, FC_STYLE, j, (FcChar8**)&t) == FcResultMatch; ++j) { - std::string full(s); - full += " "; - full += t; - if (name == full) { - NameCollection* names = readNames(pat); - addToMaps(pat, names); - cacheFamilyMembers(names->familyNames); - delete names; - found = true; - goto next_font; - } - } - } - - next_font: - ; - } - - if (found || cachedAll) - break; - cachedAll = true; - } + if (cachedAll) // we've already loaded everything on an earlier search + return; + + std::string famName; + int hyph = name.find('-'); + if (hyph > 0 && hyph < name.length() - 1) + famName.assign(name.begin(), name.begin() + hyph); + else + hyph = 0; + + bool found = false; + while (1) { + for (int f = 0; f < allFonts->nfont; ++f) { + restart: + FcPattern* pat = allFonts->fonts[f]; + if (platformRefToFont.find(pat) != platformRefToFont.end()) + continue; + + if (cachedAll) { + // failed to find it via FC; add everything to our maps (potentially slow) as a last resort + NameCollection* names = readNames(pat); + addToMaps(pat, names); + delete names; + continue; + } + + char* s; + int i; + for (i = 0; FcPatternGetString(pat, FC_FULLNAME, i, (FcChar8**)&s) == FcResultMatch; ++i) { + if (name == s) { + NameCollection* names = readNames(pat); + addToMaps(pat, names); + cacheFamilyMembers(names->familyNames); + delete names; + found = true; + goto next_font; + } + } + + for (i = 0; FcPatternGetString(pat, FC_FAMILY, i, (FcChar8**)&s) == FcResultMatch; ++i) { + if (name == s || (hyph && famName == s)) { + NameCollection* names = readNames(pat); + addToMaps(pat, names); + cacheFamilyMembers(names->familyNames); + delete names; + found = true; + goto next_font; + } + char* t; + for (int j = 0; FcPatternGetString(pat, FC_STYLE, j, (FcChar8**)&t) == FcResultMatch; ++j) { + std::string full(s); + full += " "; + full += t; + if (name == full) { + NameCollection* names = readNames(pat); + addToMaps(pat, names); + cacheFamilyMembers(names->familyNames); + delete names; + found = true; + goto next_font; + } + } + } + + next_font: + ; + } + + if (found || cachedAll) + break; + cachedAll = true; + } } void XeTeXFontMgr_FC::initialize() { - if (FcInit() == FcFalse) { - fprintf(stderr, "fontconfig initialization failed!\n"); - exit(9); - } - - if (gFreeTypeLibrary == 0 && FT_Init_FreeType(&gFreeTypeLibrary) != 0) { - fprintf(stderr, "FreeType initialization failed!\n"); - exit(9); - } - - UErrorCode err = U_ZERO_ERROR; - macRomanConv = ucnv_open("macintosh", &err); - utf16beConv = ucnv_open("UTF16BE", &err); - utf8Conv = ucnv_open("UTF8", &err); - if (err != 0) { - fprintf(stderr, "internal error; cannot read font names\n"); - exit(3); - } - - FcPattern* pat = FcNameParse((const FcChar8*)":outline=true"); - FcObjectSet* os = FcObjectSetBuild(FC_FAMILY, FC_STYLE, FC_FILE, FC_INDEX, - FC_FULLNAME, FC_WEIGHT, FC_WIDTH, FC_SLANT, FC_FONTFORMAT, NULL); - allFonts = FcFontList(FcConfigGetCurrent(), pat, os); - FcObjectSetDestroy(os); - FcPatternDestroy(pat); - - cachedAll = false; + if (FcInit() == FcFalse) { + fprintf(stderr, "fontconfig initialization failed!\n"); + exit(9); + } + + if (gFreeTypeLibrary == 0 && FT_Init_FreeType(&gFreeTypeLibrary) != 0) { + fprintf(stderr, "FreeType initialization failed!\n"); + exit(9); + } + + UErrorCode err = U_ZERO_ERROR; + macRomanConv = ucnv_open("macintosh", &err); + utf16beConv = ucnv_open("UTF16BE", &err); + utf8Conv = ucnv_open("UTF8", &err); + if (err != 0) { + fprintf(stderr, "internal error; cannot read font names\n"); + exit(3); + } + + FcPattern* pat = FcNameParse((const FcChar8*)":outline=true"); + FcObjectSet* os = FcObjectSetBuild(FC_FAMILY, FC_STYLE, FC_FILE, FC_INDEX, + FC_FULLNAME, FC_WEIGHT, FC_WIDTH, FC_SLANT, FC_FONTFORMAT, NULL); + allFonts = FcFontList(FcConfigGetCurrent(), pat, os); + FcObjectSetDestroy(os); + FcPatternDestroy(pat); + + cachedAll = false; } void XeTeXFontMgr_FC::terminate() { - if (macRomanConv != NULL) - ucnv_close(macRomanConv); - if (utf16beConv != NULL) - ucnv_close(utf16beConv); - if (utf8Conv != NULL) - ucnv_close(utf8Conv); + if (macRomanConv != NULL) + ucnv_close(macRomanConv); + if (utf16beConv != NULL) + ucnv_close(utf16beConv); + if (utf8Conv != NULL) + ucnv_close(utf8Conv); } std::string XeTeXFontMgr_FC::getPlatformFontDesc(PlatformFontRef font) const { - std::string path; - FcChar8* s; - if (FcPatternGetString(font, FC_FILE, 0, (FcChar8**)&s) == FcResultMatch) - path = (char*)s; - else - path = "[unknown]"; - return path; + std::string path; + FcChar8* s; + if (FcPatternGetString(font, FC_FILE, 0, (FcChar8**)&s) == FcResultMatch) + path = (char*)s; + else + path = "[unknown]"; + return path; } diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_FC.h b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_FC.h index 6187523027e..72889b3c971 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_FC.h +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_FC.h @@ -36,30 +36,30 @@ authorization from the copyright holders. #include "XeTeXFontMgr.h" class XeTeXFontMgr_FC - : public XeTeXFontMgr + : public XeTeXFontMgr { public: - XeTeXFontMgr_FC() - { } - virtual ~XeTeXFontMgr_FC() - { } + XeTeXFontMgr_FC() + { } + virtual ~XeTeXFontMgr_FC() + { } protected: - - virtual void initialize(); - virtual void terminate(); - virtual void getOpSizeRecAndStyleFlags(Font* theFont); - virtual void searchForHostPlatformFonts(const std::string& name); - - virtual NameCollection* readNames(FcPattern* pat); + virtual void initialize(); + virtual void terminate(); - std::string getPlatformFontDesc(PlatformFontRef font) const; - - void cacheFamilyMembers(const std::list<std::string>& familyNames); + virtual void getOpSizeRecAndStyleFlags(Font* theFont); + virtual void searchForHostPlatformFonts(const std::string& name); - FcFontSet* allFonts; - bool cachedAll; + virtual NameCollection* readNames(FcPattern* pat); + + std::string getPlatformFontDesc(PlatformFontRef font) const; + + void cacheFamilyMembers(const std::list<std::string>& familyNames); + + FcFontSet* allFonts; + bool cachedAll; }; -#endif /* __XETEX_FONT_MGR_FC_H */ +#endif /* __XETEX_FONT_MGR_FC_H */ diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.h b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.h index fe19cef7c97..f6f8a824a7d 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.h +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.h @@ -39,35 +39,35 @@ authorization from the copyright holders. #include <CoreFoundation/CoreFoundation.h> class XeTeXFontMgr_Mac - : public XeTeXFontMgr + : public XeTeXFontMgr { public: - XeTeXFontMgr_Mac() - { } - virtual ~XeTeXFontMgr_Mac() - { } + XeTeXFontMgr_Mac() + { } + virtual ~XeTeXFontMgr_Mac() + { } protected: - - virtual void initialize(); - virtual void terminate(); - virtual void searchForHostPlatformFonts(const std::string& name); - - virtual NameCollection* readNames(CTFontDescriptorRef fontRef); + virtual void initialize(); + virtual void terminate(); - virtual std::string getPlatformFontDesc(PlatformFontRef font) const; + virtual void searchForHostPlatformFonts(const std::string& name); + + virtual NameCollection* readNames(CTFontDescriptorRef fontRef); + + virtual std::string getPlatformFontDesc(PlatformFontRef font) const; private: - void addFontsToCaches(CFArrayRef fonts); + void addFontsToCaches(CFArrayRef fonts); - void addFamilyToCaches(CTFontDescriptorRef familyRef); + void addFamilyToCaches(CTFontDescriptorRef familyRef); - void addFontAndSiblingsToCaches(CTFontDescriptorRef fontRef); + void addFontAndSiblingsToCaches(CTFontDescriptorRef fontRef); - void appendNameToList(CTFontRef font, - std::list<std::string>* nameList, - CFStringRef nameKey); + void appendNameToList(CTFontRef font, + std::list<std::string>* nameList, + CFStringRef nameKey); }; -#endif /* __XETEX_FONT_MGR_MAC_H */ +#endif /* __XETEX_FONT_MGR_MAC_H */ diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.mm b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.mm index 6d818a0f386..92b11245a7e 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.mm +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.mm @@ -45,168 +45,168 @@ extern "C" { CTFontDescriptorRef findFontWithName(CFStringRef name, CFStringRef key) { - CFStringRef keys[] = { key }; - CFTypeRef values[] = { name }; - CFDictionaryRef attributes = CFDictionaryCreate(NULL, (const void **) &keys, (const void **) &values, 1, - &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); - CTFontDescriptorRef descriptor = CTFontDescriptorCreateWithAttributes(attributes); - CFRelease(attributes); - - CFSetRef mandatoryAttributes = CFSetCreate(NULL, (const void **) &keys, 1, &kCFTypeSetCallBacks); - CFArrayRef matches = CTFontDescriptorCreateMatchingFontDescriptors(descriptor, mandatoryAttributes); - CFRelease(mandatoryAttributes); - CFRelease(descriptor); - - CTFontDescriptorRef matched = NULL; - if (matches) { - if (CFArrayGetCount(matches)) { - matched = (CTFontDescriptorRef) CFArrayGetValueAtIndex(matches, 0); - CFRetain(matched); - } - CFRelease(matches); - } - return matched; + CFStringRef keys[] = { key }; + CFTypeRef values[] = { name }; + CFDictionaryRef attributes = CFDictionaryCreate(NULL, (const void **) &keys, (const void **) &values, 1, + &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); + CTFontDescriptorRef descriptor = CTFontDescriptorCreateWithAttributes(attributes); + CFRelease(attributes); + + CFSetRef mandatoryAttributes = CFSetCreate(NULL, (const void **) &keys, 1, &kCFTypeSetCallBacks); + CFArrayRef matches = CTFontDescriptorCreateMatchingFontDescriptors(descriptor, mandatoryAttributes); + CFRelease(mandatoryAttributes); + CFRelease(descriptor); + + CTFontDescriptorRef matched = NULL; + if (matches) { + if (CFArrayGetCount(matches)) { + matched = (CTFontDescriptorRef) CFArrayGetValueAtIndex(matches, 0); + CFRetain(matched); + } + CFRelease(matches); + } + return matched; } void XeTeXFontMgr_Mac::appendNameToList(CTFontRef font, - std::list<std::string>* nameList, - CFStringRef nameKey) + std::list<std::string>* nameList, + CFStringRef nameKey) { - CFStringRef name = CTFontCopyName(font, nameKey); - if (name) { - appendToList(nameList, [(NSString *) name UTF8String]); - CFRelease(name); - } - CFStringRef language; - name = CTFontCopyLocalizedName(font, nameKey, &language); - if (name) { - appendToList(nameList, [(NSString *) name UTF8String]); - CFRelease(name); - } + CFStringRef name = CTFontCopyName(font, nameKey); + if (name) { + appendToList(nameList, [(NSString *) name UTF8String]); + CFRelease(name); + } + CFStringRef language; + name = CTFontCopyLocalizedName(font, nameKey, &language); + if (name) { + appendToList(nameList, [(NSString *) name UTF8String]); + CFRelease(name); + } } XeTeXFontMgr::NameCollection* XeTeXFontMgr_Mac::readNames(CTFontDescriptorRef fontRef) { - NameCollection* names = new NameCollection; + NameCollection* names = new NameCollection; - CFStringRef psName = (CFStringRef) CTFontDescriptorCopyAttribute(fontRef, kCTFontNameAttribute); - if (!psName) - return names; + CFStringRef psName = (CFStringRef) CTFontDescriptorCopyAttribute(fontRef, kCTFontNameAttribute); + if (!psName) + return names; - NSAutoreleasePool *pool = [NSAutoreleasePool new]; + NSAutoreleasePool *pool = [NSAutoreleasePool new]; - names->psName = [(NSString *) psName UTF8String]; - CFRelease(psName); + names->psName = [(NSString *) psName UTF8String]; + CFRelease(psName); - CTFontRef font = CTFontCreateWithFontDescriptor(fontRef, 0.0, 0); - appendNameToList(font, &names->fullNames, kCTFontFullNameKey); - appendNameToList(font, &names->familyNames, kCTFontFamilyNameKey); - appendNameToList(font, &names->styleNames, kCTFontStyleNameKey); - CFRelease(font); + CTFontRef font = CTFontCreateWithFontDescriptor(fontRef, 0.0, 0); + appendNameToList(font, &names->fullNames, kCTFontFullNameKey); + appendNameToList(font, &names->familyNames, kCTFontFamilyNameKey); + appendNameToList(font, &names->styleNames, kCTFontStyleNameKey); + CFRelease(font); - [pool release]; + [pool release]; - return names; + return names; } void XeTeXFontMgr_Mac::addFontsToCaches(CFArrayRef fonts) { - NSEnumerator* enumerator = [(NSArray*)fonts objectEnumerator]; - while (id aFont = [enumerator nextObject]) { - CTFontDescriptorRef fontRef = findFontWithName((CFStringRef)[aFont objectAtIndex: 0], kCTFontNameAttribute); - NameCollection* names = readNames(fontRef); - addToMaps(fontRef, names); - delete names; - } + NSEnumerator* enumerator = [(NSArray*)fonts objectEnumerator]; + while (id aFont = [enumerator nextObject]) { + CTFontDescriptorRef fontRef = findFontWithName((CFStringRef)[aFont objectAtIndex: 0], kCTFontNameAttribute); + NameCollection* names = readNames(fontRef); + addToMaps(fontRef, names); + delete names; + } } void XeTeXFontMgr_Mac::addFamilyToCaches(CTFontDescriptorRef familyRef) { - CFStringRef nameStr = (CFStringRef) CTFontDescriptorCopyAttribute(familyRef, kCTFontFamilyNameAttribute); - if (nameStr) { - NSArray* members = [[NSFontManager sharedFontManager] - availableMembersOfFontFamily: (NSString*)nameStr]; - CFRelease(nameStr); - addFontsToCaches((CFArrayRef)members); - } + CFStringRef nameStr = (CFStringRef) CTFontDescriptorCopyAttribute(familyRef, kCTFontFamilyNameAttribute); + if (nameStr) { + NSArray* members = [[NSFontManager sharedFontManager] + availableMembersOfFontFamily: (NSString*)nameStr]; + CFRelease(nameStr); + addFontsToCaches((CFArrayRef)members); + } } void XeTeXFontMgr_Mac::addFontAndSiblingsToCaches(CTFontDescriptorRef fontRef) { - CFStringRef name = (CFStringRef) CTFontDescriptorCopyAttribute(fontRef, kCTFontNameAttribute); - if (name) { - NSFont* font = [NSFont fontWithName:(NSString*)name size:10.0]; - CFRelease(name); - NSArray* members = [[NSFontManager sharedFontManager] - availableMembersOfFontFamily: [font familyName]]; - addFontsToCaches((CFArrayRef)members); - } + CFStringRef name = (CFStringRef) CTFontDescriptorCopyAttribute(fontRef, kCTFontNameAttribute); + if (name) { + NSFont* font = [NSFont fontWithName:(NSString*)name size:10.0]; + CFRelease(name); + NSArray* members = [[NSFontManager sharedFontManager] + availableMembersOfFontFamily: [font familyName]]; + addFontsToCaches((CFArrayRef)members); + } } void XeTeXFontMgr_Mac::searchForHostPlatformFonts(const std::string& name) { - // the name might be: - // FullName - // Family-Style (if there's a hyphen) - // PSName - // Family - // ...so we need to try it as each of these - - CFStringRef nameStr = CFStringCreateWithCString(kCFAllocatorDefault, name.c_str(), kCFStringEncodingUTF8); - CTFontDescriptorRef matched = findFontWithName(nameStr, kCTFontDisplayNameAttribute); - if (matched) { - // found it, so locate the family, and add all members to the caches - addFontAndSiblingsToCaches(matched); - CFRelease(matched); - return; - } - - int hyph = name.find('-'); - if (hyph > 0 && hyph < name.length() - 1) { - std::string family(name.begin(), name.begin() + hyph); - CFStringRef familyStr = CFStringCreateWithCString(kCFAllocatorDefault, family.c_str(), kCFStringEncodingUTF8); - - NSArray* familyMembers = [[NSFontManager sharedFontManager] - availableMembersOfFontFamily: (NSString*)familyStr]; - if ([familyMembers count] > 0) { - addFontsToCaches((CFArrayRef)familyMembers); - return; - } - - matched = findFontWithName(familyStr, kCTFontFamilyNameAttribute); - if (matched) { - addFamilyToCaches(matched); - CFRelease(matched); - return; - } - } - - matched = findFontWithName(nameStr, kCTFontNameAttribute); - if (matched) { - addFontAndSiblingsToCaches(matched); - CFRelease(matched); - return; - } - - NSArray* familyMembers = [[NSFontManager sharedFontManager] - availableMembersOfFontFamily: (NSString*)nameStr]; - if ([familyMembers count] > 0) { - addFontsToCaches((CFArrayRef)familyMembers); - return; - } - - matched = findFontWithName(nameStr, kCTFontFamilyNameAttribute); - if (matched) { - addFamilyToCaches(matched); - CFRelease(matched); - return; - } + // the name might be: + // FullName + // Family-Style (if there's a hyphen) + // PSName + // Family + // ...so we need to try it as each of these + + CFStringRef nameStr = CFStringCreateWithCString(kCFAllocatorDefault, name.c_str(), kCFStringEncodingUTF8); + CTFontDescriptorRef matched = findFontWithName(nameStr, kCTFontDisplayNameAttribute); + if (matched) { + // found it, so locate the family, and add all members to the caches + addFontAndSiblingsToCaches(matched); + CFRelease(matched); + return; + } + + int hyph = name.find('-'); + if (hyph > 0 && hyph < name.length() - 1) { + std::string family(name.begin(), name.begin() + hyph); + CFStringRef familyStr = CFStringCreateWithCString(kCFAllocatorDefault, family.c_str(), kCFStringEncodingUTF8); + + NSArray* familyMembers = [[NSFontManager sharedFontManager] + availableMembersOfFontFamily: (NSString*)familyStr]; + if ([familyMembers count] > 0) { + addFontsToCaches((CFArrayRef)familyMembers); + return; + } + + matched = findFontWithName(familyStr, kCTFontFamilyNameAttribute); + if (matched) { + addFamilyToCaches(matched); + CFRelease(matched); + return; + } + } + + matched = findFontWithName(nameStr, kCTFontNameAttribute); + if (matched) { + addFontAndSiblingsToCaches(matched); + CFRelease(matched); + return; + } + + NSArray* familyMembers = [[NSFontManager sharedFontManager] + availableMembersOfFontFamily: (NSString*)nameStr]; + if ([familyMembers count] > 0) { + addFontsToCaches((CFArrayRef)familyMembers); + return; + } + + matched = findFontWithName(nameStr, kCTFontFamilyNameAttribute); + if (matched) { + addFamilyToCaches(matched); + CFRelease(matched); + return; + } } NSAutoreleasePool* pool = NULL; @@ -214,44 +214,44 @@ NSAutoreleasePool* pool = NULL; void XeTeXFontMgr_Mac::initialize() { - pool = [[NSAutoreleasePool alloc] init]; + pool = [[NSAutoreleasePool alloc] init]; } void XeTeXFontMgr_Mac::terminate() { - if (pool != NULL) { - [pool release]; - } + if (pool != NULL) { + [pool release]; + } } std::string XeTeXFontMgr_Mac::getPlatformFontDesc(PlatformFontRef descriptor) const { - std::string path; - CTFontRef ctFont = CTFontCreateWithFontDescriptor(descriptor, 0.0, 0); - if (ctFont) { - CFURLRef url = NULL; + std::string path; + CTFontRef ctFont = CTFontCreateWithFontDescriptor(descriptor, 0.0, 0); + if (ctFont) { + CFURLRef url = NULL; #if !defined(MAC_OS_X_VERSION_10_6) || MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_6 - /* kCTFontURLAttribute was not avialable before 10.6 */ - FSRef fsref; - ATSFontRef atsFont = CTFontGetPlatformFont(ctFont, NULL); - OSStatus status = ATSFontGetFileReference(atsFont, &fsref); - if (status == noErr) - url = CFURLCreateFromFSRef(NULL, &fsref); + /* kCTFontURLAttribute was not avialable before 10.6 */ + FSRef fsref; + ATSFontRef atsFont = CTFontGetPlatformFont(ctFont, NULL); + OSStatus status = ATSFontGetFileReference(atsFont, &fsref); + if (status == noErr) + url = CFURLCreateFromFSRef(NULL, &fsref); #else - url = (CFURLRef) CTFontCopyAttribute(ctFont, kCTFontURLAttribute); + url = (CFURLRef) CTFontCopyAttribute(ctFont, kCTFontURLAttribute); #endif - if (url) { - UInt8 posixPath[PATH_MAX]; - if (CFURLGetFileSystemRepresentation(url, true, posixPath, PATH_MAX)) { - path = (char*)posixPath; - } - CFRelease(url); - } - CFRelease(ctFont); - } - if (path.length() == 0) - path = "[unknown]"; - return path; + if (url) { + UInt8 posixPath[PATH_MAX]; + if (CFURLGetFileSystemRepresentation(url, true, posixPath, PATH_MAX)) { + path = (char*)posixPath; + } + CFRelease(url); + } + CFRelease(ctFont); + } + if (path.length() == 0) + path = "[unknown]"; + return path; } diff --git a/Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.cpp b/Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.cpp index 0e99efa88ec..dc1d1067f3e 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.cpp +++ b/Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.cpp @@ -39,10 +39,16 @@ extern "C" { } #endif -#include <unicode/platform.h> // We need this first +#include <unicode/platform.h> // We need this first #include <unicode/ubidi.h> #include <unicode/utext.h> +#include <graphite2/Font.h> +#include <graphite2/Segment.h> +#include <hb-graphite2.h> +#include <hb-icu.h> +#include <hb-ot.h> + #include "XeTeXLayoutInterface.h" #include "XeTeXFontInst.h" #ifdef XETEX_MAC @@ -50,21 +56,28 @@ extern "C" { #endif #include "XeTeXFontMgr.h" +typedef void* voidptr; + +extern "C" { + extern voidptr* fontlayoutengine; + extern integer* fontarea; +} + struct XeTeXLayoutEngine_rec { - XeTeXFontInst* font; - PlatformFontRef fontRef; - hb_tag_t script; - hb_tag_t language; - hb_feature_t* features; - char** ShaperList; // the requested shapers - char* shaper; // the actually used shaper - int nFeatures; - uint32_t rgbValue; - float extend; - float slant; - float embolden; - hb_buffer_t* hbBuffer; + XeTeXFontInst* font; + PlatformFontRef fontRef; + hb_tag_t script; + hb_language_t language; + hb_feature_t* features; + char** ShaperList; // the requested shapers + char* shaper; // the actually used shaper + int nFeatures; + uint32_t rgbValue; + float extend; + float slant; + float embolden; + hb_buffer_t* hbBuffer; }; /*******************************************************************/ @@ -74,815 +87,860 @@ struct XeTeXLayoutEngine_rec // key is combined value representing (font_id << 16) + glyph // value is glyph bounding box in TeX points -static std::map<uint32_t,GlyphBBox> sGlyphBoxes; +static std::map<uint32_t,GlyphBBox> sGlyphBoxes; int getCachedGlyphBBox(uint16_t fontID, uint16_t glyphID, GlyphBBox* bbox) { - uint32_t key = ((uint32_t)fontID << 16) + glyphID; - std::map<uint32_t,GlyphBBox>::const_iterator i = sGlyphBoxes.find(key); - if (i == sGlyphBoxes.end()) { - return 0; - } - *bbox = i->second; - return 1; + uint32_t key = ((uint32_t)fontID << 16) + glyphID; + std::map<uint32_t,GlyphBBox>::const_iterator i = sGlyphBoxes.find(key); + if (i == sGlyphBoxes.end()) { + return 0; + } + *bbox = i->second; + return 1; } void cacheGlyphBBox(uint16_t fontID, uint16_t glyphID, const GlyphBBox* bbox) { - uint32_t key = ((uint32_t)fontID << 16) + glyphID; - sGlyphBoxes[key] = *bbox; + uint32_t key = ((uint32_t)fontID << 16) + glyphID; + sGlyphBoxes[key] = *bbox; } /*******************************************************************/ void terminatefontmanager() { - XeTeXFontMgr::Terminate(); + XeTeXFontMgr::Terminate(); } XeTeXFont createFont(PlatformFontRef fontRef, Fixed pointSize) { - int status = 0; + int status = 0; #ifdef XETEX_MAC - XeTeXFontInst* font = new XeTeXFontInst_Mac(fontRef, Fix2D(pointSize), status); + XeTeXFontInst* font = new XeTeXFontInst_Mac(fontRef, Fix2D(pointSize), status); #else - FcChar8* pathname = 0; - FcPatternGetString(fontRef, FC_FILE, 0, &pathname); - int index; - FcPatternGetInteger(fontRef, FC_INDEX, 0, &index); - XeTeXFontInst* font = new XeTeXFontInst((const char*)pathname, index, Fix2D(pointSize), status); + FcChar8* pathname = 0; + FcPatternGetString(fontRef, FC_FILE, 0, &pathname); + int index; + FcPatternGetInteger(fontRef, FC_INDEX, 0, &index); + XeTeXFontInst* font = new XeTeXFontInst((const char*)pathname, index, Fix2D(pointSize), status); #endif - if (status != 0) { - delete font; - return NULL; - } - return (XeTeXFont)font; + if (status != 0) { + delete font; + return NULL; + } + return (XeTeXFont)font; } XeTeXFont createFontFromFile(const char* filename, int index, Fixed pointSize) { - int status = 0; - XeTeXFontInst* font = new XeTeXFontInst(filename, index, Fix2D(pointSize), status); - if (status != 0) { - delete font; - return NULL; - } - return (XeTeXFont)font; + int status = 0; + XeTeXFontInst* font = new XeTeXFontInst(filename, index, Fix2D(pointSize), status); + if (status != 0) { + delete font; + return NULL; + } + return (XeTeXFont)font; } void setFontLayoutDir(XeTeXFont font, int vertical) { - ((XeTeXFontInst*)font)->setLayoutDirVertical(vertical != 0); + ((XeTeXFontInst*)font)->setLayoutDirVertical(vertical != 0); } PlatformFontRef findFontByName(const char* name, char* var, double size) { - return (XeTeXFontMgr::GetFontManager()->findFont(name, var, size)); + return (XeTeXFontMgr::GetFontManager()->findFont(name, var, size)); } char getReqEngine() { - return XeTeXFontMgr::GetFontManager()->getReqEngine(); + return XeTeXFontMgr::GetFontManager()->getReqEngine(); } void setReqEngine(char reqEngine) { - XeTeXFontMgr::GetFontManager()->setReqEngine(reqEngine); + XeTeXFontMgr::GetFontManager()->setReqEngine(reqEngine); } const char* getFullName(PlatformFontRef fontRef) { - return XeTeXFontMgr::GetFontManager()->getFullName(fontRef); + return XeTeXFontMgr::GetFontManager()->getFullName(fontRef); } double getDesignSize(XeTeXFont font) { - return XeTeXFontMgr::GetFontManager()->getDesignSize(font); + return XeTeXFontMgr::GetFontManager()->getDesignSize(font); } const char* getFontFilename(XeTeXLayoutEngine engine) { - return engine->font->getFilename(); + return engine->font->getFilename(); } void getNames(PlatformFontRef fontRef, const char** psName, const char** famName, const char** styName) { - XeTeXFontMgr::GetFontManager()->getNames(fontRef, psName, famName, styName); + XeTeXFontMgr::GetFontManager()->getNames(fontRef, psName, famName, styName); } PlatformFontRef getFontRef(XeTeXLayoutEngine engine) { - return engine->fontRef; + return engine->fontRef; } void deleteFont(XeTeXFont font) { - delete (XeTeXFontInst*)font; + delete (XeTeXFontInst*)font; } void* getFontTablePtr(XeTeXFont font, uint32_t tableTag) { - return const_cast<void*>(((XeTeXFontInst*)font)->getFontTable(tableTag)); + return const_cast<void*>(((XeTeXFontInst*)font)->getFontTable(tableTag)); } Fixed getSlant(XeTeXFont font) { - float italAngle = ((XeTeXFontInst*)font)->getItalicAngle(); - return D2Fix(tan(-italAngle * M_PI / 180.0)); + float italAngle = ((XeTeXFontInst*)font)->getItalicAngle(); + return D2Fix(tan(-italAngle * M_PI / 180.0)); } static unsigned int getLargerScriptListTable(XeTeXFont font, hb_tag_t** scriptList) { - unsigned int rval = 0; + unsigned int rval = 0; - hb_face_t* face = hb_font_get_face(((XeTeXFontInst*)font)->getHbFont()); + hb_face_t* face = hb_font_get_face(((XeTeXFontInst*)font)->getHbFont()); - hb_tag_t* scriptListSub = NULL; - hb_tag_t* scriptListPos = NULL; + hb_tag_t* scriptListSub = NULL; + hb_tag_t* scriptListPos = NULL; - unsigned int scriptCountSub = hb_ot_layout_table_get_script_tags(face, HB_OT_TAG_GSUB, 0, NULL, NULL); - scriptListSub = (hb_tag_t*) xmalloc(scriptCountSub * sizeof(hb_tag_t*)); - hb_ot_layout_table_get_script_tags(face, HB_OT_TAG_GSUB, 0, &scriptCountSub, scriptListSub); + unsigned int scriptCountSub = hb_ot_layout_table_get_script_tags(face, HB_OT_TAG_GSUB, 0, NULL, NULL); + scriptListSub = (hb_tag_t*) xcalloc(scriptCountSub, sizeof(hb_tag_t*)); + hb_ot_layout_table_get_script_tags(face, HB_OT_TAG_GSUB, 0, &scriptCountSub, scriptListSub); - unsigned int scriptCountPos = hb_ot_layout_table_get_script_tags(face, HB_OT_TAG_GPOS, 0, NULL, NULL); - scriptListPos = (hb_tag_t*) xmalloc(scriptCountPos * sizeof(hb_tag_t*)); - hb_ot_layout_table_get_script_tags(face, HB_OT_TAG_GSUB, 0, &scriptCountPos, scriptListPos); + unsigned int scriptCountPos = hb_ot_layout_table_get_script_tags(face, HB_OT_TAG_GPOS, 0, NULL, NULL); + scriptListPos = (hb_tag_t*) xcalloc(scriptCountPos, sizeof(hb_tag_t*)); + hb_ot_layout_table_get_script_tags(face, HB_OT_TAG_GSUB, 0, &scriptCountPos, scriptListPos); - if (scriptCountSub > scriptCountPos) { - if (scriptList != NULL) - *scriptList = scriptListSub; - rval = scriptCountSub; - } else { - if (scriptList != NULL) - *scriptList = scriptListPos; - rval = scriptCountPos; - } + if (scriptCountSub > scriptCountPos) { + if (scriptList != NULL) + *scriptList = scriptListSub; + rval = scriptCountSub; + } else { + if (scriptList != NULL) + *scriptList = scriptListPos; + rval = scriptCountPos; + } - return rval; + return rval; } unsigned int countScripts(XeTeXFont font) { - return getLargerScriptListTable(font, NULL); + return getLargerScriptListTable(font, NULL); } hb_tag_t getIndScript(XeTeXFont font, unsigned int index) { - hb_tag_t rval = 0; + hb_tag_t rval = 0; - hb_tag_t* scriptList; + hb_tag_t* scriptList; - unsigned int scriptCount = getLargerScriptListTable(font, &scriptList); - if (scriptList != NULL) { - if (index < scriptCount) - rval = scriptList[index]; - } + unsigned int scriptCount = getLargerScriptListTable(font, &scriptList); + if (scriptList != NULL) { + if (index < scriptCount) + rval = scriptList[index]; + } - return rval; + return rval; } unsigned int countLanguages(XeTeXFont font, hb_tag_t script) { - unsigned int rval = 0; + unsigned int rval = 0; - hb_face_t* face = hb_font_get_face(((XeTeXFontInst*)font)->getHbFont()); - hb_tag_t* scriptList; + hb_face_t* face = hb_font_get_face(((XeTeXFontInst*)font)->getHbFont()); + hb_tag_t* scriptList; - unsigned int scriptCount = getLargerScriptListTable(font, &scriptList); - if (scriptList != NULL) { - for (int i = 0; i < scriptCount; i++) { - if (scriptList[i] == script) { - rval += hb_ot_layout_script_get_language_tags (face, HB_OT_TAG_GSUB, i, 0, NULL, NULL); - rval += hb_ot_layout_script_get_language_tags (face, HB_OT_TAG_GPOS, i, 0, NULL, NULL); - break; - } - } - } + unsigned int scriptCount = getLargerScriptListTable(font, &scriptList); + if (scriptList != NULL) { + for (int i = 0; i < scriptCount; i++) { + if (scriptList[i] == script) { + rval += hb_ot_layout_script_get_language_tags (face, HB_OT_TAG_GSUB, i, 0, NULL, NULL); + rval += hb_ot_layout_script_get_language_tags (face, HB_OT_TAG_GPOS, i, 0, NULL, NULL); + break; + } + } + } - return rval; + return rval; } hb_tag_t getIndLanguage(XeTeXFont font, hb_tag_t script, unsigned int index) { - hb_tag_t rval = 0; + hb_tag_t rval = 0; - hb_face_t* face = hb_font_get_face(((XeTeXFontInst*)font)->getHbFont()); - hb_tag_t* scriptList; + hb_face_t* face = hb_font_get_face(((XeTeXFontInst*)font)->getHbFont()); + hb_tag_t* scriptList; - unsigned int scriptCount = getLargerScriptListTable(font, &scriptList); - if (scriptList != NULL) { - for (int i = 0; i < scriptCount; i++) { - if (scriptList[i] == script) { - unsigned int langCount; - hb_tag_t* langList; + unsigned int scriptCount = getLargerScriptListTable(font, &scriptList); + if (scriptList != NULL) { + for (int i = 0; i < scriptCount; i++) { + if (scriptList[i] == script) { + unsigned int langCount; + hb_tag_t* langList; - langCount = hb_ot_layout_script_get_language_tags(face, HB_OT_TAG_GSUB, i, 0, NULL, NULL); - langList = (hb_tag_t*) xcalloc(langCount, sizeof(hb_tag_t*)); - hb_ot_layout_script_get_language_tags(face, HB_OT_TAG_GSUB, i, 0, &langCount, langList); + langCount = hb_ot_layout_script_get_language_tags(face, HB_OT_TAG_GSUB, i, 0, NULL, NULL); + langList = (hb_tag_t*) xcalloc(langCount, sizeof(hb_tag_t*)); + hb_ot_layout_script_get_language_tags(face, HB_OT_TAG_GSUB, i, 0, &langCount, langList); - if (index < langCount) { - rval = langList[index]; - break; - } + if (index < langCount) { + rval = langList[index]; + break; + } - free(langList); + free(langList); - langCount = hb_ot_layout_script_get_language_tags(face, HB_OT_TAG_GPOS, i, 0, NULL, NULL); - langList = (hb_tag_t*) xcalloc(langCount, sizeof(hb_tag_t*)); - hb_ot_layout_script_get_language_tags(face, HB_OT_TAG_GPOS, i, 0, &langCount, langList); + langCount = hb_ot_layout_script_get_language_tags(face, HB_OT_TAG_GPOS, i, 0, NULL, NULL); + langList = (hb_tag_t*) xcalloc(langCount, sizeof(hb_tag_t*)); + hb_ot_layout_script_get_language_tags(face, HB_OT_TAG_GPOS, i, 0, &langCount, langList); - if (index < langCount) { - rval = langList[index]; - break; - } + if (index < langCount) { + rval = langList[index]; + break; + } - free(langList); - } - } - } + free(langList); + } + } + } - return rval; + return rval; } unsigned int countFeatures(XeTeXFont font, hb_tag_t script, hb_tag_t language) { - unsigned int rval = 0; + unsigned int rval = 0; - hb_face_t* face = hb_font_get_face(((XeTeXFontInst*)font)->getHbFont()); + hb_face_t* face = hb_font_get_face(((XeTeXFontInst*)font)->getHbFont()); - for (int i = 0; i < 2; ++i) { - unsigned int scriptIndex, langIndex = 0; - hb_tag_t tableTag = i == 0 ? HB_OT_TAG_GSUB : HB_OT_TAG_GPOS; - if (hb_ot_layout_table_find_script(face, tableTag, script, &scriptIndex)) { - if (hb_ot_layout_script_find_language(face, tableTag, scriptIndex, language, &langIndex) || language == 0) { - rval += hb_ot_layout_language_get_feature_tags(face, tableTag, scriptIndex, langIndex, 0, NULL, NULL); - } - } - } + for (int i = 0; i < 2; ++i) { + unsigned int scriptIndex, langIndex = 0; + hb_tag_t tableTag = i == 0 ? HB_OT_TAG_GSUB : HB_OT_TAG_GPOS; + if (hb_ot_layout_table_find_script(face, tableTag, script, &scriptIndex)) { + if (hb_ot_layout_script_find_language(face, tableTag, scriptIndex, language, &langIndex) || language == 0) { + rval += hb_ot_layout_language_get_feature_tags(face, tableTag, scriptIndex, langIndex, 0, NULL, NULL); + } + } + } - return rval; + return rval; } hb_tag_t getIndFeature(XeTeXFont font, hb_tag_t script, hb_tag_t language, unsigned int index) { - hb_tag_t rval = 0; + hb_tag_t rval = 0; - hb_face_t* face = hb_font_get_face(((XeTeXFontInst*)font)->getHbFont()); + hb_face_t* face = hb_font_get_face(((XeTeXFontInst*)font)->getHbFont()); - for (int i = 0; i < 2; ++i) { - unsigned int scriptIndex, langIndex = 0; - hb_tag_t tableTag = i == 0 ? HB_OT_TAG_GSUB : HB_OT_TAG_GPOS; - if (hb_ot_layout_table_find_script(face, tableTag, script, &scriptIndex)) { - if (hb_ot_layout_script_find_language(face, tableTag, scriptIndex, language, &langIndex) || language == 0) { - unsigned int featCount = hb_ot_layout_language_get_feature_tags(face, tableTag, scriptIndex, langIndex, 0, NULL, NULL); - hb_tag_t* featList = (hb_tag_t*) xmalloc(featCount * sizeof(hb_tag_t*)); - hb_ot_layout_language_get_feature_tags(face, tableTag, scriptIndex, langIndex, 0, &featCount, featList); + for (int i = 0; i < 2; ++i) { + unsigned int scriptIndex, langIndex = 0; + hb_tag_t tableTag = i == 0 ? HB_OT_TAG_GSUB : HB_OT_TAG_GPOS; + if (hb_ot_layout_table_find_script(face, tableTag, script, &scriptIndex)) { + if (hb_ot_layout_script_find_language(face, tableTag, scriptIndex, language, &langIndex) || language == 0) { + unsigned int featCount = hb_ot_layout_language_get_feature_tags(face, tableTag, scriptIndex, langIndex, 0, NULL, NULL); + hb_tag_t* featList = (hb_tag_t*) xcalloc(featCount, sizeof(hb_tag_t*)); + hb_ot_layout_language_get_feature_tags(face, tableTag, scriptIndex, langIndex, 0, &featCount, featList); - if (index < featCount) { - rval = featList[index]; - break; - } + if (index < featCount) { + rval = featList[index]; + break; + } - index -= featCount; - } - } - } + index -= featCount; + } + } + } - return rval; + return rval; } uint32_t countGraphiteFeatures(XeTeXLayoutEngine engine) { - uint32_t rval = 0; + uint32_t rval = 0; - hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); - gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); + hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); + gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); - if (grFace != NULL) - rval = gr_face_n_fref(grFace); + if (grFace != NULL) + rval = gr_face_n_fref(grFace); - return rval; + return rval; } uint32_t getGraphiteFeatureCode(XeTeXLayoutEngine engine, uint32_t index) { - uint32_t rval = 0; + uint32_t rval = 0; - hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); - gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); + hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); + gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); - if (grFace != NULL) { - const gr_feature_ref* feature = gr_face_fref(grFace, index); - rval = gr_fref_id(feature); - } + if (grFace != NULL) { + const gr_feature_ref* feature = gr_face_fref(grFace, index); + rval = gr_fref_id(feature); + } - return rval; + return rval; } uint32_t countGraphiteFeatureSettings(XeTeXLayoutEngine engine, uint32_t featureID) { - uint32_t rval = 0; + uint32_t rval = 0; - hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); - gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); + hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); + gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); - if (grFace != NULL) { - const gr_feature_ref* feature = gr_face_find_fref(grFace, featureID); - rval = gr_fref_n_values(feature); - } + if (grFace != NULL) { + const gr_feature_ref* feature = gr_face_find_fref(grFace, featureID); + rval = gr_fref_n_values(feature); + } - return rval; + return rval; } uint32_t getGraphiteFeatureSettingCode(XeTeXLayoutEngine engine, uint32_t featureID, uint32_t index) { - uint32_t rval = 0; + uint32_t rval = 0; - hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); - gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); + hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); + gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); - if (grFace != NULL) { - const gr_feature_ref* feature = gr_face_find_fref(grFace, featureID); - rval = gr_fref_value(feature, index); - } + if (grFace != NULL) { + const gr_feature_ref* feature = gr_face_find_fref(grFace, featureID); + rval = gr_fref_value(feature, index); + } - return rval; + return rval; } +#define tag_from_lang(x) hb_tag_from_string(hb_language_to_string(x), strlen(hb_language_to_string(x))) + uint32_t getGraphiteFeatureDefaultSetting(XeTeXLayoutEngine engine, uint32_t featureID) { - uint32_t rval = 0; + uint32_t rval = 0; - hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); - gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); + hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); + gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); - if (grFace != NULL) { - const gr_feature_ref* feature = gr_face_find_fref(grFace, featureID); - gr_feature_val *featureValues = gr_face_featureval_for_lang (grFace, engine->language); + if (grFace != NULL) { + const gr_feature_ref* feature = gr_face_find_fref(grFace, featureID); + gr_feature_val *featureValues = gr_face_featureval_for_lang (grFace, tag_from_lang(engine->language)); - rval = gr_fref_feature_value(feature, featureValues); - } + rval = gr_fref_feature_value(feature, featureValues); + } - return rval; + return rval; } char * getGraphiteFeatureLabel(XeTeXLayoutEngine engine, uint32_t featureID) { - hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); - gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); + hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); + gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); - if (grFace != NULL) { - const gr_feature_ref* feature = gr_face_find_fref(grFace, featureID); - uint32_t len = 0; - uint16_t langID = 0x409; + if (grFace != NULL) { + const gr_feature_ref* feature = gr_face_find_fref(grFace, featureID); + uint32_t len = 0; + uint16_t langID = 0x409; - return (char *) gr_fref_label(feature, &langID, gr_utf8, &len); - } + return (char *) gr_fref_label(feature, &langID, gr_utf8, &len); + } - return NULL; + return NULL; } char * getGraphiteFeatureSettingLabel(XeTeXLayoutEngine engine, uint32_t featureID, uint32_t settingID) { - hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); - gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); + hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); + gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); - if (grFace != NULL) { - const gr_feature_ref* feature = gr_face_find_fref(grFace, featureID); - for (int i = 0; i < gr_fref_n_values(feature); i++) { - if (settingID == gr_fref_value(feature, i)) { - uint32_t len = 0; - uint16_t langID = 0x409; + if (grFace != NULL) { + const gr_feature_ref* feature = gr_face_find_fref(grFace, featureID); + for (int i = 0; i < gr_fref_n_values(feature); i++) { + if (settingID == gr_fref_value(feature, i)) { + uint32_t len = 0; + uint16_t langID = 0x409; - return (char *) gr_fref_value_label(feature, i, &langID, gr_utf8, &len); - } - } - } + return (char *) gr_fref_value_label(feature, i, &langID, gr_utf8, &len); + } + } + } - return NULL; + return NULL; } bool findGraphiteFeature(XeTeXLayoutEngine engine, const char* s, const char* e, hb_tag_t* f, int* v) - /* s...e is a "feature=setting" string; look for this in the font */ + /* s...e is a "feature=setting" string; look for this in the font */ { - *f = 0; - *v = 0; - while (*s == ' ' || *s == '\t') - ++s; - const char* cp = s; - while (cp < e && *cp != '=') - ++cp; + *f = 0; + *v = 0; + while (*s == ' ' || *s == '\t') + ++s; + const char* cp = s; + while (cp < e && *cp != '=') + ++cp; - *f = findGraphiteFeatureNamed(engine, s, cp - s); - if (*f == -1) - return false; + *f = findGraphiteFeatureNamed(engine, s, cp - s); + if (*f == -1) + return false; - ++cp; - while (cp < e && (*cp == ' ' || *cp == '\t')) - ++cp; + ++cp; + while (cp < e && (*cp == ' ' || *cp == '\t')) + ++cp; - if (cp == e) - /* no setting was specified */ - return false; + if (cp == e) + /* no setting was specified */ + return false; - *v = findGraphiteFeatureSettingNamed(engine, *f, cp, e - cp); - if (*v == -1) - return false; + *v = findGraphiteFeatureSettingNamed(engine, *f, cp, e - cp); + if (*v == -1) + return false; - return true; + return true; } long findGraphiteFeatureNamed(XeTeXLayoutEngine engine, const char* name, int namelength) { - long rval = -1; + long rval = -1; - hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); - gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); + hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); + gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); - if (grFace != NULL) { - for (int i = 0; i < gr_face_n_fref(grFace); i++) { - const gr_feature_ref* feature = gr_face_fref(grFace, i); - uint32_t len = 0; - uint16_t langID = 0x409; + if (grFace != NULL) { + for (int i = 0; i < gr_face_n_fref(grFace); i++) { + const gr_feature_ref* feature = gr_face_fref(grFace, i); + uint32_t len = 0; + uint16_t langID = 0x409; - // the first call is to get the length of the string - gr_fref_label(feature, &langID, gr_utf8, &len); - char* label = (char*) xmalloc(len); - label = (char*) gr_fref_label(feature, &langID, gr_utf8, &len); + // the first call is to get the length of the string + gr_fref_label(feature, &langID, gr_utf8, &len); + char* label = (char*) xmalloc(len); + label = (char*) gr_fref_label(feature, &langID, gr_utf8, &len); - if (strncmp(label, name, namelength) == 0) { - rval = gr_fref_id(feature); - gr_label_destroy(label); - break; - } + if (strncmp(label, name, namelength) == 0) { + rval = gr_fref_id(feature); + gr_label_destroy(label); + break; + } - gr_label_destroy(label); - } - } + gr_label_destroy(label); + } + } - return rval; + return rval; } long findGraphiteFeatureSettingNamed(XeTeXLayoutEngine engine, uint32_t id, const char* name, int namelength) { - long rval = -1; + long rval = -1; - hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); - gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); + hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); + gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); - if (grFace != NULL) { - const gr_feature_ref* feature = gr_face_find_fref(grFace, id); - for (int i = 0; i < gr_fref_n_values(feature); i++) { - uint32_t len = 0; - uint16_t langID = 0x409; + if (grFace != NULL) { + const gr_feature_ref* feature = gr_face_find_fref(grFace, id); + for (int i = 0; i < gr_fref_n_values(feature); i++) { + uint32_t len = 0; + uint16_t langID = 0x409; - // the first call is to get the length of the string - gr_fref_value_label(feature, i, &langID, gr_utf8, &len); - char* label = (char*) xmalloc(len); - label = (char*) gr_fref_value_label(feature, i, &langID, gr_utf8, &len); + // the first call is to get the length of the string + gr_fref_value_label(feature, i, &langID, gr_utf8, &len); + char* label = (char*) xmalloc(len); + label = (char*) gr_fref_value_label(feature, i, &langID, gr_utf8, &len); - if (strncmp(label, name, namelength) == 0) { - rval = gr_fref_value(feature, i); - gr_label_destroy(label); - break; - } + if (strncmp(label, name, namelength) == 0) { + rval = gr_fref_value(feature, i); + gr_label_destroy(label); + break; + } - gr_label_destroy(label); - } - } + gr_label_destroy(label); + } + } - return rval; + return rval; } float getGlyphWidth(XeTeXFont font, uint32_t gid) { - return ((XeTeXFontInst*)font)->getGlyphWidth(gid); + return ((XeTeXFontInst*)font)->getGlyphWidth(gid); } unsigned int countGlyphs(XeTeXFont font) { - return ((XeTeXFontInst*)font)->getNumGlyphs(); + return ((XeTeXFontInst*)font)->getNumGlyphs(); } XeTeXFont getFont(XeTeXLayoutEngine engine) { - return (XeTeXFont)(engine->font); + return (XeTeXFont)(engine->font); } float getExtendFactor(XeTeXLayoutEngine engine) { - return engine->extend; + return engine->extend; } float getSlantFactor(XeTeXLayoutEngine engine) { - return engine->slant; + return engine->slant; } float getEmboldenFactor(XeTeXLayoutEngine engine) { - return engine->embolden; + return engine->embolden; } XeTeXLayoutEngine -createLayoutEngine(PlatformFontRef fontRef, XeTeXFont font, hb_tag_t script, hb_tag_t language, - hb_feature_t* features, int nFeatures, char **shapers, uint32_t rgbValue, - float extend, float slant, float embolden) -{ - XeTeXLayoutEngine result = new XeTeXLayoutEngine_rec; - result->fontRef = fontRef; - result->font = (XeTeXFontInst*)font; - result->script = script; - result->language = language; - result->features = features; - result->ShaperList = shapers; - result->shaper = NULL; - result->nFeatures = nFeatures; - result->rgbValue = rgbValue; - result->extend = extend; - result->slant = slant; - result->embolden = embolden; - result->hbBuffer = hb_buffer_create(); - - return result; +createLayoutEngine(PlatformFontRef fontRef, XeTeXFont font, hb_tag_t script, char *language, + hb_feature_t* features, int nFeatures, char **shapers, uint32_t rgbValue, + float extend, float slant, float embolden) +{ + XeTeXLayoutEngine result = new XeTeXLayoutEngine_rec; + result->fontRef = fontRef; + result->font = (XeTeXFontInst*)font; + result->script = script; + result->features = features; + result->ShaperList = shapers; + result->shaper = NULL; + result->nFeatures = nFeatures; + result->rgbValue = rgbValue; + result->extend = extend; + result->slant = slant; + result->embolden = embolden; + result->hbBuffer = hb_buffer_create(); + + // For Graphite fonts treat the language as BCP 47 tag, for OpenType we + // treat it as a OT language tag for backward compatibility with pre-0.9999 + // XeTeX. + if (getReqEngine() == 'G') + result->language = hb_language_from_string(language, -1); + else + result->language = hb_ot_tag_to_language(hb_tag_from_string(language, -1)); + + free(language); + + return result; } void deleteLayoutEngine(XeTeXLayoutEngine engine) { - hb_buffer_destroy(engine->hbBuffer); - delete engine->font; + hb_buffer_destroy(engine->hbBuffer); + delete engine->font; + free(engine->shaper); +} + +static unsigned int +_decompose_compat(hb_unicode_funcs_t* ufuncs, + hb_codepoint_t u, + hb_codepoint_t* decomposed, + void* user_data) +{ + return 0; +} + +static hb_unicode_funcs_t* +_get_unicode_funcs(void) +{ + static hb_unicode_funcs_t* ufuncs = hb_unicode_funcs_create(hb_icu_get_unicode_funcs()); + hb_unicode_funcs_set_decompose_compatibility_func(ufuncs, _decompose_compat, NULL, NULL); + return ufuncs; } +static hb_unicode_funcs_t* hbUnicodeFuncs = NULL; + int layoutChars(XeTeXLayoutEngine engine, uint16_t chars[], int32_t offset, int32_t count, int32_t max, - bool rightToLeft) -{ - bool res; - hb_script_t script = HB_SCRIPT_INVALID; - hb_language_t language = HB_LANGUAGE_INVALID; - hb_direction_t direction = HB_DIRECTION_LTR; - hb_segment_properties_t segment_props; - hb_shape_plan_t *shape_plan; - hb_font_t* hbFont = engine->font->getHbFont(); - hb_face_t* hbFace = hb_font_get_face(hbFont); - - if (engine->font->getLayoutDirVertical()) - direction = HB_DIRECTION_TTB; - else if (rightToLeft) - direction = HB_DIRECTION_RTL; - - script = hb_ot_tag_to_script (engine->script); - language = hb_ot_tag_to_language (engine->language); - - hb_buffer_reset(engine->hbBuffer); - hb_buffer_add_utf16(engine->hbBuffer, chars, max, offset, count); - hb_buffer_set_direction(engine->hbBuffer, direction); - hb_buffer_set_script(engine->hbBuffer, script); - hb_buffer_set_language(engine->hbBuffer, language); - - hb_buffer_guess_segment_properties(engine->hbBuffer); - hb_buffer_get_segment_properties(engine->hbBuffer, &segment_props); - - shape_plan = hb_shape_plan_create_cached(hbFace, &segment_props, engine->features, engine->nFeatures, engine->ShaperList); - res = hb_shape_plan_execute(shape_plan, hbFont, engine->hbBuffer, engine->features, engine->nFeatures); - - if (res) { - engine->shaper = strdup(hb_shape_plan_get_shaper(shape_plan)); - hb_buffer_set_content_type(engine->hbBuffer, HB_BUFFER_CONTENT_TYPE_GLYPHS); - } else { - // all selected shapers failed, retrying with default - // we don't use _cached here as the cached plain will always fail. - hb_shape_plan_destroy(shape_plan); - shape_plan = hb_shape_plan_create(hbFace, &segment_props, engine->features, engine->nFeatures, NULL); - res = hb_shape_plan_execute(shape_plan, hbFont, engine->hbBuffer, engine->features, engine->nFeatures); - - if (res) { - engine->shaper = strdup(hb_shape_plan_get_shaper(shape_plan)); - hb_buffer_set_content_type(engine->hbBuffer, HB_BUFFER_CONTENT_TYPE_GLYPHS); - } else { - fprintf(stderr, "\nERROR: all shapers failed\n"); - exit(3); - } - } + bool rightToLeft) +{ + bool res; + hb_script_t script = HB_SCRIPT_INVALID; + hb_direction_t direction = HB_DIRECTION_LTR; + hb_segment_properties_t segment_props; + hb_shape_plan_t *shape_plan; + hb_font_t* hbFont = engine->font->getHbFont(); + hb_face_t* hbFace = hb_font_get_face(hbFont); + + if (engine->font->getLayoutDirVertical()) + direction = HB_DIRECTION_TTB; + else if (rightToLeft) + direction = HB_DIRECTION_RTL; + + script = hb_ot_tag_to_script (engine->script); + + if (hbUnicodeFuncs == NULL) + hbUnicodeFuncs = _get_unicode_funcs(); + + hb_buffer_reset(engine->hbBuffer); + hb_buffer_set_unicode_funcs(engine->hbBuffer, hbUnicodeFuncs); + hb_buffer_add_utf16(engine->hbBuffer, chars, max, offset, count); + hb_buffer_set_direction(engine->hbBuffer, direction); + hb_buffer_set_script(engine->hbBuffer, script); + hb_buffer_set_language(engine->hbBuffer, engine->language); + + hb_buffer_guess_segment_properties(engine->hbBuffer); + hb_buffer_get_segment_properties(engine->hbBuffer, &segment_props); + + if (engine->ShaperList == NULL) { + // HarfBuzz gives graphite2 shaper a priority, so that for hybrid + // Graphite/OpenType fonts, Graphite will be used. However, pre-0.9999 + // XeTeX preferred OpenType over Graphite, so we are doing the same + // here for sake of backward compatibility. + engine->ShaperList = (char**) xcalloc(4, sizeof(char*)); + engine->ShaperList[0] = (char*) "ot"; + engine->ShaperList[1] = (char*) "graphite2"; + engine->ShaperList[2] = (char*) "fallback"; + engine->ShaperList[3] = NULL; + } - hb_shape_plan_destroy(shape_plan); + shape_plan = hb_shape_plan_create_cached(hbFace, &segment_props, engine->features, engine->nFeatures, engine->ShaperList); + res = hb_shape_plan_execute(shape_plan, hbFont, engine->hbBuffer, engine->features, engine->nFeatures); + + if (res) { + engine->shaper = strdup(hb_shape_plan_get_shaper(shape_plan)); + hb_buffer_set_content_type(engine->hbBuffer, HB_BUFFER_CONTENT_TYPE_GLYPHS); + } else { + // all selected shapers failed, retrying with default + // we don't use _cached here as the cached plain will always fail. + hb_shape_plan_destroy(shape_plan); + shape_plan = hb_shape_plan_create(hbFace, &segment_props, engine->features, engine->nFeatures, NULL); + res = hb_shape_plan_execute(shape_plan, hbFont, engine->hbBuffer, engine->features, engine->nFeatures); + + if (res) { + engine->shaper = strdup(hb_shape_plan_get_shaper(shape_plan)); + hb_buffer_set_content_type(engine->hbBuffer, HB_BUFFER_CONTENT_TYPE_GLYPHS); + } else { + fprintf(stderr, "\nERROR: all shapers failed\n"); + exit(3); + } + } + + hb_shape_plan_destroy(shape_plan); - int glyphCount = hb_buffer_get_length(engine->hbBuffer); + int glyphCount = hb_buffer_get_length(engine->hbBuffer); #ifdef DEBUG - char buf[1024]; - unsigned int consumed; + char buf[1024]; + unsigned int consumed; - printf ("shaper: %s\n", engine->shaper); + printf ("shaper: %s\n", engine->shaper); - hb_buffer_serialize_flags_t flags = HB_BUFFER_SERIALIZE_FLAGS_DEFAULT; - hb_buffer_serialize_format_t format = HB_BUFFER_SERIALIZE_FORMAT_JSON; + hb_buffer_serialize_flags_t flags = HB_BUFFER_SERIALIZE_FLAGS_DEFAULT; + hb_buffer_serialize_format_t format = HB_BUFFER_SERIALIZE_FORMAT_JSON; - hb_buffer_serialize_glyphs (engine->hbBuffer, 0, glyphCount, buf, sizeof(buf), &consumed, hbFont, format, flags); - if (consumed) - printf ("buffer glyphs: %s\n", buf); + hb_buffer_serialize_glyphs (engine->hbBuffer, 0, glyphCount, buf, sizeof(buf), &consumed, hbFont, format, flags); + if (consumed) + printf ("buffer glyphs: %s\n", buf); #endif - return glyphCount; + return glyphCount; } void getGlyphs(XeTeXLayoutEngine engine, uint32_t glyphs[]) { - int glyphCount = hb_buffer_get_length(engine->hbBuffer); - hb_glyph_info_t *hbGlyphs = hb_buffer_get_glyph_infos(engine->hbBuffer, NULL); + int glyphCount = hb_buffer_get_length(engine->hbBuffer); + hb_glyph_info_t *hbGlyphs = hb_buffer_get_glyph_infos(engine->hbBuffer, NULL); - for (int i = 0; i < glyphCount; i++) - glyphs[i] = hbGlyphs[i].codepoint; + for (int i = 0; i < glyphCount; i++) + glyphs[i] = hbGlyphs[i].codepoint; } void getGlyphAdvances(XeTeXLayoutEngine engine, float advances[]) { - int glyphCount = hb_buffer_get_length(engine->hbBuffer); - hb_glyph_position_t *hbPositions = hb_buffer_get_glyph_positions(engine->hbBuffer, NULL); + int glyphCount = hb_buffer_get_length(engine->hbBuffer); + hb_glyph_position_t *hbPositions = hb_buffer_get_glyph_positions(engine->hbBuffer, NULL); - for (int i = 0; i < glyphCount; i++) { - if (engine->font->getLayoutDirVertical()) - advances[i] = engine->font->unitsToPoints(hbPositions[i].y_advance); - else - advances[i] = engine->font->unitsToPoints(hbPositions[i].x_advance); - } + for (int i = 0; i < glyphCount; i++) { + if (engine->font->getLayoutDirVertical()) + advances[i] = engine->font->unitsToPoints(hbPositions[i].y_advance); + else + advances[i] = engine->font->unitsToPoints(hbPositions[i].x_advance); + } } void getGlyphPositions(XeTeXLayoutEngine engine, float positions[]) { - int glyphCount = hb_buffer_get_length(engine->hbBuffer); - hb_glyph_position_t *hbPositions = hb_buffer_get_glyph_positions(engine->hbBuffer, NULL); - - int i = 0; - float x = 0, y = 0; - - if (engine->font->getLayoutDirVertical()) { - for (i = 0; i < glyphCount; i++) { - positions[2*i] = - engine->font->unitsToPoints(x + hbPositions[i].y_offset); /* negative is forwards */ - positions[2*i+1] = engine->font->unitsToPoints(y - hbPositions[i].x_offset); - x += hbPositions[i].y_advance; - y += hbPositions[i].x_advance; - } - positions[2*i] = - engine->font->unitsToPoints(x); - positions[2*i+1] = engine->font->unitsToPoints(y); - } else { - for (i = 0; i < glyphCount; i++) { - positions[2*i] = engine->font->unitsToPoints(x + hbPositions[i].x_offset); - positions[2*i+1] = - engine->font->unitsToPoints(y + hbPositions[i].y_offset); /* negative is upwards */ - x += hbPositions[i].x_advance; - y += hbPositions[i].y_advance; - } - positions[2*i] = engine->font->unitsToPoints(x); - positions[2*i+1] = - engine->font->unitsToPoints(y); - } + int glyphCount = hb_buffer_get_length(engine->hbBuffer); + hb_glyph_position_t *hbPositions = hb_buffer_get_glyph_positions(engine->hbBuffer, NULL); + + int i = 0; + float x = 0, y = 0; + + if (engine->font->getLayoutDirVertical()) { + for (i = 0; i < glyphCount; i++) { + positions[2*i] = - engine->font->unitsToPoints(x + hbPositions[i].y_offset); /* negative is forwards */ + positions[2*i+1] = engine->font->unitsToPoints(y - hbPositions[i].x_offset); + x += hbPositions[i].y_advance; + y += hbPositions[i].x_advance; + } + positions[2*i] = - engine->font->unitsToPoints(x); + positions[2*i+1] = engine->font->unitsToPoints(y); + } else { + for (i = 0; i < glyphCount; i++) { + positions[2*i] = engine->font->unitsToPoints(x + hbPositions[i].x_offset); + positions[2*i+1] = - engine->font->unitsToPoints(y + hbPositions[i].y_offset); /* negative is upwards */ + x += hbPositions[i].x_advance; + y += hbPositions[i].y_advance; + } + positions[2*i] = engine->font->unitsToPoints(x); + positions[2*i+1] = - engine->font->unitsToPoints(y); + } - if (engine->extend != 1.0 || engine->slant != 0.0) - for (int i = 0; i <= glyphCount; ++i) - positions[2*i] = positions[2*i] * engine->extend - positions[2*i+1] * engine->slant; + if (engine->extend != 1.0 || engine->slant != 0.0) + for (int i = 0; i <= glyphCount; ++i) + positions[2*i] = positions[2*i] * engine->extend - positions[2*i+1] * engine->slant; } float getPointSize(XeTeXLayoutEngine engine) { - return engine->font->getPointSize(); + return engine->font->getPointSize(); } void getAscentAndDescent(XeTeXLayoutEngine engine, float* ascent, float* descent) { - *ascent = engine->font->getAscent(); - *descent = engine->font->getDescent(); + *ascent = engine->font->getAscent(); + *descent = engine->font->getDescent(); } void getCapAndXHeight(XeTeXLayoutEngine engine, float* capheight, float* xheight) { - *capheight = engine->font->getCapHeight(); - *xheight = engine->font->getXHeight(); + *capheight = engine->font->getCapHeight(); + *xheight = engine->font->getXHeight(); } int getDefaultDirection(XeTeXLayoutEngine engine) { - hb_script_t script = hb_buffer_get_script(engine->hbBuffer); - if (hb_script_get_horizontal_direction (script) == HB_DIRECTION_RTL) - return UBIDI_DEFAULT_RTL; - else - return UBIDI_DEFAULT_LTR; + hb_script_t script = hb_buffer_get_script(engine->hbBuffer); + if (hb_script_get_horizontal_direction (script) == HB_DIRECTION_RTL) + return UBIDI_DEFAULT_RTL; + else + return UBIDI_DEFAULT_LTR; } uint32_t getRgbValue(XeTeXLayoutEngine engine) { - return engine->rgbValue; + return engine->rgbValue; } void getGlyphBounds(XeTeXLayoutEngine engine, uint32_t glyphID, GlyphBBox* bbox) { - engine->font->getGlyphBounds(glyphID, bbox); - if (engine->extend != 0.0) { - bbox->xMin *= engine->extend; - bbox->xMax *= engine->extend; + engine->font->getGlyphBounds(glyphID, bbox); + if (engine->extend != 0.0) { + bbox->xMin *= engine->extend; + bbox->xMax *= engine->extend; } } float getGlyphWidthFromEngine(XeTeXLayoutEngine engine, uint32_t glyphID) { - return engine->extend * engine->font->getGlyphWidth(glyphID); + return engine->extend * engine->font->getGlyphWidth(glyphID); } void getGlyphHeightDepth(XeTeXLayoutEngine engine, uint32_t glyphID, float* height, float* depth) { - engine->font->getGlyphHeightDepth(glyphID, height, depth); + engine->font->getGlyphHeightDepth(glyphID, height, depth); } void getGlyphSidebearings(XeTeXLayoutEngine engine, uint32_t glyphID, float* lsb, float* rsb) { - engine->font->getGlyphSidebearings(glyphID, lsb, rsb); - if (engine->extend != 0.0) { - *lsb *= engine->extend; - *rsb *= engine->extend; - } + engine->font->getGlyphSidebearings(glyphID, lsb, rsb); + if (engine->extend != 0.0) { + *lsb *= engine->extend; + *rsb *= engine->extend; + } } float getGlyphItalCorr(XeTeXLayoutEngine engine, uint32_t glyphID) { - return engine->extend * engine->font->getGlyphItalCorr(glyphID); + return engine->extend * engine->font->getGlyphItalCorr(glyphID); } uint32_t mapCharToGlyph(XeTeXLayoutEngine engine, uint32_t charCode) { - return engine->font->mapCharToGlyph(charCode); + return engine->font->mapCharToGlyph(charCode); } int getFontCharRange(XeTeXLayoutEngine engine, int reqFirst) { - if (reqFirst) - return engine->font->getFirstCharCode(); - else - return engine->font->getLastCharCode(); + if (reqFirst) + return engine->font->getFirstCharCode(); + else + return engine->font->getLastCharCode(); } const char* getGlyphName(XeTeXFont font, uint16_t gid, int* len) { - return ((XeTeXFontInst*)font)->getGlyphName(gid, *len); + return ((XeTeXFontInst*)font)->getGlyphName(gid, *len); } int mapGlyphToIndex(XeTeXLayoutEngine engine, const char* glyphName) { - return engine->font->mapGlyphToIndex(glyphName); + return engine->font->mapGlyphToIndex(glyphName); } static gr_segment* grSegment = NULL; @@ -892,95 +950,110 @@ static int grTextLen; bool initGraphiteBreaking(XeTeXLayoutEngine engine, const uint16_t* txtPtr, int txtLen) { - hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); - gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); - gr_font* grFont = hb_graphite2_font_get_gr_font(engine->font->getHbFont()); - if (grFace != NULL && grFont != NULL) { - if (grSegment != NULL) { - gr_seg_destroy(grSegment); - grSegment = NULL; - grPrevSlot = NULL; - } - - gr_feature_val *grFeatureValues = gr_face_featureval_for_lang (grFace, engine->language); - - int nFeatures = engine->nFeatures; - hb_feature_t *features = engine->features; - while (nFeatures--) { - const gr_feature_ref *fref = gr_face_find_fref (grFace, features->tag); - if (fref) - gr_fref_set_feature_value (fref, features->value, grFeatureValues); - features++; - } - - grSegment = gr_make_seg(grFont, grFace, engine->script, grFeatureValues, gr_utf16, txtPtr, txtLen, 0); - grPrevSlot = gr_seg_first_slot(grSegment); - grTextLen = txtLen; - - return true; - } + hb_face_t* hbFace = hb_font_get_face(engine->font->getHbFont()); + gr_face* grFace = hb_graphite2_face_get_gr_face(hbFace); + gr_font* grFont = hb_graphite2_font_get_gr_font(engine->font->getHbFont()); + if (grFace != NULL && grFont != NULL) { + if (grSegment != NULL) { + gr_seg_destroy(grSegment); + grSegment = NULL; + grPrevSlot = NULL; + } + + gr_feature_val *grFeatureValues = gr_face_featureval_for_lang (grFace, tag_from_lang(engine->language)); + + int nFeatures = engine->nFeatures; + hb_feature_t *features = engine->features; + while (nFeatures--) { + const gr_feature_ref *fref = gr_face_find_fref (grFace, features->tag); + if (fref) + gr_fref_set_feature_value (fref, features->value, grFeatureValues); + features++; + } + + grSegment = gr_make_seg(grFont, grFace, engine->script, grFeatureValues, gr_utf16, txtPtr, txtLen, 0); + grPrevSlot = gr_seg_first_slot(grSegment); + grTextLen = txtLen; + + return true; + } - return false; + return false; } int findNextGraphiteBreak(void) { - int ret = -1; - - if (grSegment != NULL) { - if (grPrevSlot && grPrevSlot != gr_seg_last_slot(grSegment)) { - for (const gr_slot* s = gr_slot_next_in_segment(grPrevSlot); s != NULL; s = gr_slot_next_in_segment(s)) { - const gr_char_info* ci = NULL; - int bw; - - ci = gr_seg_cinfo(grSegment, gr_slot_index(s)); - bw = gr_cinfo_break_weight(ci); - if (bw < gr_breakNone && bw >= gr_breakBeforeWord) { - grPrevSlot = s; - ret = gr_cinfo_base(ci); - } else if (bw > gr_breakNone && bw <= gr_breakWord) { - grPrevSlot = gr_slot_next_in_segment(s); - ret = gr_cinfo_base(ci) + 1; - } - - if (ret != -1) - break; - } - - if (ret == -1) { - grPrevSlot = gr_seg_last_slot(grSegment); - ret = grTextLen; - } - } - } + int ret = -1; + + if (grSegment != NULL) { + if (grPrevSlot && grPrevSlot != gr_seg_last_slot(grSegment)) { + for (const gr_slot* s = gr_slot_next_in_segment(grPrevSlot); s != NULL; s = gr_slot_next_in_segment(s)) { + const gr_char_info* ci = NULL; + int bw; + + ci = gr_seg_cinfo(grSegment, gr_slot_index(s)); + bw = gr_cinfo_break_weight(ci); + if (bw < gr_breakNone && bw >= gr_breakBeforeWord) { + grPrevSlot = s; + ret = gr_cinfo_base(ci); + } else if (bw > gr_breakNone && bw <= gr_breakWord) { + grPrevSlot = gr_slot_next_in_segment(s); + ret = gr_cinfo_base(ci) + 1; + } + + if (ret != -1) + break; + } + + if (ret == -1) { + grPrevSlot = gr_seg_last_slot(grSegment); + ret = grTextLen; + } + } + } - return ret; + return ret; } bool -usingGraphite(XeTeXLayoutEngine engine) +usingGraphite(int font) { - if (engine->shaper != NULL && (strcmp("graphite2", engine->shaper) == 0)) - return true; - else - return false; + bool ret = false; + if (fontarea[font] == OTGR_FONT_FLAG) { + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[font]; + if (engine->shaper != NULL && (strcmp("graphite2", engine->shaper) == 0)) { + ret = true; + } + } + + return ret; } bool -usingOpenType(XeTeXLayoutEngine engine) +usingOpenType(int font) { - if (engine->shaper == NULL || (strcmp("ot", engine->shaper) == 0)) - return true; - else - return false; + bool ret = false; + if (fontarea[font] == OTGR_FONT_FLAG) { + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[font]; + if (engine->shaper == NULL || (strcmp("ot", engine->shaper) == 0)) { + ret = true; + } + } + + return ret; } bool -isOpenTypeMathFont(XeTeXLayoutEngine engine) +isOpenTypeMathFont(int font) { - if (engine->font->getMathTable() != NULL) - return true; - else - return false; + bool ret = false; + if (fontarea[font] == OTGR_FONT_FLAG) { + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[font]; + if (engine->font->getMathTable() != NULL) { + ret = true; + } + } + + return ret; } diff --git a/Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.h b/Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.h index 4b2b8e2dde3..d7f598f8f58 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.h +++ b/Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.h @@ -48,12 +48,6 @@ typedef struct XeTeXLayoutEngine_rec* XeTeXLayoutEngine; #include FT_TRUETYPE_TABLES_H #include <hb.h> -#include <hb-ot.h> -#include <hb-icu.h> - -#include <graphite2/Font.h> -#include <graphite2/Segment.h> -#include <hb-graphite2.h> #include "XeTeX_ext.h" #include "XeTeXFontMgr.h" @@ -62,7 +56,7 @@ typedef struct XeTeXLayoutEngine_rec* XeTeXLayoutEngine; extern "C" { #endif -extern char gPrefEngine; +extern char gPrefEngine; int getCachedGlyphBBox(uint16_t fontID, uint16_t glyphID, GlyphBBox* bbox); void cacheGlyphBBox(uint16_t fontID, uint16_t glyphID, const GlyphBBox* bbox); @@ -102,9 +96,9 @@ hb_tag_t getIndFeature(XeTeXFont font, hb_tag_t script, hb_tag_t language, unsig float getGlyphWidth(XeTeXFont font, uint32_t gid); -XeTeXLayoutEngine createLayoutEngine(PlatformFontRef fontRef, XeTeXFont font, hb_tag_t script, hb_tag_t language, - hb_feature_t* features, int nFeatures, char **shapers, uint32_t rgbValue, - float extend, float slant, float embolden); +XeTeXLayoutEngine createLayoutEngine(PlatformFontRef fontRef, XeTeXFont font, hb_tag_t script, char *language, + hb_feature_t* features, int nFeatures, char **shapers, uint32_t rgbValue, + float extend, float slant, float embolden); void deleteLayoutEngine(XeTeXLayoutEngine engine); @@ -116,7 +110,7 @@ float getSlantFactor(XeTeXLayoutEngine engine); float getEmboldenFactor(XeTeXLayoutEngine engine); int layoutChars(XeTeXLayoutEngine engine, uint16_t* chars, int32_t offset, int32_t count, int32_t max, - bool rightToLeft); + bool rightToLeft); void getGlyphs(XeTeXLayoutEngine engine, uint32_t* glyphs); void getGlyphAdvances(XeTeXLayoutEngine engine, float *advances); @@ -143,7 +137,7 @@ float getGlyphItalCorr(XeTeXLayoutEngine engine, uint32_t glyphID); uint32_t mapCharToGlyph(XeTeXLayoutEngine engine, uint32_t charCode); -int mapGlyphToIndex(XeTeXLayoutEngine engine, const char* glyphName); +int mapGlyphToIndex(XeTeXLayoutEngine engine, const char* glyphName); const char* getGlyphName(XeTeXFont font, uint16_t gid, int* len); @@ -153,9 +147,9 @@ int getFontCharRange(XeTeXLayoutEngine engine, int reqFirst); bool initGraphiteBreaking(XeTeXLayoutEngine engine, const uint16_t* txtPtr, int txtLen); int findNextGraphiteBreak(void); -bool usingOpenType(XeTeXLayoutEngine engine); -bool usingGraphite(XeTeXLayoutEngine engine); -bool isOpenTypeMathFont(XeTeXLayoutEngine engine); +bool usingOpenType(int); +bool usingGraphite(int); +bool isOpenTypeMathFont(int); bool findGraphiteFeature(XeTeXLayoutEngine engine, const char* s, const char* e, hb_tag_t* f, int* v); diff --git a/Build/source/texk/web2c/xetexdir/XeTeXOTMath.cpp b/Build/source/texk/web2c/xetexdir/XeTeXOTMath.cpp index 3f43d6272c5..f66a23c6fe6 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeXOTMath.cpp +++ b/Build/source/texk/web2c/xetexdir/XeTeXOTMath.cpp @@ -48,455 +48,455 @@ extern "C" { #include "XeTeXFontInst.h" #include "XeTeXswap.h" -typedef void* voidptr; +typedef void* voidptr; extern "C" { - extern voidptr* fontlayoutengine; - extern integer* fontarea; - extern integer* fontsize; + extern voidptr* fontlayoutengine; + extern integer* fontarea; + extern integer* fontsize; } static int32_t getCoverage(const Coverage* coverage, GlyphID g) { - if (SWAP(coverage->format) == 1) { - const CoverageFormat1 *table = (const CoverageFormat1 *) coverage; - for (int i = 0; i < SWAP(table->glyphCount); i++) { - if (SWAP(table->glyphArray[i]) == g) - return i; - } - } else if (SWAP(coverage->format) == 2) { - const CoverageFormat2 *table = (const CoverageFormat2 *) coverage; - for (int i = 0; i < SWAP(table->rangeCount); i++) { - if (SWAP(table->rangeArray[i].start) <= g && SWAP(table->rangeArray[i].end) >= g) - return SWAP(table->rangeArray[i].startCoverageIndex) + (g - SWAP(table->rangeArray[i].start)); - } - } - - return -1; + if (SWAP(coverage->format) == 1) { + const CoverageFormat1 *table = (const CoverageFormat1 *) coverage; + for (int i = 0; i < SWAP(table->glyphCount); i++) { + if (SWAP(table->glyphArray[i]) == g) + return i; + } + } else if (SWAP(coverage->format) == 2) { + const CoverageFormat2 *table = (const CoverageFormat2 *) coverage; + for (int i = 0; i < SWAP(table->rangeCount); i++) { + if (SWAP(table->rangeArray[i].start) <= g && SWAP(table->rangeArray[i].end) >= g) + return SWAP(table->rangeArray[i].startCoverageIndex) + (g - SWAP(table->rangeArray[i].start)); + } + } + + return -1; } static int16_t getMathConstant(XeTeXFontInst* fontInst, mathConstantIndex whichConstant) { - const char* table = fontInst->getMathTable(); - if (table == NULL) - return 0; - - const uint16_t* constants = (const uint16_t*)(table + SWAP(((const MathTableHeader*)table)->mathConstants)); - - if (whichConstant < firstMathValueRecord) { - /* it's a simple 16-bit value */ - return SWAP(constants[whichConstant]); - } - else if (whichConstant <= lastMathValueRecord) { - const MathValueRecord* valueRecords = (const MathValueRecord*) - ((char*)constants + firstMathValueRecord * sizeof(uint16_t) - firstMathValueRecord * sizeof(MathValueRecord)); - return SWAP(valueRecords[whichConstant].value); - } - else if (whichConstant <= lastMathConstant) { - return SWAP(constants[whichConstant + (lastMathValueRecord - firstMathValueRecord + 1)]); - } - else - return 0; /* or abort, with "internal error" or something */ + const char* table = fontInst->getMathTable(); + if (table == NULL) + return 0; + + const uint16_t* constants = (const uint16_t*)(table + SWAP(((const MathTableHeader*)table)->mathConstants)); + + if (whichConstant < firstMathValueRecord) { + /* it's a simple 16-bit value */ + return SWAP(constants[whichConstant]); + } + else if (whichConstant <= lastMathValueRecord) { + const MathValueRecord* valueRecords = (const MathValueRecord*) + ((char*)constants + firstMathValueRecord * sizeof(uint16_t) - firstMathValueRecord * sizeof(MathValueRecord)); + return SWAP(valueRecords[whichConstant].value); + } + else if (whichConstant <= lastMathConstant) { + return SWAP(constants[whichConstant + (lastMathValueRecord - firstMathValueRecord + 1)]); + } + else + return 0; /* or abort, with "internal error" or something */ } int get_ot_math_constant(int f, int n) { - int rval = 0; - - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); - rval = getMathConstant(font, (mathConstantIndex)n); - /* scale according to font size, except the ones that are percentages */ - if (n > scriptScriptPercentScaleDown && n < radicalDegreeBottomRaisePercent) - rval = D2Fix(font->unitsToPoints(rval)); - } - return rval; + int rval = 0; + + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); + rval = getMathConstant(font, (mathConstantIndex)n); + /* scale according to font size, except the ones that are percentages */ + if (n > scriptScriptPercentScaleDown && n < radicalDegreeBottomRaisePercent) + rval = D2Fix(font->unitsToPoints(rval)); + } + return rval; } /* fontdimen IDs for math symbols font (family 2) */ -#define math_x_height 5 -#define math_quad 6 -#define num1 8 /* numerator shift-up in display styles */ -#define num2 9 /* numerator shift-up in non-display, non-\.{\\atop} */ -#define num3 10 /* numerator shift-up in non-display \.{\\atop} */ -#define denom1 11 /* denominator shift-down in display styles */ -#define denom2 12 /* denominator shift-down in non-display styles */ -#define sup1 13 /* superscript shift-up in uncramped display style */ -#define sup2 14 /* superscript shift-up in uncramped non-display */ -#define sup3 15 /* superscript shift-up in cramped styles */ -#define sub1 16 /* subscript shift-down if superscript is absent */ -#define sub2 17 /* subscript shift-down if superscript is present */ -#define sup_drop 18 /* superscript baseline below top of large box */ -#define sub_drop 19 /* subscript baseline below bottom of large box */ -#define delim1 20 /* size of \.{\\atopwithdelims} delimiters */ -#define delim2 21 /* size of \.{\\atopwithdelims} delimiters in non-displays */ -#define axis_height 22 /* height of fraction lines above the baseline */ +#define math_x_height 5 +#define math_quad 6 +#define num1 8 /* numerator shift-up in display styles */ +#define num2 9 /* numerator shift-up in non-display, non-\.{\\atop} */ +#define num3 10 /* numerator shift-up in non-display \.{\\atop} */ +#define denom1 11 /* denominator shift-down in display styles */ +#define denom2 12 /* denominator shift-down in non-display styles */ +#define sup1 13 /* superscript shift-up in uncramped display style */ +#define sup2 14 /* superscript shift-up in uncramped non-display */ +#define sup3 15 /* superscript shift-up in cramped styles */ +#define sub1 16 /* subscript shift-down if superscript is absent */ +#define sub2 17 /* subscript shift-down if superscript is present */ +#define sup_drop 18 /* superscript baseline below top of large box */ +#define sub_drop 19 /* subscript baseline below bottom of large box */ +#define delim1 20 /* size of \.{\\atopwithdelims} delimiters */ +#define delim2 21 /* size of \.{\\atopwithdelims} delimiters in non-displays */ +#define axis_height 22 /* height of fraction lines above the baseline */ const mathConstantIndex TeX_sym_to_OT_map[] = { - unknown, - unknown, - unknown, - unknown, - unknown, - accentBaseHeight, // x-height - unknown, // quad - unknown, - fractionNumeratorDisplayStyleShiftUp, - fractionNumeratorShiftUp, - stackTopShiftUp, - fractionDenominatorDisplayStyleShiftDown, - fractionDenominatorShiftDown, - superscriptShiftUp, // ?? - superscriptShiftUp, // ?? - superscriptShiftUpCramped, - subscriptShiftDown, // ?? - subscriptShiftDown, // ?? - superscriptBaselineDropMax, // ?? - subscriptBaselineDropMin, // ?? - delimitedSubFormulaMinHeight, - unknown, // using quad instead for now - axisHeight + unknown, + unknown, + unknown, + unknown, + unknown, + accentBaseHeight, // x-height + unknown, // quad + unknown, + fractionNumeratorDisplayStyleShiftUp, + fractionNumeratorShiftUp, + stackTopShiftUp, + fractionDenominatorDisplayStyleShiftDown, + fractionDenominatorShiftDown, + superscriptShiftUp, // ?? + superscriptShiftUp, // ?? + superscriptShiftUpCramped, + subscriptShiftDown, // ?? + subscriptShiftDown, // ?? + superscriptBaselineDropMax, // ?? + subscriptBaselineDropMin, // ?? + delimitedSubFormulaMinHeight, + unknown, // using quad instead for now + axisHeight }; int get_native_mathsy_param(int f, int n) { - int rval = 0; - - if (n == math_quad || n == delim2) - rval = fontsize[f]; - else { - if (n < sizeof(TeX_sym_to_OT_map) / sizeof(mathConstantIndex)) { - mathConstantIndex ot_index = TeX_sym_to_OT_map[n]; - if (ot_index != unknown) - rval = get_ot_math_constant(f, (int)ot_index); - } - } -// fprintf(stderr, " math_sy(%d, %d) returns %.3f\n", f, n, Fix2D(rval)); - - return rval; + int rval = 0; + + if (n == math_quad || n == delim2) + rval = fontsize[f]; + else { + if (n < sizeof(TeX_sym_to_OT_map) / sizeof(mathConstantIndex)) { + mathConstantIndex ot_index = TeX_sym_to_OT_map[n]; + if (ot_index != unknown) + rval = get_ot_math_constant(f, (int)ot_index); + } + } +// fprintf(stderr, " math_sy(%d, %d) returns %.3f\n", f, n, Fix2D(rval)); + + return rval; } /* fontdimen IDs for math extension font (family 3) */ -#define default_rule_thickness 8 /* thickness of \.{\\over} bars */ -#define big_op_spacing1 9 /* minimum clearance above a displayed op */ -#define big_op_spacing2 10 /* minimum clearance below a displayed op */ -#define big_op_spacing3 11 /* minimum baselineskip above displayed op */ -#define big_op_spacing4 12 /* minimum baselineskip below displayed op */ -#define big_op_spacing5 13 /* padding above and below displayed limits */ +#define default_rule_thickness 8 /* thickness of \.{\\over} bars */ +#define big_op_spacing1 9 /* minimum clearance above a displayed op */ +#define big_op_spacing2 10 /* minimum clearance below a displayed op */ +#define big_op_spacing3 11 /* minimum baselineskip above displayed op */ +#define big_op_spacing4 12 /* minimum baselineskip below displayed op */ +#define big_op_spacing5 13 /* padding above and below displayed limits */ const mathConstantIndex TeX_ext_to_OT_map[] = { - unknown, - unknown, - unknown, - unknown, - unknown, - accentBaseHeight, // x-height - unknown, // quad - unknown, - fractionRuleThickness, // default_rule_thickness - upperLimitGapMin, // big_op_spacing1 - lowerLimitGapMin, // big_op_spacing2 - upperLimitBaselineRiseMin, // big_op_spacing3 - lowerLimitBaselineDropMin, // big_op_spacing4 - stackGapMin // big_op_spacing5 + unknown, + unknown, + unknown, + unknown, + unknown, + accentBaseHeight, // x-height + unknown, // quad + unknown, + fractionRuleThickness, // default_rule_thickness + upperLimitGapMin, // big_op_spacing1 + lowerLimitGapMin, // big_op_spacing2 + upperLimitBaselineRiseMin, // big_op_spacing3 + lowerLimitBaselineDropMin, // big_op_spacing4 + stackGapMin // big_op_spacing5 }; int get_native_mathex_param(int f, int n) { - int rval = 0; - - if (n == math_quad) - rval = fontsize[f]; - else { - if (n < sizeof(TeX_ext_to_OT_map) / sizeof(mathConstantIndex)) { - mathConstantIndex ot_index = TeX_ext_to_OT_map[n]; - if (ot_index != unknown) - rval = get_ot_math_constant(f, (int)ot_index); - } - } -// fprintf(stderr, " math_ex(%d, %d) returns %.3f\n", f, n, Fix2D(rval)); - - return rval; + int rval = 0; + + if (n == math_quad) + rval = fontsize[f]; + else { + if (n < sizeof(TeX_ext_to_OT_map) / sizeof(mathConstantIndex)) { + mathConstantIndex ot_index = TeX_ext_to_OT_map[n]; + if (ot_index != unknown) + rval = get_ot_math_constant(f, (int)ot_index); + } + } +// fprintf(stderr, " math_ex(%d, %d) returns %.3f\n", f, n, Fix2D(rval)); + + return rval; } int get_ot_math_variant(int f, int g, int v, integer* adv, int horiz) { - int rval = g; - *adv = -1; - - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); - - const char* table = font->getMathTable(); - if (table == NULL) - return rval; - - uint16_t offset = SWAP(((const MathTableHeader*)table)->mathVariants); - if (offset == 0) - return rval; - const MathVariants* variants = (const MathVariants*)(table + offset); - - offset = horiz ? SWAP(variants->horizGlyphCoverage) : SWAP(variants->vertGlyphCoverage); - if (offset == 0) - return rval; - const Coverage* coverage = (const Coverage*)(((const char*)variants) + offset); - - int32_t index = getCoverage(coverage, g); - if (index >= 0) { - if (horiz) - index += SWAP(variants->vertGlyphCount); - const MathGlyphConstruction* construction = (const MathGlyphConstruction*)(((const char*)variants) - + SWAP(variants->vertGlyphConstruction[index])); - if (v < SWAP(construction->variantCount)) { - rval = SWAP(construction->mathGlyphVariantRecord[v].variantGlyph); - *adv = D2Fix(font->unitsToPoints(SWAP(construction->mathGlyphVariantRecord[v].advanceMeasurement))); - } - } - } - - return rval; + int rval = g; + *adv = -1; + + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); + + const char* table = font->getMathTable(); + if (table == NULL) + return rval; + + uint16_t offset = SWAP(((const MathTableHeader*)table)->mathVariants); + if (offset == 0) + return rval; + const MathVariants* variants = (const MathVariants*)(table + offset); + + offset = horiz ? SWAP(variants->horizGlyphCoverage) : SWAP(variants->vertGlyphCoverage); + if (offset == 0) + return rval; + const Coverage* coverage = (const Coverage*)(((const char*)variants) + offset); + + int32_t index = getCoverage(coverage, g); + if (index >= 0) { + if (horiz) + index += SWAP(variants->vertGlyphCount); + const MathGlyphConstruction* construction = (const MathGlyphConstruction*)(((const char*)variants) + + SWAP(variants->vertGlyphConstruction[index])); + if (v < SWAP(construction->variantCount)) { + rval = SWAP(construction->mathGlyphVariantRecord[v].variantGlyph); + *adv = D2Fix(font->unitsToPoints(SWAP(construction->mathGlyphVariantRecord[v].advanceMeasurement))); + } + } + } + + return rval; } void* get_ot_assembly_ptr(int f, int g, int horiz) { - void* rval = NULL; - - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); - - const char* table = font->getMathTable(); - if (table == NULL) - return rval; - - uint16_t offset = SWAP(((const MathTableHeader*)table)->mathVariants); - if (offset == 0) - return rval; - const MathVariants* variants = (const MathVariants*)(table + offset); - - offset = horiz ? SWAP(variants->horizGlyphCoverage) : SWAP(variants->vertGlyphCoverage); - if (offset == 0) - return rval; - const Coverage* coverage = (const Coverage*)(((const char*)variants) + offset); - - int32_t index = getCoverage(coverage, g); - if (index >= 0) { - if (horiz) - index += SWAP(variants->vertGlyphCount); - const MathGlyphConstruction* construction = (const MathGlyphConstruction*)(((const char*)variants) - + SWAP(variants->vertGlyphConstruction[index])); - offset = SWAP(construction->glyphAssembly); - if (offset != 0) - rval = (void*)(((const char*)construction) + offset); - } - } - - return rval; + void* rval = NULL; + + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); + + const char* table = font->getMathTable(); + if (table == NULL) + return rval; + + uint16_t offset = SWAP(((const MathTableHeader*)table)->mathVariants); + if (offset == 0) + return rval; + const MathVariants* variants = (const MathVariants*)(table + offset); + + offset = horiz ? SWAP(variants->horizGlyphCoverage) : SWAP(variants->vertGlyphCoverage); + if (offset == 0) + return rval; + const Coverage* coverage = (const Coverage*)(((const char*)variants) + offset); + + int32_t index = getCoverage(coverage, g); + if (index >= 0) { + if (horiz) + index += SWAP(variants->vertGlyphCount); + const MathGlyphConstruction* construction = (const MathGlyphConstruction*)(((const char*)variants) + + SWAP(variants->vertGlyphConstruction[index])); + offset = SWAP(construction->glyphAssembly); + if (offset != 0) + rval = (void*)(((const char*)construction) + offset); + } + } + + return rval; } int get_ot_math_ital_corr(int f, int g) { - int rval = 0; - - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); - - const char* table = font->getMathTable(); - if (table == NULL) - return rval; - - uint16_t offset = SWAP(((const MathTableHeader*)table)->mathGlyphInfo); - if (offset == 0) - return rval; - const MathGlyphInfo* glyphInfo = (const MathGlyphInfo*)(table + offset); - - offset = SWAP(glyphInfo->mathItalicsCorrectionInfo); - if (offset == 0) - return rval; - const MathItalicsCorrectionInfo* italCorrInfo = (const MathItalicsCorrectionInfo*)(((const char*)glyphInfo) + offset); - - offset = SWAP(italCorrInfo->coverage); - if (offset == 0) - return rval; - const Coverage* coverage = (const Coverage*)(((const char*)italCorrInfo) + offset); - - int32_t index = getCoverage(coverage, g); - if (index >= 0 && index < SWAP(italCorrInfo->italicsCorrectionCount)) - rval = D2Fix(font->unitsToPoints(SWAP(italCorrInfo->italicsCorrection[index].value))); - } - - return rval; + int rval = 0; + + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); + + const char* table = font->getMathTable(); + if (table == NULL) + return rval; + + uint16_t offset = SWAP(((const MathTableHeader*)table)->mathGlyphInfo); + if (offset == 0) + return rval; + const MathGlyphInfo* glyphInfo = (const MathGlyphInfo*)(table + offset); + + offset = SWAP(glyphInfo->mathItalicsCorrectionInfo); + if (offset == 0) + return rval; + const MathItalicsCorrectionInfo* italCorrInfo = (const MathItalicsCorrectionInfo*)(((const char*)glyphInfo) + offset); + + offset = SWAP(italCorrInfo->coverage); + if (offset == 0) + return rval; + const Coverage* coverage = (const Coverage*)(((const char*)italCorrInfo) + offset); + + int32_t index = getCoverage(coverage, g); + if (index >= 0 && index < SWAP(italCorrInfo->italicsCorrectionCount)) + rval = D2Fix(font->unitsToPoints(SWAP(italCorrInfo->italicsCorrection[index].value))); + } + + return rval; } int get_ot_math_accent_pos(int f, int g) { - int rval = 0x7fffffffUL; - - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); - - const char* table = font->getMathTable(); - if (table == NULL) - return rval; - - uint16_t offset = SWAP(((const MathTableHeader*)table)->mathGlyphInfo); - if (offset == 0) - return rval; - const MathGlyphInfo* glyphInfo = (const MathGlyphInfo*)(table + offset); - - offset = SWAP(glyphInfo->mathTopAccentAttachment); - if (offset == 0) - return rval; - const MathTopAccentAttachment* accentAttachment = (const MathTopAccentAttachment*)(((const char*)glyphInfo) + offset); - - offset = SWAP(accentAttachment->coverage); - if (offset == 0) - return rval; - const Coverage* coverage = (const Coverage*)(((const char*)accentAttachment) + offset); - - int32_t index = getCoverage(coverage, g); - if (index >= 0 && index < SWAP(accentAttachment->topAccentAttachmentCount)) { - rval = (int16_t)SWAP(accentAttachment->topAccentAttachment[index].value); - rval = D2Fix(font->unitsToPoints(rval)); - } - } - - return rval; + int rval = 0x7fffffffUL; + + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); + + const char* table = font->getMathTable(); + if (table == NULL) + return rval; + + uint16_t offset = SWAP(((const MathTableHeader*)table)->mathGlyphInfo); + if (offset == 0) + return rval; + const MathGlyphInfo* glyphInfo = (const MathGlyphInfo*)(table + offset); + + offset = SWAP(glyphInfo->mathTopAccentAttachment); + if (offset == 0) + return rval; + const MathTopAccentAttachment* accentAttachment = (const MathTopAccentAttachment*)(((const char*)glyphInfo) + offset); + + offset = SWAP(accentAttachment->coverage); + if (offset == 0) + return rval; + const Coverage* coverage = (const Coverage*)(((const char*)accentAttachment) + offset); + + int32_t index = getCoverage(coverage, g); + if (index >= 0 && index < SWAP(accentAttachment->topAccentAttachmentCount)) { + rval = (int16_t)SWAP(accentAttachment->topAccentAttachment[index].value); + rval = D2Fix(font->unitsToPoints(rval)); + } + } + + return rval; } int ot_min_connector_overlap(int f) { - int rval = 0; - - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); + int rval = 0; - const char* table = font->getMathTable(); - if (table == NULL) - return rval; + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); - uint16_t offset = SWAP(((const MathTableHeader*)table)->mathVariants); - if (offset == 0) - return rval; - const MathVariants* variants = (const MathVariants*)(table + offset); + const char* table = font->getMathTable(); + if (table == NULL) + return rval; - rval = D2Fix(font->unitsToPoints(SWAP(variants->minConnectorOverlap))); - } + uint16_t offset = SWAP(((const MathTableHeader*)table)->mathVariants); + if (offset == 0) + return rval; + const MathVariants* variants = (const MathVariants*)(table + offset); - return rval; + rval = D2Fix(font->unitsToPoints(SWAP(variants->minConnectorOverlap))); + } + + return rval; } typedef enum { - topRight, - topLeft, - bottomRight, - bottomLeft, + topRight, + topLeft, + bottomRight, + bottomLeft, } MathKernSide; static int getMathKernAt(int f, int g, MathKernSide side, int height) { - int rval = 0; - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); - - const char* table = font->getMathTable(); - if (table == NULL) - return rval; - - uint16_t offset = SWAP(((const MathTableHeader*)table)->mathGlyphInfo); - if (offset == 0) - return rval; - - const MathGlyphInfo* glyphInfo = (const MathGlyphInfo*)(table + offset); - - offset = SWAP(glyphInfo->mathKernInfo); - if (offset == 0) - return rval; - - const MathKernInfo* mathKernInfo = (const MathKernInfo*)(((const char*)glyphInfo) + offset); - - offset = SWAP(mathKernInfo->coverage); - if (offset == 0) - return rval; - - const Coverage* coverage = (const Coverage*)(((const char*)mathKernInfo) + offset); - - int32_t index = getCoverage(coverage, g); - if (index >= 0 && index < SWAP(mathKernInfo->kernInfoCount)) { - if (side == topRight) - offset = SWAP(mathKernInfo->kernInfo[index].topRight); - else if (side == bottomRight) - offset = SWAP(mathKernInfo->kernInfo[index].bottomRight); - else if (side == topLeft) - offset = SWAP(mathKernInfo->kernInfo[index].topLeft); - else if (side == bottomLeft) - offset = SWAP(mathKernInfo->kernInfo[index].bottomLeft); - else - assert(0); // we should not reach here - - if (offset == 0) - return rval; - - const MathKernTable* kernTable = (const MathKernTable*)(((const char*)mathKernInfo) + offset); - - uint16_t count = SWAP(kernTable->heightCount); - - // XXX: the following makes no sense WRT my understanding of the - // spec! it is just how things worked for me. - if (count == 0) - rval = SWAP(kernTable->kern[-1].value); - else if (height < SWAP(kernTable->height[0].value)) - rval = SWAP(kernTable->kern[1].value); - else if (height > SWAP(kernTable->height[count].value)) - rval = SWAP(kernTable->kern[count+1].value); - else { - for (int i = 0; i < count; i++) { - if (height > SWAP(kernTable->height[i].value)) { - rval = SWAP(kernTable->kern[i+1].value); - break; - } - } - } - - //fprintf(stderr, " kern: %f %f\n", font->unitsToPoints(height), font->unitsToPoints(rval)); - } - } - - return rval; + int rval = 0; + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); + + const char* table = font->getMathTable(); + if (table == NULL) + return rval; + + uint16_t offset = SWAP(((const MathTableHeader*)table)->mathGlyphInfo); + if (offset == 0) + return rval; + + const MathGlyphInfo* glyphInfo = (const MathGlyphInfo*)(table + offset); + + offset = SWAP(glyphInfo->mathKernInfo); + if (offset == 0) + return rval; + + const MathKernInfo* mathKernInfo = (const MathKernInfo*)(((const char*)glyphInfo) + offset); + + offset = SWAP(mathKernInfo->coverage); + if (offset == 0) + return rval; + + const Coverage* coverage = (const Coverage*)(((const char*)mathKernInfo) + offset); + + int32_t index = getCoverage(coverage, g); + if (index >= 0 && index < SWAP(mathKernInfo->kernInfoCount)) { + if (side == topRight) + offset = SWAP(mathKernInfo->kernInfo[index].topRight); + else if (side == bottomRight) + offset = SWAP(mathKernInfo->kernInfo[index].bottomRight); + else if (side == topLeft) + offset = SWAP(mathKernInfo->kernInfo[index].topLeft); + else if (side == bottomLeft) + offset = SWAP(mathKernInfo->kernInfo[index].bottomLeft); + else + assert(0); // we should not reach here + + if (offset == 0) + return rval; + + const MathKernTable* kernTable = (const MathKernTable*)(((const char*)mathKernInfo) + offset); + + uint16_t count = SWAP(kernTable->heightCount); + + // XXX: the following makes no sense WRT my understanding of the + // spec! it is just how things worked for me. + if (count == 0) + rval = SWAP(kernTable->kern[-1].value); + else if (height < SWAP(kernTable->height[0].value)) + rval = SWAP(kernTable->kern[1].value); + else if (height > SWAP(kernTable->height[count].value)) + rval = SWAP(kernTable->kern[count+1].value); + else { + for (int i = 0; i < count; i++) { + if (height > SWAP(kernTable->height[i].value)) { + rval = SWAP(kernTable->kern[i+1].value); + break; + } + } + } + + //fprintf(stderr, " kern: %f %f\n", font->unitsToPoints(height), font->unitsToPoints(rval)); + } + } + + return rval; } static float glyph_height(int f, int g) { - float rval = 0.0; + float rval = 0.0; - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[f]; - getGlyphHeightDepth(engine, g, &rval, NULL); - } + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[f]; + getGlyphHeightDepth(engine, g, &rval, NULL); + } - return rval; + return rval; } static float glyph_depth(int f, int g) { - float rval = 0.0; + float rval = 0.0; - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[f]; - getGlyphHeightDepth(engine, g, NULL, &rval); - } + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[f]; + getGlyphHeightDepth(engine, g, NULL, &rval); + } - return rval; + return rval; } // keep in sync with xetex.web @@ -506,104 +506,104 @@ glyph_depth(int f, int g) int get_ot_math_kern(int f, int g, int sf, int sg, int cmd, int shift) { - int rval = 0; + int rval = 0; - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); - int kern = 0, skern = 0; - float corr_height_top = 0.0, corr_height_bot = 0.0; + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); + int kern = 0, skern = 0; + float corr_height_top = 0.0, corr_height_bot = 0.0; - shift = Fix2D(shift); + shift = Fix2D(shift); - if (cmd == sup_cmd) { // superscript - corr_height_top = font->pointsToUnits(glyph_height(f, g)); - corr_height_bot = -font->pointsToUnits(glyph_depth(sf, sg) + shift); + if (cmd == sup_cmd) { // superscript + corr_height_top = font->pointsToUnits(glyph_height(f, g)); + corr_height_bot = -font->pointsToUnits(glyph_depth(sf, sg) + shift); - kern = getMathKernAt(f, g, topRight, corr_height_top); - skern = getMathKernAt(sf, sg, bottomLeft, corr_height_top); - rval = kern + skern; + kern = getMathKernAt(f, g, topRight, corr_height_top); + skern = getMathKernAt(sf, sg, bottomLeft, corr_height_top); + rval = kern + skern; - kern = getMathKernAt(f, g, topRight, corr_height_bot); - skern = getMathKernAt(sf, sg, bottomLeft, corr_height_bot); - if ((kern + skern) < rval) - rval = kern + skern; + kern = getMathKernAt(f, g, topRight, corr_height_bot); + skern = getMathKernAt(sf, sg, bottomLeft, corr_height_bot); + if ((kern + skern) < rval) + rval = kern + skern; - } else if (cmd == sub_cmd) { // subscript - corr_height_top = font->pointsToUnits(glyph_height(sf, sg) - shift); - corr_height_bot = -font->pointsToUnits(glyph_depth(f, g)); + } else if (cmd == sub_cmd) { // subscript + corr_height_top = font->pointsToUnits(glyph_height(sf, sg) - shift); + corr_height_bot = -font->pointsToUnits(glyph_depth(f, g)); - kern = getMathKernAt(f, g, bottomRight, corr_height_top); - skern = getMathKernAt(sf, sg, topLeft, corr_height_top); - rval = kern + skern; + kern = getMathKernAt(f, g, bottomRight, corr_height_top); + skern = getMathKernAt(sf, sg, topLeft, corr_height_top); + rval = kern + skern; - kern = getMathKernAt(f, g, bottomRight, corr_height_bot); - skern = getMathKernAt(sf, sg, topLeft, corr_height_bot); - if ((kern + skern) < rval) - rval = kern + skern; + kern = getMathKernAt(f, g, bottomRight, corr_height_bot); + skern = getMathKernAt(sf, sg, topLeft, corr_height_bot); + if ((kern + skern) < rval) + rval = kern + skern; - } else { - assert(0); // we should not reach here - } + } else { + assert(0); // we should not reach here + } - rval = D2Fix(font->unitsToPoints(rval)); - } + rval = D2Fix(font->unitsToPoints(rval)); + } - return rval; + return rval; } int ot_part_count(const GlyphAssembly* a) { - return SWAP(a->partCount); + return SWAP(a->partCount); } int ot_part_glyph(const GlyphAssembly* a, int i) { - return SWAP(a->partRecords[i].glyph); + return SWAP(a->partRecords[i].glyph); } int ot_part_is_extender(const GlyphAssembly* a, int i) { - return (SWAP(a->partRecords[i].partFlags) & fExtender) != 0; + return (SWAP(a->partRecords[i].partFlags) & fExtender) != 0; } int ot_part_start_connector(int f, const GlyphAssembly* a, int i) { - int rval = 0; - - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); - rval = D2Fix(font->unitsToPoints(SWAP(a->partRecords[i].startConnectorLength))); - } - - return rval; + int rval = 0; + + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); + rval = D2Fix(font->unitsToPoints(SWAP(a->partRecords[i].startConnectorLength))); + } + + return rval; } int ot_part_end_connector(int f, const GlyphAssembly* a, int i) { - int rval = 0; - - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); - rval = D2Fix(font->unitsToPoints(SWAP(a->partRecords[i].endConnectorLength))); - } - - return rval; + int rval = 0; + + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); + rval = D2Fix(font->unitsToPoints(SWAP(a->partRecords[i].endConnectorLength))); + } + + return rval; } int ot_part_full_advance(int f, const GlyphAssembly* a, int i) { - int rval = 0; - - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); - rval = D2Fix(font->unitsToPoints(SWAP(a->partRecords[i].fullAdvance))); - } - - return rval; + int rval = 0; + + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXFontInst* font = (XeTeXFontInst*)getFont((XeTeXLayoutEngine)fontlayoutengine[f]); + rval = D2Fix(font->unitsToPoints(SWAP(a->partRecords[i].fullAdvance))); + } + + return rval; } diff --git a/Build/source/texk/web2c/xetexdir/XeTeXOTMath.h b/Build/source/texk/web2c/xetexdir/XeTeXOTMath.h index 1304c84e76e..ba2cc873041 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeXOTMath.h +++ b/Build/source/texk/web2c/xetexdir/XeTeXOTMath.h @@ -40,21 +40,21 @@ authorization from the copyright holders. #ifdef __cplusplus extern "C" { #endif - int get_native_mathsy_param(int f, int n); - int get_native_mathex_param(int f, int n); - int get_ot_math_constant(int f, int n); - int get_ot_math_variant(int f, int g, int v, integer* adv, int horiz); - void* get_ot_assembly_ptr(int f, int g, int horiz); - int get_ot_math_ital_corr(int f, int g); - int get_ot_math_accent_pos(int f, int g); - int get_ot_math_kern(int f, int g, int sf, int sg, int cmd, int shift); - int ot_part_count(const GlyphAssembly* a); - int ot_part_glyph(const GlyphAssembly* a, int i); - int ot_part_is_extender(const GlyphAssembly* a, int i); - int ot_part_start_connector(int f, const GlyphAssembly* a, int i); - int ot_part_end_connector(int f, const GlyphAssembly* a, int i); - int ot_part_full_advance(int f, const GlyphAssembly* a, int i); - int ot_min_connector_overlap(int f); + int get_native_mathsy_param(int f, int n); + int get_native_mathex_param(int f, int n); + int get_ot_math_constant(int f, int n); + int get_ot_math_variant(int f, int g, int v, integer* adv, int horiz); + void* get_ot_assembly_ptr(int f, int g, int horiz); + int get_ot_math_ital_corr(int f, int g); + int get_ot_math_accent_pos(int f, int g); + int get_ot_math_kern(int f, int g, int sf, int sg, int cmd, int shift); + int ot_part_count(const GlyphAssembly* a); + int ot_part_glyph(const GlyphAssembly* a, int i); + int ot_part_is_extender(const GlyphAssembly* a, int i); + int ot_part_start_connector(int f, const GlyphAssembly* a, int i); + int ot_part_end_connector(int f, const GlyphAssembly* a, int i); + int ot_part_full_advance(int f, const GlyphAssembly* a, int i); + int ot_min_connector_overlap(int f); #ifdef __cplusplus }; #endif diff --git a/Build/source/texk/web2c/xetexdir/XeTeX_ext.c b/Build/source/texk/web2c/xetexdir/XeTeX_ext.c index afbce0bd4f1..721ab678724 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeX_ext.c +++ b/Build/source/texk/web2c/xetexdir/XeTeX_ext.c @@ -38,12 +38,10 @@ authorization from the copyright holders. #include <w2c/config.h> -#ifdef XETEX_OTHER -#include "poppler-config.h" -#include "png.h" -#endif - -#include "zlib.h" +#include <poppler-config.h> +#include <png.h> +#include <zlib.h> +#include <graphite2/Font.h> #ifdef _MSC_VER #undef timezone @@ -90,45 +88,45 @@ authorization from the copyright holders. #include <assert.h> -/* tables/values used in UTF-8 interpretation - +/* tables/values used in UTF-8 interpretation - code is based on ConvertUTF.[ch] sample code published by the Unicode consortium */ const uint32_t -offsetsFromUTF8[6] = { - 0x00000000UL, - 0x00003080UL, - 0x000E2080UL, - 0x03C82080UL, - 0xFA082080UL, - 0x82082080UL +offsetsFromUTF8[6] = { + 0x00000000UL, + 0x00003080UL, + 0x000E2080UL, + 0x03C82080UL, + 0xFA082080UL, + 0x82082080UL }; const uint8_t bytesFromUTF8[256] = { - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 }; const uint8_t firstByteMark[7] = { - 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC + 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; -const int halfShift = 10; -const uint32_t halfBase = 0x0010000UL; -const uint32_t halfMask = 0x3FFUL; -const uint32_t kSurrogateHighStart = 0xD800UL; -const uint32_t kSurrogateHighEnd = 0xDBFFUL; -const uint32_t kSurrogateLowStart = 0xDC00UL; -const uint32_t kSurrogateLowEnd = 0xDFFFUL; -const uint32_t byteMask = 0x000000BFUL; -const uint32_t byteMark = 0x00000080UL; +const int halfShift = 10; +const uint32_t halfBase = 0x0010000UL; +const uint32_t halfMask = 0x3FFUL; +const uint32_t kSurrogateHighStart = 0xD800UL; +const uint32_t kSurrogateHighEnd = 0xDBFFUL; +const uint32_t kSurrogateLowStart = 0xDC00UL; +const uint32_t kSurrogateLowEnd = 0xDFFFUL; +const uint32_t byteMask = 0x000000BFUL; +const uint32_t byteMark = 0x00000080UL; /* if the user specifies a paper size or output driver program */ @@ -138,184 +136,184 @@ const char *outputdriver = "xdvipdfmx -q -E"; /* default to portable xdvipdfmx d void initversionstring(char **versions) { -#ifdef XETEX_OTHER - int fc_version = FcGetVersion(); +#ifndef XETEX_MAC + int fc_version = FcGetVersion(); #endif - FT_Int ftMajor, ftMinor, ftPatch; - int grMajor, grMinor, grBugfix; - UVersionInfo icuVersion; - char icu_version[U_MAX_VERSION_STRING_LENGTH] = ""; - - const_string fmt = - "Compiled with ICU version %s; using %s\n" - "Compiled with zlib version %s; using %s\n" - "Compiled with FreeType2 version %d.%d.%d; using %d.%d.%d\n" - "Compiled with Graphite2 version %d.%d.%d; using %d.%d.%d\n" - "Compiled with HarfBuzz version %s; using %s\n" + FT_Int ftMajor, ftMinor, ftPatch; + int grMajor, grMinor, grBugfix; + UVersionInfo icuVersion; + char icu_version[U_MAX_VERSION_STRING_LENGTH] = ""; + + const_string fmt = + "Compiled with ICU version %s; using %s\n" + "Compiled with zlib version %s; using %s\n" + "Compiled with FreeType2 version %d.%d.%d; using %d.%d.%d\n" + "Compiled with Graphite2 version %d.%d.%d; using %d.%d.%d\n" + "Compiled with HarfBuzz version %s; using %s\n" + "Compiled with libpng version %s; using %s\n" + "Compiled with poppler version %s\n" #ifdef XETEX_MAC - "Using Mac OS X Core Text, Cocoa & ImageIO frameworks\n" + "Using Mac OS X Core Text and Cocoa frameworks\n" #else - "Compiled with fontconfig version %d.%d.%d; using %d.%d.%d\n" - "Compiled with libpng version %s; using %s\n" - "Compiled with poppler version %s\n" + "Compiled with fontconfig version %d.%d.%d; using %d.%d.%d\n" #endif - ; - - int len = strlen(fmt) - + strlen(U_ICU_VERSION) - + strlen(icu_version) - + strlen(ZLIB_VERSION) - + strlen(zlib_version) - + strlen(HB_VERSION_STRING) - + strlen(hb_version_string()) -#ifdef XETEX_OTHER - + strlen(PNG_LIBPNG_VER_STRING) - + strlen(png_libpng_ver) - + strlen(POPPLER_VERSION) - + 6 * 3 /* for fontconfig version #s (won't really need 3 digits per field!) */ + ; + + int len = strlen(fmt) + + strlen(U_ICU_VERSION) + + strlen(icu_version) + + strlen(ZLIB_VERSION) + + strlen(zlib_version) + + strlen(HB_VERSION_STRING) + + strlen(hb_version_string()) + + strlen(PNG_LIBPNG_VER_STRING) + + strlen(png_libpng_ver) + + strlen(POPPLER_VERSION) +#ifndef XETEX_MAC + + 6 * 3 /* for fontconfig version #s (won't really need 3 digits per field!) */ #endif - + 6 * 3 /* for graphite2 version #s (ditto) */ - + 6 * 3; /* for freetype version #s (ditto) */ + + 6 * 3 /* for graphite2 version #s (ditto) */ + + 6 * 3; /* for freetype version #s (ditto) */ - *versions = xmalloc(len + 1); - /* len will be more than enough, because of the placeholder chars in fmt - that get replaced by the arguments */ + *versions = (char *) xmalloc(len + 1); + /* len will be more than enough, because of the placeholder chars in fmt + that get replaced by the arguments */ - u_getVersion(icuVersion); - u_versionToString(icuVersion, icu_version); + u_getVersion(icuVersion); + u_versionToString(icuVersion, icu_version); - if (gFreeTypeLibrary == 0 && FT_Init_FreeType(&gFreeTypeLibrary) != 0) { - fprintf(stderr, "FreeType initialization failed!\n"); - exit(9); - } - FT_Library_Version(gFreeTypeLibrary, &ftMajor, &ftMinor, &ftPatch); + if (gFreeTypeLibrary == 0 && FT_Init_FreeType(&gFreeTypeLibrary) != 0) { + fprintf(stderr, "FreeType initialization failed!\n"); + exit(9); + } + FT_Library_Version(gFreeTypeLibrary, &ftMajor, &ftMinor, &ftPatch); - gr_engine_version(&grMajor, &grMinor, &grBugfix); + gr_engine_version(&grMajor, &grMinor, &grBugfix); (void)sprintf(*versions, fmt, - U_ICU_VERSION, icu_version, - ZLIB_VERSION, zlib_version, - FREETYPE_MAJOR, FREETYPE_MINOR, FREETYPE_PATCH, - ftMajor, ftMinor, ftPatch, - GR2_VERSION_MAJOR, GR2_VERSION_MINOR, GR2_VERSION_BUGFIX, - grMajor, grMinor, grBugfix, - HB_VERSION_STRING, hb_version_string() -#ifdef XETEX_OTHER - , - FC_VERSION / 10000, (FC_VERSION % 10000) / 100, FC_VERSION % 100, - fc_version / 10000, (fc_version % 10000) / 100, fc_version % 100, - PNG_LIBPNG_VER_STRING, png_libpng_ver, POPPLER_VERSION + U_ICU_VERSION, icu_version, + ZLIB_VERSION, zlib_version, + FREETYPE_MAJOR, FREETYPE_MINOR, FREETYPE_PATCH, + ftMajor, ftMinor, ftPatch, + GR2_VERSION_MAJOR, GR2_VERSION_MINOR, GR2_VERSION_BUGFIX, + grMajor, grMinor, grBugfix, + HB_VERSION_STRING, hb_version_string(), + PNG_LIBPNG_VER_STRING, png_libpng_ver, POPPLER_VERSION +#ifndef XETEX_MAC + , + FC_VERSION / 10000, (FC_VERSION % 10000) / 100, FC_VERSION % 100, + fc_version / 10000, (fc_version % 10000) / 100, fc_version % 100 #endif - ); + ); } void setinputfileencoding(UFILE* f, integer mode, integer encodingData) { - if ((f->encodingMode == ICUMAPPING) && (f->conversionData != NULL)) - ucnv_close((UConverter*)(f->conversionData)); - f->conversionData = 0; - - switch (mode) { - case UTF8: - case UTF16BE: - case UTF16LE: - case RAW: - f->encodingMode = mode; - break; - - case ICUMAPPING: - { - char* name = gettexstring(encodingData); - UErrorCode err = 0; - UConverter* cnv = ucnv_open(name, &err); - if (cnv == NULL) { - begindiagnostic(); - printnl('E'); - printcstring("rror "); - printint(err); - printcstring(" creating Unicode converter for `"); - printcstring(name); - printcstring("'; reading as raw bytes"); - enddiagnostic(1); - f->encodingMode = RAW; - } else { - f->encodingMode = ICUMAPPING; - f->conversionData = cnv; - } - free(name); - } - break; - } + if ((f->encodingMode == ICUMAPPING) && (f->conversionData != NULL)) + ucnv_close((UConverter*)(f->conversionData)); + f->conversionData = 0; + + switch (mode) { + case UTF8: + case UTF16BE: + case UTF16LE: + case RAW: + f->encodingMode = mode; + break; + + case ICUMAPPING: + { + char* name = gettexstring(encodingData); + UErrorCode err = U_ZERO_ERROR; + UConverter* cnv = ucnv_open(name, &err); + if (cnv == NULL) { + begindiagnostic(); + printnl('E'); + printcstring("rror "); + printint(err); + printcstring(" creating Unicode converter for `"); + printcstring(name); + printcstring("'; reading as raw bytes"); + enddiagnostic(1); + f->encodingMode = RAW; + } else { + f->encodingMode = ICUMAPPING; + f->conversionData = cnv; + } + free(name); + } + break; + } } void uclose(UFILE* f) { - if (f != 0) { - fclose(f->f); - if ((f->encodingMode == ICUMAPPING) && (f->conversionData != NULL)) - ucnv_close((UConverter*)(f->conversionData)); - free((void*)f); - } + if (f != 0) { + fclose(f->f); + if ((f->encodingMode == ICUMAPPING) && (f->conversionData != NULL)) + ucnv_close((UConverter*)(f->conversionData)); + free((void*)f); + } } static void buffer_overflow() { - fprintf (stderr, "! Unable to read an entire line---bufsize=%u.\n", - (unsigned) bufsize); - fputs ("Please increase buf_size in texmf.cnf.\n", stderr); - uexit (1); + fprintf (stderr, "! Unable to read an entire line---bufsize=%u.\n", + (unsigned) bufsize); + fputs ("Please increase buf_size in texmf.cnf.\n", stderr); + uexit (1); } static void conversion_error(int errcode) { - begindiagnostic(); - printnl('U'); - printcstring("nicode conversion failed (ICU error code = "); - printint(errcode); - printcstring(") discarding any remaining text"); - enddiagnostic(1); + begindiagnostic(); + printnl('U'); + printcstring("nicode conversion failed (ICU error code = "); + printint(errcode); + printcstring(") discarding any remaining text"); + enddiagnostic(1); } #ifdef WORDS_BIGENDIAN -#define NATIVE_UTF32 kForm_UTF32BE +#define NATIVE_UTF32 kForm_UTF32BE #else -#define NATIVE_UTF32 kForm_UTF32LE +#define NATIVE_UTF32 kForm_UTF32LE #endif static void apply_normalization(uint32_t* buf, int len, int norm) { - static TECkit_Converter normalizers[2] = { NULL, NULL }; - - TECkit_Status status; - UInt32 inUsed, outUsed; - TECkit_Converter *normPtr = &normalizers[norm - 1]; - if (*normPtr == NULL) { - status = TECkit_CreateConverter(NULL, 0, 1, - NATIVE_UTF32, NATIVE_UTF32 | (norm == 1 ? kForm_NFC : kForm_NFD), - &*normPtr); - if (status != kStatus_NoError) { - fprintf(stderr, "! Failed to create normalizer: error code = %d\n", (int)status); - uexit (1); - } - } + static TECkit_Converter normalizers[2] = { NULL, NULL }; + + TECkit_Status status; + UInt32 inUsed, outUsed; + TECkit_Converter *normPtr = &normalizers[norm - 1]; + if (*normPtr == NULL) { + status = TECkit_CreateConverter(NULL, 0, 1, + NATIVE_UTF32, NATIVE_UTF32 | (norm == 1 ? kForm_NFC : kForm_NFD), + &*normPtr); + if (status != kStatus_NoError) { + fprintf(stderr, "! Failed to create normalizer: error code = %d\n", (int)status); + uexit (1); + } + } - status = TECkit_ConvertBuffer(*normPtr, (Byte*)buf, len * sizeof(UInt32), &inUsed, - (Byte*)&buffer[first], sizeof(*buffer) * (bufsize - first), &outUsed, 1); - if (status != kStatus_NoError) - buffer_overflow(); - last = first + outUsed / sizeof(*buffer); + status = TECkit_ConvertBuffer(*normPtr, (Byte*)buf, len * sizeof(UInt32), &inUsed, + (Byte*)&buffer[first], sizeof(*buffer) * (bufsize - first), &outUsed, 1); + if (status != kStatus_NoError) + buffer_overflow(); + last = first + outUsed / sizeof(*buffer); } #ifdef WORDS_BIGENDIAN -#define UCNV_UTF32_NativeEndian UCNV_UTF32_BigEndian +#define UCNV_UTF32_NativeEndian UCNV_UTF32_BigEndian #else -#define UCNV_UTF32_NativeEndian UCNV_UTF32_LittleEndian +#define UCNV_UTF32_NativeEndian UCNV_UTF32_LittleEndian #endif int @@ -323,267 +321,265 @@ input_line(UFILE* f) { static char* byteBuffer = NULL; static uint32_t *utf32Buf = NULL; - int i, tmpLen; - int norm = getinputnormalizationstate(); + int i, tmpLen; + int norm = getinputnormalizationstate(); #ifdef WIN32 - const int fd = fileno(f->f); - if (fd == _fileno(stdin) && _isatty(fd)) { - f->encodingMode = WIN32CONSOLE; - } + const int fd = fileno(f->f); + if (fd == _fileno(stdin) && _isatty(fd)) { + f->encodingMode = WIN32CONSOLE; + } #endif - last = first; - - if (f->encodingMode == ICUMAPPING) { - uint32_t bytesRead = 0; - UConverter* cnv; - int outLen; - UErrorCode errorCode = 0; - - if (byteBuffer == NULL) - byteBuffer = xmalloc(bufsize + 1); - - /* Recognize either LF or CR as a line terminator; skip initial LF if prev line ended with CR. */ - i = getc(f->f); - if (f->skipNextLF) { - f->skipNextLF = 0; - if (i == '\n') - i = getc(f->f); - } - - if (i != EOF && i != '\n' && i != '\r') - byteBuffer[bytesRead++] = i; - if (i != EOF && i != '\n' && i != '\r') - while (bytesRead < bufsize && (i = getc(f->f)) != EOF && i != '\n' && i != '\r') - byteBuffer[bytesRead++] = i; - - if (i == EOF && errno != EINTR && bytesRead == 0) - return false; - - if (i != EOF && i != '\n' && i != '\r') - buffer_overflow(); - - /* now apply the mapping to turn external bytes into Unicode characters in buffer */ - cnv = (UConverter*)(f->conversionData); - switch (norm) { - case 1: // NFC - case 2: // NFD - if (utf32Buf == NULL) - utf32Buf = (uint32_t*)xmalloc(bufsize * sizeof(*utf32Buf)); - tmpLen = ucnv_toAlgorithmic(UCNV_UTF32_NativeEndian, cnv, - (char*)utf32Buf, bufsize * sizeof(*utf32Buf), - byteBuffer, bytesRead, &errorCode); - if (errorCode != 0) { - conversion_error((int)errorCode); - return false; - } - apply_normalization(utf32Buf, tmpLen / sizeof(*utf32Buf), norm); // sets 'last' correctly - break; - - default: // none - outLen = ucnv_toAlgorithmic(UCNV_UTF32_NativeEndian, cnv, - (char*)&buffer[first], sizeof(*buffer) * (bufsize - first), - byteBuffer, bytesRead, &errorCode); - if (errorCode != 0) { - conversion_error((int)errorCode); - return false; - } - outLen /= sizeof(*buffer); - last = first + outLen; - break; - } - } else { - /* Recognize either LF or CR as a line terminator; skip initial LF if prev line ended with CR. */ - i = get_uni_c(f); - if (f->skipNextLF) { - f->skipNextLF = 0; - if (i == '\n') - i = get_uni_c(f); - } - - switch (norm) { - case 1: // NFC - case 2: // NFD - // read Unicode chars into utf32Buf as UTF32 - if (utf32Buf == NULL) - utf32Buf = xmalloc(bufsize * sizeof(*utf32Buf)); - tmpLen = 0; - if (i != EOF && i != '\n' && i != '\r') - utf32Buf[tmpLen++] = i; - if (i != EOF && i != '\n' && i != '\r') - while (tmpLen < bufsize && (i = get_uni_c(f)) != EOF && i != '\n' && i != '\r') - utf32Buf[tmpLen++] = i; - - if (i == EOF && errno != EINTR && tmpLen == 0) - return false; - - /* We didn't get the whole line because our buffer was too small. */ - if (i != EOF && i != '\n' && i != '\r') - buffer_overflow(); - apply_normalization(utf32Buf, tmpLen, norm); - break; - - default: // none - if (last < bufsize && i != EOF && i != '\n' && i != '\r') - buffer[last++] = i; - if (i != EOF && i != '\n' && i != '\r') - while (last < bufsize && (i = get_uni_c(f)) != EOF && i != '\n' && i != '\r') - buffer[last++] = i; - - if (i == EOF && errno != EINTR && last == first) - return false; - - /* We didn't get the whole line because our buffer was too small. */ - if (i != EOF && i != '\n' && i != '\r') - buffer_overflow(); - break; - } - } - - /* If line ended with CR, remember to skip following LF. */ - if (i == '\r') - f->skipNextLF = 1; - - buffer[last] = ' '; - if (last >= maxbufstack) - maxbufstack = last; - - /* Trim trailing whitespace. */ - while (last > first && ISBLANK(buffer[last - 1])) - --last; - - return true; + last = first; + + if (f->encodingMode == ICUMAPPING) { + uint32_t bytesRead = 0; + UConverter* cnv; + int outLen; + UErrorCode errorCode = U_ZERO_ERROR; + + if (byteBuffer == NULL) + byteBuffer = (char*) xmalloc(bufsize + 1); + + /* Recognize either LF or CR as a line terminator; skip initial LF if prev line ended with CR. */ + i = getc(f->f); + if (f->skipNextLF) { + f->skipNextLF = 0; + if (i == '\n') + i = getc(f->f); + } + + if (i != EOF && i != '\n' && i != '\r') + byteBuffer[bytesRead++] = i; + if (i != EOF && i != '\n' && i != '\r') + while (bytesRead < bufsize && (i = getc(f->f)) != EOF && i != '\n' && i != '\r') + byteBuffer[bytesRead++] = i; + + if (i == EOF && errno != EINTR && bytesRead == 0) + return false; + + if (i != EOF && i != '\n' && i != '\r') + buffer_overflow(); + + /* now apply the mapping to turn external bytes into Unicode characters in buffer */ + cnv = (UConverter*)(f->conversionData); + switch (norm) { + case 1: // NFC + case 2: // NFD + if (utf32Buf == NULL) + utf32Buf = (uint32_t*) xcalloc(bufsize, sizeof(uint32_t)); + tmpLen = ucnv_toAlgorithmic(UCNV_UTF32_NativeEndian, cnv, + (char*)utf32Buf, bufsize * sizeof(*utf32Buf), + byteBuffer, bytesRead, &errorCode); + if (errorCode != 0) { + conversion_error((int)errorCode); + return false; + } + apply_normalization(utf32Buf, tmpLen / sizeof(*utf32Buf), norm); // sets 'last' correctly + break; + + default: // none + outLen = ucnv_toAlgorithmic(UCNV_UTF32_NativeEndian, cnv, + (char*)&buffer[first], sizeof(*buffer) * (bufsize - first), + byteBuffer, bytesRead, &errorCode); + if (errorCode != 0) { + conversion_error((int)errorCode); + return false; + } + outLen /= sizeof(*buffer); + last = first + outLen; + break; + } + } else { + /* Recognize either LF or CR as a line terminator; skip initial LF if prev line ended with CR. */ + i = get_uni_c(f); + if (f->skipNextLF) { + f->skipNextLF = 0; + if (i == '\n') + i = get_uni_c(f); + } + + switch (norm) { + case 1: // NFC + case 2: // NFD + // read Unicode chars into utf32Buf as UTF32 + if (utf32Buf == NULL) + utf32Buf = (uint32_t*) xcalloc(bufsize, sizeof(uint32_t)); + tmpLen = 0; + if (i != EOF && i != '\n' && i != '\r') + utf32Buf[tmpLen++] = i; + if (i != EOF && i != '\n' && i != '\r') + while (tmpLen < bufsize && (i = get_uni_c(f)) != EOF && i != '\n' && i != '\r') + utf32Buf[tmpLen++] = i; + + if (i == EOF && errno != EINTR && tmpLen == 0) + return false; + + /* We didn't get the whole line because our buffer was too small. */ + if (i != EOF && i != '\n' && i != '\r') + buffer_overflow(); + apply_normalization(utf32Buf, tmpLen, norm); + break; + + default: // none + if (last < bufsize && i != EOF && i != '\n' && i != '\r') + buffer[last++] = i; + if (i != EOF && i != '\n' && i != '\r') + while (last < bufsize && (i = get_uni_c(f)) != EOF && i != '\n' && i != '\r') + buffer[last++] = i; + + if (i == EOF && errno != EINTR && last == first) + return false; + + /* We didn't get the whole line because our buffer was too small. */ + if (i != EOF && i != '\n' && i != '\r') + buffer_overflow(); + break; + } + } + + /* If line ended with CR, remember to skip following LF. */ + if (i == '\r') + f->skipNextLF = 1; + + buffer[last] = ' '; + if (last >= maxbufstack) + maxbufstack = last; + + /* Trim trailing whitespace. */ + while (last > first && ISBLANK(buffer[last - 1])) + --last; + + return true; } static void die(const_string s, int i) { - fprintf(stderr, s, i); - fprintf(stderr, " - exiting\n"); - exit(3); + fprintf(stderr, s, i); + fprintf(stderr, " - exiting\n"); + exit(3); } -static UBreakIterator* brkIter = NULL; -static int brkLocaleStrNum = 0; +static UBreakIterator* brkIter = NULL; +static int brkLocaleStrNum = 0; void linebreakstart(int f, integer localeStrNum, const uint16_t* text, integer textLength) { - UErrorCode status; - char* locale = (char*)gettexstring(localeStrNum); - - if (fontarea[f] == OTGR_FONT_FLAG && strcmp(locale, "G") == 0) { - XeTeXLayoutEngine engine = (XeTeXLayoutEngine) fontlayoutengine[f]; - if (initGraphiteBreaking(engine, text, textLength)) - /* user asked for Graphite line breaking and the font supports it */ - return; - } - - status = 0; - - if ((localeStrNum != brkLocaleStrNum) && (brkIter != NULL)) { - ubrk_close(brkIter); - brkIter = NULL; - } - - if (brkIter == NULL) { - brkIter = ubrk_open(UBRK_LINE, locale, NULL, 0, &status); - if (U_FAILURE(status)) { - begindiagnostic(); - printnl('E'); - printcstring("rror "); - printint(status); - printcstring(" creating linebreak iterator for locale `"); - printcstring(locale); - printcstring("'; trying default locale `en_us'."); - enddiagnostic(1); - if (brkIter != NULL) - ubrk_close(brkIter); - status = 0; - brkIter = ubrk_open(UBRK_LINE, "en_us", NULL, 0, &status); - } - free(locale); - brkLocaleStrNum = localeStrNum; - } - - if (brkIter == NULL) { - die("! failed to create linebreak iterator, status=%d", (int)status); - } - - ubrk_setText(brkIter, text, textLength, &status); + UErrorCode status = U_ZERO_ERROR; + char* locale = (char*)gettexstring(localeStrNum); + + if (fontarea[f] == OTGR_FONT_FLAG && strcmp(locale, "G") == 0) { + XeTeXLayoutEngine engine = (XeTeXLayoutEngine) fontlayoutengine[f]; + if (initGraphiteBreaking(engine, text, textLength)) + /* user asked for Graphite line breaking and the font supports it */ + return; + } + + if ((localeStrNum != brkLocaleStrNum) && (brkIter != NULL)) { + ubrk_close(brkIter); + brkIter = NULL; + } + + if (brkIter == NULL) { + brkIter = ubrk_open(UBRK_LINE, locale, NULL, 0, &status); + if (U_FAILURE(status)) { + begindiagnostic(); + printnl('E'); + printcstring("rror "); + printint(status); + printcstring(" creating linebreak iterator for locale `"); + printcstring(locale); + printcstring("'; trying default locale `en_us'."); + enddiagnostic(1); + if (brkIter != NULL) + ubrk_close(brkIter); + status = U_ZERO_ERROR; + brkIter = ubrk_open(UBRK_LINE, "en_us", NULL, 0, &status); + } + free(locale); + brkLocaleStrNum = localeStrNum; + } + + if (brkIter == NULL) { + die("! failed to create linebreak iterator, status=%d", (int)status); + } + + ubrk_setText(brkIter, (UChar*) text, textLength, &status); } int linebreaknext() { - if (brkIter != NULL) - return ubrk_next((UBreakIterator*)brkIter); - else - return findNextGraphiteBreak(); + if (brkIter != NULL) + return ubrk_next((UBreakIterator*)brkIter); + else + return findNextGraphiteBreak(); } int getencodingmodeandinfo(integer* info) { - /* \XeTeXinputencoding "enc-name" - * -> name is packed in |nameoffile| as a C string, starting at [1] - * Check if it's a built-in name; if not, try to open an ICU converter by that name - */ - UErrorCode err = 0; - UConverter* cnv; - char* name = (char*)nameoffile + 1; - *info = 0; - if (strcasecmp(name, "auto") == 0) { - return AUTO; - } - if (strcasecmp(name, "utf8") == 0) { - return UTF8; - } - if (strcasecmp(name, "utf16") == 0) { /* depends on host platform */ + /* \XeTeXinputencoding "enc-name" + * -> name is packed in |nameoffile| as a C string, starting at [1] + * Check if it's a built-in name; if not, try to open an ICU converter by that name + */ + UErrorCode err = U_ZERO_ERROR; + UConverter* cnv; + char* name = (char*)nameoffile + 1; + *info = 0; + if (strcasecmp(name, "auto") == 0) { + return AUTO; + } + if (strcasecmp(name, "utf8") == 0) { + return UTF8; + } + if (strcasecmp(name, "utf16") == 0) { /* depends on host platform */ #ifdef WORDS_BIGENDIAN - return UTF16BE; + return UTF16BE; #else - return UTF16LE; + return UTF16LE; #endif - } - if (strcasecmp(name, "utf16be") == 0) { - return UTF16BE; - } - if (strcasecmp(name, "utf16le") == 0) { - return UTF16LE; - } - if (strcasecmp(name, "bytes") == 0) { - return RAW; - } - - /* try for an ICU converter */ - cnv = ucnv_open(name, &err); - if (cnv == NULL) { - begindiagnostic(); - printnl('U'); /* ensure message starts on a new line */ - printcstring("nknown encoding `"); - printcstring(name); - printcstring("'; reading as raw bytes"); - enddiagnostic(1); - return RAW; - } else { - ucnv_close(cnv); - *info = maketexstring(name); - return ICUMAPPING; - } + } + if (strcasecmp(name, "utf16be") == 0) { + return UTF16BE; + } + if (strcasecmp(name, "utf16le") == 0) { + return UTF16LE; + } + if (strcasecmp(name, "bytes") == 0) { + return RAW; + } + + /* try for an ICU converter */ + cnv = ucnv_open(name, &err); + if (cnv == NULL) { + begindiagnostic(); + printnl('U'); /* ensure message starts on a new line */ + printcstring("nknown encoding `"); + printcstring(name); + printcstring("'; reading as raw bytes"); + enddiagnostic(1); + return RAW; + } else { + ucnv_close(cnv); + *info = maketexstring(name); + return ICUMAPPING; + } } void printutf8str(const unsigned char* str, int len) { - while (len-- > 0) - printrawchar(*(str++), true); /* bypass utf-8 encoding done in print_char() */ + while (len-- > 0) + printrawchar(*(str++), true); /* bypass utf-8 encoding done in print_char() */ } void printchars(const unsigned short* str, int len) { - while (len-- > 0) - printchar(*(str++)); + while (len-- > 0) + printchar(*(str++)); } #ifdef WORDS_BIGENDIAN @@ -595,1728 +591,1737 @@ printchars(const unsigned short* str, int len) static void* load_mapping_file(const char* s, const char* e, char byteMapping) { - char* mapPath; - TECkit_Converter cnv = 0; - char* buffer = xmalloc(e - s + 5); - strncpy(buffer, s, e - s); - buffer[e - s] = 0; - strcat(buffer, ".tec"); - mapPath = kpse_find_file(buffer, kpse_miscfonts_format, 1); - - if (mapPath) { - FILE* mapFile = fopen(mapPath, FOPEN_RBIN_MODE); - free(mapPath); - if (mapFile) { - uint32_t mappingSize; - Byte* mapping; - TECkit_Status status; - fseek(mapFile, 0, SEEK_END); - mappingSize = ftell(mapFile); - fseek(mapFile, 0, SEEK_SET); - mapping = xmalloc(mappingSize); - fread(mapping, 1, mappingSize, mapFile); - fclose(mapFile); - if (byteMapping != 0) - status = TECkit_CreateConverter(mapping, mappingSize, - false, - UTF16_NATIVE, kForm_Bytes, - &cnv); - else - status = TECkit_CreateConverter(mapping, mappingSize, - true, - UTF16_NATIVE, UTF16_NATIVE, - &cnv); - free(mapping); - } - if (cnv == NULL) - fontmappingwarning(buffer, strlen(buffer), 2); /* not loadable */ - else if (gettracingfontsstate() > 1) - fontmappingwarning(buffer, strlen(buffer), 0); /* tracing */ - } else { - fontmappingwarning(buffer, strlen(buffer), 1); /* not found */ - } - - free(buffer); - - return cnv; + char* mapPath; + TECkit_Converter cnv = 0; + char* buffer = (char*) xmalloc(e - s + 5); + strncpy(buffer, s, e - s); + buffer[e - s] = 0; + strcat(buffer, ".tec"); + mapPath = kpse_find_file(buffer, kpse_miscfonts_format, 1); + + if (mapPath) { + FILE* mapFile = fopen(mapPath, FOPEN_RBIN_MODE); + free(mapPath); + if (mapFile) { + uint32_t mappingSize; + Byte* mapping; + TECkit_Status status; + fseek(mapFile, 0, SEEK_END); + mappingSize = ftell(mapFile); + fseek(mapFile, 0, SEEK_SET); + mapping = (Byte*) xmalloc(mappingSize); + fread(mapping, 1, mappingSize, mapFile); + fclose(mapFile); + if (byteMapping != 0) + status = TECkit_CreateConverter(mapping, mappingSize, + false, + UTF16_NATIVE, kForm_Bytes, + &cnv); + else + status = TECkit_CreateConverter(mapping, mappingSize, + true, + UTF16_NATIVE, UTF16_NATIVE, + &cnv); + free(mapping); + } + if (cnv == NULL) + fontmappingwarning(buffer, strlen(buffer), 2); /* not loadable */ + else if (gettracingfontsstate() > 1) + fontmappingwarning(buffer, strlen(buffer), 0); /* tracing */ + } else { + fontmappingwarning(buffer, strlen(buffer), 1); /* not found */ + } + + free(buffer); + + return cnv; } char *saved_mapping_name = NULL; void checkfortfmfontmapping() { - char* cp = strstr((char*)nameoffile + 1, ":mapping="); - if (saved_mapping_name != NULL) { - free(saved_mapping_name); - saved_mapping_name = NULL; - } - if (cp != NULL) { - *cp = 0; - cp += 9; - while (*cp && *cp <= ' ') - ++cp; - if (*cp) - saved_mapping_name = xstrdup(cp); - } + char* cp = strstr((char*)nameoffile + 1, ":mapping="); + if (saved_mapping_name != NULL) { + free(saved_mapping_name); + saved_mapping_name = NULL; + } + if (cp != NULL) { + *cp = 0; + cp += 9; + while (*cp && *cp <= ' ') + ++cp; + if (*cp) + saved_mapping_name = xstrdup(cp); + } } void* loadtfmfontmapping() { - void* rval = NULL; - if (saved_mapping_name != NULL) { - rval = load_mapping_file(saved_mapping_name, - saved_mapping_name + strlen(saved_mapping_name), 1); - free(saved_mapping_name); - saved_mapping_name = NULL; - } - return rval; + void* rval = NULL; + if (saved_mapping_name != NULL) { + rval = load_mapping_file(saved_mapping_name, + saved_mapping_name + strlen(saved_mapping_name), 1); + free(saved_mapping_name); + saved_mapping_name = NULL; + } + return rval; } int applytfmfontmapping(void* cnv, int c) { - UniChar in = c; - Byte out[2]; - UInt32 inUsed, outUsed; - TECkit_Status status = TECkit_ConvertBuffer((TECkit_Converter)cnv, - (const Byte*)&in, sizeof(in), &inUsed, out, sizeof(out), &outUsed, 1); - if (outUsed < 1) - return 0; - else - return out[0]; + UniChar in = c; + Byte out[2]; + UInt32 inUsed, outUsed; + TECkit_Status status = TECkit_ConvertBuffer((TECkit_Converter)cnv, + (const Byte*)&in, sizeof(in), &inUsed, out, sizeof(out), &outUsed, 1); + if (outUsed < 1) + return 0; + else + return out[0]; } double read_double(const char** s) { - int neg = 0; - double val = 0.0; - const char* cp = *s; - - while (*cp == ' '|| *cp == '\t') - ++cp; - if (*cp == '-') { - neg = 1; - ++cp; - } else if (*cp == '+') { - ++cp; - } - - while (*cp >= '0' && *cp <= '9') { - val = val * 10.0 + *cp - '0'; - ++cp; - } - if (*cp == '.') { - double dec = 10.0; - ++cp; - while (*cp >= '0' && *cp <= '9') { - val = val + (*cp - '0') / dec; - ++cp; - dec = dec * 10.0; - } - } - *s = cp; - - return neg ? -val : val; + int neg = 0; + double val = 0.0; + const char* cp = *s; + + while (*cp == ' '|| *cp == '\t') + ++cp; + if (*cp == '-') { + neg = 1; + ++cp; + } else if (*cp == '+') { + ++cp; + } + + while (*cp >= '0' && *cp <= '9') { + val = val * 10.0 + *cp - '0'; + ++cp; + } + if (*cp == '.') { + double dec = 10.0; + ++cp; + while (*cp >= '0' && *cp <= '9') { + val = val + (*cp - '0') / dec; + ++cp; + dec = dec * 10.0; + } + } + *s = cp; + + return neg ? -val : val; } static hb_tag_t read_tag_with_param(const char* cp, int* param) { - const char* cp2; - hb_tag_t tag; - - cp2 = cp; - while (*cp2 && (*cp2 != ':') && (*cp2 != ';') && (*cp2 != ',') && (*cp2 != '=')) - ++cp2; - - tag = hb_tag_from_string(cp, cp2 - cp); - - cp = cp2; - if (*cp == '=') { - int neg = 0; - ++cp; - if (*cp == '-') { - ++neg; - ++cp; - } - while (*cp >= '0' && *cp <= '9') { - *param = *param * 10 + *cp - '0'; - ++cp; - } - if (neg) - *param = -(*param); - } + const char* cp2; + hb_tag_t tag; + + cp2 = cp; + while (*cp2 && (*cp2 != ':') && (*cp2 != ';') && (*cp2 != ',') && (*cp2 != '=')) + ++cp2; + + tag = hb_tag_from_string(cp, cp2 - cp); + + cp = cp2; + if (*cp == '=') { + int neg = 0; + ++cp; + if (*cp == '-') { + ++neg; + ++cp; + } + while (*cp >= '0' && *cp <= '9') { + *param = *param * 10 + *cp - '0'; + ++cp; + } + if (neg) + *param = -(*param); + } - return tag; + return tag; } unsigned int read_rgb_a(const char** cp) { - uint32_t rgbValue = 0; - uint32_t alpha = 0; - int i; - for (i = 0; i < 6; ++i) { - if ((**cp >= '0') && (**cp <= '9')) - rgbValue = (rgbValue << 4) + **cp - '0'; - else if ((**cp >= 'A') && (**cp <= 'F')) - rgbValue = (rgbValue << 4) + **cp - 'A' + 10; - else if ((**cp >= 'a') && (**cp <= 'f')) - rgbValue = (rgbValue << 4) + **cp - 'a' + 10; - else - return 0x000000FF; - (*cp)++; - } - rgbValue <<= 8; - for (i = 0; i < 2; ++i) { - if ((**cp >= '0') && (**cp <= '9')) - alpha = (alpha << 4) + **cp - '0'; - else if ((**cp >= 'A') && (**cp <= 'F')) - alpha = (alpha << 4) + **cp - 'A' + 10; - else if ((**cp >= 'a') && (**cp <= 'f')) - alpha = (alpha << 4) + **cp - 'a' + 10; - else - break; - (*cp)++; - } - if (i == 2) - rgbValue += alpha; - else - rgbValue += 0xFF; - return rgbValue; + uint32_t rgbValue = 0; + uint32_t alpha = 0; + int i; + for (i = 0; i < 6; ++i) { + if ((**cp >= '0') && (**cp <= '9')) + rgbValue = (rgbValue << 4) + **cp - '0'; + else if ((**cp >= 'A') && (**cp <= 'F')) + rgbValue = (rgbValue << 4) + **cp - 'A' + 10; + else if ((**cp >= 'a') && (**cp <= 'f')) + rgbValue = (rgbValue << 4) + **cp - 'a' + 10; + else + return 0x000000FF; + (*cp)++; + } + rgbValue <<= 8; + for (i = 0; i < 2; ++i) { + if ((**cp >= '0') && (**cp <= '9')) + alpha = (alpha << 4) + **cp - '0'; + else if ((**cp >= 'A') && (**cp <= 'F')) + alpha = (alpha << 4) + **cp - 'A' + 10; + else if ((**cp >= 'a') && (**cp <= 'f')) + alpha = (alpha << 4) + **cp - 'a' + 10; + else + break; + (*cp)++; + } + if (i == 2) + rgbValue += alpha; + else + rgbValue += 0xFF; + return rgbValue; } int readCommonFeatures(const char* feat, const char* end, float* extend, float* slant, float* embolden, float* letterspace, uint32_t* rgbValue) - // returns 1 to go to next_option, -1 for bad_option, 0 to continue -{ - const char* sep; - if (strncmp(feat, "mapping", 7) == 0) { - sep = feat + 7; - if (*sep != '=') - return -1; - loadedfontmapping = load_mapping_file(sep + 1, end, 0); - return 1; - } - - if (strncmp(feat, "extend", 6) == 0) { - sep = feat + 6; - if (*sep != '=') - return -1; - ++sep; - *extend = read_double(&sep); - return 1; - } - - if (strncmp(feat, "slant", 5) == 0) { - sep = feat + 5; - if (*sep != '=') - return -1; - ++sep; - *slant = read_double(&sep); - return 1; - } - - if (strncmp(feat, "embolden", 8) == 0) { - sep = feat + 8; - if (*sep != '=') - return -1; - ++sep; - *embolden = read_double(&sep); - return 1; - } - - if (strncmp(feat, "letterspace", 11) == 0) { - sep = feat + 11; - if (*sep != '=') - return -1; - ++sep; - *letterspace = read_double(&sep); - return 1; - } - - if (strncmp(feat, "color", 5) == 0) { - const char* s; - sep = feat + 5; - if (*sep != '=') - return -1; - ++sep; - s = sep; - *rgbValue = read_rgb_a(&sep); - if ((sep == s+6) || (sep == s+8)) - loadedfontflags |= FONT_FLAGS_COLORED; - else - return -1; - return 1; - } - - return 0; + // returns 1 to go to next_option, -1 for bad_option, 0 to continue +{ + const char* sep; + if (strncmp(feat, "mapping", 7) == 0) { + sep = feat + 7; + if (*sep != '=') + return -1; + loadedfontmapping = load_mapping_file(sep + 1, end, 0); + return 1; + } + + if (strncmp(feat, "extend", 6) == 0) { + sep = feat + 6; + if (*sep != '=') + return -1; + ++sep; + *extend = read_double(&sep); + return 1; + } + + if (strncmp(feat, "slant", 5) == 0) { + sep = feat + 5; + if (*sep != '=') + return -1; + ++sep; + *slant = read_double(&sep); + return 1; + } + + if (strncmp(feat, "embolden", 8) == 0) { + sep = feat + 8; + if (*sep != '=') + return -1; + ++sep; + *embolden = read_double(&sep); + return 1; + } + + if (strncmp(feat, "letterspace", 11) == 0) { + sep = feat + 11; + if (*sep != '=') + return -1; + ++sep; + *letterspace = read_double(&sep); + return 1; + } + + if (strncmp(feat, "color", 5) == 0) { + const char* s; + sep = feat + 5; + if (*sep != '=') + return -1; + ++sep; + s = sep; + *rgbValue = read_rgb_a(&sep); + if ((sep == s+6) || (sep == s+8)) + loadedfontflags |= FONT_FLAGS_COLORED; + else + return -1; + return 1; + } + + return 0; } static bool readFeatureNumber(const char* s, const char* e, hb_tag_t* f, int* v) - /* s...e is a "id=setting" string; */ -{ - *f = 0; - *v = 0; - if (*s < '0' || *s > '9') - return false; - while (*s >= '0' && *s <= '9') - *f = *f * 10 + *s++ - '0'; - while ((*s == ' ') || (*s == '\t')) - ++s; - if (*s++ != '=') - /* no setting was specified */ - return false; - - if (*s < '0' || *s > '9') - return false; - while (*s >= '0' && *s <= '9') - *v = *v * 10 + *s++ - '0'; - while ((*s == ' ') || (*s == '\t')) - ++s; - if (s != e) - return false; - return true; + /* s...e is a "id=setting" string; */ +{ + *f = 0; + *v = 0; + if (*s < '0' || *s > '9') + return false; + while (*s >= '0' && *s <= '9') + *f = *f * 10 + *s++ - '0'; + while ((*s == ' ') || (*s == '\t')) + ++s; + if (*s++ != '=') + /* no setting was specified */ + return false; + + if (*s < '0' || *s > '9') + return false; + while (*s >= '0' && *s <= '9') + *v = *v * 10 + *s++ - '0'; + while ((*s == ' ') || (*s == '\t')) + ++s; + if (s != e) + return false; + return true; } static void* loadOTfont(PlatformFontRef fontRef, XeTeXFont font, Fixed scaled_size, const char* cp1) { - XeTeXLayoutEngine engine; - hb_tag_t script = HB_TAG_NONE; - hb_tag_t language = HB_TAG_NONE; - hb_feature_t* features = NULL; - char** shapers = NULL; /* NULL-terminated array */ - int nFeatures = 0; - int nShapers = 0; - - const char* cp2; - const char* cp3; - - hb_tag_t tag; - - uint32_t rgbValue = 0x000000FF; - - float extend = 1.0; - float slant = 0.0; - float embolden = 0.0; - float letterspace = 0.0; - - int i; - - char reqEngine = getReqEngine(); - - if (reqEngine == 'O' || reqEngine == 'G') { - shapers = xrealloc(shapers, (nShapers + 1) * sizeof(char *)); - if (reqEngine == 'O') - shapers[nShapers] = strdup("ot"); - else if (reqEngine == 'G') - shapers[nShapers] = strdup("graphite2"); - nShapers++; - } - - if (reqEngine == 'G') { - char* tmpShapers[] = {shapers[0]}; - /* create a default engine so we can query the font for Graphite features; - * because of font caching, it's cheap to discard this and create the real one later */ - engine = createLayoutEngine(fontRef, font, script, language, - features, nFeatures, tmpShapers, rgbValue, extend, slant, embolden); - - if (engine == NULL) - return NULL; - } - - /* scan the feature string (if any) */ - if (cp1 != NULL) { - while (*cp1) { - if ((*cp1 == ':') || (*cp1 == ';') || (*cp1 == ',')) - ++cp1; - while ((*cp1 == ' ') || (*cp1 == '\t')) /* skip leading whitespace */ - ++cp1; - if (*cp1 == 0) /* break if end of string */ - break; - - cp2 = cp1; - while (*cp2 && (*cp2 != ':') && (*cp2 != ';') && (*cp2 != ',')) - ++cp2; - - if (strncmp(cp1, "script", 6) == 0) { - cp3 = cp1 + 6; - if (*cp3 != '=') - goto bad_option; - ++cp3; - script = hb_tag_from_string(cp3, cp2 - cp3); - goto next_option; - } - - if (strncmp(cp1, "language", 8) == 0) { - cp3 = cp1 + 8; - if (*cp3 != '=') - goto bad_option; - ++cp3; - language = hb_tag_from_string(cp3, cp2 - cp3); - goto next_option; - } - - if (strncmp(cp1, "shaper", 6) == 0) { - cp3 = cp1 + 6; - if (*cp3 != '=') - goto bad_option; - ++cp3; - shapers = xrealloc(shapers, (nShapers + 1) * sizeof(char *)); - /* some dumb systems have no strndup() */ - shapers[nShapers] = strdup(cp3); - shapers[nShapers][cp2 - cp3] = '\0'; - nShapers++; - goto next_option; - } - - i = readCommonFeatures(cp1, cp2, &extend, &slant, &embolden, &letterspace, &rgbValue); - if (i == 1) - goto next_option; - else if (i == -1) - goto bad_option; - - if (reqEngine == 'G') { - int value = 0; - if (readFeatureNumber(cp1, cp2, &tag, &value) - || findGraphiteFeature(engine, cp1, cp2, &tag, &value)) { - features = xrealloc(features, (nFeatures + 1) * sizeof(hb_feature_t)); - features[nFeatures].tag = tag; - features[nFeatures].value = value; - features[nFeatures].start = 0; - features[nFeatures].end = (unsigned int) -1; - nFeatures++; - goto next_option; - } - } - - if (*cp1 == '+') { - int param = 0; - tag = read_tag_with_param(cp1 + 1, ¶m); - features = xrealloc(features, (nFeatures + 1) * sizeof(hb_feature_t)); - features[nFeatures].tag = tag; - features[nFeatures].start = 0; - features[nFeatures].end = (unsigned int) -1; - // for backward compatibility with pre-0.9999 where feature - // indices started from 0 - if (param >= 0) - param++; - features[nFeatures].value = param; - nFeatures++; - goto next_option; - } - - if (*cp1 == '-') { - ++cp1; - tag = hb_tag_from_string(cp1, cp2 - cp1); - features = xrealloc(features, (nFeatures + 1) * sizeof(hb_feature_t)); - features[nFeatures].tag = tag; - features[nFeatures].start = 0; - features[nFeatures].end = (unsigned int) -1; - features[nFeatures].value = 0; - nFeatures++; - goto next_option; - } - - if (strncmp(cp1, "vertical", 8) == 0) { - cp3 = cp2; - if (*cp3 == ';' || *cp3 == ':' || *cp3 == ',') - --cp3; - while (*cp3 == '\0' || *cp3 == ' ' || *cp3 == '\t') - --cp3; - if (*cp3) - ++cp3; - if (cp3 == cp1 + 8) { - loadedfontflags |= FONT_FLAGS_VERTICAL; - goto next_option; - } - } - - bad_option: - fontfeaturewarning(cp1, cp2 - cp1, 0, 0); - - next_option: - cp1 = cp2; - } - } - - if (shapers != NULL) { - shapers = xrealloc(shapers, (nShapers + 1) * sizeof(char *)); - shapers[nShapers] = NULL; - } - - if (embolden != 0.0) - embolden = embolden * Fix2D(scaled_size) / 100.0; - - if (letterspace != 0.0) - loadedfontletterspace = (letterspace / 100.0) * scaled_size; - - if ((loadedfontflags & FONT_FLAGS_COLORED) == 0) - rgbValue = 0x000000FF; - - if ((loadedfontflags & FONT_FLAGS_VERTICAL) != 0) - setFontLayoutDir(font, 1); - - engine = createLayoutEngine(fontRef, font, script, language, - features, nFeatures, shapers, rgbValue, extend, slant, embolden); - - if (engine == 0) { - // only free these if creation failed, otherwise the engine now owns them - free(features); - free(shapers); - } else { - nativefonttypeflag = OTGR_FONT_FLAG; - } - - return engine; + XeTeXLayoutEngine engine; + hb_tag_t script = HB_TAG_NONE; + char * language = NULL; + hb_feature_t* features = NULL; + char** shapers = NULL; /* NULL-terminated array */ + int nFeatures = 0; + int nShapers = 0; + + const char* cp2; + const char* cp3; + + hb_tag_t tag; + + uint32_t rgbValue = 0x000000FF; + + float extend = 1.0; + float slant = 0.0; + float embolden = 0.0; + float letterspace = 0.0; + + int i; + + char reqEngine = getReqEngine(); + + if (reqEngine == 'O' || reqEngine == 'G') { + shapers = (char**) xrealloc(shapers, (nShapers + 1) * sizeof(char *)); + if (reqEngine == 'O') + shapers[nShapers] = "ot"; + else if (reqEngine == 'G') + shapers[nShapers] = "graphite2"; + nShapers++; + } + + if (reqEngine == 'G') { + char* tmpShapers[] = {shapers[0]}; + /* create a default engine so we can query the font for Graphite features; + * because of font caching, it's cheap to discard this and create the real one later */ + engine = createLayoutEngine(fontRef, font, script, language, + features, nFeatures, tmpShapers, rgbValue, extend, slant, embolden); + + if (engine == NULL) + return NULL; + } + + /* scan the feature string (if any) */ + if (cp1 != NULL) { + while (*cp1) { + if ((*cp1 == ':') || (*cp1 == ';') || (*cp1 == ',')) + ++cp1; + while ((*cp1 == ' ') || (*cp1 == '\t')) /* skip leading whitespace */ + ++cp1; + if (*cp1 == 0) /* break if end of string */ + break; + + cp2 = cp1; + while (*cp2 && (*cp2 != ':') && (*cp2 != ';') && (*cp2 != ',')) + ++cp2; + + if (strncmp(cp1, "script", 6) == 0) { + cp3 = cp1 + 6; + if (*cp3 != '=') + goto bad_option; + ++cp3; + script = hb_tag_from_string(cp3, cp2 - cp3); + goto next_option; + } + + if (strncmp(cp1, "language", 8) == 0) { + cp3 = cp1 + 8; + if (*cp3 != '=') + goto bad_option; + ++cp3; + language = (char*)xmalloc(cp2 - cp3 + 1); + language[cp2 - cp3] = '\0'; + memcpy(language, cp3, cp2 - cp3); + goto next_option; + } + + if (strncmp(cp1, "shaper", 6) == 0) { + cp3 = cp1 + 6; + if (*cp3 != '=') + goto bad_option; + ++cp3; + shapers = (char**) xrealloc(shapers, (nShapers + 1) * sizeof(char *)); + /* some dumb systems have no strndup() */ + shapers[nShapers] = strdup(cp3); + shapers[nShapers][cp2 - cp3] = '\0'; + nShapers++; + goto next_option; + } + + i = readCommonFeatures(cp1, cp2, &extend, &slant, &embolden, &letterspace, &rgbValue); + if (i == 1) + goto next_option; + else if (i == -1) + goto bad_option; + + if (reqEngine == 'G') { + int value = 0; + if (readFeatureNumber(cp1, cp2, &tag, &value) + || findGraphiteFeature(engine, cp1, cp2, &tag, &value)) { + features = (hb_feature_t*) xrealloc(features, (nFeatures + 1) * sizeof(hb_feature_t)); + features[nFeatures].tag = tag; + features[nFeatures].value = value; + features[nFeatures].start = 0; + features[nFeatures].end = (unsigned int) -1; + nFeatures++; + goto next_option; + } + } + + if (*cp1 == '+') { + int param = 0; + tag = read_tag_with_param(cp1 + 1, ¶m); + features = (hb_feature_t*) xrealloc(features, (nFeatures + 1) * sizeof(hb_feature_t)); + features[nFeatures].tag = tag; + features[nFeatures].start = 0; + features[nFeatures].end = (unsigned int) -1; + // for backward compatibility with pre-0.9999 where feature + // indices started from 0 + if (param >= 0) + param++; + features[nFeatures].value = param; + nFeatures++; + goto next_option; + } + + if (*cp1 == '-') { + ++cp1; + tag = hb_tag_from_string(cp1, cp2 - cp1); + features = (hb_feature_t*) xrealloc(features, (nFeatures + 1) * sizeof(hb_feature_t)); + features[nFeatures].tag = tag; + features[nFeatures].start = 0; + features[nFeatures].end = (unsigned int) -1; + features[nFeatures].value = 0; + nFeatures++; + goto next_option; + } + + if (strncmp(cp1, "vertical", 8) == 0) { + cp3 = cp2; + if (*cp3 == ';' || *cp3 == ':' || *cp3 == ',') + --cp3; + while (*cp3 == '\0' || *cp3 == ' ' || *cp3 == '\t') + --cp3; + if (*cp3) + ++cp3; + if (cp3 == cp1 + 8) { + loadedfontflags |= FONT_FLAGS_VERTICAL; + goto next_option; + } + } + + bad_option: + fontfeaturewarning((void*) cp1, cp2 - cp1, 0, 0); + + next_option: + cp1 = cp2; + } + } + + if (shapers != NULL) { + shapers = (char**) xrealloc(shapers, (nShapers + 1) * sizeof(char *)); + shapers[nShapers] = NULL; + } + + if (embolden != 0.0) + embolden = embolden * Fix2D(scaled_size) / 100.0; + + if (letterspace != 0.0) + loadedfontletterspace = (letterspace / 100.0) * scaled_size; + + if ((loadedfontflags & FONT_FLAGS_COLORED) == 0) + rgbValue = 0x000000FF; + + if ((loadedfontflags & FONT_FLAGS_VERTICAL) != 0) + setFontLayoutDir(font, 1); + + engine = createLayoutEngine(fontRef, font, script, language, + features, nFeatures, shapers, rgbValue, extend, slant, embolden); + + if (engine == 0) { + // only free these if creation failed, otherwise the engine now owns them + free(features); + free(shapers); + } else { + nativefonttypeflag = OTGR_FONT_FLAG; + } + + return engine; } static void splitFontName(char* name, char** var, char** feat, char** end, int* index) { - *var = NULL; - *feat = NULL; - *index = 0; - if (*name == '[') { - int withinFileName = 1; + *var = NULL; + *feat = NULL; + *index = 0; + if (*name == '[') { + int withinFileName = 1; #ifdef WIN32 - char* start = name + 1; + char* start = name + 1; #endif - ++name; - while (*name) { - if (withinFileName && *name == ']') { - withinFileName = 0; - if (*var == NULL) - *var = name; - } else if (*name == ':') { - if (withinFileName && *var == NULL + ++name; + while (*name) { + if (withinFileName && *name == ']') { + withinFileName = 0; + if (*var == NULL) + *var = name; + } else if (*name == ':') { + if (withinFileName && *var == NULL #ifdef WIN32 - && !((name - start == 1) && isalpha(*start)) + && !((name - start == 1) && isalpha(*start)) #endif - ) { - *var = name; - ++name; - while (*name >= '0' && *name <= '9') - *index = *index * 10 + *name++ - '0'; - --name; - } else if (!withinFileName && *feat == NULL) - *feat = name; - } - ++name; - } - *end = name; - } else { - while (*name) { - if (*name == '/' && *var == NULL && *feat == NULL) - *var = name; - else if (*name == ':' && *feat == NULL) - *feat = name; - ++name; - } - *end = name; - } - if (*feat == NULL) - *feat = name; - if (*var == NULL) - *var = *feat; + ) { + *var = name; + ++name; + while (*name >= '0' && *name <= '9') + *index = *index * 10 + *name++ - '0'; + --name; + } else if (!withinFileName && *feat == NULL) + *feat = name; + } + ++name; + } + *end = name; + } else { + while (*name) { + if (*name == '/' && *var == NULL && *feat == NULL) + *var = name; + else if (*name == ':' && *feat == NULL) + *feat = name; + ++name; + } + *end = name; + } + if (*feat == NULL) + *feat = name; + if (*var == NULL) + *var = *feat; } void* findnativefont(unsigned char* uname, integer scaled_size) - /* scaled_size here is in TeX points, or is a negative integer for 'scaled' */ -{ - void* rval = NULL; - char* nameString; - char* var; - char* feat; - char* end; - char* name = (char*)uname; - char* varString = NULL; - char* featString = NULL; - PlatformFontRef fontRef; - XeTeXFont font = NULL; - int index = 0; - - loadedfontmapping = NULL; - loadedfontflags = 0; - loadedfontletterspace = 0; - - splitFontName(name, &var, &feat, &end, &index); - nameString = xmalloc(var - name + 1); - strncpy(nameString, name, var - name); - nameString[var - name] = 0; - - if (feat > var) { - varString = xmalloc(feat - var); - strncpy(varString, var + 1, feat - var - 1); - varString[feat - var - 1] = 0; - } - - if (end > feat) { - featString = xmalloc(end - feat); - strncpy(featString, feat + 1, end - feat - 1); - featString[end - feat - 1] = 0; - } - - // check for "[filename]" form, don't search maps in this case - if (nameString[0] == '[') { - char* path = kpse_find_file(nameString + 1, kpse_opentype_format, 0); - if (path == NULL) - path = kpse_find_file(nameString + 1, kpse_truetype_format, 0); - if (path == NULL) - path = kpse_find_file(nameString + 1, kpse_type1_format, 0); - if (path != NULL) { - if (scaled_size < 0) { - font = createFontFromFile(path, index, 655360L); - if (font != NULL) { - Fixed dsize = D2Fix(getDesignSize(font)); - if (scaled_size == -1000) - scaled_size = dsize; - else - scaled_size = zxnoverd(dsize, -scaled_size, 1000); - deleteFont(font); - } - } - font = createFontFromFile(path, index, scaled_size); - if (font != NULL) { - loadedfontdesignsize = D2Fix(getDesignSize(font)); - - /* This is duplicated in XeTeXFontMgr::findFont! */ - setReqEngine(0); - if (varString) { - if (strncmp(varString, "/AAT", 4) == 0) - setReqEngine('A'); - else if ((strncmp(varString, "/OT", 3) == 0) || (strncmp(varString, "/ICU", 4) == 0)) - setReqEngine('O'); - else if (strncmp(varString, "/GR", 3) == 0) - setReqEngine('G'); - } - - rval = loadOTfont(0, font, scaled_size, featString); - if (rval == NULL) - deleteFont(font); - if (rval != NULL && gettracingfontsstate() > 0) { - begindiagnostic(); - zprintnl(' '); - printcstring("-> "); - printcstring(path); - zenddiagnostic(0); - } - } - } - } else { - fontRef = findFontByName(nameString, varString, Fix2D(scaled_size)); - - if (fontRef != 0) { - /* update nameoffile to the full name of the font, for error messages during font loading */ - const char* fullName = getFullName(fontRef); - namelength = strlen(fullName); - if (featString != NULL) - namelength += strlen(featString) + 1; - if (varString != NULL) - namelength += strlen(varString) + 1; - free(nameoffile); - nameoffile = xmalloc(namelength + 4); /* +2 would be correct: initial space, final NUL */ - nameoffile[0] = ' '; - strcpy((char*)nameoffile + 1, fullName); - - if (scaled_size < 0) { - font = createFont(fontRef, scaled_size); - if (font != NULL) { - Fixed dsize = D2Fix(getDesignSize(font)); - if (scaled_size == -1000) - scaled_size = dsize; - else - scaled_size = zxnoverd(dsize, -scaled_size, 1000); - deleteFont(font); - } - } - - font = createFont(fontRef, scaled_size); - if (font != NULL) { + /* scaled_size here is in TeX points, or is a negative integer for 'scaled' */ +{ + void* rval = NULL; + char* nameString; + char* var; + char* feat; + char* end; + char* name = (char*)uname; + char* varString = NULL; + char* featString = NULL; + PlatformFontRef fontRef; + XeTeXFont font = NULL; + int index = 0; + + loadedfontmapping = NULL; + loadedfontflags = 0; + loadedfontletterspace = 0; + + splitFontName(name, &var, &feat, &end, &index); + nameString = (char*) xmalloc(var - name + 1); + strncpy(nameString, name, var - name); + nameString[var - name] = 0; + + if (feat > var) { + varString = (char*) xmalloc(feat - var); + strncpy(varString, var + 1, feat - var - 1); + varString[feat - var - 1] = 0; + } + + if (end > feat) { + featString = (char*) xmalloc(end - feat); + strncpy(featString, feat + 1, end - feat - 1); + featString[end - feat - 1] = 0; + } + + // check for "[filename]" form, don't search maps in this case + if (nameString[0] == '[') { + char* path = kpse_find_file(nameString + 1, kpse_opentype_format, 0); + if (path == NULL) + path = kpse_find_file(nameString + 1, kpse_truetype_format, 0); + if (path == NULL) + path = kpse_find_file(nameString + 1, kpse_type1_format, 0); + if (path != NULL) { + if (scaled_size < 0) { + font = createFontFromFile(path, index, 655360L); + if (font != NULL) { + Fixed dsize = D2Fix(getDesignSize(font)); + if (scaled_size == -1000) + scaled_size = dsize; + else + scaled_size = zxnoverd(dsize, -scaled_size, 1000); + deleteFont(font); + } + } + font = createFontFromFile(path, index, scaled_size); + if (font != NULL) { + loadedfontdesignsize = D2Fix(getDesignSize(font)); + + /* This is duplicated in XeTeXFontMgr::findFont! */ + setReqEngine(0); + if (varString) { + if (strncmp(varString, "/AAT", 4) == 0) + setReqEngine('A'); + else if ((strncmp(varString, "/OT", 3) == 0) || (strncmp(varString, "/ICU", 4) == 0)) + setReqEngine('O'); + else if (strncmp(varString, "/GR", 3) == 0) + setReqEngine('G'); + } + + rval = loadOTfont(0, font, scaled_size, featString); + if (rval == NULL) + deleteFont(font); + if (rval != NULL && gettracingfontsstate() > 0) { + begindiagnostic(); + zprintnl(' '); + printcstring("-> "); + printcstring(path); + zenddiagnostic(0); + } + } + } + } else { + fontRef = findFontByName(nameString, varString, Fix2D(scaled_size)); + + if (fontRef != 0) { + /* update nameoffile to the full name of the font, for error messages during font loading */ + const char* fullName = getFullName(fontRef); + namelength = strlen(fullName); + if (featString != NULL) + namelength += strlen(featString) + 1; + if (varString != NULL) + namelength += strlen(varString) + 1; + free(nameoffile); + nameoffile = xmalloc(namelength + 4); /* +2 would be correct: initial space, final NUL */ + nameoffile[0] = ' '; + strcpy((char*)nameoffile + 1, fullName); + + if (scaled_size < 0) { + font = createFont(fontRef, scaled_size); + if (font != NULL) { + Fixed dsize = D2Fix(getDesignSize(font)); + if (scaled_size == -1000) + scaled_size = dsize; + else + scaled_size = zxnoverd(dsize, -scaled_size, 1000); + deleteFont(font); + } + } + + font = createFont(fontRef, scaled_size); + if (font != NULL) { #ifdef XETEX_MAC - /* decide whether to use AAT or OpenType rendering with this font */ - if (getReqEngine() == 'A') { - rval = loadAATfont(fontRef, scaled_size, featString); - if (rval == NULL) - deleteFont(font); - } else { - if (getReqEngine() == 'O' || getReqEngine() == 'G' || - getFontTablePtr(font, kGSUB) != NULL || getFontTablePtr(font, kGPOS) != NULL) - rval = loadOTfont(fontRef, font, scaled_size, featString); - - /* loadOTfont failed or the above check was false */ - if (rval == NULL) - rval = loadAATfont(fontRef, scaled_size, featString); - - if (rval == NULL) - deleteFont(font); - } + /* decide whether to use AAT or OpenType rendering with this font */ + if (getReqEngine() == 'A') { + rval = loadAATfont(fontRef, scaled_size, featString); + if (rval == NULL) + deleteFont(font); + } else { + if (getReqEngine() == 'O' || getReqEngine() == 'G' || + getFontTablePtr(font, kGSUB) != NULL || getFontTablePtr(font, kGPOS) != NULL) + rval = loadOTfont(fontRef, font, scaled_size, featString); + + /* loadOTfont failed or the above check was false */ + if (rval == NULL) + rval = loadAATfont(fontRef, scaled_size, featString); + + if (rval == NULL) + deleteFont(font); + } #else - rval = loadOTfont(fontRef, font, scaled_size, featString); - if (rval == NULL) - deleteFont(font); + rval = loadOTfont(fontRef, font, scaled_size, featString); + if (rval == NULL) + deleteFont(font); #endif - } - - /* append the style and feature strings, so that \show\fontID will give a full result */ - if (varString != NULL && *varString != 0) { - strcat((char*)nameoffile + 1, "/"); - strcat((char*)nameoffile + 1, varString); - } - if (featString != NULL && *featString != 0) { - strcat((char*)nameoffile + 1, ":"); - strcat((char*)nameoffile + 1, featString); - } - namelength = strlen((char*)nameoffile + 1); - } - } - - if (varString != NULL) - free(varString); - - if (featString != NULL) - free(featString); - - free(nameString); - - return rval; + } + + /* append the style and feature strings, so that \show\fontID will give a full result */ + if (varString != NULL && *varString != 0) { + strcat((char*)nameoffile + 1, "/"); + strcat((char*)nameoffile + 1, varString); + } + if (featString != NULL && *featString != 0) { + strcat((char*)nameoffile + 1, ":"); + strcat((char*)nameoffile + 1, featString); + } + namelength = strlen((char*)nameoffile + 1); + } + } + + if (varString != NULL) + free(varString); + + if (featString != NULL) + free(featString); + + free(nameString); + + return rval; } void releasefontengine(void* engine, int type_flag) { #ifdef XETEX_MAC - if (type_flag == AAT_FONT_FLAG) { - CFRelease((CFDictionaryRef)engine); - } else + if (type_flag == AAT_FONT_FLAG) { + CFRelease((CFDictionaryRef)engine); + } else #endif - if (type_flag == OTGR_FONT_FLAG) { - deleteLayoutEngine((XeTeXLayoutEngine)engine); - } + if (type_flag == OTGR_FONT_FLAG) { + deleteLayoutEngine((XeTeXLayoutEngine)engine); + } } /* params are given as 'integer' in the header file, but are really TeX scaled integers */ void otgetfontmetrics(void* pEngine, scaled* ascent, scaled* descent, scaled* xheight, scaled* capheight, scaled* slant) { - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; - float a, d; - - getAscentAndDescent(engine, &a, &d); - *ascent = D2Fix(a); - *descent = D2Fix(d); - - *slant = D2Fix(Fix2D(getSlant(getFont(engine))) * getExtendFactor(engine) - + getSlantFactor(engine)); - - /* get cap and x height from OS/2 table */ - getCapAndXHeight(engine, &a, &d); - *capheight = D2Fix(a); - *xheight = D2Fix(d); - - /* fallback in case the font does not have OS/2 table */ - if (*xheight == 0) { - int glyphID = mapCharToGlyph(engine, 'x'); - if (glyphID != 0) { - getGlyphHeightDepth(engine, glyphID, &a, &d); - *xheight = D2Fix(a); - } else { - *xheight = *ascent / 2; /* arbitrary figure if there's no 'x' in the font */ - } - } - - if (*capheight == 0) { - int glyphID = mapCharToGlyph(engine, 'X'); - if (glyphID != 0) { - getGlyphHeightDepth(engine, glyphID, &a, &d); - *capheight = D2Fix(a); - } else { - *capheight = *ascent; /* arbitrary figure if there's no 'X' in the font */ - } - } + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; + float a, d; + + getAscentAndDescent(engine, &a, &d); + *ascent = D2Fix(a); + *descent = D2Fix(d); + + *slant = D2Fix(Fix2D(getSlant(getFont(engine))) * getExtendFactor(engine) + + getSlantFactor(engine)); + + /* get cap and x height from OS/2 table */ + getCapAndXHeight(engine, &a, &d); + *capheight = D2Fix(a); + *xheight = D2Fix(d); + + /* fallback in case the font does not have OS/2 table */ + if (*xheight == 0) { + int glyphID = mapCharToGlyph(engine, 'x'); + if (glyphID != 0) { + getGlyphHeightDepth(engine, glyphID, &a, &d); + *xheight = D2Fix(a); + } else { + *xheight = *ascent / 2; /* arbitrary figure if there's no 'x' in the font */ + } + } + + if (*capheight == 0) { + int glyphID = mapCharToGlyph(engine, 'X'); + if (glyphID != 0) { + getGlyphHeightDepth(engine, glyphID, &a, &d); + *capheight = D2Fix(a); + } else { + *capheight = *ascent; /* arbitrary figure if there's no 'X' in the font */ + } + } } integer otfontget(integer what, void* pEngine) { - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; - XeTeXFont fontInst = getFont(engine); - switch (what) { - case XeTeX_count_glyphs: - return countGlyphs(fontInst); - break; - - case XeTeX_count_features: /* ie Graphite features */ - return countGraphiteFeatures(engine); - break; + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; + XeTeXFont fontInst = getFont(engine); + switch (what) { + case XeTeX_count_glyphs: + return countGlyphs(fontInst); + break; - case XeTeX_OT_count_scripts: - return countScripts(fontInst); - break; - } - return 0; + case XeTeX_count_features: /* ie Graphite features */ + return countGraphiteFeatures(engine); + break; + + case XeTeX_OT_count_scripts: + return countScripts(fontInst); + break; + } + return 0; } integer otfontget1(integer what, void* pEngine, integer param) { - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; - XeTeXFont fontInst = getFont(engine); - switch (what) { - case XeTeX_OT_count_languages: - return countLanguages(fontInst, param); - break; - - case XeTeX_OT_script_code: - return getIndScript(fontInst, param); - break; - - /* for graphite fonts...*/ - case XeTeX_feature_code: - return getGraphiteFeatureCode(engine, param); - break; - case XeTeX_is_exclusive_feature: - return 1; - break; - case XeTeX_count_selectors: - return countGraphiteFeatureSettings(engine, param); - break; - } - return 0; + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; + XeTeXFont fontInst = getFont(engine); + switch (what) { + case XeTeX_OT_count_languages: + return countLanguages(fontInst, param); + break; + + case XeTeX_OT_script_code: + return getIndScript(fontInst, param); + break; + + /* for graphite fonts...*/ + case XeTeX_feature_code: + return getGraphiteFeatureCode(engine, param); + break; + case XeTeX_is_exclusive_feature: + return 1; + break; + case XeTeX_count_selectors: + return countGraphiteFeatureSettings(engine, param); + break; + } + return 0; } integer otfontget2(integer what, void* pEngine, integer param1, integer param2) { - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; - XeTeXFont fontInst = getFont(engine); - switch (what) { - case XeTeX_OT_language_code: - return getIndLanguage(fontInst, param1, param2); - break; - - case XeTeX_OT_count_features: - return countFeatures(fontInst, param1, param2); - break; + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; + XeTeXFont fontInst = getFont(engine); + switch (what) { + case XeTeX_OT_language_code: + return getIndLanguage(fontInst, param1, param2); + break; + + case XeTeX_OT_count_features: + return countFeatures(fontInst, param1, param2); + break; + + /* for graphite fonts */ + case XeTeX_selector_code: + return getGraphiteFeatureSettingCode(engine, param1, param2); + break; + case XeTeX_is_default_selector: + return getGraphiteFeatureDefaultSetting(engine, param1) == param2; + break; + } - /* for graphite fonts */ - case XeTeX_selector_code: - return getGraphiteFeatureSettingCode(engine, param1, param2); - break; - case XeTeX_is_default_selector: - return getGraphiteFeatureDefaultSetting(engine, param1) == param2; - break; - } - - return 0; + return 0; } integer otfontget3(integer what, void* pEngine, integer param1, integer param2, integer param3) { - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; - XeTeXFont fontInst = getFont(engine); - switch (what) { - case XeTeX_OT_feature_code: - return getIndFeature(fontInst, param1, param2, param3); - break; - } - - return 0; + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; + XeTeXFont fontInst = getFont(engine); + switch (what) { + case XeTeX_OT_feature_code: + return getIndFeature(fontInst, param1, param2, param3); + break; + } + + return 0; } void grprintfontname(integer what, void* pEngine, integer param1, integer param2) { - char* name = NULL; - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; - switch (what) { - case XeTeX_feature_name: - name = getGraphiteFeatureLabel(engine, param1); - break; - case XeTeX_selector_name: - name = getGraphiteFeatureSettingLabel(engine, param1, param2); - break; - } + char* name = NULL; + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; + switch (what) { + case XeTeX_feature_name: + name = getGraphiteFeatureLabel(engine, param1); + break; + case XeTeX_selector_name: + name = getGraphiteFeatureSettingLabel(engine, param1, param2); + break; + } - if (name != NULL) { - printcstring(name); - gr_label_destroy(name); - } + if (name != NULL) { + printcstring(name); + gr_label_destroy(name); + } } integer grfontgetnamed(integer what, void* pEngine) { - long rval = -1; - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; - switch (what) { - case XeTeX_find_feature_by_name: - rval = findGraphiteFeatureNamed(engine, (const char*)nameoffile + 1, namelength); - break; - } - return rval; + long rval = -1; + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; + switch (what) { + case XeTeX_find_feature_by_name: + rval = findGraphiteFeatureNamed(engine, (const char*)nameoffile + 1, namelength); + break; + } + return rval; } integer grfontgetnamed1(integer what, void* pEngine, integer param) { - long rval = -1; - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; - switch (what) { - case XeTeX_find_selector_by_name: - rval = findGraphiteFeatureSettingNamed(engine, param, (const char*)nameoffile + 1, namelength); - break; - } - return rval; + long rval = -1; + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; + switch (what) { + case XeTeX_find_selector_by_name: + rval = findGraphiteFeatureSettingNamed(engine, param, (const char*)nameoffile + 1, namelength); + break; + } + return rval; } -#define XDV_FLAG_FONTTYPE_AAT 0x0001 -#define XDV_FLAG_FONTTYPE_OT 0x0002 +#define XDV_FLAG_FONTTYPE_AAT 0x0001 +#define XDV_FLAG_FONTTYPE_OT 0x0002 -#define XDV_FLAG_VERTICAL 0x0100 -#define XDV_FLAG_COLORED 0x0200 -#define XDV_FLAG_FEATURES 0x0400 -#define XDV_FLAG_VARIATIONS 0x0800 -#define XDV_FLAG_EXTEND 0x1000 -#define XDV_FLAG_SLANT 0x2000 -#define XDV_FLAG_EMBOLDEN 0x4000 +#define XDV_FLAG_VERTICAL 0x0100 +#define XDV_FLAG_COLORED 0x0200 +#define XDV_FLAG_FEATURES 0x0400 +#define XDV_FLAG_VARIATIONS 0x0800 +#define XDV_FLAG_EXTEND 0x1000 +#define XDV_FLAG_SLANT 0x2000 +#define XDV_FLAG_EMBOLDEN 0x4000 #ifdef XETEX_MAC static UInt32 cgColorToRGBA32(CGColorRef color) { - const CGFloat *components = CGColorGetComponents(color); + const CGFloat *components = CGColorGetComponents(color); - UInt32 rval = (UInt8)(components[0] * 255.0 + 0.5); - rval <<= 8; - rval += (UInt8)(components[1] * 255.0 + 0.5); - rval <<= 8; - rval += (UInt8)(components[2] * 255.0 + 0.5); - rval <<= 8; - rval += (UInt8)(components[3] * 255.0 + 0.5); - return rval; + UInt32 rval = (UInt8)(components[0] * 255.0 + 0.5); + rval <<= 8; + rval += (UInt8)(components[1] * 255.0 + 0.5); + rval <<= 8; + rval += (UInt8)(components[2] * 255.0 + 0.5); + rval <<= 8; + rval += (UInt8)(components[3] * 255.0 + 0.5); + return rval; } #endif -static int xdvBufSize = 0; +static int xdvBufSize = 0; int makeXDVGlyphArrayData(void* pNode) { - unsigned char* cp; - uint16_t* glyphIDs; - memoryword* p = pNode; - void* glyph_info; - FixedPoint* locations; - int opcode; - Fixed width; - uint16_t glyphCount = native_glyph_count(p); - - int i = glyphCount * native_glyph_info_size + 8; /* to guarantee enough space in the buffer */ - if (i > xdvBufSize) { - if (xdvbuffer != NULL) - free(xdvbuffer); - xdvBufSize = ((i / 1024) + 1) * 1024; - xdvbuffer = (char*)xmalloc(xdvBufSize); - } - - glyph_info = native_glyph_info_ptr(p); - locations = (FixedPoint*)glyph_info; - glyphIDs = (uint16_t*)(locations + glyphCount); - - opcode = XDV_GLYPH_STRING; - for (i = 0; i < glyphCount; ++i) - if (locations[i].y != 0) { - opcode = XDV_GLYPH_ARRAY; - break; - } - - cp = (unsigned char*)xdvbuffer; - *cp++ = opcode; - - width = node_width(p); - *cp++ = (width >> 24) & 0xff; - *cp++ = (width >> 16) & 0xff; - *cp++ = (width >> 8) & 0xff; - *cp++ = width & 0xff; - - *cp++ = (glyphCount >> 8) & 0xff; - *cp++ = glyphCount & 0xff; - - for (i = 0; i < glyphCount; ++i) { - Fixed x = locations[i].x; - *cp++ = (x >> 24) & 0xff; - *cp++ = (x >> 16) & 0xff; - *cp++ = (x >> 8) & 0xff; - *cp++ = x & 0xff; - if (opcode == XDV_GLYPH_ARRAY) { - Fixed y = locations[i].y; - *cp++ = (y >> 24) & 0xff; - *cp++ = (y >> 16) & 0xff; - *cp++ = (y >> 8) & 0xff; - *cp++ = y & 0xff; - } - } - - for (i = 0; i < glyphCount; ++i) { - uint16_t g = glyphIDs[i]; - *cp++ = (g >> 8) & 0xff; - *cp++ = g & 0xff; - } - - return ((char*)cp - xdvbuffer); + unsigned char* cp; + uint16_t* glyphIDs; + memoryword* p = (memoryword*) pNode; + void* glyph_info; + FixedPoint* locations; + int opcode; + Fixed width; + uint16_t glyphCount = native_glyph_count(p); + + int i = glyphCount * native_glyph_info_size + 8; /* to guarantee enough space in the buffer */ + if (i > xdvBufSize) { + if (xdvbuffer != NULL) + free(xdvbuffer); + xdvBufSize = ((i / 1024) + 1) * 1024; + xdvbuffer = (char*) xmalloc(xdvBufSize); + } + + glyph_info = native_glyph_info_ptr(p); + locations = (FixedPoint*)glyph_info; + glyphIDs = (uint16_t*)(locations + glyphCount); + + opcode = XDV_GLYPH_STRING; + for (i = 0; i < glyphCount; ++i) + if (locations[i].y != 0) { + opcode = XDV_GLYPH_ARRAY; + break; + } + + cp = (unsigned char*)xdvbuffer; + *cp++ = opcode; + + width = node_width(p); + *cp++ = (width >> 24) & 0xff; + *cp++ = (width >> 16) & 0xff; + *cp++ = (width >> 8) & 0xff; + *cp++ = width & 0xff; + + *cp++ = (glyphCount >> 8) & 0xff; + *cp++ = glyphCount & 0xff; + + for (i = 0; i < glyphCount; ++i) { + Fixed x = locations[i].x; + *cp++ = (x >> 24) & 0xff; + *cp++ = (x >> 16) & 0xff; + *cp++ = (x >> 8) & 0xff; + *cp++ = x & 0xff; + if (opcode == XDV_GLYPH_ARRAY) { + Fixed y = locations[i].y; + *cp++ = (y >> 24) & 0xff; + *cp++ = (y >> 16) & 0xff; + *cp++ = (y >> 8) & 0xff; + *cp++ = y & 0xff; + } + } + + for (i = 0; i < glyphCount; ++i) { + uint16_t g = glyphIDs[i]; + *cp++ = (g >> 8) & 0xff; + *cp++ = g & 0xff; + } + + return ((char*)cp - xdvbuffer); } int makefontdef(integer f) { - uint16_t flags = 0; - uint32_t variationCount = 0; - uint32_t rgba; - Fixed size; - const char* psName; - const char* famName; - const char* styName; - uint8_t psLen; - uint8_t famLen; - uint8_t styLen; - int fontDefLength; - char* cp; - PlatformFontRef fontRef = 0; - float extend = 1.0; - float slant = 0.0; - float embolden = 0.0; + uint16_t flags = 0; + uint32_t variationCount = 0; + uint32_t rgba; + Fixed size; + const char* psName; + const char* famName; + const char* styName; + uint8_t psLen; + uint8_t famLen; + uint8_t styLen; + int fontDefLength; + char* cp; + PlatformFontRef fontRef = 0; + float extend = 1.0; + float slant = 0.0; + float embolden = 0.0; #ifdef XETEX_MAC - CFDictionaryRef attributes = NULL; - CFDictionaryRef variation = NULL; - - if (fontarea[f] == AAT_FONT_FLAG) { - CTFontRef font; - CGColorRef color; - CGAffineTransform t; - CFNumberRef emboldenNumber; - CGFloat fSize; - char *pathname; - int index; - - flags = XDV_FLAG_FONTTYPE_AAT; - attributes = (CFDictionaryRef) fontlayoutengine[f]; - font = CFDictionaryGetValue(attributes, kCTFontAttributeName); - variation = CTFontCopyVariation(font); - if (variation) { - variationCount = CFDictionaryGetCount(variation); - CFRelease(variation); - } - - pathname = getFileNameFromCTFont(font, &index); - if (pathname) { - char buf[20]; - - if (index > 0) - sprintf(buf, ":%d", index); - else - buf[0] = '\0'; - - psName = xmalloc(strlen((char*) pathname) + 2 + strlen(buf) + 1); - sprintf((char*) psName, "[%s%s]", pathname, buf); - famName = ""; - styName = ""; - } else { - psName = getNameFromCTFont(font, kCTFontPostScriptNameKey); - famName = getNameFromCTFont(font, kCTFontFamilyNameKey); - styName = getNameFromCTFont(font, kCTFontStyleNameKey); - } - - if (CFDictionaryGetValue(attributes, kCTVerticalFormsAttributeName)) - flags |= XDV_FLAG_VERTICAL; - - color = (CGColorRef) CFDictionaryGetValue(attributes, kCTForegroundColorAttributeName); - if (color) - rgba = cgColorToRGBA32(color); - - t = CTFontGetMatrix(font); - extend = t.a; - slant = t.b; - - emboldenNumber = CFDictionaryGetValue(attributes, kXeTeXEmboldenAttributeName); - if (emboldenNumber) - CFNumberGetValue(emboldenNumber, kCFNumberFloatType, &embolden); - - fSize = CTFontGetSize(font); - size = D2Fix(fSize); - } else + CFDictionaryRef attributes = NULL; + CFDictionaryRef variation = NULL; + + if (fontarea[f] == AAT_FONT_FLAG) { + CTFontRef font; + CGColorRef color; + CGAffineTransform t; + CFNumberRef emboldenNumber; + CGFloat fSize; + char *pathname; + int index; + + flags = XDV_FLAG_FONTTYPE_AAT; + attributes = (CFDictionaryRef) fontlayoutengine[f]; + font = CFDictionaryGetValue(attributes, kCTFontAttributeName); + variation = CTFontCopyVariation(font); + if (variation) { + variationCount = CFDictionaryGetCount(variation); + CFRelease(variation); + } + + pathname = getFileNameFromCTFont(font, &index); + if (pathname) { + char buf[20]; + + if (index > 0) + sprintf(buf, ":%d", index); + else + buf[0] = '\0'; + + psName = xmalloc(strlen((char*) pathname) + 2 + strlen(buf) + 1); + sprintf((char*) psName, "[%s%s]", pathname, buf); + famName = xstrdup(""); + styName = xstrdup(""); + } else { + psName = getNameFromCTFont(font, kCTFontPostScriptNameKey); + famName = getNameFromCTFont(font, kCTFontFamilyNameKey); + styName = getNameFromCTFont(font, kCTFontStyleNameKey); + } + + if (CFDictionaryGetValue(attributes, kCTVerticalFormsAttributeName)) + flags |= XDV_FLAG_VERTICAL; + + color = (CGColorRef) CFDictionaryGetValue(attributes, kCTForegroundColorAttributeName); + if (color) + rgba = cgColorToRGBA32(color); + + t = CTFontGetMatrix(font); + extend = t.a; + slant = t.b; + + emboldenNumber = CFDictionaryGetValue(attributes, kXeTeXEmboldenAttributeName); + if (emboldenNumber) + CFNumberGetValue(emboldenNumber, kCFNumberFloatType, &embolden); + + fSize = CTFontGetSize(font); + size = D2Fix(fSize); + } else #endif - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXLayoutEngine engine; - flags = XDV_FLAG_FONTTYPE_OT; - - engine = (XeTeXLayoutEngine)fontlayoutengine[f]; - fontRef = getFontRef(engine); - psName = getFontFilename(engine); - if (psName) { - famName = ""; - styName = ""; - } else { - getNames(getFontRef(engine), &psName, &famName, &styName); - } - - rgba = getRgbValue(engine); - if ((fontflags[f] & FONT_FLAGS_VERTICAL) != 0) - flags |= XDV_FLAG_VERTICAL; - - extend = getExtendFactor(engine); - slant = getSlantFactor(engine); - embolden = getEmboldenFactor(engine); - - size = D2Fix(getPointSize(engine)); - } else { - fprintf(stderr, "\n! Internal error: bad native font flag in `make_font_def'\n"); - exit(3); - } - - psLen = strlen(psName); - famLen = strlen(famName); - styLen = strlen(styName); - - /* parameters after internal font ID: - // size[4] - // flags[2] - // lp[1] lf[1] ls[1] ps[lp] fam[lf] sty[ls] - // if flags & COLORED: - // c[4] - // if flags & VARIATIONS: - // nv[2] - // a[4nv] - // v[4nv] - */ - - fontDefLength - = 4 /* size */ - + 2 /* flags */ - + 3 /* name length */ - + psLen + famLen + styLen; - - if ((fontflags[f] & FONT_FLAGS_COLORED) != 0) { - fontDefLength += 4; /* 32-bit RGBA value */ - flags |= XDV_FLAG_COLORED; - } - - if (extend != 1.0) { - fontDefLength += 4; - flags |= XDV_FLAG_EXTEND; - } - if (slant != 0.0) { - fontDefLength += 4; - flags |= XDV_FLAG_SLANT; - } - if (embolden != 0.0) { - fontDefLength += 4; - flags |= XDV_FLAG_EMBOLDEN; - } - - if (fontDefLength > xdvBufSize) { - if (xdvbuffer != NULL) - free(xdvbuffer); - xdvBufSize = ((fontDefLength / 1024) + 1) * 1024; - xdvbuffer = (char*)xmalloc(xdvBufSize); - } - cp = xdvbuffer; - - *(Fixed*)cp = SWAP32(size); - cp += 4; - - *(uint16_t*)cp = SWAP16(flags); - cp += 2; - - *(uint8_t*)cp = psLen; - cp += 1; - *(uint8_t*)cp = famLen; - cp += 1; - *(uint8_t*)cp = styLen; - cp += 1; - memcpy(cp, psName, psLen); - cp += psLen; - memcpy(cp, famName, famLen); - cp += famLen; - memcpy(cp, styName, styLen); - cp += styLen; - - if ((fontflags[f] & FONT_FLAGS_COLORED) != 0) { - *(uint32_t*)cp = SWAP32(rgba); - cp += 4; - } - - if (flags & XDV_FLAG_EXTEND) { - Fixed f = D2Fix(extend); - *(uint32_t*)(cp) = SWAP32(f); - cp += 4; - } - if (flags & XDV_FLAG_SLANT) { - Fixed f = D2Fix(slant); - *(uint32_t*)(cp) = SWAP32(f); - cp += 4; - } - if (flags & XDV_FLAG_EMBOLDEN) { - Fixed f = D2Fix(embolden); - *(uint32_t*)(cp) = SWAP32(f); - cp += 4; - } - - return fontDefLength; + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXLayoutEngine engine; + flags = XDV_FLAG_FONTTYPE_OT; + + engine = (XeTeXLayoutEngine)fontlayoutengine[f]; + fontRef = getFontRef(engine); + psName = xstrdup(getFontFilename(engine)); + if (psName) { + famName = xstrdup(""); + styName = xstrdup(""); + } else { + getNames(getFontRef(engine), &psName, &famName, &styName); + } + + rgba = getRgbValue(engine); + if ((fontflags[f] & FONT_FLAGS_VERTICAL) != 0) + flags |= XDV_FLAG_VERTICAL; + + extend = getExtendFactor(engine); + slant = getSlantFactor(engine); + embolden = getEmboldenFactor(engine); + + size = D2Fix(getPointSize(engine)); + } else { + fprintf(stderr, "\n! Internal error: bad native font flag in `make_font_def'\n"); + exit(3); + } + + psLen = strlen(psName); + famLen = strlen(famName); + styLen = strlen(styName); + + /* parameters after internal font ID: + // size[4] + // flags[2] + // lp[1] lf[1] ls[1] ps[lp] fam[lf] sty[ls] + // if flags & COLORED: + // c[4] + // if flags & VARIATIONS: + // nv[2] + // a[4nv] + // v[4nv] + */ + + fontDefLength + = 4 /* size */ + + 2 /* flags */ + + 3 /* name length */ + + psLen + famLen + styLen; + + if ((fontflags[f] & FONT_FLAGS_COLORED) != 0) { + fontDefLength += 4; /* 32-bit RGBA value */ + flags |= XDV_FLAG_COLORED; + } + + if (extend != 1.0) { + fontDefLength += 4; + flags |= XDV_FLAG_EXTEND; + } + if (slant != 0.0) { + fontDefLength += 4; + flags |= XDV_FLAG_SLANT; + } + if (embolden != 0.0) { + fontDefLength += 4; + flags |= XDV_FLAG_EMBOLDEN; + } + + if (fontDefLength > xdvBufSize) { + if (xdvbuffer != NULL) + free(xdvbuffer); + xdvBufSize = ((fontDefLength / 1024) + 1) * 1024; + xdvbuffer = (char*) xmalloc(xdvBufSize); + } + cp = xdvbuffer; + + *(Fixed*)cp = SWAP32(size); + cp += 4; + + *(uint16_t*)cp = SWAP16(flags); + cp += 2; + + *(uint8_t*)cp = psLen; + cp += 1; + *(uint8_t*)cp = famLen; + cp += 1; + *(uint8_t*)cp = styLen; + cp += 1; + memcpy(cp, psName, psLen); + cp += psLen; + memcpy(cp, famName, famLen); + cp += famLen; + memcpy(cp, styName, styLen); + cp += styLen; + + if ((fontflags[f] & FONT_FLAGS_COLORED) != 0) { + *(uint32_t*)cp = SWAP32(rgba); + cp += 4; + } + + if (flags & XDV_FLAG_EXTEND) { + Fixed f = D2Fix(extend); + *(uint32_t*)(cp) = SWAP32(f); + cp += 4; + } + if (flags & XDV_FLAG_SLANT) { + Fixed f = D2Fix(slant); + *(uint32_t*)(cp) = SWAP32(f); + cp += 4; + } + if (flags & XDV_FLAG_EMBOLDEN) { + Fixed f = D2Fix(embolden); + *(uint32_t*)(cp) = SWAP32(f); + cp += 4; + } + + free((char*) psName); + free((char*) famName); + free((char*) styName); + + return fontDefLength; } int applymapping(void* pCnv, const uint16_t* txtPtr, int txtLen) { - TECkit_Converter cnv = (TECkit_Converter)pCnv; - UInt32 inUsed, outUsed; - TECkit_Status status; - static UInt32 outLength = 0; - - /* allocate outBuffer if not big enough */ - if (outLength < txtLen * sizeof(UniChar) + 32) { - if (mappedtext != 0) - free(mappedtext); - outLength = txtLen * sizeof(UniChar) + 32; - mappedtext = xmalloc(outLength); - } - - /* try the mapping */ + TECkit_Converter cnv = (TECkit_Converter)pCnv; + UInt32 inUsed, outUsed; + TECkit_Status status; + static UInt32 outLength = 0; + + /* allocate outBuffer if not big enough */ + if (outLength < txtLen * sizeof(UniChar) + 32) { + if (mappedtext != 0) + free(mappedtext); + outLength = txtLen * sizeof(UniChar) + 32; + mappedtext = xmalloc(outLength); + } + + /* try the mapping */ retry: - status = TECkit_ConvertBuffer(cnv, - (Byte*)txtPtr, txtLen * sizeof(UniChar), &inUsed, - (Byte*)mappedtext, outLength, &outUsed, true); - - switch (status) { - case kStatus_NoError: - txtPtr = (const UniChar*)mappedtext; - return outUsed / sizeof(UniChar); - - case kStatus_OutputBufferFull: - outLength += (txtLen * sizeof(UniChar)) + 32; - free(mappedtext); - mappedtext = xmalloc(outLength); - goto retry; - - default: - return 0; - } + status = TECkit_ConvertBuffer(cnv, + (Byte*)txtPtr, txtLen * sizeof(UniChar), &inUsed, + (Byte*)mappedtext, outLength, &outUsed, true); + + switch (status) { + case kStatus_NoError: + txtPtr = (const UniChar*)mappedtext; + return outUsed / sizeof(UniChar); + + case kStatus_OutputBufferFull: + outLength += (txtLen * sizeof(UniChar)) + 32; + free(mappedtext); + mappedtext = xmalloc(outLength); + goto retry; + + default: + return 0; + } } static void snap_zone(scaled* value, scaled snap_value, scaled fuzz) { - scaled difference = *value - snap_value; - if (difference <= fuzz && difference >= -fuzz) - *value = snap_value; + scaled difference = *value - snap_value; + if (difference <= fuzz && difference >= -fuzz) + *value = snap_value; } void getnativecharheightdepth(integer font, integer ch, scaled* height, scaled* depth) { -#define QUAD(f) fontinfo[6+parambase[f]].cint -#define X_HEIGHT(f) fontinfo[5+parambase[f]].cint -#define CAP_HEIGHT(f) fontinfo[8+parambase[f]].cint +#define QUAD(f) fontinfo[6+parambase[f]].cint +#define X_HEIGHT(f) fontinfo[5+parambase[f]].cint +#define CAP_HEIGHT(f) fontinfo[8+parambase[f]].cint - float ht = 0.0; - float dp = 0.0; - Fixed fuzz; + float ht = 0.0; + float dp = 0.0; + Fixed fuzz; #ifdef XETEX_MAC - if (fontarea[font] == AAT_FONT_FLAG) { - CFDictionaryRef attributes = (CFDictionaryRef)(fontlayoutengine[font]); - int gid = MapCharToGlyph_AAT(attributes, ch); - GetGlyphHeightDepth_AAT(attributes, gid, &ht, &dp); - } else + if (fontarea[font] == AAT_FONT_FLAG) { + CFDictionaryRef attributes = (CFDictionaryRef)(fontlayoutengine[font]); + int gid = MapCharToGlyph_AAT(attributes, ch); + GetGlyphHeightDepth_AAT(attributes, gid, &ht, &dp); + } else #endif - if (fontarea[font] == OTGR_FONT_FLAG) { - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[font]; - int gid = mapCharToGlyph(engine, ch); - getGlyphHeightDepth(engine, gid, &ht, &dp); - } else { - fprintf(stderr, "\n! Internal error: bad native font flag in `get_native_char_height_depth`\n"); - exit(3); - } - - *height = D2Fix(ht); - *depth = D2Fix(dp); - - /* snap to "known" zones for baseline, x-height, cap-height if within 4% of em-size */ - fuzz = QUAD(font) / 25; - snap_zone(depth, 0, fuzz); - snap_zone(height, 0, fuzz); - snap_zone(height, X_HEIGHT(font), fuzz); - snap_zone(height, CAP_HEIGHT(font), fuzz); + if (fontarea[font] == OTGR_FONT_FLAG) { + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[font]; + int gid = mapCharToGlyph(engine, ch); + getGlyphHeightDepth(engine, gid, &ht, &dp); + } else { + fprintf(stderr, "\n! Internal error: bad native font flag in `get_native_char_height_depth`\n"); + exit(3); + } + + *height = D2Fix(ht); + *depth = D2Fix(dp); + + /* snap to "known" zones for baseline, x-height, cap-height if within 4% of em-size */ + fuzz = QUAD(font) / 25; + snap_zone(depth, 0, fuzz); + snap_zone(height, 0, fuzz); + snap_zone(height, X_HEIGHT(font), fuzz); + snap_zone(height, CAP_HEIGHT(font), fuzz); } scaled getnativecharht(integer f, integer c) { - scaled h, d; - getnativecharheightdepth(f, c, &h, &d); - return h; + scaled h, d; + getnativecharheightdepth(f, c, &h, &d); + return h; } scaled getnativechardp(integer f, integer c) { - scaled h, d; - getnativecharheightdepth(f, c, &h, &d); - return d; + scaled h, d; + getnativecharheightdepth(f, c, &h, &d); + return d; } void getnativecharsidebearings(integer font, integer ch, scaled* lsb, scaled* rsb) { - float l, r; + float l, r; #ifdef XETEX_MAC - if (fontarea[font] == AAT_FONT_FLAG) { - CFDictionaryRef attributes = (CFDictionaryRef)(fontlayoutengine[font]); - int gid = MapCharToGlyph_AAT(attributes, ch); - GetGlyphSidebearings_AAT(attributes, gid, &l, &r); - } else + if (fontarea[font] == AAT_FONT_FLAG) { + CFDictionaryRef attributes = (CFDictionaryRef)(fontlayoutengine[font]); + int gid = MapCharToGlyph_AAT(attributes, ch); + GetGlyphSidebearings_AAT(attributes, gid, &l, &r); + } else #endif - if (fontarea[font] == OTGR_FONT_FLAG) { - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[font]; - int gid = mapCharToGlyph(engine, ch); - getGlyphSidebearings(engine, gid, &l, &r); - } else { - fprintf(stderr, "\n! Internal error: bad native font flag in `get_native_char_side_bearings'\n"); - exit(3); - } + if (fontarea[font] == OTGR_FONT_FLAG) { + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[font]; + int gid = mapCharToGlyph(engine, ch); + getGlyphSidebearings(engine, gid, &l, &r); + } else { + fprintf(stderr, "\n! Internal error: bad native font flag in `get_native_char_side_bearings'\n"); + exit(3); + } - *lsb = D2Fix(l); - *rsb = D2Fix(r); + *lsb = D2Fix(l); + *rsb = D2Fix(r); } scaled getglyphbounds(integer font, integer edge, integer gid) { /* edge codes 1,2,3,4 => L T R B */ - float a, b; - + float a, b; + #ifdef XETEX_MAC - if (fontarea[font] == AAT_FONT_FLAG) { - CFDictionaryRef attributes = (CFDictionaryRef)(fontlayoutengine[font]); - if (edge & 1) - GetGlyphSidebearings_AAT(attributes, gid, &a, &b); - else - GetGlyphHeightDepth_AAT(attributes, gid, &a, &b); - } else + if (fontarea[font] == AAT_FONT_FLAG) { + CFDictionaryRef attributes = (CFDictionaryRef)(fontlayoutengine[font]); + if (edge & 1) + GetGlyphSidebearings_AAT(attributes, gid, &a, &b); + else + GetGlyphHeightDepth_AAT(attributes, gid, &a, &b); + } else #endif - if (fontarea[font] == OTGR_FONT_FLAG) { - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[font]; - if (edge & 1) - getGlyphSidebearings(engine, gid, &a, &b); - else - getGlyphHeightDepth(engine, gid, &a, &b); - } else { - fprintf(stderr, "\n! Internal error: bad native font flag in `get_glyph_bounds'\n"); - exit(3); - } - return D2Fix((edge <= 2) ? a : b); + if (fontarea[font] == OTGR_FONT_FLAG) { + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[font]; + if (edge & 1) + getGlyphSidebearings(engine, gid, &a, &b); + else + getGlyphHeightDepth(engine, gid, &a, &b); + } else { + fprintf(stderr, "\n! Internal error: bad native font flag in `get_glyph_bounds'\n"); + exit(3); + } + return D2Fix((edge <= 2) ? a : b); } scaled getnativecharic(integer f, integer c) { - scaled lsb, rsb; - getnativecharsidebearings(f, c, &lsb, &rsb); - if (rsb < 0) - return fontletterspace[f] - rsb; - else - return fontletterspace[f]; + scaled lsb, rsb; + getnativecharsidebearings(f, c, &lsb, &rsb); + if (rsb < 0) + return fontletterspace[f] - rsb; + else + return fontletterspace[f]; } scaled getnativecharwd(integer f, integer c) { - scaled wd = 0; + scaled wd = 0; #ifdef XETEX_MAC - if (fontarea[f] == AAT_FONT_FLAG) { - CFDictionaryRef attributes = (CFDictionaryRef)(fontlayoutengine[f]); - int gid = MapCharToGlyph_AAT(attributes, c); - wd = D2Fix(GetGlyphWidth_AAT(attributes, gid)); - } else + if (fontarea[f] == AAT_FONT_FLAG) { + CFDictionaryRef attributes = (CFDictionaryRef)(fontlayoutengine[f]); + int gid = MapCharToGlyph_AAT(attributes, c); + wd = D2Fix(GetGlyphWidth_AAT(attributes, gid)); + } else #endif - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[f]; - int gid = mapCharToGlyph(engine, c); - wd = D2Fix(getGlyphWidthFromEngine(engine, gid)); - } else { - fprintf(stderr, "\n! Internal error: bad native font flag in `get_native_char_wd'\n"); - exit(3); - } - return wd; + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[f]; + int gid = mapCharToGlyph(engine, c); + wd = D2Fix(getGlyphWidthFromEngine(engine, gid)); + } else { + fprintf(stderr, "\n! Internal error: bad native font flag in `get_native_char_wd'\n"); + exit(3); + } + return wd; } uint16_t get_native_glyph(void* pNode, unsigned index) { - memoryword* node = (memoryword*)pNode; - FixedPoint* locations = (FixedPoint*)native_glyph_info_ptr(node); - uint16_t* glyphIDs = (uint16_t*)(locations + native_glyph_count(node)); - if (index >= native_glyph_count(node)) - return 0; - else - return glyphIDs[index]; + memoryword* node = (memoryword*)pNode; + FixedPoint* locations = (FixedPoint*)native_glyph_info_ptr(node); + uint16_t* glyphIDs = (uint16_t*)(locations + native_glyph_count(node)); + if (index >= native_glyph_count(node)) + return 0; + else + return glyphIDs[index]; } void store_justified_native_glyphs(void* node) { #ifdef XETEX_MAC /* this is only called for AAT fonts */ - (void)DoAATLayout(node, 1); + (void)DoAATLayout(node, 1); #endif } void measure_native_node(void* pNode, int use_glyph_metrics) { - memoryword* node = (memoryword*)pNode; - int txtLen = native_length(node); - uint16_t* txtPtr = (uint16_t*)(node + native_node_size); + memoryword* node = (memoryword*)pNode; + int txtLen = native_length(node); + uint16_t* txtPtr = (uint16_t*)(node + native_node_size); - unsigned f = native_font(node); + unsigned f = native_font(node); #ifdef XETEX_MAC - if (fontarea[f] == AAT_FONT_FLAG) { - /* we're using this font in AAT mode, so fontlayoutengine[f] is actually a CFDictionaryRef */ - DoAATLayout(node, 0); - } else + if (fontarea[f] == AAT_FONT_FLAG) { + /* we're using this font in AAT mode, so fontlayoutengine[f] is actually a CFDictionaryRef */ + DoAATLayout(node, 0); + } else #endif - if (fontarea[f] == OTGR_FONT_FLAG) { - /* using this font in OT Layout mode, so fontlayoutengine[f] is actually a XeTeXLayoutEngine */ - - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)(fontlayoutengine[f]); - - FixedPoint* locations; - uint16_t* glyphIDs; - Fixed* glyphAdvances; - int totalGlyphCount = 0; - - /* need to find direction runs within the text, and call layoutChars separately for each */ - - UBiDiDirection dir; - void* glyph_info = 0; - static float* positions = 0; - static float* advances = 0; - static uint32_t* glyphs = 0; - - UBiDi* pBiDi = ubidi_open(); - - UErrorCode errorCode = (UErrorCode)0; - ubidi_setPara(pBiDi, txtPtr, txtLen, getDefaultDirection(engine), NULL, &errorCode); - - dir = ubidi_getDirection(pBiDi); - if (dir == UBIDI_MIXED) { - /* we actually do the layout twice here, once to count glyphs and then again to get them; - which is inefficient, but i figure that MIXED is a relatively rare occurrence, so i can't be - bothered to deal with the memory reallocation headache of doing it differently - */ - int nRuns = ubidi_countRuns(pBiDi, &errorCode); - double width = 0; - int i, runIndex; - int32_t logicalStart, length; - for (runIndex = 0; runIndex < nRuns; ++runIndex) { - dir = ubidi_getVisualRun(pBiDi, runIndex, &logicalStart, &length); - totalGlyphCount += layoutChars(engine, txtPtr, logicalStart, length, txtLen, (dir == UBIDI_RTL)); - } - - if (totalGlyphCount > 0) { - double x, y; - glyph_info = xmalloc(totalGlyphCount * native_glyph_info_size); - locations = (FixedPoint*)glyph_info; - glyphIDs = (uint16_t*)(locations + totalGlyphCount); - glyphAdvances = xmalloc(totalGlyphCount * sizeof(Fixed)); - totalGlyphCount = 0; - - x = y = 0.0; - for (runIndex = 0; runIndex < nRuns; ++runIndex) { - int nGlyphs; - dir = ubidi_getVisualRun(pBiDi, runIndex, &logicalStart, &length); - nGlyphs = layoutChars(engine, txtPtr, logicalStart, length, txtLen, - (dir == UBIDI_RTL)); - - glyphs = xmalloc(nGlyphs * sizeof(uint32_t)); - positions = xmalloc((nGlyphs * 2 + 2) * sizeof(float)); - advances = xmalloc(nGlyphs * sizeof(float)); - - getGlyphs(engine, glyphs); - getGlyphAdvances(engine, advances); - getGlyphPositions(engine, positions); - - for (i = 0; i < nGlyphs; ++i) { - glyphIDs[totalGlyphCount] = glyphs[i]; - locations[totalGlyphCount].x = D2Fix(positions[2*i] + x); - locations[totalGlyphCount].y = D2Fix(positions[2*i+1] + y); - glyphAdvances[totalGlyphCount] = D2Fix(advances[i]); - ++totalGlyphCount; - } - x += positions[2*i]; - y += positions[2*i+1]; - - free(glyphs); - free(positions); - } - width = x; - } - - node_width(node) = D2Fix(width); - native_glyph_count(node) = totalGlyphCount; - native_glyph_info_ptr(node) = glyph_info; - } else { - double width = 0; - totalGlyphCount = layoutChars(engine, txtPtr, 0, txtLen, txtLen, (dir == UBIDI_RTL)); - - glyphs = xmalloc(totalGlyphCount * sizeof(uint32_t)); - positions = xmalloc((totalGlyphCount * 2 + 2) * sizeof(float)); - advances = xmalloc(totalGlyphCount * sizeof(float)); - - getGlyphs(engine, glyphs); - getGlyphAdvances(engine, advances); - getGlyphPositions(engine, positions); - - if (totalGlyphCount > 0) { - int i; - glyph_info = xmalloc(totalGlyphCount * native_glyph_info_size); - locations = (FixedPoint*)glyph_info; - glyphIDs = (uint16_t*)(locations + totalGlyphCount); - glyphAdvances = xmalloc(totalGlyphCount * sizeof(Fixed)); - for (i = 0; i < totalGlyphCount; ++i) { - glyphIDs[i] = glyphs[i]; - glyphAdvances[i] = D2Fix(advances[i]); - locations[i].x = D2Fix(positions[2*i]); - locations[i].y = D2Fix(positions[2*i+1]); - } - width = D2Fix(positions[2*i]); - } - - node_width(node) = width; - native_glyph_count(node) = totalGlyphCount; - native_glyph_info_ptr(node) = glyph_info; - - free(glyphs); - free(positions); - } - - ubidi_close(pBiDi); - - - if (fontletterspace[f] != 0) { - Fixed lsDelta = 0; - Fixed lsUnit = fontletterspace[f]; - int i; - for (i = 0; i < totalGlyphCount; ++i) { - if (glyphAdvances[i] == 0 && lsDelta != 0) - lsDelta -= lsUnit; - locations[i].x += lsDelta; - lsDelta += lsUnit; - } - if (lsDelta != 0) { - lsDelta -= lsUnit; - node_width(node) += lsDelta; - } - } - } else { - fprintf(stderr, "\n! Internal error: bad native font flag in `measure_native_node'\n"); - exit(3); - } - - if (use_glyph_metrics == 0 || native_glyph_count(node) == 0) { - /* for efficiency, height and depth are the font's ascent/descent, - not true values based on the actual content of the word, - unless use_glyph_metrics is non-zero */ - node_height(node) = heightbase[f]; - node_depth(node) = depthbase[f]; - } else { - /* this iterates over the glyph data whether it comes from AAT or OT layout */ - FixedPoint* locations = (FixedPoint*)native_glyph_info_ptr(node); - uint16_t* glyphIDs = (uint16_t*)(locations + native_glyph_count(node)); - float yMin = 65536.0; - float yMax = -65536.0; - int i; - for (i = 0; i < native_glyph_count(node); ++i) { - float ht, dp; - float y = Fix2D(-locations[i].y); /* NB negative is upwards in locations[].y! */ - - GlyphBBox bbox; - if (getCachedGlyphBBox(f, glyphIDs[i], &bbox) == 0) { + if (fontarea[f] == OTGR_FONT_FLAG) { + /* using this font in OT Layout mode, so fontlayoutengine[f] is actually a XeTeXLayoutEngine */ + + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)(fontlayoutengine[f]); + + FixedPoint* locations; + uint16_t* glyphIDs; + Fixed* glyphAdvances; + int totalGlyphCount = 0; + + /* need to find direction runs within the text, and call layoutChars separately for each */ + + UBiDiDirection dir; + void* glyph_info = 0; + static float* positions = 0; + static float* advances = 0; + static uint32_t* glyphs = 0; + + UBiDi* pBiDi = ubidi_open(); + + UErrorCode errorCode = U_ZERO_ERROR; + ubidi_setPara(pBiDi, (const UChar*) txtPtr, txtLen, getDefaultDirection(engine), NULL, &errorCode); + + dir = ubidi_getDirection(pBiDi); + if (dir == UBIDI_MIXED) { + /* we actually do the layout twice here, once to count glyphs and then again to get them; + which is inefficient, but i figure that MIXED is a relatively rare occurrence, so i can't be + bothered to deal with the memory reallocation headache of doing it differently + */ + int nRuns = ubidi_countRuns(pBiDi, &errorCode); + double width = 0; + int i, runIndex; + int32_t logicalStart, length; + for (runIndex = 0; runIndex < nRuns; ++runIndex) { + dir = ubidi_getVisualRun(pBiDi, runIndex, &logicalStart, &length); + totalGlyphCount += layoutChars(engine, txtPtr, logicalStart, length, txtLen, (dir == UBIDI_RTL)); + } + + if (totalGlyphCount > 0) { + double x, y; + glyph_info = xcalloc(totalGlyphCount, native_glyph_info_size); + locations = (FixedPoint*)glyph_info; + glyphIDs = (uint16_t*)(locations + totalGlyphCount); + glyphAdvances = (Fixed*) xcalloc(totalGlyphCount, sizeof(Fixed)); + totalGlyphCount = 0; + + x = y = 0.0; + for (runIndex = 0; runIndex < nRuns; ++runIndex) { + int nGlyphs; + dir = ubidi_getVisualRun(pBiDi, runIndex, &logicalStart, &length); + nGlyphs = layoutChars(engine, txtPtr, logicalStart, length, txtLen, + (dir == UBIDI_RTL)); + + glyphs = (uint32_t*) xcalloc(nGlyphs, sizeof(uint32_t)); + positions = (float*) xcalloc(nGlyphs * 2 + 2, sizeof(float)); + advances = (float*) xcalloc(nGlyphs, sizeof(float)); + + getGlyphs(engine, glyphs); + getGlyphAdvances(engine, advances); + getGlyphPositions(engine, positions); + + for (i = 0; i < nGlyphs; ++i) { + glyphIDs[totalGlyphCount] = glyphs[i]; + locations[totalGlyphCount].x = D2Fix(positions[2*i] + x); + locations[totalGlyphCount].y = D2Fix(positions[2*i+1] + y); + glyphAdvances[totalGlyphCount] = D2Fix(advances[i]); + ++totalGlyphCount; + } + x += positions[2*i]; + y += positions[2*i+1]; + + free(glyphs); + free(positions); + free(advances); + } + width = x; + } + + node_width(node) = D2Fix(width); + native_glyph_count(node) = totalGlyphCount; + native_glyph_info_ptr(node) = glyph_info; + } else { + double width = 0; + totalGlyphCount = layoutChars(engine, txtPtr, 0, txtLen, txtLen, (dir == UBIDI_RTL)); + + glyphs = (uint32_t*) xcalloc(totalGlyphCount, sizeof(uint32_t)); + positions = (float*) xcalloc(totalGlyphCount * 2 + 2, sizeof(float)); + advances = (float*) xcalloc(totalGlyphCount, sizeof(float)); + + getGlyphs(engine, glyphs); + getGlyphAdvances(engine, advances); + getGlyphPositions(engine, positions); + + if (totalGlyphCount > 0) { + int i; + glyph_info = xcalloc(totalGlyphCount, native_glyph_info_size); + locations = (FixedPoint*)glyph_info; + glyphIDs = (uint16_t*)(locations + totalGlyphCount); + glyphAdvances = (Fixed*) xcalloc(totalGlyphCount, sizeof(Fixed)); + for (i = 0; i < totalGlyphCount; ++i) { + glyphIDs[i] = glyphs[i]; + glyphAdvances[i] = D2Fix(advances[i]); + locations[i].x = D2Fix(positions[2*i]); + locations[i].y = D2Fix(positions[2*i+1]); + } + width = D2Fix(positions[2*i]); + } + + node_width(node) = width; + native_glyph_count(node) = totalGlyphCount; + native_glyph_info_ptr(node) = glyph_info; + + free(glyphs); + free(positions); + free(advances); + } + + ubidi_close(pBiDi); + + + if (fontletterspace[f] != 0) { + Fixed lsDelta = 0; + Fixed lsUnit = fontletterspace[f]; + int i; + for (i = 0; i < totalGlyphCount; ++i) { + if (glyphAdvances[i] == 0 && lsDelta != 0) + lsDelta -= lsUnit; + locations[i].x += lsDelta; + lsDelta += lsUnit; + } + if (lsDelta != 0) { + lsDelta -= lsUnit; + node_width(node) += lsDelta; + } + } + free(glyphAdvances); + } else { + fprintf(stderr, "\n! Internal error: bad native font flag in `measure_native_node'\n"); + exit(3); + } + + if (use_glyph_metrics == 0 || native_glyph_count(node) == 0) { + /* for efficiency, height and depth are the font's ascent/descent, + not true values based on the actual content of the word, + unless use_glyph_metrics is non-zero */ + node_height(node) = heightbase[f]; + node_depth(node) = depthbase[f]; + } else { + /* this iterates over the glyph data whether it comes from AAT or OT layout */ + FixedPoint* locations = (FixedPoint*)native_glyph_info_ptr(node); + uint16_t* glyphIDs = (uint16_t*)(locations + native_glyph_count(node)); + float yMin = 65536.0; + float yMax = -65536.0; + int i; + for (i = 0; i < native_glyph_count(node); ++i) { + float ht, dp; + float y = Fix2D(-locations[i].y); /* NB negative is upwards in locations[].y! */ + + GlyphBBox bbox; + if (getCachedGlyphBBox(f, glyphIDs[i], &bbox) == 0) { #ifdef XETEX_MAC - if (fontarea[f] == AAT_FONT_FLAG) - GetGlyphBBox_AAT((CFDictionaryRef)(fontlayoutengine[f]), glyphIDs[i], &bbox); - else + if (fontarea[f] == AAT_FONT_FLAG) + GetGlyphBBox_AAT((CFDictionaryRef)(fontlayoutengine[f]), glyphIDs[i], &bbox); + else #endif - if (fontarea[f] == OTGR_FONT_FLAG) - getGlyphBounds((XeTeXLayoutEngine)(fontlayoutengine[f]), glyphIDs[i], &bbox); - - cacheGlyphBBox(f, glyphIDs[i], &bbox); - } - - ht = bbox.yMax; - dp = -bbox.yMin; - - if (y + ht > yMax) - yMax = y + ht; - if (y - dp < yMin) - yMin = y - dp; - } - node_height(node) = D2Fix(yMax); - node_depth(node) = -D2Fix(yMin); - } + if (fontarea[f] == OTGR_FONT_FLAG) + getGlyphBounds((XeTeXLayoutEngine)(fontlayoutengine[f]), glyphIDs[i], &bbox); + + cacheGlyphBBox(f, glyphIDs[i], &bbox); + } + + ht = bbox.yMax; + dp = -bbox.yMin; + + if (y + ht > yMax) + yMax = y + ht; + if (y - dp < yMin) + yMin = y - dp; + } + node_height(node) = D2Fix(yMax); + node_depth(node) = -D2Fix(yMin); + } } Fixed get_native_italic_correction(void* pNode) { - memoryword* node = pNode; - unsigned f = native_font(node); - unsigned n = native_glyph_count(node); - if (n > 0) { - FixedPoint* locations = (FixedPoint*)native_glyph_info_ptr(node); - uint16_t* glyphIDs = (uint16_t*)(locations + n); + memoryword* node = (memoryword*) pNode; + unsigned f = native_font(node); + unsigned n = native_glyph_count(node); + if (n > 0) { + FixedPoint* locations = (FixedPoint*)native_glyph_info_ptr(node); + uint16_t* glyphIDs = (uint16_t*)(locations + n); #ifdef XETEX_MAC - if (fontarea[f] == AAT_FONT_FLAG) - return D2Fix(GetGlyphItalCorr_AAT((CFDictionaryRef)(fontlayoutengine[f]), glyphIDs[n-1])) - + fontletterspace[f]; + if (fontarea[f] == AAT_FONT_FLAG) + return D2Fix(GetGlyphItalCorr_AAT((CFDictionaryRef)(fontlayoutengine[f]), glyphIDs[n-1])) + + fontletterspace[f]; #endif - if (fontarea[f] == OTGR_FONT_FLAG) - return D2Fix(getGlyphItalCorr((XeTeXLayoutEngine)(fontlayoutengine[f]), glyphIDs[n-1])) - + fontletterspace[f]; - } + if (fontarea[f] == OTGR_FONT_FLAG) + return D2Fix(getGlyphItalCorr((XeTeXLayoutEngine)(fontlayoutengine[f]), glyphIDs[n-1])) + + fontletterspace[f]; + } - return 0; + return 0; } Fixed get_native_glyph_italic_correction(void* pNode) { - memoryword* node = pNode; - uint16_t gid = native_glyph(node); - unsigned f = native_font(node); + memoryword* node = (memoryword*) pNode; + uint16_t gid = native_glyph(node); + unsigned f = native_font(node); #ifdef XETEX_MAC - if (fontarea[f] == AAT_FONT_FLAG) - return D2Fix(GetGlyphItalCorr_AAT((CFDictionaryRef)(fontlayoutengine[f]), gid)); + if (fontarea[f] == AAT_FONT_FLAG) + return D2Fix(GetGlyphItalCorr_AAT((CFDictionaryRef)(fontlayoutengine[f]), gid)); #endif - if (fontarea[f] == OTGR_FONT_FLAG) - return D2Fix(getGlyphItalCorr((XeTeXLayoutEngine)(fontlayoutengine[f]), gid)); + if (fontarea[f] == OTGR_FONT_FLAG) + return D2Fix(getGlyphItalCorr((XeTeXLayoutEngine)(fontlayoutengine[f]), gid)); - return 0; /* can't actually happen */ + return 0; /* can't actually happen */ } void measure_native_glyph(void* pNode, int use_glyph_metrics) { - memoryword* node = pNode; - uint16_t gid = native_glyph(node); - unsigned f = native_font(node); + memoryword* node = (memoryword*) pNode; + uint16_t gid = native_glyph(node); + unsigned f = native_font(node); - float ht = 0.0; - float dp = 0.0; + float ht = 0.0; + float dp = 0.0; #ifdef XETEX_MAC - if (fontarea[f] == AAT_FONT_FLAG) { - CFDictionaryRef attributes = (CFDictionaryRef)(fontlayoutengine[f]); - node_width(node) = D2Fix(GetGlyphWidth_AAT(attributes, gid)); - if (use_glyph_metrics) - GetGlyphHeightDepth_AAT(attributes, gid, &ht, &dp); - } else + if (fontarea[f] == AAT_FONT_FLAG) { + CFDictionaryRef attributes = (CFDictionaryRef)(fontlayoutengine[f]); + node_width(node) = D2Fix(GetGlyphWidth_AAT(attributes, gid)); + if (use_glyph_metrics) + GetGlyphHeightDepth_AAT(attributes, gid, &ht, &dp); + } else #endif - if (fontarea[f] == OTGR_FONT_FLAG) { - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[f]; - XeTeXFont fontInst = getFont(engine); - node_width(node) = D2Fix(getGlyphWidth(fontInst, gid)); - if (use_glyph_metrics) - getGlyphHeightDepth(engine, gid, &ht, &dp); - } else { - fprintf(stderr, "\n! Internal error: bad native font flag in `measure_native_glyph'\n"); - exit(3); - } - - if (use_glyph_metrics) { - node_height(node) = D2Fix(ht); - node_depth(node) = D2Fix(dp); - } else { - node_height(node) = heightbase[f]; - node_depth(node) = depthbase[f]; - } + if (fontarea[f] == OTGR_FONT_FLAG) { + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[f]; + XeTeXFont fontInst = getFont(engine); + node_width(node) = D2Fix(getGlyphWidth(fontInst, gid)); + if (use_glyph_metrics) + getGlyphHeightDepth(engine, gid, &ht, &dp); + } else { + fprintf(stderr, "\n! Internal error: bad native font flag in `measure_native_glyph'\n"); + exit(3); + } + + if (use_glyph_metrics) { + node_height(node) = D2Fix(ht); + node_depth(node) = D2Fix(dp); + } else { + node_height(node) = heightbase[f]; + node_depth(node) = depthbase[f]; + } } integer mapchartoglyph(integer font, integer ch) { - if (ch > 0x10ffff || ((ch >= 0xd800) && (ch <= 0xdfff))) - return 0; + if (ch > 0x10ffff || ((ch >= 0xd800) && (ch <= 0xdfff))) + return 0; #ifdef XETEX_MAC - if (fontarea[font] == AAT_FONT_FLAG) - return MapCharToGlyph_AAT((CFDictionaryRef)(fontlayoutengine[font]), ch); - else + if (fontarea[font] == AAT_FONT_FLAG) + return MapCharToGlyph_AAT((CFDictionaryRef)(fontlayoutengine[font]), ch); + else #endif - if (fontarea[font] == OTGR_FONT_FLAG) - return mapCharToGlyph((XeTeXLayoutEngine)(fontlayoutengine[font]), ch); - else { - fprintf(stderr, "\n! Internal error: bad native font flag in `map_char_to_glyph'\n"); - exit(3); - } + if (fontarea[font] == OTGR_FONT_FLAG) + return mapCharToGlyph((XeTeXLayoutEngine)(fontlayoutengine[font]), ch); + else { + fprintf(stderr, "\n! Internal error: bad native font flag in `map_char_to_glyph'\n"); + exit(3); + } } integer mapglyphtoindex(integer font) - /* glyph name is at nameoffile+1 */ + /* glyph name is at nameoffile+1 */ { #ifdef XETEX_MAC - if (fontarea[font] == AAT_FONT_FLAG) - return MapGlyphToIndex_AAT((CFDictionaryRef)(fontlayoutengine[font]), (const char*)nameoffile + 1); - else + if (fontarea[font] == AAT_FONT_FLAG) + return MapGlyphToIndex_AAT((CFDictionaryRef)(fontlayoutengine[font]), (const char*)nameoffile + 1); + else #endif - if (fontarea[font] == OTGR_FONT_FLAG) - return mapGlyphToIndex((XeTeXLayoutEngine)(fontlayoutengine[font]), (const char*)nameoffile + 1); - else { - fprintf(stderr, "\n! Internal error: bad native font flag in `map_glyph_to_index'\n"); - exit(3); - } + if (fontarea[font] == OTGR_FONT_FLAG) + return mapGlyphToIndex((XeTeXLayoutEngine)(fontlayoutengine[font]), (const char*)nameoffile + 1); + else { + fprintf(stderr, "\n! Internal error: bad native font flag in `map_glyph_to_index'\n"); + exit(3); + } } integer getfontcharrange(integer font, int first) { #ifdef XETEX_MAC - if (fontarea[font] == AAT_FONT_FLAG) - return GetFontCharRange_AAT((CFDictionaryRef)(fontlayoutengine[font]), first); - else + if (fontarea[font] == AAT_FONT_FLAG) + return GetFontCharRange_AAT((CFDictionaryRef)(fontlayoutengine[font]), first); + else #endif - if (fontarea[font] == OTGR_FONT_FLAG) - return getFontCharRange((XeTeXLayoutEngine)(fontlayoutengine[font]), first); - else { - fprintf(stderr, "\n! Internal error: bad native font flag in `get_font_char_range'\n"); - exit(3); - } + if (fontarea[font] == OTGR_FONT_FLAG) + return getFontCharRange((XeTeXLayoutEngine)(fontlayoutengine[font]), first); + else { + fprintf(stderr, "\n! Internal error: bad native font flag in `get_font_char_range'\n"); + exit(3); + } } Fixed D2Fix(double d) { - Fixed rval = (int)(d * 65536.0 + 0.5); - return rval; + Fixed rval = (int)(d * 65536.0 + 0.5); + return rval; } double Fix2D(Fixed f) { - double rval = f / 65536.0; - return rval; + double rval = f / 65536.0; + return rval; } /* these are here, not XeTeX_mac.c, because we need stubs on other platforms */ @@ -2324,633 +2329,633 @@ void aatgetfontmetrics(CFDictionaryRef attributes, integer* ascent, integer* descent, integer* xheight, integer* capheight, integer* slant) { #ifdef XETEX_MAC - CTFontRef font = fontFromAttributes(attributes); + CTFontRef font = fontFromAttributes(attributes); - *ascent = D2Fix(CTFontGetAscent(font)); - *descent = D2Fix(CTFontGetDescent(font)); - *xheight = D2Fix(CTFontGetXHeight(font)); - *capheight = D2Fix(CTFontGetCapHeight(font)); - *slant = D2Fix(tan(-CTFontGetSlantAngle(font) * M_PI / 180.0)); + *ascent = D2Fix(CTFontGetAscent(font)); + *descent = D2Fix(CTFontGetDescent(font)); + *xheight = D2Fix(CTFontGetXHeight(font)); + *capheight = D2Fix(CTFontGetCapHeight(font)); + *slant = D2Fix(tan(-CTFontGetSlantAngle(font) * M_PI / 180.0)); #endif } int aatfontget(int what, CFDictionaryRef attributes) { - int rval = -1; + int rval = -1; #ifdef XETEX_MAC - CTFontRef font = fontFromAttributes(attributes); - CFArrayRef list; - - switch (what) { - case XeTeX_count_glyphs: - rval = CTFontGetGlyphCount(font); - break; - - case XeTeX_count_variations: - case XeTeX_count_features: - list = (what == XeTeX_count_variations ? CTFontCopyVariationAxes(font) - : CTFontCopyFeatures(font)); - if (list) { - rval = CFArrayGetCount(list); - CFRelease(list); - } - break; - } + CTFontRef font = fontFromAttributes(attributes); + CFArrayRef list; + + switch (what) { + case XeTeX_count_glyphs: + rval = CTFontGetGlyphCount(font); + break; + + case XeTeX_count_variations: + case XeTeX_count_features: + list = (what == XeTeX_count_variations ? CTFontCopyVariationAxes(font) + : CTFontCopyFeatures(font)); + if (list) { + rval = CFArrayGetCount(list); + CFRelease(list); + } + break; + } #endif - return rval; + return rval; } int aatfontget1(int what, CFDictionaryRef attributes, int param) { - int rval = -1; + int rval = -1; #ifdef XETEX_MAC - CTFontRef font = fontFromAttributes(attributes); - - switch (what) { - case XeTeX_variation: - { - CFArrayRef axes = CTFontCopyVariationAxes(font); - if (axes) { - if (CFArrayGetCount(axes) > param) { - CFDictionaryRef variation = CFArrayGetValueAtIndex(axes, param); - CFNumberRef identifier = CFDictionaryGetValue(variation, kCTFontVariationAxisIdentifierKey); - if (identifier) - CFNumberGetValue(identifier, kCFNumberIntType, &rval); - } - CFRelease(axes); - } - break; - } - - case XeTeX_variation_min: - case XeTeX_variation_max: - case XeTeX_variation_default: - { - CFArrayRef axes = CTFontCopyVariationAxes(font); - if (axes) { - CFDictionaryRef variation = findDictionaryInArrayWithIdentifier(axes, kCTFontVariationAxisIdentifierKey, param); - CFStringRef key = (what == XeTeX_variation_min ? kCTFontVariationAxisMinimumValueKey : - (what == XeTeX_variation_max ? kCTFontVariationAxisMaximumValueKey : - kCTFontVariationAxisDefaultValueKey)); - CFNumberRef value = CFDictionaryGetValue(variation, key); - if (value) - CFNumberGetValue(value, kCFNumberIntType, &rval); - CFRelease(axes); - } - break; - } - - case XeTeX_feature_code: - { - CFArrayRef features = CTFontCopyFeatures(font); - if (features) { - if (CFArrayGetCount(features) > param) { - CFDictionaryRef feature = CFArrayGetValueAtIndex(features, param); - CFNumberRef identifier = CFDictionaryGetValue(feature, kCTFontFeatureTypeIdentifierKey); - if (identifier) - CFNumberGetValue(identifier, kCFNumberIntType, &rval); - } - CFRelease(features); - } - break; - } - - case XeTeX_is_exclusive_feature: - { - CFArrayRef features = CTFontCopyFeatures(font); - if (features) { - CFBooleanRef value; - CFDictionaryRef feature = findDictionaryInArrayWithIdentifier(features, kCTFontFeatureTypeIdentifierKey, param); - Boolean found = CFDictionaryGetValueIfPresent(feature, kCTFontFeatureTypeExclusiveKey, (const void **)&value); - if (found) - rval = CFBooleanGetValue(value); - CFRelease(features); - } - break; - } - - case XeTeX_count_selectors: - { - CFArrayRef features = CTFontCopyFeatures(font); - if (features) { - CFDictionaryRef feature = findDictionaryInArrayWithIdentifier(features, kCTFontFeatureTypeIdentifierKey, param); - if (feature) { - CFArrayRef selectors = CFDictionaryGetValue(feature, kCTFontFeatureTypeSelectorsKey); - if (selectors) - rval = CFArrayGetCount(selectors); - } - CFRelease(features); - } - break; - } - } + CTFontRef font = fontFromAttributes(attributes); + + switch (what) { + case XeTeX_variation: + { + CFArrayRef axes = CTFontCopyVariationAxes(font); + if (axes) { + if (CFArrayGetCount(axes) > param) { + CFDictionaryRef variation = CFArrayGetValueAtIndex(axes, param); + CFNumberRef identifier = CFDictionaryGetValue(variation, kCTFontVariationAxisIdentifierKey); + if (identifier) + CFNumberGetValue(identifier, kCFNumberIntType, &rval); + } + CFRelease(axes); + } + break; + } + + case XeTeX_variation_min: + case XeTeX_variation_max: + case XeTeX_variation_default: + { + CFArrayRef axes = CTFontCopyVariationAxes(font); + if (axes) { + CFDictionaryRef variation = findDictionaryInArrayWithIdentifier(axes, kCTFontVariationAxisIdentifierKey, param); + CFStringRef key = (what == XeTeX_variation_min ? kCTFontVariationAxisMinimumValueKey : + (what == XeTeX_variation_max ? kCTFontVariationAxisMaximumValueKey : + kCTFontVariationAxisDefaultValueKey)); + CFNumberRef value = CFDictionaryGetValue(variation, key); + if (value) + CFNumberGetValue(value, kCFNumberIntType, &rval); + CFRelease(axes); + } + break; + } + + case XeTeX_feature_code: + { + CFArrayRef features = CTFontCopyFeatures(font); + if (features) { + if (CFArrayGetCount(features) > param) { + CFDictionaryRef feature = CFArrayGetValueAtIndex(features, param); + CFNumberRef identifier = CFDictionaryGetValue(feature, kCTFontFeatureTypeIdentifierKey); + if (identifier) + CFNumberGetValue(identifier, kCFNumberIntType, &rval); + } + CFRelease(features); + } + break; + } + + case XeTeX_is_exclusive_feature: + { + CFArrayRef features = CTFontCopyFeatures(font); + if (features) { + CFBooleanRef value; + CFDictionaryRef feature = findDictionaryInArrayWithIdentifier(features, kCTFontFeatureTypeIdentifierKey, param); + Boolean found = CFDictionaryGetValueIfPresent(feature, kCTFontFeatureTypeExclusiveKey, (const void **)&value); + if (found) + rval = CFBooleanGetValue(value); + CFRelease(features); + } + break; + } + + case XeTeX_count_selectors: + { + CFArrayRef features = CTFontCopyFeatures(font); + if (features) { + CFDictionaryRef feature = findDictionaryInArrayWithIdentifier(features, kCTFontFeatureTypeIdentifierKey, param); + if (feature) { + CFArrayRef selectors = CFDictionaryGetValue(feature, kCTFontFeatureTypeSelectorsKey); + if (selectors) + rval = CFArrayGetCount(selectors); + } + CFRelease(features); + } + break; + } + } #endif - - return rval; + + return rval; } int aatfontget2(int what, CFDictionaryRef attributes, int param1, int param2) { - int rval = -1; + int rval = -1; #ifdef XETEX_MAC - CTFontRef font = fontFromAttributes(attributes); - CFArrayRef features = CTFontCopyFeatures(font); - if (features) { - CFDictionaryRef feature = findDictionaryInArrayWithIdentifier(features, kCTFontFeatureTypeIdentifierKey, param1); - if (feature) { - CFArrayRef selectors = CFDictionaryGetValue(feature, kCTFontFeatureTypeSelectorsKey); - if (selectors) { - CFDictionaryRef selector; - switch (what) { - case XeTeX_selector_code: - if (CFArrayGetCount(selectors) > param2) { - CFNumberRef identifier; - selector = CFArrayGetValueAtIndex(selectors, param2); - identifier = CFDictionaryGetValue(selector, kCTFontFeatureSelectorIdentifierKey); - if (identifier) - CFNumberGetValue(identifier, kCFNumberIntType, &rval); - } - break; - case XeTeX_is_default_selector: - selector = findDictionaryInArrayWithIdentifier(selectors, kCTFontFeatureSelectorIdentifierKey, param2); - if (selector) { - CFBooleanRef isDefault; - Boolean found = CFDictionaryGetValueIfPresent(selector, kCTFontFeatureSelectorDefaultKey, (const void **)&isDefault); - if (found) - rval = CFBooleanGetValue(isDefault); - } - break; - } - } - } - CFRelease(features); - } + CTFontRef font = fontFromAttributes(attributes); + CFArrayRef features = CTFontCopyFeatures(font); + if (features) { + CFDictionaryRef feature = findDictionaryInArrayWithIdentifier(features, kCTFontFeatureTypeIdentifierKey, param1); + if (feature) { + CFArrayRef selectors = CFDictionaryGetValue(feature, kCTFontFeatureTypeSelectorsKey); + if (selectors) { + CFDictionaryRef selector; + switch (what) { + case XeTeX_selector_code: + if (CFArrayGetCount(selectors) > param2) { + CFNumberRef identifier; + selector = CFArrayGetValueAtIndex(selectors, param2); + identifier = CFDictionaryGetValue(selector, kCTFontFeatureSelectorIdentifierKey); + if (identifier) + CFNumberGetValue(identifier, kCFNumberIntType, &rval); + } + break; + case XeTeX_is_default_selector: + selector = findDictionaryInArrayWithIdentifier(selectors, kCTFontFeatureSelectorIdentifierKey, param2); + if (selector) { + CFBooleanRef isDefault; + Boolean found = CFDictionaryGetValueIfPresent(selector, kCTFontFeatureSelectorDefaultKey, (const void **)&isDefault); + if (found) + rval = CFBooleanGetValue(isDefault); + } + break; + } + } + } + CFRelease(features); + } #endif - - return rval; + + return rval; } int aatfontgetnamed(int what, CFDictionaryRef attributes) { - int rval = -1; + int rval = -1; #ifdef XETEX_MAC - CTFontRef font = fontFromAttributes(attributes); - - switch (what) { - case XeTeX_find_variation_by_name: - { - CFArrayRef axes = CTFontCopyVariationAxes(font); - if (axes) { - CFDictionaryRef variation = findDictionaryInArray(axes, kCTFontVariationAxisNameKey, - (const char*)nameoffile + 1, namelength); - if (variation) { - CFNumberRef identifier = CFDictionaryGetValue(variation, kCTFontVariationAxisIdentifierKey); - if (identifier) - CFNumberGetValue(identifier, kCFNumberIntType, &rval); - } - CFRelease(axes); - } - break; - } - - case XeTeX_find_feature_by_name: - { - CFArrayRef features = CTFontCopyFeatures(font); - if (features) { - CFDictionaryRef feature = findDictionaryInArray(features, kCTFontFeatureTypeNameKey, - (const char*)nameoffile + 1, namelength); - if (feature) { - CFNumberRef identifier = CFDictionaryGetValue(feature, kCTFontFeatureTypeIdentifierKey); - CFNumberGetValue(identifier, kCFNumberIntType, &rval); - } - CFRelease(features); - } - break; - } - } + CTFontRef font = fontFromAttributes(attributes); + + switch (what) { + case XeTeX_find_variation_by_name: + { + CFArrayRef axes = CTFontCopyVariationAxes(font); + if (axes) { + CFDictionaryRef variation = findDictionaryInArray(axes, kCTFontVariationAxisNameKey, + (const char*)nameoffile + 1, namelength); + if (variation) { + CFNumberRef identifier = CFDictionaryGetValue(variation, kCTFontVariationAxisIdentifierKey); + if (identifier) + CFNumberGetValue(identifier, kCFNumberIntType, &rval); + } + CFRelease(axes); + } + break; + } + + case XeTeX_find_feature_by_name: + { + CFArrayRef features = CTFontCopyFeatures(font); + if (features) { + CFDictionaryRef feature = findDictionaryInArray(features, kCTFontFeatureTypeNameKey, + (const char*)nameoffile + 1, namelength); + if (feature) { + CFNumberRef identifier = CFDictionaryGetValue(feature, kCTFontFeatureTypeIdentifierKey); + CFNumberGetValue(identifier, kCFNumberIntType, &rval); + } + CFRelease(features); + } + break; + } + } #endif - - return rval; + + return rval; } int aatfontgetnamed1(int what, CFDictionaryRef attributes, int param) { - int rval = -1; + int rval = -1; #ifdef XETEX_MAC - CTFontRef font = fontFromAttributes(attributes); - - if (what == XeTeX_find_selector_by_name) { - CFArrayRef features = CTFontCopyFeatures(font); - if (features) { - CFDictionaryRef feature = findDictionaryInArrayWithIdentifier(features, kCTFontFeatureTypeIdentifierKey, param); - if (feature) { - CFNumberRef selector = findSelectorByName(feature, (const char*)nameoffile + 1, namelength); - if (selector) - CFNumberGetValue(selector, kCFNumberIntType, &rval); - } - CFRelease(features); - } - } + CTFontRef font = fontFromAttributes(attributes); + + if (what == XeTeX_find_selector_by_name) { + CFArrayRef features = CTFontCopyFeatures(font); + if (features) { + CFDictionaryRef feature = findDictionaryInArrayWithIdentifier(features, kCTFontFeatureTypeIdentifierKey, param); + if (feature) { + CFNumberRef selector = findSelectorByName(feature, (const char*)nameoffile + 1, namelength); + if (selector) + CFNumberGetValue(selector, kCFNumberIntType, &rval); + } + CFRelease(features); + } + } #endif - - return rval; + + return rval; } void aatprintfontname(int what, CFDictionaryRef attributes, int param1, int param2) { #ifdef XETEX_MAC - CTFontRef font = fontFromAttributes(attributes); - CFStringRef name = NULL; - if (what == XeTeX_variation_name) { - CFArrayRef axes = CTFontCopyVariationAxes(font); - if (axes) { - CFDictionaryRef variation = findDictionaryInArrayWithIdentifier(axes, - kCTFontVariationAxisIdentifierKey, - param1); - if (variation) - name = CFDictionaryGetValue(variation, kCTFontVariationAxisNameKey); - CFRelease(axes); - } - } else if (what == XeTeX_feature_name || what == XeTeX_selector_name) { - CFArrayRef features = CTFontCopyFeatures(font); - if (features) { - CFDictionaryRef feature = findDictionaryInArrayWithIdentifier(features, - kCTFontFeatureTypeIdentifierKey, - param1); - if (feature) { - if (what == XeTeX_feature_name) - name = CFDictionaryGetValue(feature, kCTFontFeatureTypeNameKey); - else { - CFArrayRef selectors = CFDictionaryGetValue(feature, kCTFontFeatureTypeSelectorsKey); - CFDictionaryRef selector = findDictionaryInArrayWithIdentifier(selectors, - kCTFontFeatureSelectorIdentifierKey, - param2); - if (selector) - name = CFDictionaryGetValue(selector, kCTFontFeatureSelectorNameKey); - } - } - CFRelease(features); - } - } - - if (name) { - CFIndex len = CFStringGetLength(name); - UniChar* buf = xmalloc(len * sizeof(UniChar)); - CFStringGetCharacters(name, CFRangeMake(0, len), buf); - printchars(buf, len); - free(buf); - } + CTFontRef font = fontFromAttributes(attributes); + CFStringRef name = NULL; + if (what == XeTeX_variation_name) { + CFArrayRef axes = CTFontCopyVariationAxes(font); + if (axes) { + CFDictionaryRef variation = findDictionaryInArrayWithIdentifier(axes, + kCTFontVariationAxisIdentifierKey, + param1); + if (variation) + name = CFDictionaryGetValue(variation, kCTFontVariationAxisNameKey); + CFRelease(axes); + } + } else if (what == XeTeX_feature_name || what == XeTeX_selector_name) { + CFArrayRef features = CTFontCopyFeatures(font); + if (features) { + CFDictionaryRef feature = findDictionaryInArrayWithIdentifier(features, + kCTFontFeatureTypeIdentifierKey, + param1); + if (feature) { + if (what == XeTeX_feature_name) + name = CFDictionaryGetValue(feature, kCTFontFeatureTypeNameKey); + else { + CFArrayRef selectors = CFDictionaryGetValue(feature, kCTFontFeatureTypeSelectorsKey); + CFDictionaryRef selector = findDictionaryInArrayWithIdentifier(selectors, + kCTFontFeatureSelectorIdentifierKey, + param2); + if (selector) + name = CFDictionaryGetValue(selector, kCTFontFeatureSelectorNameKey); + } + } + CFRelease(features); + } + } + + if (name) { + CFIndex len = CFStringGetLength(name); + UniChar* buf = xcalloc(len, sizeof(UniChar)); + CFStringGetCharacters(name, CFRangeMake(0, len), buf); + printchars(buf, len); + free(buf); + } #endif } void printglyphname(integer font, integer gid) { - char* s; - int len = 0; + char* s; + int len = 0; #ifdef XETEX_MAC - if (fontarea[font] == AAT_FONT_FLAG) { - s = GetGlyphNameFromCTFont(fontFromInteger(font), gid, &len); - } else + if (fontarea[font] == AAT_FONT_FLAG) { + s = GetGlyphNameFromCTFont(fontFromInteger(font), gid, &len); + } else #endif - if (fontarea[font] == OTGR_FONT_FLAG) { - XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[font]; - s = (char*)getGlyphName(getFont(engine), gid, &len); - } else { - fprintf(stderr, "\n! Internal error: bad native font flag in `print_glyph_name'\n"); - exit(3); - } - while (len-- > 0) - printchar(*s++); + if (fontarea[font] == OTGR_FONT_FLAG) { + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[font]; + s = (char*)getGlyphName(getFont(engine), gid, &len); + } else { + fprintf(stderr, "\n! Internal error: bad native font flag in `print_glyph_name'\n"); + exit(3); + } + while (len-- > 0) + printchar(*s++); } int u_open_in(unicodefile* f, integer filefmt, const_string fopen_mode, integer mode, integer encodingData) { - boolean rval; - *f = xmalloc(sizeof(UFILE)); - (*f)->encodingMode = 0; - (*f)->conversionData = 0; - (*f)->savedChar = -1; - (*f)->skipNextLF = 0; - rval = open_input (&((*f)->f), filefmt, fopen_mode); - if (rval) { - int B1, B2; - if (mode == AUTO) { - /* sniff encoding form */ - B1 = getc((*f)->f); - B2 = getc((*f)->f); - if (B1 == 0xfe && B2 == 0xff) - mode = UTF16BE; - else if (B2 == 0xfe && B1 == 0xff) - mode = UTF16LE; - else if (B1 == 0 && B2 != 0) { - mode = UTF16BE; - rewind((*f)->f); - } else if (B2 == 0 && B1 != 0) { - mode = UTF16LE; - rewind((*f)->f); - } else if (B1 == 0xef && B2 == 0xbb) { - int B3 = getc((*f)->f); - if (B3 == 0xbf) - mode = UTF8; - } - if (mode == AUTO) { - rewind((*f)->f); - mode = UTF8; - } - } - - setinputfileencoding(*f, mode, encodingData); - } - return rval; + boolean rval; + *f = (unicodefile) xmalloc(sizeof(UFILE)); + (*f)->encodingMode = 0; + (*f)->conversionData = 0; + (*f)->savedChar = -1; + (*f)->skipNextLF = 0; + rval = open_input (&((*f)->f), filefmt, fopen_mode); + if (rval) { + int B1, B2; + if (mode == AUTO) { + /* sniff encoding form */ + B1 = getc((*f)->f); + B2 = getc((*f)->f); + if (B1 == 0xfe && B2 == 0xff) + mode = UTF16BE; + else if (B2 == 0xfe && B1 == 0xff) + mode = UTF16LE; + else if (B1 == 0 && B2 != 0) { + mode = UTF16BE; + rewind((*f)->f); + } else if (B2 == 0 && B1 != 0) { + mode = UTF16LE; + rewind((*f)->f); + } else if (B1 == 0xef && B2 == 0xbb) { + int B3 = getc((*f)->f); + if (B3 == 0xbf) + mode = UTF8; + } + if (mode == AUTO) { + rewind((*f)->f); + mode = UTF8; + } + } + + setinputfileencoding(*f, mode, encodingData); + } + return rval; } #if defined(WIN32) static int Isspace(char c) { - return (c == ' ' || c == '\t'); + return (c == ' ' || c == '\t'); } #endif int open_dvi_output(FILE** fptr) { - if (nopdfoutput) { - return open_output(fptr, FOPEN_WBIN_MODE); - } else { - const char *p = (const char*)nameoffile+1; - char *cmd, *q; - int len = strlen(p); - while (*p) - if (*p++ == '\"') - ++len; - len += strlen(outputdriver); - if (output_directory) - len += strlen(output_directory); - len += 10; /* space for -o flag, quotes, NUL */ - for (p = (const char*)nameoffile+1; *p; p++) - if (*p == '\"') - ++len; /* allow extra space to escape quotes in filename */ - cmd = xmalloc(len); - strcpy(cmd, outputdriver); - strcat(cmd, " -o \""); - if (output_directory) { - len = strlen(output_directory); - if (IS_DIR_SEP(output_directory[len-1])) - output_directory[len-1] = '\0'; - strcat(cmd, output_directory); - strcat(cmd, "/"); - } - q = cmd + strlen(cmd); - for (p = (const char*)nameoffile+1; *p; p++) { - if (*p == '\"') - *q++ = '\\'; - *q++ = *p; - } - *q++ = '\"'; - *q = '\0'; - if (papersize != 0) { - char* cmd2 = concat3(cmd, " -p ", papersize); - free(cmd); - cmd = cmd2; - } - if (output_directory) { - char *fullname = concat3(output_directory, "/", (const char*)nameoffile+1); - free(nameoffile); - namelength = strlen(fullname); - nameoffile = (unsigned char*)xmalloc(namelength+2); - strcpy((char*)nameoffile+1, fullname); - free(fullname); - } + if (nopdfoutput) { + return open_output(fptr, FOPEN_WBIN_MODE); + } else { + const char *p = (const char*)nameoffile+1; + char *cmd, *q; + int len = strlen(p); + while (*p) + if (*p++ == '\"') + ++len; + len += strlen(outputdriver); + if (output_directory) + len += strlen(output_directory); + len += 10; /* space for -o flag, quotes, NUL */ + for (p = (const char*)nameoffile+1; *p; p++) + if (*p == '\"') + ++len; /* allow extra space to escape quotes in filename */ + cmd = xmalloc(len); + strcpy(cmd, outputdriver); + strcat(cmd, " -o \""); + if (output_directory) { + len = strlen(output_directory); + if (IS_DIR_SEP(output_directory[len-1])) + output_directory[len-1] = '\0'; + strcat(cmd, output_directory); + strcat(cmd, "/"); + } + q = cmd + strlen(cmd); + for (p = (const char*)nameoffile+1; *p; p++) { + if (*p == '\"') + *q++ = '\\'; + *q++ = *p; + } + *q++ = '\"'; + *q = '\0'; + if (papersize != 0) { + char* cmd2 = concat3(cmd, " -p ", papersize); + free(cmd); + cmd = cmd2; + } + if (output_directory) { + char *fullname = concat3(output_directory, "/", (const char*)nameoffile+1); + free(nameoffile); + namelength = strlen(fullname); + nameoffile = (unsigned char*) xmalloc(namelength + 2); + strcpy((char*)nameoffile+1, fullname); + free(fullname); + } #if defined(WIN32) - { - wchar_t *tmp1w; - char *p, *pp, *bindir, *fullcmd, *prgnam; - bindir = kpse_var_value("SELFAUTOLOC"); - for(pp = bindir; *pp; pp++) { - if(*pp == '/') *pp = '\\'; - } - pp = cmd; - while(Isspace(*pp)) - pp++; - prgnam = xmalloc(strlen(cmd)); - p = prgnam; - while(!Isspace(*pp)) { - *p++ = *pp++; - } - *p = '\0'; - fullcmd = concatn("\"\"", bindir, "\\", prgnam, "\"", pp, "\"", NULL); - tmp1w = get_wstring_from_mbstring(CP_UTF8, (const char *)fullcmd, tmp1w=NULL); - *fptr = _wpopen(tmp1w, L"wb"); - free(bindir); - free(prgnam); - free(fullcmd); - free(tmp1w); - } + { + wchar_t *tmp1w; + char *p, *pp, *bindir, *fullcmd, *prgnam; + bindir = kpse_var_value("SELFAUTOLOC"); + for(pp = bindir; *pp; pp++) { + if(*pp == '/') *pp = '\\'; + } + pp = cmd; + while(Isspace(*pp)) + pp++; + prgnam = xmalloc(strlen(cmd)); + p = prgnam; + while(!Isspace(*pp)) { + *p++ = *pp++; + } + *p = '\0'; + fullcmd = concatn("\"\"", bindir, "\\", prgnam, "\"", pp, "\"", NULL); + tmp1w = get_wstring_from_mbstring(CP_UTF8, (const char *)fullcmd, tmp1w=NULL); + *fptr = _wpopen(tmp1w, L"wb"); + free(bindir); + free(prgnam); + free(fullcmd); + free(tmp1w); + } #else - *fptr = popen(cmd, "w"); + *fptr = popen(cmd, "w"); #endif - free(cmd); - return (*fptr != 0); - } + free(cmd); + return (*fptr != 0); + } } int dviclose(FILE* fptr) { - if (nopdfoutput) { - if (fclose(fptr) != 0) - return errno; - } else { - return pclose(fptr); - } - return 0; + if (nopdfoutput) { + if (fclose(fptr) != 0) + return errno; + } else { + return pclose(fptr); + } + return 0; } int get_uni_c(UFILE* f) { - int rval; - int c; + int rval; + int c; #ifdef WIN32 - HANDLE hStdin; - DWORD ret; - wint_t wc[1]; + HANDLE hStdin; + DWORD ret; + wint_t wc[1]; #endif - if (f->savedChar != -1) { - rval = f->savedChar; - f->savedChar = -1; - return rval; - } - - switch (f->encodingMode) { - case UTF8: - c = rval = getc(f->f); - if (rval != EOF) { - uint16_t extraBytes = bytesFromUTF8[rval]; - switch (extraBytes) { /* note: code falls through cases! */ - case 3: c = getc(f->f); - if (c < 0x80 || c >= 0xc0) goto bad_utf8; - rval <<= 6; rval += c; - case 2: c = getc(f->f); - if (c < 0x80 || c >= 0xc0) goto bad_utf8; - rval <<= 6; rval += c; - case 1: c = getc(f->f); - if (c < 0x80 || c >= 0xc0) goto bad_utf8; - rval <<= 6; rval += c; - case 0: - break; - - bad_utf8: - if (c != EOF) - ungetc(c, f->f); - case 5: - case 4: - badutf8warning(); - return 0xfffd; /* return without adjusting by offsetsFromUTF8 */ - }; - rval -= offsetsFromUTF8[extraBytes]; - } - break; - - case UTF16BE: - rval = getc(f->f); - if (rval != EOF) { - rval <<= 8; - rval += getc(f->f); - if (rval >= 0xd800 && rval <= 0xdbff) { - int lo = getc(f->f); - lo <<= 8; - lo += getc(f->f); - if (lo >= 0xdc00 && lo <= 0xdfff) - rval = 0x10000 + (rval - 0xd800) * 0x400 + (lo - 0xdc00); - else { - rval = 0xfffd; - f->savedChar = lo; - } - } else if (rval >= 0xdc00 && rval <= 0xdfff) - rval = 0xfffd; - } - break; - - case UTF16LE: - rval = getc(f->f); - if (rval != EOF) { - rval += (getc(f->f) << 8); - if (rval >= 0xd800 && rval <= 0xdbff) { - int lo = getc(f->f); - lo += (getc(f->f) << 8); - if (lo >= 0xdc00 && lo <= 0xdfff) - rval = 0x10000 + (rval - 0xd800) * 0x400 + (lo - 0xdc00); - else { - rval = 0xfffd; - f->savedChar = lo; - } - } else if (rval >= 0xdc00 && rval <= 0xdfff) - rval = 0xfffd; - } - break; + if (f->savedChar != -1) { + rval = f->savedChar; + f->savedChar = -1; + return rval; + } + + switch (f->encodingMode) { + case UTF8: + c = rval = getc(f->f); + if (rval != EOF) { + uint16_t extraBytes = bytesFromUTF8[rval]; + switch (extraBytes) { /* note: code falls through cases! */ + case 3: c = getc(f->f); + if (c < 0x80 || c >= 0xc0) goto bad_utf8; + rval <<= 6; rval += c; + case 2: c = getc(f->f); + if (c < 0x80 || c >= 0xc0) goto bad_utf8; + rval <<= 6; rval += c; + case 1: c = getc(f->f); + if (c < 0x80 || c >= 0xc0) goto bad_utf8; + rval <<= 6; rval += c; + case 0: + break; + + bad_utf8: + if (c != EOF) + ungetc(c, f->f); + case 5: + case 4: + badutf8warning(); + return 0xfffd; /* return without adjusting by offsetsFromUTF8 */ + }; + rval -= offsetsFromUTF8[extraBytes]; + } + break; + + case UTF16BE: + rval = getc(f->f); + if (rval != EOF) { + rval <<= 8; + rval += getc(f->f); + if (rval >= 0xd800 && rval <= 0xdbff) { + int lo = getc(f->f); + lo <<= 8; + lo += getc(f->f); + if (lo >= 0xdc00 && lo <= 0xdfff) + rval = 0x10000 + (rval - 0xd800) * 0x400 + (lo - 0xdc00); + else { + rval = 0xfffd; + f->savedChar = lo; + } + } else if (rval >= 0xdc00 && rval <= 0xdfff) + rval = 0xfffd; + } + break; + + case UTF16LE: + rval = getc(f->f); + if (rval != EOF) { + rval += (getc(f->f) << 8); + if (rval >= 0xd800 && rval <= 0xdbff) { + int lo = getc(f->f); + lo += (getc(f->f) << 8); + if (lo >= 0xdc00 && lo <= 0xdfff) + rval = 0x10000 + (rval - 0xd800) * 0x400 + (lo - 0xdc00); + else { + rval = 0xfffd; + f->savedChar = lo; + } + } else if (rval >= 0xdc00 && rval <= 0xdfff) + rval = 0xfffd; + } + break; #ifdef WIN32 - case WIN32CONSOLE: - hStdin = GetStdHandle(STD_INPUT_HANDLE); - if (ReadConsoleW(hStdin, wc, 1, &ret, NULL) == 0) { - rval = EOF; - break; - } - rval = wc[0]; - if (rval >= 0xd800 && rval <= 0xdbff) { - int lo; - if (ReadConsoleW(hStdin, wc, 1, &ret, NULL) == 0) { - rval = EOF; - break; - } - lo = wc[0]; - if (lo >= 0xdc00 && lo <= 0xdfff) - rval = 0x10000 + (rval - 0xd800) * 0x400 + (lo - 0xdc00); - else { - rval = 0xfffd; - f->savedChar = lo; - } - } else if (rval >= 0xdc00 && rval <= 0xdfff) - rval = 0xfffd; - break; + case WIN32CONSOLE: + hStdin = GetStdHandle(STD_INPUT_HANDLE); + if (ReadConsoleW(hStdin, wc, 1, &ret, NULL) == 0) { + rval = EOF; + break; + } + rval = wc[0]; + if (rval >= 0xd800 && rval <= 0xdbff) { + int lo; + if (ReadConsoleW(hStdin, wc, 1, &ret, NULL) == 0) { + rval = EOF; + break; + } + lo = wc[0]; + if (lo >= 0xdc00 && lo <= 0xdfff) + rval = 0x10000 + (rval - 0xd800) * 0x400 + (lo - 0xdc00); + else { + rval = 0xfffd; + f->savedChar = lo; + } + } else if (rval >= 0xdc00 && rval <= 0xdfff) + rval = 0xfffd; + break; #endif - case RAW: - rval = getc(f->f); - break; + case RAW: + rval = getc(f->f); + break; - default: - /* this can't happen */ - fprintf(stderr, "! Internal error---file input mode=%d.\n", f->encodingMode); - uexit(3); - } + default: + /* this can't happen */ + fprintf(stderr, "! Internal error---file input mode=%d.\n", f->encodingMode); + uexit(3); + } - return rval; + return rval; } void makeutf16name() { - unsigned char* s = nameoffile + 1; - uint32_t rval; - uint16_t* t; - static int name16len = 0; - if (name16len <= namelength) { - if (nameoffile16 != 0) - free(nameoffile16); - name16len = namelength + 10; - nameoffile16 = xmalloc(name16len * sizeof(uint16_t)); - } - t = nameoffile16; - while (s <= nameoffile + namelength) { - uint16_t extraBytes; - rval = *(s++); - extraBytes = bytesFromUTF8[rval]; - switch (extraBytes) { /* note: code falls through cases! */ - case 5: rval <<= 6; if (*s) rval += *(s++); - case 4: rval <<= 6; if (*s) rval += *(s++); - case 3: rval <<= 6; if (*s) rval += *(s++); - case 2: rval <<= 6; if (*s) rval += *(s++); - case 1: rval <<= 6; if (*s) rval += *(s++); - case 0: ; - }; - rval -= offsetsFromUTF8[extraBytes]; - if (rval > 0xffff) { - rval -= 0x10000; - *(t++) = 0xd800 + rval / 0x0400; - *(t++) = 0xdc00 + rval % 0x0400; - } else { - *(t++) = rval; - } - } - namelength16 = t - nameoffile16; + unsigned char* s = nameoffile + 1; + uint32_t rval; + uint16_t* t; + static int name16len = 0; + if (name16len <= namelength) { + if (nameoffile16 != 0) + free(nameoffile16); + name16len = namelength + 10; + nameoffile16 = (uint16_t*) xcalloc(name16len, sizeof(uint16_t)); + } + t = nameoffile16; + while (s <= nameoffile + namelength) { + uint16_t extraBytes; + rval = *(s++); + extraBytes = bytesFromUTF8[rval]; + switch (extraBytes) { /* note: code falls through cases! */ + case 5: rval <<= 6; if (*s) rval += *(s++); + case 4: rval <<= 6; if (*s) rval += *(s++); + case 3: rval <<= 6; if (*s) rval += *(s++); + case 2: rval <<= 6; if (*s) rval += *(s++); + case 1: rval <<= 6; if (*s) rval += *(s++); + case 0: ; + }; + rval -= offsetsFromUTF8[extraBytes]; + if (rval > 0xffff) { + rval -= 0x10000; + *(t++) = 0xd800 + rval / 0x0400; + *(t++) = 0xdc00 + rval % 0x0400; + } else { + *(t++) = rval; + } + } + namelength16 = t - nameoffile16; } integer get_native_word_cp(void* pNode, int side) { - memoryword* node = (memoryword*)pNode; - FixedPoint* locations = (FixedPoint*)native_glyph_info_ptr(node); - uint16_t* glyphIDs = (uint16_t*)(locations + native_glyph_count(node)); - uint16_t glyphCount = native_glyph_count(node); - integer f = native_font(node); - uint16_t actual_glyph; + memoryword* node = (memoryword*)pNode; + FixedPoint* locations = (FixedPoint*)native_glyph_info_ptr(node); + uint16_t* glyphIDs = (uint16_t*)(locations + native_glyph_count(node)); + uint16_t glyphCount = native_glyph_count(node); + integer f = native_font(node); + uint16_t actual_glyph; if (glyphCount == 0) return 0; diff --git a/Build/source/texk/web2c/xetexdir/XeTeX_ext.h b/Build/source/texk/web2c/xetexdir/XeTeX_ext.h index e81b8781373..b0c42fe3060 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeX_ext.h +++ b/Build/source/texk/web2c/xetexdir/XeTeX_ext.h @@ -41,11 +41,11 @@ authorization from the copyright holders. typedef struct UFILE* unicodefile; #endif -#define AAT_FONT_FLAG 0xFFFFU -#define OTGR_FONT_FLAG 0xFFFEU +#define AAT_FONT_FLAG 0xFFFFU +#define OTGR_FONT_FLAG 0xFFFEU -#define FONT_FLAGS_COLORED 0x01 -#define FONT_FLAGS_VERTICAL 0x02 +#define FONT_FLAGS_COLORED 0x01 +#define FONT_FLAGS_VERTICAL 0x02 /* some typedefs that XeTeX uses - on Mac OS, we get these from Apple headers, but otherwise we'll need these substitute definitions */ @@ -54,10 +54,10 @@ typedef struct UFILE* unicodefile; #include <CoreFoundation/CoreFoundation.h> #include <ApplicationServices/ApplicationServices.h> #else -typedef int32_t Fixed; +typedef int32_t Fixed; typedef struct { - Fixed x; - Fixed y; + Fixed x; + Fixed y; } FixedPoint; #endif @@ -67,76 +67,76 @@ typedef uint16_t GlyphID; /* these are also in xetex.web and must correspond! */ -#define pdfbox_crop 1 -#define pdfbox_media 2 -#define pdfbox_bleed 3 -#define pdfbox_trim 4 -#define pdfbox_art 5 +#define pdfbox_crop 1 +#define pdfbox_media 2 +#define pdfbox_bleed 3 +#define pdfbox_trim 4 +#define pdfbox_art 5 -#define XeTeX_count_glyphs 1 +#define XeTeX_count_glyphs 1 -#define XeTeX_count_variations 2 -#define XeTeX_variation 3 -#define XeTeX_find_variation_by_name 4 -#define XeTeX_variation_min 5 -#define XeTeX_variation_max 6 -#define XeTeX_variation_default 7 +#define XeTeX_count_variations 2 +#define XeTeX_variation 3 +#define XeTeX_find_variation_by_name 4 +#define XeTeX_variation_min 5 +#define XeTeX_variation_max 6 +#define XeTeX_variation_default 7 -#define XeTeX_count_features 8 -#define XeTeX_feature_code 9 -#define XeTeX_find_feature_by_name 10 -#define XeTeX_is_exclusive_feature 11 -#define XeTeX_count_selectors 12 -#define XeTeX_selector_code 13 -#define XeTeX_find_selector_by_name 14 -#define XeTeX_is_default_selector 15 +#define XeTeX_count_features 8 +#define XeTeX_feature_code 9 +#define XeTeX_find_feature_by_name 10 +#define XeTeX_is_exclusive_feature 11 +#define XeTeX_count_selectors 12 +#define XeTeX_selector_code 13 +#define XeTeX_find_selector_by_name 14 +#define XeTeX_is_default_selector 15 -#define XeTeX_OT_count_scripts 16 -#define XeTeX_OT_count_languages 17 -#define XeTeX_OT_count_features 18 -#define XeTeX_OT_script_code 19 -#define XeTeX_OT_language_code 20 -#define XeTeX_OT_feature_code 21 +#define XeTeX_OT_count_scripts 16 +#define XeTeX_OT_count_languages 17 +#define XeTeX_OT_count_features 18 +#define XeTeX_OT_script_code 19 +#define XeTeX_OT_language_code 20 +#define XeTeX_OT_feature_code 21 -#define XeTeX_map_char_to_glyph_code 22 +#define XeTeX_map_char_to_glyph_code 22 -#define XeTeX_variation_name 7 /* must match xetex.web */ -#define XeTeX_feature_name 8 -#define XeTeX_selector_name 9 +#define XeTeX_variation_name 7 /* must match xetex.web */ +#define XeTeX_feature_name 8 +#define XeTeX_selector_name 9 /* definitions used to access info in a native_word_node; must correspond with defines in xetex.web */ -#define width_offset 1 -#define depth_offset 2 -#define height_offset 3 -#define native_info_offset 4 -#define native_glyph_info_offset 5 - -#define node_width(node) node[width_offset].cint -#define node_depth(node) node[depth_offset].cint -#define node_height(node) node[height_offset].cint -#define native_length(node) node[native_info_offset].qqqq.b2 -#define native_font(node) node[native_info_offset].qqqq.b1 -#define native_glyph_count(node) node[native_info_offset].qqqq.b3 -#define native_glyph_info_ptr(node) node[native_glyph_info_offset].ptr -#define native_glyph_info_size 10 /* info for each glyph is location (FixedPoint) + glyph ID (uint16_t) */ - -#define native_glyph(p) native_length(p) /* glyph ID field in a glyph_node */ - -#define XDV_GLYPH_STRING 254 -#define XDV_GLYPH_ARRAY 253 +#define width_offset 1 +#define depth_offset 2 +#define height_offset 3 +#define native_info_offset 4 +#define native_glyph_info_offset 5 + +#define node_width(node) node[width_offset].cint +#define node_depth(node) node[depth_offset].cint +#define node_height(node) node[height_offset].cint +#define native_length(node) node[native_info_offset].qqqq.b2 +#define native_font(node) node[native_info_offset].qqqq.b1 +#define native_glyph_count(node) node[native_info_offset].qqqq.b3 +#define native_glyph_info_ptr(node) node[native_glyph_info_offset].ptr +#define native_glyph_info_size 10 /* info for each glyph is location (FixedPoint) + glyph ID (uint16_t) */ + +#define native_glyph(p) native_length(p) /* glyph ID field in a glyph_node */ + +#define XDV_GLYPH_STRING 254 +#define XDV_GLYPH_ARRAY 253 /* OT-related constants we need */ -#define kGSUB HB_TAG('G','S','U','B') -#define kGPOS HB_TAG('G','P','O','S') +#define kGSUB HB_TAG('G','S','U','B') +#define kGPOS HB_TAG('G','P','O','S') typedef struct { - float xMin; - float yMin; - float xMax; - float yMax; + float xMin; + float yMin; + float xMax; + float yMax; } GlyphBBox; @@ -200,110 +200,111 @@ extern const CFStringRef kXeTeXEmboldenAttributeName; #ifdef __cplusplus extern "C" { #endif - void initversionstring(char **versions); - - void setinputfileencoding(unicodefile f, integer mode, integer encodingData); - void uclose(unicodefile f); - void linebreakstart(int f, integer localeStrNum, const uint16_t* text, integer textLength); - int linebreaknext(); - int getencodingmodeandinfo(integer* info); - void printutf8str(const unsigned char* str, int len); - void printchars(const unsigned short* str, int len); - void* findnativefont(unsigned char* name, integer scaled_size); - void releasefontengine(void* engine, int type_flag); - int readCommonFeatures(const char* feat, const char* end, float* extend, float* slant, float* embolden, float* letterspace, uint32_t* rgbValue); - - /* the metrics params here are really TeX 'scaled' values, but that typedef isn't available every place this is included */ - void otgetfontmetrics(void* engine, integer* ascent, integer* descent, integer* xheight, integer* capheight, integer* slant); - void getnativecharheightdepth(integer font, integer ch, integer* height, integer* depth); - void getnativecharsidebearings(integer font, integer ch, integer* lsb, integer* rsb); - - /* single-purpose metrics accessors */ - integer getnativecharwd(integer font, integer ch); - integer getnativecharht(integer font, integer ch); - integer getnativechardp(integer font, integer ch); - integer getnativecharic(integer font, integer ch); - - integer getglyphbounds(integer font, integer edge, integer gid); - - integer otfontget(integer what, void* engine); - integer otfontget1(integer what, void* engine, integer param); - integer otfontget2(integer what, void* engine, integer param1, integer param2); - integer otfontget3(integer what, void* engine, integer param1, integer param2, integer param3); - int makeXDVGlyphArrayData(void* p); - int makefontdef(integer f); - int applymapping(void* cnv, const uint16_t* txtPtr, int txtLen); - void store_justified_native_glyphs(void* node); - void measure_native_node(void* node, int use_glyph_metrics); - Fixed get_native_italic_correction(void* node); - Fixed get_native_glyph_italic_correection(void* node); - void measure_native_glyph(void* node, int use_glyph_metrics); - integer mapchartoglyph(integer font, integer ch); - integer mapglyphtoindex(integer font); - integer getfontcharrange(integer font, int first); - void printglyphname(integer font, integer gid); - uint16_t get_native_glyph(void* pNode, unsigned index); - - void grprintfontname(integer what, void* pEngine, integer param1, integer param2); - integer grfontgetnamed(integer what, void* pEngine); - integer grfontgetnamed1(integer what, void* pEngine, integer param); - - double read_double(const char** s); - unsigned int read_rgb_a(const char** cp); - - int countpdffilepages(); - int find_pic_file(char** path, realrect* bounds, int pdfBoxType, int page); - int u_open_in(unicodefile* f, integer filefmt, const char* fopen_mode, integer mode, integer encodingData); - int open_dvi_output(FILE** fptr); - int dviclose(FILE* fptr); - int get_uni_c(UFILE* f); - int input_line(UFILE* f); - void makeutf16name(); - - void terminatefontmanager(); - int maketexstring(const char* s); - - void checkfortfmfontmapping(); - void* loadtfmfontmapping(); - int applytfmfontmapping(void* mapping, int c); + void initversionstring(char **versions); + + void setinputfileencoding(unicodefile f, integer mode, integer encodingData); + void uclose(unicodefile f); + void linebreakstart(int f, integer localeStrNum, const uint16_t* text, integer textLength); + int linebreaknext(); + int getencodingmodeandinfo(integer* info); + void printutf8str(const unsigned char* str, int len); + void printchars(const unsigned short* str, int len); + void* findnativefont(unsigned char* name, integer scaled_size); + void releasefontengine(void* engine, int type_flag); + int readCommonFeatures(const char* feat, const char* end, float* extend, float* slant, float* embolden, float* letterspace, uint32_t* rgbValue); + + /* the metrics params here are really TeX 'scaled' values, but that typedef isn't available every place this is included */ + void otgetfontmetrics(void* engine, integer* ascent, integer* descent, integer* xheight, integer* capheight, integer* slant); + void getnativecharheightdepth(integer font, integer ch, integer* height, integer* depth); + void getnativecharsidebearings(integer font, integer ch, integer* lsb, integer* rsb); + + /* single-purpose metrics accessors */ + integer getnativecharwd(integer font, integer ch); + integer getnativecharht(integer font, integer ch); + integer getnativechardp(integer font, integer ch); + integer getnativecharic(integer font, integer ch); + + integer getglyphbounds(integer font, integer edge, integer gid); + + integer otfontget(integer what, void* engine); + integer otfontget1(integer what, void* engine, integer param); + integer otfontget2(integer what, void* engine, integer param1, integer param2); + integer otfontget3(integer what, void* engine, integer param1, integer param2, integer param3); + int makeXDVGlyphArrayData(void* p); + int makefontdef(integer f); + int applymapping(void* cnv, const uint16_t* txtPtr, int txtLen); + void store_justified_native_glyphs(void* node); + void measure_native_node(void* node, int use_glyph_metrics); + Fixed get_native_italic_correction(void* node); + Fixed get_native_glyph_italic_correction(void* node); + integer get_native_word_cp(void* node, int side); + void measure_native_glyph(void* node, int use_glyph_metrics); + integer mapchartoglyph(integer font, integer ch); + integer mapglyphtoindex(integer font); + integer getfontcharrange(integer font, int first); + void printglyphname(integer font, integer gid); + uint16_t get_native_glyph(void* pNode, unsigned index); + + void grprintfontname(integer what, void* pEngine, integer param1, integer param2); + integer grfontgetnamed(integer what, void* pEngine); + integer grfontgetnamed1(integer what, void* pEngine, integer param); + + double read_double(const char** s); + unsigned int read_rgb_a(const char** cp); + + int countpdffilepages(); + int find_pic_file(char** path, realrect* bounds, int pdfBoxType, int page); + int u_open_in(unicodefile* f, integer filefmt, const char* fopen_mode, integer mode, integer encodingData); + int open_dvi_output(FILE** fptr); + int dviclose(FILE* fptr); + int get_uni_c(UFILE* f); + int input_line(UFILE* f); + void makeutf16name(); + + void terminatefontmanager(); + int maketexstring(const char* s); + + void checkfortfmfontmapping(); + void* loadtfmfontmapping(); + int applytfmfontmapping(void* mapping, int c); #ifndef XETEX_MAC typedef void* CFDictionaryRef; /* dummy declaration just so the stubs can compile */ #endif - int aatfontget(int what, CFDictionaryRef attrs); - int aatfontget1(int what, CFDictionaryRef attrs, int param); - int aatfontget2(int what, CFDictionaryRef attrs, int param1, int param2); - int aatfontgetnamed(int what, CFDictionaryRef attrs); - int aatfontgetnamed1(int what, CFDictionaryRef attrs, int param); - void aatprintfontname(int what, CFDictionaryRef attrs, int param1, int param2); - /* the metrics params here are really TeX 'scaled' (or MacOS 'Fixed') values, but that typedef isn't available every place this is included */ - void aatgetfontmetrics(CFDictionaryRef attrs, integer* ascent, integer* descent, integer* xheight, integer* capheight, integer* slant); + int aatfontget(int what, CFDictionaryRef attrs); + int aatfontget1(int what, CFDictionaryRef attrs, int param); + int aatfontget2(int what, CFDictionaryRef attrs, int param1, int param2); + int aatfontgetnamed(int what, CFDictionaryRef attrs); + int aatfontgetnamed1(int what, CFDictionaryRef attrs, int param); + void aatprintfontname(int what, CFDictionaryRef attrs, int param1, int param2); + /* the metrics params here are really TeX 'scaled' (or MacOS 'Fixed') values, but that typedef isn't available every place this is included */ + void aatgetfontmetrics(CFDictionaryRef attrs, integer* ascent, integer* descent, integer* xheight, integer* capheight, integer* slant); - void set_cp_code(int fontNum, unsigned int code, int side, int value); - int get_cp_code(int fontNum, unsigned int code, int side); + void set_cp_code(int fontNum, unsigned int code, int side, int value); + int get_cp_code(int fontNum, unsigned int code, int side); #ifdef XETEX_MAC /* functions in XeTeX_mac.c */ - void* loadAATfont(CTFontDescriptorRef descriptor, integer scaled_size, const char* cp1); - void DoAATLayout(void* node, int justify); - void GetGlyphBBox_AAT(CFDictionaryRef fontAttrs, uint16_t gid, GlyphBBox* bbox); - double GetGlyphWidth_AAT(CFDictionaryRef fontAttrs, uint16_t gid); - void GetGlyphHeightDepth_AAT(CFDictionaryRef fontAttrs, uint16_t gid, float* ht, float* dp); - void GetGlyphSidebearings_AAT(CFDictionaryRef fontAttrs, uint16_t gid, float* lsb, float* rsb); - double GetGlyphItalCorr_AAT(CFDictionaryRef fontAttrs, uint16_t gid); - int MapCharToGlyph_AAT(CFDictionaryRef fontAttrs, UInt32 ch); - int MapGlyphToIndex_AAT(CFDictionaryRef attributes, const char* glyphName); - char* GetGlyphNameFromCTFont(CTFontRef ctFontRef, uint16_t gid, int* len); - CFDictionaryRef findDictionaryInArray(CFArrayRef array, const void* nameKey, const char* name, int nameLength); - CFDictionaryRef findDictionaryInArrayWithIdentifier(CFArrayRef array, const void* identifierKey, int identifier); - CFNumberRef findSelectorByName(CFDictionaryRef feature, const char* name, int nameLength); - char* getNameFromCTFont(CTFontRef ctFontRef, CFStringRef nameKey); - char* getFileNameFromCTFont(CTFontRef ctFontRef, int* index); - int GetFontCharRange_AAT(CFDictionaryRef fontAttrs, int reqFirst); - CTFontRef fontFromAttributes(CFDictionaryRef fontAttrs); - CTFontRef fontFromInteger(integer font); + void* loadAATfont(CTFontDescriptorRef descriptor, integer scaled_size, const char* cp1); + void DoAATLayout(void* node, int justify); + void GetGlyphBBox_AAT(CFDictionaryRef fontAttrs, uint16_t gid, GlyphBBox* bbox); + double GetGlyphWidth_AAT(CFDictionaryRef fontAttrs, uint16_t gid); + void GetGlyphHeightDepth_AAT(CFDictionaryRef fontAttrs, uint16_t gid, float* ht, float* dp); + void GetGlyphSidebearings_AAT(CFDictionaryRef fontAttrs, uint16_t gid, float* lsb, float* rsb); + double GetGlyphItalCorr_AAT(CFDictionaryRef fontAttrs, uint16_t gid); + int MapCharToGlyph_AAT(CFDictionaryRef fontAttrs, UInt32 ch); + int MapGlyphToIndex_AAT(CFDictionaryRef attributes, const char* glyphName); + char* GetGlyphNameFromCTFont(CTFontRef ctFontRef, uint16_t gid, int* len); + CFDictionaryRef findDictionaryInArray(CFArrayRef array, const void* nameKey, const char* name, int nameLength); + CFDictionaryRef findDictionaryInArrayWithIdentifier(CFArrayRef array, const void* identifierKey, int identifier); + CFNumberRef findSelectorByName(CFDictionaryRef feature, const char* name, int nameLength); + char* getNameFromCTFont(CTFontRef ctFontRef, CFStringRef nameKey); + char* getFileNameFromCTFont(CTFontRef ctFontRef, int* index); + int GetFontCharRange_AAT(CFDictionaryRef fontAttrs, int reqFirst); + CTFontRef fontFromAttributes(CFDictionaryRef fontAttrs); + CTFontRef fontFromInteger(integer font); #endif #ifdef __cplusplus }; @@ -312,14 +313,14 @@ typedef void* CFDictionaryRef; /* dummy declaration just so the stubs can compil #ifdef __cplusplus extern "C" { #endif - double Fix2D(Fixed f); - Fixed D2Fix(double d); + double Fix2D(Fixed f); + Fixed D2Fix(double d); #ifdef __cplusplus }; #endif // copied from xetex.web -#define LEFT_SIDE 0 -#define RIGHT_SIDE 1 +#define LEFT_SIDE 0 +#define RIGHT_SIDE 1 #endif /* __XETEX_EXT_H */ diff --git a/Build/source/texk/web2c/xetexdir/XeTeX_mac.c b/Build/source/texk/web2c/xetexdir/XeTeX_mac.c index 02fdc428c05..f3e78cb588b 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeX_mac.c +++ b/Build/source/texk/web2c/xetexdir/XeTeX_mac.c @@ -48,496 +48,497 @@ authorization from the copyright holders. static inline double TeXtoPSPoints(double pts) { - return pts * 72.0 / 72.27; + return pts * 72.0 / 72.27; } static inline double PStoTeXPoints(double pts) { - return pts * 72.27 / 72.0; + return pts * 72.27 / 72.0; } static inline Fixed FixedPStoTeXPoints(double pts) { - return D2Fix(PStoTeXPoints(pts)); + return D2Fix(PStoTeXPoints(pts)); } CTFontRef fontFromAttributes(CFDictionaryRef attributes) { - return CFDictionaryGetValue(attributes, kCTFontAttributeName); + return CFDictionaryGetValue(attributes, kCTFontAttributeName); } CTFontRef fontFromInteger(integer font) { - CFDictionaryRef attributes = (CFDictionaryRef) fontlayoutengine[font]; - return fontFromAttributes(attributes); + CFDictionaryRef attributes = (CFDictionaryRef) fontlayoutengine[font]; + return fontFromAttributes(attributes); } void DoAATLayout(void* p, int justify) { - CFArrayRef glyphRuns; - CFIndex i, j, runCount; - CFIndex totalGlyphCount = 0; - UInt16* glyphIDs; - Fixed* glyphAdvances; - void* glyph_info; - FixedPoint* locations; - Fixed lsUnit, lsDelta; - CGFloat width; - - long txtLen; - const UniChar* txtPtr; - - CFDictionaryRef attributes; - CFStringRef string; - CFAttributedStringRef attrString; - CTTypesetterRef typesetter; - CTLineRef line; - - memoryword* node = (memoryword*)p; - - unsigned f = native_font(node); - if (fontarea[f] != AAT_FONT_FLAG) { - fprintf(stderr, "internal error: DoAATLayout called for non-AAT font\n"); - exit(1); - } - - txtLen = native_length(node); - txtPtr = (UniChar*)(node + native_node_size); - - attributes = fontlayoutengine[native_font(node)]; - string = CFStringCreateWithCharactersNoCopy(NULL, txtPtr, txtLen, kCFAllocatorNull); - attrString = CFAttributedStringCreate(NULL, string, attributes); - CFRelease(string); - - typesetter = CTTypesetterCreateWithAttributedString(attrString); - line = CTTypesetterCreateLine(typesetter, CFRangeMake(0, txtLen)); - if (justify) { - CGFloat lineWidth = TeXtoPSPoints(Fix2D(node_width(node))); - CTLineRef justifiedLine = CTLineCreateJustifiedLine(line, TeXtoPSPoints(Fix2D(fract1)), lineWidth); - // TODO(jjgod): how to handle the case when justification failed? for - // now we just fallback to use the original line. - if (justifiedLine) { - CFRelease(line); - line = justifiedLine; - } - } - - glyphRuns = CTLineGetGlyphRuns(line); - runCount = CFArrayGetCount(glyphRuns); - totalGlyphCount = CTLineGetGlyphCount(line); - - if (totalGlyphCount > 0) { - glyph_info = xmalloc(totalGlyphCount * native_glyph_info_size); - locations = (FixedPoint*)glyph_info; - glyphIDs = (UInt16*)(locations + totalGlyphCount); - glyphAdvances = xmalloc(totalGlyphCount * sizeof(Fixed)); - totalGlyphCount = 0; - - width = 0; - for (i = 0; i < runCount; i++) { - CTRunRef run = CFArrayGetValueAtIndex(glyphRuns, i); - CFIndex count = CTRunGetGlyphCount(run); - CFDictionaryRef runAttributes = CTRunGetAttributes(run); - CFBooleanRef vertical = CFDictionaryGetValue(runAttributes, kCTVerticalFormsAttributeName); - // TODO(jjgod): Avoid unnecessary allocation with CTRunGetFoosPtr(). - CGGlyph* glyphs = (CGGlyph*) xmalloc(count * sizeof(CGGlyph)); - CGPoint* positions = (CGPoint*) xmalloc(count * sizeof(CGPoint)); - CGSize* advances = (CGSize*) xmalloc(count * sizeof(CGSize)); - CGFloat runWidth = CTRunGetTypographicBounds(run, CFRangeMake(0, 0), NULL, NULL, NULL); - CTRunGetGlyphs(run, CFRangeMake(0, 0), glyphs); - CTRunGetPositions(run, CFRangeMake(0, 0), positions); - CTRunGetAdvances(run, CFRangeMake(0, 0), advances); - for (j = 0; j < count; j++) { - // XXX Core Text has that font cascading thing that will do - // font substitution for missing glyphs, which we do not want - // but I can not find a way to disable it yet, so if the font - // of the resulting run is not the same font we asked for, use - // the glyph at index 0 (usually .notdef) instead or we will be - // showing garbage or even invalid glyphs - char *ps_name1 = getNameFromCTFont(fontFromAttributes(attributes), kCTFontPostScriptNameKey); - char *ps_name2 = getNameFromCTFont(fontFromAttributes(runAttributes), kCTFontPostScriptNameKey); - if (strcmp(ps_name1, ps_name2) != 0) - glyphIDs[totalGlyphCount] = 0; - else - glyphIDs[totalGlyphCount] = glyphs[j]; - - // Swap X and Y when doing vertical layout - if (vertical == kCFBooleanTrue) { - locations[totalGlyphCount].x = FixedPStoTeXPoints(-positions[j].y); - // XXX trasformation matrix changes y positions! - //locations[totalGlyphCount].y = FixedPStoTeXPoints(-positions[j].x); - locations[totalGlyphCount].y = 0; - } else { - locations[totalGlyphCount].x = FixedPStoTeXPoints(positions[j].x); - // XXX trasformation matrix changes y positions! - //locations[totalGlyphCount].y = FixedPStoTeXPoints(positions[j].y); - locations[totalGlyphCount].y = 0; - } - glyphAdvances[totalGlyphCount] = advances[j].width; - totalGlyphCount++; - } - width += FixedPStoTeXPoints(runWidth); - free(glyphs); - free(positions); - } - } - - native_glyph_count(node) = totalGlyphCount; - native_glyph_info_ptr(node) = glyph_info; - - if (!justify) { - node_width(node) = width; - - if (totalGlyphCount > 0) { - /* this is essentially a copy from similar code in XeTeX_ext.c, easier - * to be done here */ - if (fontletterspace[f] != 0) { - Fixed lsDelta = 0; - Fixed lsUnit = fontletterspace[f]; - int i; - for (i = 0; i < totalGlyphCount; ++i) { - if (glyphAdvances[i] == 0 && lsDelta != 0) - lsDelta -= lsUnit; - locations[i].x += lsDelta; - lsDelta += lsUnit; - } - if (lsDelta != 0) { - lsDelta -= lsUnit; - node_width(node) += lsDelta; - } - } - } - } - - CFRelease(line); - CFRelease(typesetter); + CFArrayRef glyphRuns; + CFIndex i, j, runCount; + CFIndex totalGlyphCount = 0; + UInt16* glyphIDs; + Fixed* glyphAdvances; + void* glyph_info; + FixedPoint* locations; + Fixed lsUnit, lsDelta; + CGFloat width; + + long txtLen; + const UniChar* txtPtr; + + CFDictionaryRef attributes; + CFStringRef string; + CFAttributedStringRef attrString; + CTTypesetterRef typesetter; + CTLineRef line; + + memoryword* node = (memoryword*)p; + + unsigned f = native_font(node); + if (fontarea[f] != AAT_FONT_FLAG) { + fprintf(stderr, "internal error: DoAATLayout called for non-AAT font\n"); + exit(1); + } + + txtLen = native_length(node); + txtPtr = (UniChar*)(node + native_node_size); + + attributes = fontlayoutengine[native_font(node)]; + string = CFStringCreateWithCharactersNoCopy(NULL, txtPtr, txtLen, kCFAllocatorNull); + attrString = CFAttributedStringCreate(NULL, string, attributes); + CFRelease(string); + + typesetter = CTTypesetterCreateWithAttributedString(attrString); + CFRelease(attrString); + line = CTTypesetterCreateLine(typesetter, CFRangeMake(0, txtLen)); + if (justify) { + CGFloat lineWidth = TeXtoPSPoints(Fix2D(node_width(node))); + CTLineRef justifiedLine = CTLineCreateJustifiedLine(line, TeXtoPSPoints(Fix2D(fract1)), lineWidth); + // TODO(jjgod): how to handle the case when justification failed? for + // now we just fallback to use the original line. + if (justifiedLine) { + CFRelease(line); + line = justifiedLine; + } + } + + glyphRuns = CTLineGetGlyphRuns(line); + runCount = CFArrayGetCount(glyphRuns); + totalGlyphCount = CTLineGetGlyphCount(line); + + if (totalGlyphCount > 0) { + glyph_info = xmalloc(totalGlyphCount * native_glyph_info_size); + locations = (FixedPoint*)glyph_info; + glyphIDs = (UInt16*)(locations + totalGlyphCount); + glyphAdvances = xmalloc(totalGlyphCount * sizeof(Fixed)); + totalGlyphCount = 0; + + width = 0; + for (i = 0; i < runCount; i++) { + CTRunRef run = CFArrayGetValueAtIndex(glyphRuns, i); + CFIndex count = CTRunGetGlyphCount(run); + CFDictionaryRef runAttributes = CTRunGetAttributes(run); + CFBooleanRef vertical = CFDictionaryGetValue(runAttributes, kCTVerticalFormsAttributeName); + // TODO(jjgod): Avoid unnecessary allocation with CTRunGetFoosPtr(). + CGGlyph* glyphs = (CGGlyph*) xmalloc(count * sizeof(CGGlyph)); + CGPoint* positions = (CGPoint*) xmalloc(count * sizeof(CGPoint)); + CGSize* advances = (CGSize*) xmalloc(count * sizeof(CGSize)); + CGFloat runWidth = CTRunGetTypographicBounds(run, CFRangeMake(0, 0), NULL, NULL, NULL); + CTRunGetGlyphs(run, CFRangeMake(0, 0), glyphs); + CTRunGetPositions(run, CFRangeMake(0, 0), positions); + CTRunGetAdvances(run, CFRangeMake(0, 0), advances); + for (j = 0; j < count; j++) { + // XXX Core Text has that font cascading thing that will do + // font substitution for missing glyphs, which we do not want + // but I can not find a way to disable it yet, so if the font + // of the resulting run is not the same font we asked for, use + // the glyph at index 0 (usually .notdef) instead or we will be + // showing garbage or even invalid glyphs + if (!CFEqual(fontFromAttributes(attributes), fontFromAttributes(runAttributes))) + glyphIDs[totalGlyphCount] = 0; + else + glyphIDs[totalGlyphCount] = glyphs[j]; + + // Swap X and Y when doing vertical layout + if (vertical == kCFBooleanTrue) { + locations[totalGlyphCount].x = FixedPStoTeXPoints(-positions[j].y); + // XXX trasformation matrix changes y positions! + //locations[totalGlyphCount].y = FixedPStoTeXPoints(-positions[j].x); + locations[totalGlyphCount].y = 0; + } else { + locations[totalGlyphCount].x = FixedPStoTeXPoints(positions[j].x); + // XXX trasformation matrix changes y positions! + //locations[totalGlyphCount].y = FixedPStoTeXPoints(positions[j].y); + locations[totalGlyphCount].y = 0; + } + glyphAdvances[totalGlyphCount] = advances[j].width; + totalGlyphCount++; + } + width += FixedPStoTeXPoints(runWidth); + free(glyphs); + free(positions); + free(advances); + } + } + + native_glyph_count(node) = totalGlyphCount; + native_glyph_info_ptr(node) = glyph_info; + + if (!justify) { + node_width(node) = width; + + if (totalGlyphCount > 0) { + /* this is essentially a copy from similar code in XeTeX_ext.c, easier + * to be done here */ + if (fontletterspace[f] != 0) { + Fixed lsDelta = 0; + Fixed lsUnit = fontletterspace[f]; + int i; + for (i = 0; i < totalGlyphCount; ++i) { + if (glyphAdvances[i] == 0 && lsDelta != 0) + lsDelta -= lsUnit; + locations[i].x += lsDelta; + lsDelta += lsUnit; + } + if (lsDelta != 0) { + lsDelta -= lsUnit; + node_width(node) += lsDelta; + } + } + } + } + + free(glyphAdvances); + CFRelease(line); + CFRelease(typesetter); } static void getGlyphBBoxFromCTFont(CTFontRef font, UInt16 gid, GlyphBBox* bbox) { - CGRect rect; - - bbox->xMin = 65536.0; - bbox->yMin = 65536.0; - bbox->xMax = -65536.0; - bbox->yMax = -65536.0; - - rect = CTFontGetBoundingRectsForGlyphs(font, - 0, /* Use default orientation for now, handle vertical later */ - (const CGGlyph *) &gid, NULL, 1); - - if (CGRectIsNull(rect)) - bbox->xMin = bbox->yMin = bbox->xMax = bbox->yMax = 0; - else { - bbox->yMin = PStoTeXPoints(rect.origin.y); - bbox->yMax = PStoTeXPoints(rect.origin.y + rect.size.height); - bbox->xMin = PStoTeXPoints(rect.origin.x); - bbox->xMax = PStoTeXPoints(rect.origin.x + rect.size.width); - } + CGRect rect; + + bbox->xMin = 65536.0; + bbox->yMin = 65536.0; + bbox->xMax = -65536.0; + bbox->yMax = -65536.0; + + rect = CTFontGetBoundingRectsForGlyphs(font, + 0, /* Use default orientation for now, handle vertical later */ + (const CGGlyph *) &gid, NULL, 1); + + if (CGRectIsNull(rect)) + bbox->xMin = bbox->yMin = bbox->xMax = bbox->yMax = 0; + else { + bbox->yMin = PStoTeXPoints(rect.origin.y); + bbox->yMax = PStoTeXPoints(rect.origin.y + rect.size.height); + bbox->xMin = PStoTeXPoints(rect.origin.x); + bbox->xMax = PStoTeXPoints(rect.origin.x + rect.size.width); + } } void GetGlyphBBox_AAT(CFDictionaryRef attributes, UInt16 gid, GlyphBBox* bbox) - /* returns glyph bounding box in TeX points */ + /* returns glyph bounding box in TeX points */ { - CTFontRef font = fontFromAttributes(attributes); - return getGlyphBBoxFromCTFont(font, gid, bbox); + CTFontRef font = fontFromAttributes(attributes); + return getGlyphBBoxFromCTFont(font, gid, bbox); } static double getGlyphWidthFromCTFont(CTFontRef font, UInt16 gid) { - CGSize advances[1] = { CGSizeMake(0, 0) }; - return PStoTeXPoints(CTFontGetAdvancesForGlyphs(font, 0, &gid, advances, 1)); + return PStoTeXPoints(CTFontGetAdvancesForGlyphs(font, kCTFontHorizontalOrientation, &gid, NULL, 1)); } double GetGlyphWidth_AAT(CFDictionaryRef attributes, UInt16 gid) - /* returns TeX points */ + /* returns TeX points */ { - CTFontRef font = fontFromAttributes(attributes); - return getGlyphWidthFromCTFont(font, gid); + CTFontRef font = fontFromAttributes(attributes); + return getGlyphWidthFromCTFont(font, gid); } void GetGlyphHeightDepth_AAT(CFDictionaryRef attributes, UInt16 gid, float* ht, float* dp) - /* returns TeX points */ + /* returns TeX points */ { - GlyphBBox bbox; - - GetGlyphBBox_AAT(attributes, gid, &bbox); + GlyphBBox bbox; - *ht = bbox.yMax; - *dp = -bbox.yMin; + GetGlyphBBox_AAT(attributes, gid, &bbox); + + *ht = bbox.yMax; + *dp = -bbox.yMin; } void GetGlyphSidebearings_AAT(CFDictionaryRef attributes, UInt16 gid, float* lsb, float* rsb) - /* returns TeX points */ + /* returns TeX points */ { - CTFontRef font = fontFromAttributes(attributes); - CGSize advances[1] = { CGSizeMake(0, 0) }; - double advance = CTFontGetAdvancesForGlyphs(font, 0, &gid, advances, 1); - GlyphBBox bbox; - getGlyphBBoxFromCTFont(font, gid, &bbox); - *lsb = bbox.xMin; - *rsb = PStoTeXPoints(advance) - bbox.xMax; + CTFontRef font = fontFromAttributes(attributes); + CGSize advances[1] = { CGSizeMake(0, 0) }; + double advance = CTFontGetAdvancesForGlyphs(font, 0, &gid, advances, 1); + GlyphBBox bbox; + getGlyphBBoxFromCTFont(font, gid, &bbox); + *lsb = bbox.xMin; + *rsb = PStoTeXPoints(advance) - bbox.xMax; } double GetGlyphItalCorr_AAT(CFDictionaryRef attributes, UInt16 gid) { - CTFontRef font = fontFromAttributes(attributes); - CGSize advances[1] = { CGSizeMake(0, 0) }; - double advance = CTFontGetAdvancesForGlyphs(font, 0, &gid, advances, 1); + CTFontRef font = fontFromAttributes(attributes); + CGSize advances[1] = { CGSizeMake(0, 0) }; + double advance = CTFontGetAdvancesForGlyphs(font, 0, &gid, advances, 1); - GlyphBBox bbox; - getGlyphBBoxFromCTFont(font, gid, &bbox); + GlyphBBox bbox; + getGlyphBBoxFromCTFont(font, gid, &bbox); - if (bbox.xMax > PStoTeXPoints(advance)) - return bbox.xMax - PStoTeXPoints(advance); - return 0; + if (bbox.xMax > PStoTeXPoints(advance)) + return bbox.xMax - PStoTeXPoints(advance); + return 0; } static int mapCharToGlyphFromCTFont(CTFontRef font, UInt32 ch) { - CGGlyph glyphs[2] = { 0 }; - UniChar txt[2]; - int len = 1; - - if (ch > 0xffff) { - ch -= 0x10000; - txt[0] = 0xd800 + ch / 1024; - txt[1] = 0xdc00 + ch % 1024; - len = 2; - } else { - txt[0] = ch; - } - - if (CTFontGetGlyphsForCharacters(font, txt, glyphs, len)) - return glyphs[0]; - - return 0; + CGGlyph glyphs[2] = { 0 }; + UniChar txt[2]; + int len = 1; + + if (ch > 0xffff) { + ch -= 0x10000; + txt[0] = 0xd800 + ch / 1024; + txt[1] = 0xdc00 + ch % 1024; + len = 2; + } else { + txt[0] = ch; + } + + if (CTFontGetGlyphsForCharacters(font, txt, glyphs, len)) + return glyphs[0]; + + return 0; } int MapCharToGlyph_AAT(CFDictionaryRef attributes, UInt32 ch) { - CTFontRef font = fontFromAttributes(attributes); - return mapCharToGlyphFromCTFont(font, ch); + CTFontRef font = fontFromAttributes(attributes); + return mapCharToGlyphFromCTFont(font, ch); } static int GetGlyphIDFromCTFont(CTFontRef ctFontRef, const char* glyphName) { - CFStringRef glyphname = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, - glyphName, - kCFStringEncodingUTF8, - kCFAllocatorNull); - int rval = CTFontGetGlyphWithName(ctFontRef, glyphname); - CFRelease(glyphname); - return rval; + CFStringRef glyphname = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, + glyphName, + kCFStringEncodingUTF8, + kCFAllocatorNull); + int rval = CTFontGetGlyphWithName(ctFontRef, glyphname); + CFRelease(glyphname); + return rval; } int MapGlyphToIndex_AAT(CFDictionaryRef attributes, const char* glyphName) { - CTFontRef font = fontFromAttributes(attributes); - return GetGlyphIDFromCTFont(font, glyphName); + CTFontRef font = fontFromAttributes(attributes); + return GetGlyphIDFromCTFont(font, glyphName); } char* GetGlyphNameFromCTFont(CTFontRef ctFontRef, UInt16 gid, int* len) { - CGFontRef cgfont; - static char buffer[256]; - buffer[0] = 0; - *len = 0; - - cgfont = CTFontCopyGraphicsFont(ctFontRef, 0); - if (cgfont && gid < CGFontGetNumberOfGlyphs(cgfont)) { - CFStringRef glyphname = CGFontCopyGlyphNameForGlyph(cgfont, gid); - if (glyphname) { - if (CFStringGetCString(glyphname, buffer, 256, kCFStringEncodingUTF8)) { - *len = strlen(buffer); - } - CFRelease(glyphname); - } - CGFontRelease(cgfont); - } - - return &buffer[0]; + CGFontRef cgfont; + static char buffer[256]; + buffer[0] = 0; + *len = 0; + + cgfont = CTFontCopyGraphicsFont(ctFontRef, 0); + if (cgfont && gid < CGFontGetNumberOfGlyphs(cgfont)) { + CFStringRef glyphname = CGFontCopyGlyphNameForGlyph(cgfont, gid); + if (glyphname) { + if (CFStringGetCString(glyphname, buffer, 256, kCFStringEncodingUTF8)) { + *len = strlen(buffer); + } + CFRelease(glyphname); + } + CGFontRelease(cgfont); + } + + return &buffer[0]; } int GetFontCharRange_AAT(CFDictionaryRef attributes, int reqFirst) { - if (reqFirst) { - int ch = 0; - while (MapCharToGlyph_AAT(attributes, ch) == 0 && ch < 0x10ffff) - ++ch; - return ch; - } else { - int ch = 0x10ffff; - while (MapCharToGlyph_AAT(attributes, ch) == 0 && ch > 0) - --ch; - return ch; - } + if (reqFirst) { + int ch = 0; + while (MapCharToGlyph_AAT(attributes, ch) == 0 && ch < 0x10ffff) + ++ch; + return ch; + } else { + int ch = 0x10ffff; + while (MapCharToGlyph_AAT(attributes, ch) == 0 && ch > 0) + --ch; + return ch; + } } char* getNameFromCTFont(CTFontRef ctFontRef, CFStringRef nameKey) { - char *buf; - CFStringRef name = CTFontCopyName(ctFontRef, nameKey); - CFIndex len = CFStringGetLength(name); - len = len * 6 + 1; - buf = xmalloc(len); - if (CFStringGetCString(name, buf, len, kCFStringEncodingUTF8)) - return buf; - free(buf); - return 0; + char *buf; + CFStringRef name = CTFontCopyName(ctFontRef, nameKey); + CFIndex len = CFStringGetLength(name); + len = len * 6 + 1; + buf = xmalloc(len); + if (CFStringGetCString(name, buf, len, kCFStringEncodingUTF8)) + return buf; + free(buf); + return NULL; } char* getFileNameFromCTFont(CTFontRef ctFontRef, int *index) { - char *ret = NULL; - CFURLRef url = NULL; + char *ret = NULL; + CFURLRef url = NULL; #if !defined(MAC_OS_X_VERSION_10_6) || MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_6 - /* kCTFontURLAttribute was not avialable before 10.6 */ - ATSFontRef atsFont; - FSRef fsref; - OSStatus status; - atsFont = CTFontGetPlatformFont(ctFontRef, NULL); - status = ATSFontGetFileReference(atsFont, &fsref); - if (status == noErr) - url = CFURLCreateFromFSRef(NULL, &fsref); + /* kCTFontURLAttribute was not avialable before 10.6 */ + ATSFontRef atsFont; + FSRef fsref; + OSStatus status; + atsFont = CTFontGetPlatformFont(ctFontRef, NULL); + status = ATSFontGetFileReference(atsFont, &fsref); + if (status == noErr) + url = CFURLCreateFromFSRef(NULL, &fsref); #else - url = (CFURLRef) CTFontCopyAttribute(ctFontRef, kCTFontURLAttribute); + url = (CFURLRef) CTFontCopyAttribute(ctFontRef, kCTFontURLAttribute); #endif - if (url) { - UInt8 pathname[PATH_MAX]; - if (CFURLGetFileSystemRepresentation(url, true, pathname, PATH_MAX)) { - FT_Error error; - FT_Face face; - - *index = 0; - - if (!gFreeTypeLibrary) { - error = FT_Init_FreeType(&gFreeTypeLibrary); - if (error) { - fprintf(stderr, "FreeType initialization failed! (%d)\n", error); - exit(1); - } - } - - error = FT_New_Face(gFreeTypeLibrary, (char *) pathname, 0, &face); - if (!error) { - if (face->num_faces > 1) { - int num_faces = face->num_faces; - char *ps_name1 = getNameFromCTFont(ctFontRef, kCTFontPostScriptNameKey); - int i; - *index = -1; - FT_Done_Face (face); - for (i = 0; i < num_faces; i++) { - error = FT_New_Face (gFreeTypeLibrary, (char *) pathname, i, &face); - if (!error) { - const char *ps_name2 = FT_Get_Postscript_Name(face); - if (strcmp(ps_name1, ps_name2) == 0) { - *index = i; - break; - } - FT_Done_Face (face); - } - } - } - } - - if (*index != -1) - ret = strdup((char *) pathname); - } - CFRelease(url); - } - - return ret; + if (url) { + UInt8 pathname[PATH_MAX]; + if (CFURLGetFileSystemRepresentation(url, true, pathname, PATH_MAX)) { + FT_Error error; + FT_Face face; + + *index = 0; + + if (!gFreeTypeLibrary) { + error = FT_Init_FreeType(&gFreeTypeLibrary); + if (error) { + fprintf(stderr, "FreeType initialization failed! (%d)\n", error); + exit(1); + } + } + + error = FT_New_Face(gFreeTypeLibrary, (char *) pathname, 0, &face); + if (!error) { + if (face->num_faces > 1) { + int num_faces = face->num_faces; + char *ps_name1 = getNameFromCTFont(ctFontRef, kCTFontPostScriptNameKey); + int i; + *index = -1; + FT_Done_Face (face); + for (i = 0; i < num_faces; i++) { + error = FT_New_Face (gFreeTypeLibrary, (char *) pathname, i, &face); + if (!error) { + const char *ps_name2 = FT_Get_Postscript_Name(face); + if (strcmp(ps_name1, ps_name2) == 0) { + *index = i; + break; + } + FT_Done_Face (face); + } + } + free(ps_name1); + } + } + + if (*index != -1) + ret = strdup((char *) pathname); + } + CFRelease(url); + } + + return ret; } CFDictionaryRef findDictionaryInArrayWithIdentifier(CFArrayRef array, const void* identifierKey, int identifier) { - CFDictionaryRef dict = NULL; - - if (array) { - int value = -1; - CFIndex i; - for (i = 0; i < CFArrayGetCount(array); i++) { - CFDictionaryRef item = CFArrayGetValueAtIndex(array, i); - CFNumberRef itemId = CFDictionaryGetValue(item, identifierKey); - if (itemId) { - CFNumberGetValue(itemId, kCFNumberIntType, &value); - if (value == identifier) { - dict = item; - break; - } - } - } - } - return dict; + CFDictionaryRef dict = NULL; + + if (array) { + int value = -1; + CFIndex i; + for (i = 0; i < CFArrayGetCount(array); i++) { + CFDictionaryRef item = CFArrayGetValueAtIndex(array, i); + CFNumberRef itemId = CFDictionaryGetValue(item, identifierKey); + if (itemId) { + CFNumberGetValue(itemId, kCFNumberIntType, &value); + if (value == identifier) { + dict = item; + break; + } + } + } + } + return dict; } CFDictionaryRef findDictionaryInArray(CFArrayRef array, const void* nameKey, const char* name, int nameLength) { - CFDictionaryRef dict = NULL; - - if (array) { - CFStringRef itemName; - CFIndex i; - itemName = CFStringCreateWithBytes(NULL, (UInt8 *) name, nameLength, - kCFStringEncodingUTF8, false); - for (i = 0; i < CFArrayGetCount(array); i++) { - CFDictionaryRef item = CFArrayGetValueAtIndex(array, i); - CFStringRef iName = CFDictionaryGetValue(item, nameKey); - if (iName && !CFStringCompare(itemName, iName, kCFCompareCaseInsensitive)) { - dict = item; - break; - } - } - CFRelease(itemName); - } - return dict; + CFDictionaryRef dict = NULL; + + if (array) { + CFStringRef itemName; + CFIndex i; + itemName = CFStringCreateWithBytes(NULL, (UInt8 *) name, nameLength, + kCFStringEncodingUTF8, false); + for (i = 0; i < CFArrayGetCount(array); i++) { + CFDictionaryRef item = CFArrayGetValueAtIndex(array, i); + CFStringRef iName = CFDictionaryGetValue(item, nameKey); + if (iName && !CFStringCompare(itemName, iName, kCFCompareCaseInsensitive)) { + dict = item; + break; + } + } + CFRelease(itemName); + } + return dict; } CFNumberRef findSelectorByName(CFDictionaryRef feature, const char* name, int nameLength) { - CFNumberRef selector = NULL; - CFArrayRef selectors = CFDictionaryGetValue(feature, kCTFontFeatureTypeSelectorsKey); - if (selectors) { - CFDictionaryRef s = findDictionaryInArray(selectors, kCTFontFeatureSelectorNameKey, name, nameLength); - if (s) - selector = CFDictionaryGetValue(s, kCTFontFeatureSelectorIdentifierKey); - } - return selector; + CFNumberRef selector = NULL; + CFArrayRef selectors = CFDictionaryGetValue(feature, kCTFontFeatureTypeSelectorsKey); + if (selectors) { + CFDictionaryRef s = findDictionaryInArray(selectors, kCTFontFeatureSelectorNameKey, name, nameLength); + if (s) + selector = CFDictionaryGetValue(s, kCTFontFeatureSelectorIdentifierKey); + } + return selector; } static CFDictionaryRef createFeatureSettingDictionary(CFNumberRef featureTypeIdentifier, CFNumberRef featureSelectorIdentifier) { - const void* settingKeys[] = { kCTFontFeatureTypeIdentifierKey, kCTFontFeatureSelectorIdentifierKey }; - const void* settingValues[] = { featureTypeIdentifier, featureSelectorIdentifier }; + const void* settingKeys[] = { kCTFontFeatureTypeIdentifierKey, kCTFontFeatureSelectorIdentifierKey }; + const void* settingValues[] = { featureTypeIdentifier, featureSelectorIdentifier }; - return CFDictionaryCreate(kCFAllocatorDefault, settingKeys, settingValues, 2, - &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); + return CFDictionaryCreate(kCFAllocatorDefault, settingKeys, settingValues, 2, + &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); } const CFStringRef kXeTeXEmboldenAttributeName = CFSTR("XeTeXEmbolden"); @@ -545,385 +546,260 @@ const CFStringRef kXeTeXEmboldenAttributeName = CFSTR("XeTeXEmbolden"); void* loadAATfont(CTFontDescriptorRef descriptor, integer scaled_size, const char* cp1) { - CTFontRef font, actualFont; - CGFloat ctSize; - CFMutableDictionaryRef stringAttributes, attributes; - CGAffineTransform matrix; - CFMutableArrayRef cascadeList; - CTFontDescriptorRef lastResort; - double tracking = 0.0; - float extend = 1.0; - float slant = 0.0; - float embolden = 0.0; - float letterspace = 0.0; - uint32_t rgbValue; - - // create a base font instance for applying further attributes - ctSize = TeXtoPSPoints(Fix2D(scaled_size)); - font = CTFontCreateWithFontDescriptor(descriptor, ctSize, NULL); - if (!font) - return NULL; - - stringAttributes = CFDictionaryCreateMutable(NULL, 0, - &kCFTypeDictionaryKeyCallBacks, - &kCFTypeDictionaryValueCallBacks); - attributes = CFDictionaryCreateMutable(NULL, 0, - &kCFTypeDictionaryKeyCallBacks, - &kCFTypeDictionaryValueCallBacks); - if (cp1) { - CFArrayRef features = CTFontCopyFeatures(font); - CFArrayRef axes = CTFontCopyVariationAxes(font); - CFMutableArrayRef featureSettings = - CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); - CFMutableDictionaryRef variation = - CFDictionaryCreateMutable(NULL, 0, - &kCFTypeDictionaryKeyCallBacks, - &kCFTypeDictionaryValueCallBacks); - - // interpret features & variations following ":" - while (*cp1) { - CFDictionaryRef feature, axis; - int ret; - const char* cp2; - const char* cp3; - // locate beginning of name=value pair - if (*cp1 == ':' || *cp1 == ';') // skip over separator - ++cp1; - while (*cp1 == ' ' || *cp1 == '\t') // skip leading whitespace - ++cp1; - if (*cp1 == 0) // break if end of string - break; - - // scan to end of pair - cp2 = cp1; - while (*cp2 && (*cp2 != ';') && (*cp2 != ':')) - ++cp2; - - // look for the '=' separator - cp3 = cp1; - while ((cp3 < cp2) && (*cp3 != '=')) - ++cp3; - if (cp3 == cp2) - goto bad_option; - - // now cp1 points to option name, cp3 to '=', cp2 to ';' or null - - // first try for a feature by this name - feature = findDictionaryInArray(features, kCTFontFeatureTypeNameKey, cp1, cp3 - cp1); - if (feature) { - // look past the '=' separator for setting names - int featLen = cp3 - cp1; - int zeroInteger = 0; - CFNumberRef zero = CFNumberCreate(NULL, kCFNumberIntType, &zeroInteger); - ++cp3; - while (cp3 < cp2) { - CFNumberRef selector; - int disable = 0; - const char* cp4; - // skip leading whitespace - while (*cp3 == ' ' || *cp3 == '\t') - ++cp3; - - // possibly multiple settings... - if (*cp3 == '!') { // check for negation - disable = 1; - ++cp3; - } - - // scan for end of setting name - cp4 = cp3; - while (cp4 < cp2 && *cp4 != ',') - ++cp4; - - // now cp3 points to name, cp4 to ',' or ';' or null - selector = findSelectorByName(feature, cp3, cp4 - cp3); - if (selector && CFNumberCompare(selector, zero, NULL) >= 0) { - CFNumberRef featureType = CFDictionaryGetValue(feature, kCTFontFeatureTypeIdentifierKey); - CFDictionaryRef featureSetting = createFeatureSettingDictionary(featureType, selector); - CFArrayAppendValue(featureSettings, featureSetting); - CFRelease(featureSetting); - } else { - fontfeaturewarning(cp1, featLen, cp3, cp4 - cp3); - } - - // point beyond setting name terminator - cp3 = cp4 + 1; - } - CFRelease(zero); - - goto next_option; - } - - // try to find a variation by this name - axis = findDictionaryInArray(axes, kCTFontVariationAxisNameKey, cp1, cp3 - cp1); - if (axis) { - CFNumberRef axisIdentifier, axisValue; - double value = 0.0, decimal = 1.0; - bool negate = false; - // look past the '=' separator for the value - ++cp3; - if (*cp3 == '-') { - ++cp3; - negate = true; - } - while (cp3 < cp2) { - int v = *cp3 - '0'; - if (v >= 0 && v <= 9) { - if (decimal != 1.0) { - value += v / decimal; - decimal *= 10.0; - } else { - value = value * 10.0 + v; - } - } else if (*cp3 == '.') { - if (decimal != 1.0) - break; - decimal = 10.0; - } else { - break; - } - ++cp3; - } - if (negate) - value = -value; - - axisIdentifier = CFDictionaryGetValue(axis, kCTFontVariationAxisIdentifierKey); - axisValue = CFNumberCreate(NULL, kCFNumberDoubleType, &value); - CFDictionaryAddValue(variation, axisIdentifier, axisValue); - CFRelease(axisValue); - - goto next_option; - } - - // didn't find feature or variation, try other options... - ret = readCommonFeatures(cp1, cp2, &extend, &slant, &embolden, &letterspace, &rgbValue); - if (ret == 1) - goto next_option; - else if (ret == -1) - goto bad_option; - - if (strncmp(cp1, "tracking", 8) == 0) { - CFNumberRef trackingNumber; - cp3 = cp1 + 8; - if (*cp3 != '=') - goto bad_option; - ++cp3; - tracking = read_double(&cp3); - trackingNumber = CFNumberCreate(NULL, kCFNumberDoubleType, &tracking); - CFDictionaryAddValue(stringAttributes, kCTKernAttributeName, trackingNumber); - CFRelease(trackingNumber); - goto next_option; - } - - bad_option: - // not a name=value pair, or not recognized.... - // check for plain "vertical" before complaining - if (strncmp(cp1, "vertical", 8) == 0) { - cp3 = cp2; - if (*cp3 == ';' || *cp3 == ':') - --cp3; - while (*cp3 == '\0' || *cp3 == ' ' || *cp3 == '\t') - --cp3; - if (*cp3) - ++cp3; - if (cp3 == cp1 + 8) { - int orientation = kCTFontVerticalOrientation; - CFNumberRef orientationNumber = CFNumberCreate(NULL, kCFNumberIntType, &orientation); - CFDictionaryAddValue(attributes, kCTFontOrientationAttribute, orientationNumber); - CFRelease(orientationNumber); - CFDictionaryAddValue(stringAttributes, kCTVerticalFormsAttributeName, kCFBooleanTrue); - goto next_option; - } - } - - fontfeaturewarning(cp1, cp2 - cp1, 0, 0); - - next_option: - // go to next name=value pair - cp1 = cp2; - } - - if (features) - CFRelease(features); - if (axes) - CFRelease(axes); - - if (CFArrayGetCount(featureSettings)) - CFDictionaryAddValue(attributes, kCTFontFeatureSettingsAttribute, featureSettings); - CFRelease(featureSettings); - - if (CFDictionaryGetCount(variation)) - CFDictionaryAddValue(attributes, kCTFontVariationAttribute, variation); - CFRelease(variation); - } - - if ((loadedfontflags & FONT_FLAGS_COLORED) != 0) { - CGFloat red = ((rgbValue & 0xFF000000) >> 24) / 255.0; - CGFloat green = ((rgbValue & 0x00FF0000) >> 16) / 255.0; - CGFloat blue = ((rgbValue & 0x0000FF00) >> 8 ) / 255.0; - CGFloat alpha = ((rgbValue & 0x000000FF) ) / 255.0; - CGColorRef color = CGColorCreateGenericRGB(red, green, blue, alpha); - CFDictionaryAddValue(stringAttributes, kCTForegroundColorAttributeName, color); - CGColorRelease(color); - } - - matrix = CGAffineTransformIdentity; - // XXX this breaks y glyph positioning - if (extend != 1.0 || slant != 0.0) - matrix = CGAffineTransformMake(extend, slant, 0, 1.0, 0, 0); - - if (embolden != 0.0) { - CFNumberRef emboldenNumber; - embolden = embolden * Fix2D(scaled_size) / 100.0; - emboldenNumber = CFNumberCreate(NULL, kCFNumberFloatType, &embolden); - CFDictionaryAddValue(stringAttributes, kXeTeXEmboldenAttributeName, emboldenNumber); - CFRelease(emboldenNumber); - } - - if (letterspace != 0.0) - loadedfontletterspace = (letterspace / 100.0) * scaled_size; - - // Disable Core Text font fallback (cascading) with only the last resort font - // in the cascade list. - cascadeList = CFArrayCreateMutable(NULL, 1, &kCFTypeArrayCallBacks); - lastResort = CTFontDescriptorCreateWithNameAndSize(CFSTR("LastResort"), 0); - CFArrayAppendValue(cascadeList, lastResort); - CFRelease(lastResort); - CFDictionaryAddValue(attributes, kCTFontCascadeListAttribute, cascadeList); - CFRelease(cascadeList); - - descriptor = CTFontDescriptorCreateWithAttributes(attributes); - CFRelease(attributes); - actualFont = CTFontCreateCopyWithAttributes(font, ctSize, &matrix, descriptor); - CFRelease(font); - CFDictionaryAddValue(stringAttributes, kCTFontAttributeName, actualFont); - CFRelease(actualFont); - - nativefonttypeflag = AAT_FONT_FLAG; - return (void *) stringAttributes; -} - -int -countpdffilepages() -{ - int rval = 0; - - char* pic_path = kpse_find_file((char*)nameoffile + 1, kpse_pict_format, 1); - CFURLRef picFileURL = NULL; - if (pic_path) { - picFileURL = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (UInt8*)pic_path, strlen(pic_path), false); - if (picFileURL != NULL) { - FSRef picFileRef; - CGPDFDocumentRef document; - CFURLGetFSRef(picFileURL, &picFileRef); - document = CGPDFDocumentCreateWithURL(picFileURL); - if (document != NULL) { - rval = CGPDFDocumentGetNumberOfPages(document); - CGPDFDocumentRelease(document); - } - CFRelease(picFileURL); - } - free(pic_path); - } - - return rval; -} - -int -find_pic_file(char** path, realrect* bounds, int pdfBoxType, int page) - /* returns bounds in TeX points */ -{ - OSStatus result = fnfErr; - char* pic_path = kpse_find_file((char*)nameoffile + 1, kpse_pict_format, 1); - CFURLRef picFileURL = NULL; - - *path = NULL; - - if (pic_path) { - picFileURL = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (UInt8*)pic_path, strlen(pic_path), false); - - if (picFileURL != NULL) { - if (pdfBoxType > 0) { - CGPDFDocumentRef document = CGPDFDocumentCreateWithURL(picFileURL); - if (document != NULL) { - CGPDFPageRef pageRef; - CGRect r; - CGPDFBox boxType; - int nPages = CGPDFDocumentGetNumberOfPages(document); - if (page < 0) - page = nPages + 1 + page; - if (page < 1) - page = 1; - if (page > nPages) - page = nPages; - - pageRef = CGPDFDocumentGetPage(document, page); - switch (pdfBoxType) { - case pdfbox_crop: - default: - boxType = kCGPDFCropBox; - break; - case pdfbox_media: - boxType = kCGPDFMediaBox; - break; - case pdfbox_bleed: - boxType = kCGPDFBleedBox; - break; - case pdfbox_trim: - boxType = kCGPDFTrimBox; - break; - case pdfbox_art: - boxType = kCGPDFArtBox; - break; - } - r = CGPDFPageGetBoxRect(pageRef, boxType); - - bounds->x = r.origin.x * 72.27 / 72.0; - bounds->y = r.origin.y * 72.27 / 72.0; - bounds->wd = r.size.width * 72.27 / 72.0; - bounds->ht = r.size.height * 72.27 / 72.0; - CGPDFDocumentRelease(document); - result = noErr; - } - } else { - CGImageSourceRef picFileSource = CGImageSourceCreateWithURL(picFileURL, NULL); - if (picFileSource) { - CFDictionaryRef properties = CGImageSourceCopyPropertiesAtIndex(picFileSource, 0, NULL); - - CFNumberRef imageWidth = CFDictionaryGetValue(properties, kCGImagePropertyPixelWidth); - CFNumberRef imageHeight = CFDictionaryGetValue(properties, kCGImagePropertyPixelHeight); - CFNumberRef DPIWidth = CFDictionaryGetValue(properties, kCGImagePropertyDPIWidth); - CFNumberRef DPIHeight = CFDictionaryGetValue(properties, kCGImagePropertyDPIHeight); - - if (imageWidth && imageHeight) { - int w = 0, h = 0, hRes = 72, vRes = 72; - CFNumberGetValue(imageWidth, kCFNumberIntType, &w); - CFNumberGetValue(imageHeight, kCFNumberIntType, &h); - if (DPIWidth) - CFNumberGetValue(DPIWidth, kCFNumberIntType, &hRes); - if (DPIHeight) - CFNumberGetValue(DPIHeight, kCFNumberIntType, &vRes); - - bounds->x = 0; - bounds->y = 0; - bounds->wd = w * 72.27 / hRes; - bounds->ht = h * 72.27 / vRes; - CFRelease(properties); - CFRelease(picFileSource); - result = noErr; - } - } - } - - CFRelease(picFileURL); - } - - /* if we couldn't import it, toss the pathname as we'll be returning an error */ - if (result != noErr) - free(pic_path); - else - *path = (char*)pic_path; - } - - return result; + CTFontRef font, actualFont; + CGFloat ctSize; + CFMutableDictionaryRef stringAttributes, attributes; + CGAffineTransform matrix; + CFMutableArrayRef cascadeList; + CTFontDescriptorRef lastResort; + double tracking = 0.0; + float extend = 1.0; + float slant = 0.0; + float embolden = 0.0; + float letterspace = 0.0; + uint32_t rgbValue; + + // create a base font instance for applying further attributes + ctSize = TeXtoPSPoints(Fix2D(scaled_size)); + font = CTFontCreateWithFontDescriptor(descriptor, ctSize, NULL); + if (!font) + return NULL; + + stringAttributes = CFDictionaryCreateMutable(NULL, 0, + &kCFTypeDictionaryKeyCallBacks, + &kCFTypeDictionaryValueCallBacks); + attributes = CFDictionaryCreateMutable(NULL, 0, + &kCFTypeDictionaryKeyCallBacks, + &kCFTypeDictionaryValueCallBacks); + if (cp1) { + CFArrayRef features = CTFontCopyFeatures(font); + CFArrayRef axes = CTFontCopyVariationAxes(font); + CFMutableArrayRef featureSettings = + CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); + CFMutableDictionaryRef variation = + CFDictionaryCreateMutable(NULL, 0, + &kCFTypeDictionaryKeyCallBacks, + &kCFTypeDictionaryValueCallBacks); + + // interpret features & variations following ":" + while (*cp1) { + CFDictionaryRef feature, axis; + int ret; + const char* cp2; + const char* cp3; + // locate beginning of name=value pair + if (*cp1 == ':' || *cp1 == ';') // skip over separator + ++cp1; + while (*cp1 == ' ' || *cp1 == '\t') // skip leading whitespace + ++cp1; + if (*cp1 == 0) // break if end of string + break; + + // scan to end of pair + cp2 = cp1; + while (*cp2 && (*cp2 != ';') && (*cp2 != ':')) + ++cp2; + + // look for the '=' separator + cp3 = cp1; + while ((cp3 < cp2) && (*cp3 != '=')) + ++cp3; + if (cp3 == cp2) + goto bad_option; + + // now cp1 points to option name, cp3 to '=', cp2 to ';' or null + + // first try for a feature by this name + feature = findDictionaryInArray(features, kCTFontFeatureTypeNameKey, cp1, cp3 - cp1); + if (feature) { + // look past the '=' separator for setting names + int featLen = cp3 - cp1; + int zeroInteger = 0; + CFNumberRef zero = CFNumberCreate(NULL, kCFNumberIntType, &zeroInteger); + ++cp3; + while (cp3 < cp2) { + CFNumberRef selector; + int disable = 0; + const char* cp4; + // skip leading whitespace + while (*cp3 == ' ' || *cp3 == '\t') + ++cp3; + + // possibly multiple settings... + if (*cp3 == '!') { // check for negation + disable = 1; + ++cp3; + } + + // scan for end of setting name + cp4 = cp3; + while (cp4 < cp2 && *cp4 != ',') + ++cp4; + + // now cp3 points to name, cp4 to ',' or ';' or null + selector = findSelectorByName(feature, cp3, cp4 - cp3); + if (selector && CFNumberCompare(selector, zero, NULL) >= 0) { + CFNumberRef featureType = CFDictionaryGetValue(feature, kCTFontFeatureTypeIdentifierKey); + CFDictionaryRef featureSetting = createFeatureSettingDictionary(featureType, selector); + CFArrayAppendValue(featureSettings, featureSetting); + CFRelease(featureSetting); + } else { + fontfeaturewarning(cp1, featLen, cp3, cp4 - cp3); + } + + // point beyond setting name terminator + cp3 = cp4 + 1; + } + CFRelease(zero); + + goto next_option; + } + + // try to find a variation by this name + axis = findDictionaryInArray(axes, kCTFontVariationAxisNameKey, cp1, cp3 - cp1); + if (axis) { + CFNumberRef axisIdentifier, axisValue; + double value = 0.0, decimal = 1.0; + bool negate = false; + // look past the '=' separator for the value + ++cp3; + if (*cp3 == '-') { + ++cp3; + negate = true; + } + while (cp3 < cp2) { + int v = *cp3 - '0'; + if (v >= 0 && v <= 9) { + if (decimal != 1.0) { + value += v / decimal; + decimal *= 10.0; + } else { + value = value * 10.0 + v; + } + } else if (*cp3 == '.') { + if (decimal != 1.0) + break; + decimal = 10.0; + } else { + break; + } + ++cp3; + } + if (negate) + value = -value; + + axisIdentifier = CFDictionaryGetValue(axis, kCTFontVariationAxisIdentifierKey); + axisValue = CFNumberCreate(NULL, kCFNumberDoubleType, &value); + CFDictionaryAddValue(variation, axisIdentifier, axisValue); + CFRelease(axisValue); + + goto next_option; + } + + // didn't find feature or variation, try other options... + ret = readCommonFeatures(cp1, cp2, &extend, &slant, &embolden, &letterspace, &rgbValue); + if (ret == 1) + goto next_option; + else if (ret == -1) + goto bad_option; + + if (strncmp(cp1, "tracking", 8) == 0) { + CFNumberRef trackingNumber; + cp3 = cp1 + 8; + if (*cp3 != '=') + goto bad_option; + ++cp3; + tracking = read_double(&cp3); + trackingNumber = CFNumberCreate(NULL, kCFNumberDoubleType, &tracking); + CFDictionaryAddValue(stringAttributes, kCTKernAttributeName, trackingNumber); + CFRelease(trackingNumber); + goto next_option; + } + + bad_option: + // not a name=value pair, or not recognized.... + // check for plain "vertical" before complaining + if (strncmp(cp1, "vertical", 8) == 0) { + cp3 = cp2; + if (*cp3 == ';' || *cp3 == ':') + --cp3; + while (*cp3 == '\0' || *cp3 == ' ' || *cp3 == '\t') + --cp3; + if (*cp3) + ++cp3; + if (cp3 == cp1 + 8) { + int orientation = kCTFontVerticalOrientation; + CFNumberRef orientationNumber = CFNumberCreate(NULL, kCFNumberIntType, &orientation); + CFDictionaryAddValue(attributes, kCTFontOrientationAttribute, orientationNumber); + CFRelease(orientationNumber); + CFDictionaryAddValue(stringAttributes, kCTVerticalFormsAttributeName, kCFBooleanTrue); + goto next_option; + } + } + + fontfeaturewarning(cp1, cp2 - cp1, 0, 0); + + next_option: + // go to next name=value pair + cp1 = cp2; + } + + if (features) + CFRelease(features); + if (axes) + CFRelease(axes); + + if (CFArrayGetCount(featureSettings)) + CFDictionaryAddValue(attributes, kCTFontFeatureSettingsAttribute, featureSettings); + CFRelease(featureSettings); + + if (CFDictionaryGetCount(variation)) + CFDictionaryAddValue(attributes, kCTFontVariationAttribute, variation); + CFRelease(variation); + } + + if ((loadedfontflags & FONT_FLAGS_COLORED) != 0) { + CGFloat red = ((rgbValue & 0xFF000000) >> 24) / 255.0; + CGFloat green = ((rgbValue & 0x00FF0000) >> 16) / 255.0; + CGFloat blue = ((rgbValue & 0x0000FF00) >> 8 ) / 255.0; + CGFloat alpha = ((rgbValue & 0x000000FF) ) / 255.0; + CGColorRef color = CGColorCreateGenericRGB(red, green, blue, alpha); + CFDictionaryAddValue(stringAttributes, kCTForegroundColorAttributeName, color); + CGColorRelease(color); + } + + matrix = CGAffineTransformIdentity; + // XXX this breaks y glyph positioning + if (extend != 1.0 || slant != 0.0) + matrix = CGAffineTransformMake(extend, slant, 0, 1.0, 0, 0); + + if (embolden != 0.0) { + CFNumberRef emboldenNumber; + embolden = embolden * Fix2D(scaled_size) / 100.0; + emboldenNumber = CFNumberCreate(NULL, kCFNumberFloatType, &embolden); + CFDictionaryAddValue(stringAttributes, kXeTeXEmboldenAttributeName, emboldenNumber); + CFRelease(emboldenNumber); + } + + if (letterspace != 0.0) + loadedfontletterspace = (letterspace / 100.0) * scaled_size; + + // Disable Core Text font fallback (cascading) with only the last resort font + // in the cascade list. + cascadeList = CFArrayCreateMutable(NULL, 1, &kCFTypeArrayCallBacks); + lastResort = CTFontDescriptorCreateWithNameAndSize(CFSTR("LastResort"), 0); + CFArrayAppendValue(cascadeList, lastResort); + CFRelease(lastResort); + CFDictionaryAddValue(attributes, kCTFontCascadeListAttribute, cascadeList); + CFRelease(cascadeList); + + descriptor = CTFontDescriptorCreateWithAttributes(attributes); + CFRelease(attributes); + actualFont = CTFontCreateCopyWithAttributes(font, ctSize, &matrix, descriptor); + CFRelease(font); + CFDictionaryAddValue(stringAttributes, kCTFontAttributeName, actualFont); + CFRelease(actualFont); + + nativefonttypeflag = AAT_FONT_FLAG; + return (void *) stringAttributes; } diff --git a/Build/source/texk/web2c/xetexdir/XeTeX_pic.c b/Build/source/texk/web2c/xetexdir/XeTeX_pic.c index ff4266be280..92233654232 100644 --- a/Build/source/texk/web2c/xetexdir/XeTeX_pic.c +++ b/Build/source/texk/web2c/xetexdir/XeTeX_pic.c @@ -33,7 +33,6 @@ authorization from the copyright holders. /* XeTeX_pic.c interface between xetex and graphics files - (not used on OS X -- we use ImageIO graphics importers instead) only needs to get image dimensions, not actually load/process the file */ @@ -110,7 +109,7 @@ find_pic_file(char** path, realrect* bounds, int pdfBoxType, int page) } goto done; } - + if (check_for_bmp(fp)) { struct bmp_info info; err = bmp_scan_file(&info, fp); @@ -120,7 +119,7 @@ find_pic_file(char** path, realrect* bounds, int pdfBoxType, int page) } goto done; } - + if (check_for_png(fp)) { struct png_info info; err = png_scan_file(&info, fp); @@ -129,10 +128,10 @@ find_pic_file(char** path, realrect* bounds, int pdfBoxType, int page) bounds->ht = (info.height * 72.27) / info.ydpi; } goto done; - } + } /* could support other file types here (TIFF, WMF, etc?) */ - + done: if (fp != NULL) fclose(fp); @@ -143,6 +142,6 @@ done: if (pic_path != NULL) free(pic_path); } - + return err; } diff --git a/Build/source/texk/web2c/xetexdir/am/xetex.am b/Build/source/texk/web2c/xetexdir/am/xetex.am index ef7683209c7..4bdc8b63e5c 100644 --- a/Build/source/texk/web2c/xetexdir/am/xetex.am +++ b/Build/source/texk/web2c/xetexdir/am/xetex.am @@ -26,9 +26,28 @@ xetex_cppflags += $(FREETYPE2_INCLUDES) xetex_cppflags += $(TECKIT_INCLUDES) xetex_cppflags += $(HARFBUZZ_INCLUDES) xetex_cppflags += $(GRAPHITE2_INCLUDES) -xetex_ldadd = $(libxetex) $(HARFBUZZ_LIBS) $(GRAPHITE2_LIBS) $(ICU_LIBS) $(TECKIT_LIBS) -xetex_dependencies = $(proglib) $(KPATHSEA_DEPEND) -xetex_dependencies += $(ICU_DEPEND) $(TECKIT_DEPEND) $(HARFBUZZ_DEPEND) $(GRAPHITE2_DEPEND) +xetex_cppflags += $(POPPLER_INCLUDES) +xetex_cppflags += $(LIBPNG_INCLUDES) +xetex_cppflags += $(ZLIB_INCLUDES) +xetex_ldadd = $(libxetex) +xetex_ldadd += $(HARFBUZZ_LIBS) +xetex_ldadd += $(GRAPHITE2_LIBS) +xetex_ldadd += $(ICU_LIBS) +xetex_ldadd += $(TECKIT_LIBS) +xetex_ldadd += $(POPPLER_LIBS) +xetex_ldadd += $(LIBPNG_LIBS) +xetex_ldadd += $(FREETYPE2_LIBS) +xetex_ldadd += $(ZLIB_LIBS) +xetex_dependencies = $(proglib) +xetex_dependencies += $(KPATHSEA_DEPEND) +xetex_dependencies += $(ICU_DEPEND) +xetex_dependencies += $(TECKIT_DEPEND) +xetex_dependencies += $(HARFBUZZ_DEPEND) +xetex_dependencies += $(GRAPHITE2_DEPEND) +xetex_dependencies += $(POPPLER_DEPEND) +xetex_dependencies += $(LIBPNG_DEPEND) +xetex_dependencies += $(FREETYPE2_DEPEND) +xetex_dependencies += $(ZLIB_DEPEND) if XETEX_MACOSX @@ -37,16 +56,11 @@ xetex_LDFLAGS = -framework ApplicationServices -framework Cocoa else !XETEX_MACOSX -xetex_cppflags += -DXETEX_OTHER -xetex_cppflags += $(POPPLER_INCLUDES) $(LIBPNG_INCLUDES) $(FONTCONFIG_INCLUDES) -xetex_ldadd += $(POPPLER_LIBS) $(LIBPNG_LIBS) $(FONTCONFIG_LIBS) -xetex_dependencies += $(POPPLER_DEPEND) $(LIBPNG_DEPEND) +xetex_cppflags += $(FONTCONFIG_INCLUDES) +xetex_ldadd += $(FONTCONFIG_LIBS) endif !XETEX_MACOSX -xetex_cppflags += $(ZLIB_INCLUDES) -xetex_ldadd += $(FREETYPE2_LIBS) $(ZLIB_LIBS) -xetex_dependencies += $(FREETYPE2_DEPEND) $(ZLIB_DEPEND) xetex_CPPFLAGS = $(xetex_cppflags) xetex_CFLAGS = # $(WARNING_CFLAGS) @@ -107,8 +121,6 @@ EXTRA_DIST += $(xetex_web_srcs) $(xetex_ch_srcs) xetexdir/xetex.defines DISTCLEANFILES += $(nodist_xetex_SOURCES) xetex.web xetex.ch xetex-web2c \ xetex.p xetex.pool xetex-tangle -EXTRA_DIST += \ - xetexdir/unicode-char-prep.pl ## libxetex ## @@ -131,11 +143,24 @@ libxetex_a_SOURCES = \ xetexdir/XeTeXOTMath.h \ xetexdir/XeTeX_ext.c \ xetexdir/XeTeX_ext.h \ + xetexdir/XeTeX_pic.c \ xetexdir/XeTeXswap.h \ xetexdir/trans.c \ xetexdir/trans.h \ xetexdir/hz.cpp \ - xetexdir/xetex.h + xetexdir/xetex.h \ + xetexdir/pdfimage.cpp \ + xetexdir/pdfimage.h \ + xetexdir/image/bmpimage.c \ + xetexdir/image/bmpimage.h \ + xetexdir/image/jpegimage.c \ + xetexdir/image/jpegimage.h \ + xetexdir/image/mfileio.c \ + xetexdir/image/mfileio.h \ + xetexdir/image/numbers.c \ + xetexdir/image/numbers.h \ + xetexdir/image/pngimage.c \ + xetexdir/image/pngimage.h if XETEX_MACOSX @@ -150,20 +175,7 @@ else !XETEX_MACOSX libxetex_a_SOURCES += \ xetexdir/XeTeXFontMgr_FC.cpp \ - xetexdir/XeTeXFontMgr_FC.h \ - xetexdir/XeTeX_pic.c \ - xetexdir/pdfimage.cpp \ - xetexdir/pdfimage.h \ - xetexdir/image/bmpimage.c \ - xetexdir/image/bmpimage.h \ - xetexdir/image/jpegimage.c \ - xetexdir/image/jpegimage.h \ - xetexdir/image/mfileio.c \ - xetexdir/image/mfileio.h \ - xetexdir/image/numbers.c \ - xetexdir/image/numbers.h \ - xetexdir/image/pngimage.c \ - xetexdir/image/pngimage.h + xetexdir/XeTeXFontMgr_FC.h endif !XETEX_MACOSX @@ -171,7 +183,6 @@ endif !XETEX_MACOSX libxetex_prereq = xetexd.h $(xetex_dependencies) $(libxetex_a_OBJECTS): $(libxetex_prereq) -EXTRA_DIST += xetexdir/ChangeLog # XeTeX Tests # @@ -183,9 +194,9 @@ if XETEX TESTS += $(xetex_tests) endif XETEX -## Not used -## EXTRA_DIST += \ + xetexdir/unicode-char-prep.pl \ + xetexdir/ChangeLog \ xetexdir/COPYING \ xetexdir/NEWS \ xetexdir/image/README \ diff --git a/Build/source/texk/web2c/xetexdir/pdfimage.cpp b/Build/source/texk/web2c/xetexdir/pdfimage.cpp index fac84953c5f..a9ccbd02e77 100644 --- a/Build/source/texk/web2c/xetexdir/pdfimage.cpp +++ b/Build/source/texk/web2c/xetexdir/pdfimage.cpp @@ -61,19 +61,19 @@ pdf_get_rect(char* filename, int page_num, int pdf_box, realrect* box) { GooString* name = new GooString(filename); PDFDoc* doc = new PDFDoc(name); - + if (!doc) { delete name; return -1; } - + /* if the doc got created, it now owns name, so we mustn't delete it! */ - + if (!doc->isOk()) { delete doc; return -1; } - + int pages = doc->getNumPages(); if (page_num > pages) page_num = pages; @@ -120,14 +120,14 @@ pdf_count_pages(char* filename) int pages = 0; GooString* name = new GooString(filename); PDFDoc* doc = new PDFDoc(name); - + if (!doc) { delete name; return 0; } - + /* if the doc got created, it now owns name, so we mustn't delete it! */ - + if (doc->isOk()) pages = doc->getNumPages(); diff --git a/Build/source/texk/web2c/xetexdir/xetex.ch b/Build/source/texk/web2c/xetexdir/xetex.ch index 304a3831307..1c389489fc9 100644 --- a/Build/source/texk/web2c/xetexdir/xetex.ch +++ b/Build/source/texk/web2c/xetexdir/xetex.ch @@ -277,7 +277,7 @@ if #<>0 then begin if #<>0 then begin j:=str_start_macro(#); while ((not must_quote) or (quote_char=0)) and (j<str_start_macro(#+1)) do begin - if (str_pool[j]=" ") then must_quote:=true + if str_pool[j]=" " then must_quote:=true else if (str_pool[j]="""") or (str_pool[j]="'") then begin must_quote:=true; quote_char:="""" + "'" - str_pool[j]; @@ -773,7 +773,7 @@ var i,@!j,@!k:integer; {all-purpose integers} @x [53a.1379] l.??? -etex command line switch incr(loc); eTeX_mode:=1; {enter extended mode} @y - if (buffer[loc]="*") then incr(loc); + if buffer[loc]="*" then incr(loc); eTeX_mode:=1; {enter extended mode} @z diff --git a/Build/source/texk/web2c/xetexdir/xetex.h b/Build/source/texk/web2c/xetexdir/xetex.h index 73d8f95502d..bcd5d0cfed8 100644 --- a/Build/source/texk/web2c/xetexdir/xetex.h +++ b/Build/source/texk/web2c/xetexdir/xetex.h @@ -32,11 +32,11 @@ authorization from the copyright holders. /* additional declarations we want to slip in for xetex */ -#define native_node_size 6 -#define native_node_text(p) ((unsigned short*)(&(mem[(p) + native_node_size]))) +#define native_node_size 6 +#define native_node_text(p) ((unsigned short*)(&(mem[(p) + native_node_size]))) -#define getnativechar(p,i) native_node_text(p)[i] -#define setnativechar(p,i,v) native_node_text(p)[i] = v +#define getnativechar(p,i) native_node_text(p)[i] +#define setnativechar(p,i,v) native_node_text(p)[i] = v #define getnativeusv(p,i) \ ((native_node_text(p)[i] >= 0xd800 && native_node_text(p)[i] < 0xdc00) ? \ @@ -44,84 +44,84 @@ authorization from the copyright holders. native_node_text(p)[i]) /* p is native_word node; g is XeTeX_use_glyph_metrics flag */ -#define setnativemetrics(p,g) measure_native_node(&(mem[p]), g) +#define setnativemetrics(p,g) measure_native_node(&(mem[p]), g) -#define setnativeglyphmetrics(p,g) measure_native_glyph(&(mem[p]), g) +#define setnativeglyphmetrics(p,g) measure_native_glyph(&(mem[p]), g) -#define setjustifiednativeglyphs(p) store_justified_native_glyphs(&(mem[p])) +#define setjustifiednativeglyphs(p) store_justified_native_glyphs(&(mem[p])) -#define getnativeitaliccorrection(p) get_native_italic_correction(&(mem[p])) -#define getnativeglyphitaliccorrection(p) get_native_glyph_italic_correction(&(mem[p])) +#define getnativeitaliccorrection(p) get_native_italic_correction(&(mem[p])) +#define getnativeglyphitaliccorrection(p) get_native_glyph_italic_correction(&(mem[p])) -#define getnativeglyph(p,i) get_native_glyph(&(mem[p]), i) +#define getnativeglyph(p,i) get_native_glyph(&(mem[p]), i) -#define makexdvglypharraydata(p) makeXDVGlyphArrayData(&(mem[p])) -#define xdvbufferbyte(i) xdvbuffer[i] +#define makexdvglypharraydata(p) makeXDVGlyphArrayData(&(mem[p])) +#define xdvbufferbyte(i) xdvbuffer[i] -#define getcpcode get_cp_code -#define setcpcode set_cp_code -#define getnativewordcp(p,s) get_native_word_cp(&(mem[p]), s) +#define getcpcode get_cp_code +#define setcpcode set_cp_code +#define getnativewordcp(p,s) get_native_word_cp(&(mem[p]), s) -#define pic_node_size 8 +#define pic_node_size 8 -#define deref(p) (*(p)) +#define deref(p) (*(p)) -#define findpicfile(a,b,c,d) find_pic_file(a, b, c, d) +#define findpicfile(a,b,c,d) find_pic_file(a, b, c, d) -#define picpathbyte(p,i) ((unsigned char*)&(mem[p+pic_node_size]))[i] +#define picpathbyte(p,i) ((unsigned char*)&(mem[p+pic_node_size]))[i] -#define dviopenout(f) open_dvi_output(&(f)) +#define dviopenout(f) open_dvi_output(&(f)) -#define nullptr (NULL) -#define glyphinfobyte(p,k) ((unsigned char*)p)[k] -#define casttoushort(x) (unsigned short)(x) +#define nullptr (NULL) +#define glyphinfobyte(p,k) ((unsigned char*)p)[k] +#define casttoushort(x) (unsigned short)(x) /* easier to do the bit-twiddling here than in Pascal */ /* read fields from a 32-bit math code */ -#define mathfamfield(x) (((unsigned)(x) >> 24) & 0xFF) -#define mathclassfield(x) (((unsigned)(x) >> 21) & 0x07) -#define mathcharfield(x) ((unsigned)(x) & 0x1FFFFF) +#define mathfamfield(x) (((unsigned)(x) >> 24) & 0xFF) +#define mathclassfield(x) (((unsigned)(x) >> 21) & 0x07) +#define mathcharfield(x) ((unsigned)(x) & 0x1FFFFF) /* calculate pieces to assign to a math code */ -#define setfamilyfield(x) (((unsigned)(x) & 0xFF) << 24) -#define setclassfield(x) (((unsigned)(x) & 0x07) << 21) +#define setfamilyfield(x) (((unsigned)(x) & 0xFF) << 24) +#define setclassfield(x) (((unsigned)(x) & 0x07) << 21) /* aliases */ -#define getnativemathsyparam get_native_mathsy_param -#define getnativemathexparam get_native_mathex_param -#define getotmathconstant get_ot_math_constant -#define getotmathvariant get_ot_math_variant -#define getotassemblyptr get_ot_assembly_ptr -#define getotmathitalcorr get_ot_math_ital_corr -#define getotmathaccentpos get_ot_math_accent_pos -#define getotmathkern get_ot_math_kern -#define otpartcount ot_part_count -#define otpartglyph ot_part_glyph -#define otpartisextender ot_part_is_extender -#define otpartstartconnector ot_part_start_connector -#define otpartendconnector ot_part_end_connector -#define otpartfulladvance ot_part_full_advance -#define otminconnectoroverlap ot_min_connector_overlap +#define getnativemathsyparam get_native_mathsy_param +#define getnativemathexparam get_native_mathex_param +#define getotmathconstant get_ot_math_constant +#define getotmathvariant get_ot_math_variant +#define getotassemblyptr get_ot_assembly_ptr +#define getotmathitalcorr get_ot_math_ital_corr +#define getotmathaccentpos get_ot_math_accent_pos +#define getotmathkern get_ot_math_kern +#define otpartcount ot_part_count +#define otpartglyph ot_part_glyph +#define otpartisextender ot_part_is_extender +#define otpartstartconnector ot_part_start_connector +#define otpartendconnector ot_part_end_connector +#define otpartfulladvance ot_part_full_advance +#define otminconnectoroverlap ot_min_connector_overlap /* prototypes used in xetex.web */ #include "XeTeXOTMath.h" /* Unicode file reading modes */ -#define AUTO 0 /* default: will become one of 1..3 at file open time, after sniffing */ -#define UTF8 1 -#define UTF16BE 2 -#define UTF16LE 3 -#define RAW 4 -#define ICUMAPPING 5 +#define AUTO 0 /* default: will become one of 1..3 at file open time, after sniffing */ +#define UTF8 1 +#define UTF16BE 2 +#define UTF16LE 3 +#define RAW 4 +#define ICUMAPPING 5 #ifdef WIN32 -#define WIN32CONSOLE 6 +#define WIN32CONSOLE 6 #endif /* we don't use xchr, so change the cpascal.h definition of this... */ #undef Xchr -#define Xchr(x) (x) +#define Xchr(x) (x) -#include "trans.h" /* functions for affine transform operations */ -#include <teckit/TECkit_Common.h> /* include this before XeTeX_ext.h */ -#include "XeTeX_ext.h" /* other extension functions */ +#include "trans.h" /* functions for affine transform operations */ +#include <teckit/TECkit_Common.h> /* include this before XeTeX_ext.h */ +#include "XeTeX_ext.h" /* other extension functions */ #include <math.h> /* apparently M_PI isn't defined by <math.h> under VC++ */ diff --git a/Build/source/texk/web2c/xetexdir/xetex.web b/Build/source/texk/web2c/xetexdir/xetex.web index 63dec34b229..9ad16b235a9 100644 --- a/Build/source/texk/web2c/xetexdir/xetex.web +++ b/Build/source/texk/web2c/xetexdir/xetex.web @@ -324,8 +324,8 @@ known as `\eTeX'. @d eTeX_version_string=='-2.6' {current \eTeX\ version} @# @d XeTeX_version=0 { \.{\\XeTeXversion} } -@d XeTeX_revision==".9999" { \.{\\XeTeXrevision} } -@d XeTeX_version_string=='-0.9999.3' {current \XeTeX\ version} +@d XeTeX_revision==".99991" { \.{\\XeTeXrevision} } +@d XeTeX_version_string=='-0.99991' {current \XeTeX\ version} @# @d XeTeX_banner=='This is XeTeX, Version 3.14159265',eTeX_version_string,XeTeX_version_string {printed when \XeTeX\ starts} @@ -1676,49 +1676,49 @@ label exit; var l: small_number; begin if (selector>pseudo) and (not doing_special) then {``printing'' to a new string, encode as UTF-16 rather than UTF-8} - begin if s>=@"10000 then begin - print_visible_char(@"D800 + (s - @"10000) div @"400); - print_visible_char(@"DC00 + (s - @"10000) mod @"400); - end else print_visible_char(s); - return; + begin if s>=@"10000 then + begin print_visible_char(@"D800 + (s - @"10000) div @"400); + print_visible_char(@"DC00 + (s - @"10000) mod @"400); + end else print_visible_char(s); + return; end; if @<Character |s| is the current new-line character@> then if selector<pseudo then begin print_ln; return; end; -if (s < 32) and (eight_bit_p = 0) and (not doing_special) then {control char: \.{\^\^X}} - begin - print_visible_char("^"); print_visible_char("^"); print_visible_char(s+64); -end else if s < 127 then - { printable ASCII } - print_visible_char(s) -else if (s = 127) then begin - { DEL } - if (eight_bit_p = 0) and (not doing_special) then begin - print_visible_char("^"); print_visible_char("^"); print_visible_char("?") - end else - print_visible_char(s) -end else if (s < @"A0) and (eight_bit_p = 0) and (not doing_special) then {C1 controls: \.{\^\^xx}} - begin - print_visible_char("^"); print_visible_char("^"); - print_lc_hex((s mod @"100) div @"10); print_lc_hex(s mod @"10); -end else begin - { |char >= 128|: encode as UTF8 } - if s<@"800 then begin - print_raw_char(@"C0 + s div @"40, false); - print_raw_char(@"80 + s mod @"40, true); - end - else if s<@"10000 then begin - print_raw_char(@"E0 + (s div @"1000), false); - print_raw_char(@"80 + (s mod @"1000) div @"40, false); - print_raw_char(@"80 + (s mod @"40), true); - end else begin - print_raw_char(@"F0 + (s div @"40000), false); - print_raw_char(@"80 + (s mod @"40000) div @"1000, false); - print_raw_char(@"80 + (s mod @"1000) div @"40, false); - print_raw_char(@"80 + (s mod @"40), true); - end -end; + if (s < 32) and (eight_bit_p = 0) and (not doing_special) then {control char: \.{\^\^X}} + begin print_visible_char("^"); print_visible_char("^"); print_visible_char(s+64); + end + else if s<127 then { printable ASCII } + print_visible_char(s) + else if s=127 then { DEL } + begin if (eight_bit_p = 0) and (not doing_special) then + begin print_visible_char("^"); print_visible_char("^"); print_visible_char("?") + end else + print_visible_char(s) + end + else if (s < @"A0) and (eight_bit_p = 0) and (not doing_special) then {C1 controls: \.{\^\^xx}} + begin print_visible_char("^"); print_visible_char("^"); + print_lc_hex((s mod @"100) div @"10); print_lc_hex(s mod @"10); + end + else begin + { |char >= 128|: encode as UTF8 } + if s<@"800 then begin + print_raw_char(@"C0 + s div @"40, false); + print_raw_char(@"80 + s mod @"40, true); + end + else if s<@"10000 then begin + print_raw_char(@"E0 + (s div @"1000), false); + print_raw_char(@"80 + (s mod @"1000) div @"40, false); + print_raw_char(@"80 + (s mod @"40), true); + end + else begin + print_raw_char(@"F0 + (s div @"40000), false); + print_raw_char(@"80 + (s mod @"40000) div @"1000, false); + print_raw_char(@"80 + (s mod @"1000) div @"40, false); + print_raw_char(@"80 + (s mod @"40), true); + end + end; exit:end; @ @d native_room(#)==while native_text_size <= native_len+# do begin @@ -1759,7 +1759,7 @@ else if s<biggest_char then else begin if selector>pseudo then begin print_char(s); return; {internal strings are not expanded} end; - if (@<Character |s| is the current new-line character@>) then + if @<Character |s| is the current new-line character@> then if selector<pseudo then begin print_ln; return; end; @@ -2904,7 +2904,7 @@ of its other fields and its other words. when |max_halfword| appears in the |link| field of a nonempty node.) @d empty_flag == max_halfword {the |link| of an empty variable-size node} -@d is_empty(#) == (link(#)=empty_flag) {tests for empty node} +@d is_empty(#) == link(#)=empty_flag {tests for empty node} @d node_size == info {the size field in empty variable-size nodes} @d llink(#) == info(#+1) {left link in doubly-linked list of empty nodes} @d rlink(#) == link(#+1) {right link in doubly-linked list of empty nodes} @@ -3171,7 +3171,7 @@ an hlist; the |height| and |depth| are never running in a~vlist. @d rule_node=2 {|type| of rule nodes} @d rule_node_size=4 {number of words to allocate for a rule node} @d null_flag==-@'10000000000 {$-2^{30}$, signifies a missing item} -@d is_running(#) == (#=null_flag) {tests for a running dimension} +@d is_running(#) == #=null_flag {tests for a running dimension} @ A new rule node is delivered by the |new_rule| function. It makes all the dimensions ``running,'' so you have to change the @@ -3973,13 +3973,13 @@ whatsit_node: case subtype(p) of native_word_node: begin if native_font(p)<>font_in_short_display then begin - print_esc(font_id_text(native_font(p))); - print_char(" "); - font_in_short_display:=native_font(p); - end; - print_native_word(p); - end; - othercases print("[]") + print_esc(font_id_text(native_font(p))); + print_char(" "); + font_in_short_display:=native_font(p); + end; + print_native_word(p); + end; + othercases print("[]") endcases; rule_node: print_char("|"); glue_node: if glue_ptr(p)<>zero_glue then print_char(" "); @@ -6064,7 +6064,7 @@ A global boolean variable called |no_new_control_sequence| is set to @d next(#) == hash[#].lh {link for coalesced lists} @d text(#) == hash[#].rh {string number for control sequence name} -@d hash_is_full == (hash_used=hash_base) {test if all positions are occupied} +@d hash_is_full == hash_used=hash_base {test if all positions are occupied} @d font_id_text(#) == text(font_id_base+#) {a frozen font identifier's name} @<Glob...@>= @@ -6081,7 +6081,7 @@ A global boolean variable called |no_new_control_sequence| is set to @d prim_base=1 @d prim_next(#) == prim[#].lh {link for coalesced lists} @d prim_text(#) == prim[#].rh {string number for control sequence name} -@d prim_is_full == (prim_used=prim_base) {test if all positions are occupied} +@d prim_is_full == prim_used=prim_base {test if all positions are occupied} @d prim_eq_level_field(#)==#.hh.b1 @d prim_eq_type_field(#)==#.hh.b0 @d prim_equiv_field(#)==#.hh.rh @@ -6710,7 +6710,7 @@ the call, since |eq_save| makes the necessary test. @p procedure eq_define(@!p:pointer;@!t:quarterword;@!e:halfword); {new data for |eqtb|} label exit; -begin if eTeX_ex and(eq_type(p)=t)and(equiv(p)=e) then +begin if (eTeX_ex)and(eq_type(p)=t)and(equiv(p)=e) then begin assign_trace(p,"reassigning")@;@/ eq_destroy(eqtb[p]); return; end; @@ -6727,7 +6727,7 @@ exit:end; @p procedure eq_word_define(@!p:pointer;@!w:integer); label exit; -begin if eTeX_ex and(eqtb[p].int=w) then +begin if (eTeX_ex)and(eqtb[p].int=w) then begin assign_trace(p,"reassigning")@;@/ return; end; @@ -7330,7 +7330,7 @@ put into a variable |@!page|, maintained for enclosing levels in by analogy with |line_stack|. @^system dependencies@> -@d terminal_input==(name=0) {are we reading from the terminal?} +@d terminal_input==name=0 {are we reading from the terminal?} @d cur_file==input_file[index] {the current |alpha_file| variable} @<Glob...@>= @@ -7558,7 +7558,7 @@ begin base_ptr:=input_ptr; input_stack[base_ptr]:=cur_input; {store current state} nn:=-1; bottom_line:=false; loop@+begin cur_input:=input_stack[base_ptr]; {enter into the context} - if (state<>token_list) then + if state<>token_list then if (name>19) or (base_ptr=0) then bottom_line:=true; if (base_ptr=input_ptr)or bottom_line or(nn<error_context_lines) then @<Display the current context@> @@ -7882,7 +7882,7 @@ inserted `\.{\\show}' commands, the following routine removes completed error-inserted lines from memory. @p procedure clear_for_error_prompt; -begin while (state<>token_list)and terminal_input and@| +begin while (state<>token_list)and(terminal_input)and@| (input_ptr>0)and(loc>limit) do end_file_reading; print_ln; clear_terminal; end; @@ -8381,7 +8381,7 @@ There is one more branch. @<Move to next line of file, or |goto restart|...@>= if name>17 then @<Read next line of file into |buffer|, or |goto restart| if the file has ended@> -else begin if not terminal_input then {\.{\\read} line has ended} +else begin if not (terminal_input) then {\.{\\read} line has ended} begin cur_cmd:=0; cur_chr:=0; return; end; if input_ptr>0 then {text was inserted during error recovery} @@ -12062,14 +12062,14 @@ the font. @d otgr_font_flag=@"FFFE @d aat_font_flag=@"FFFF -@d is_aat_font(#)==(font_area[#]=aat_font_flag) -@d is_ot_font(#)==((font_area[#]=otgr_font_flag) and (usingOpenType(font_layout_engine[#]))) -@d is_gr_font(#)==((font_area[#]=otgr_font_flag) and (usingGraphite(font_layout_engine[#]))) -@d is_otgr_font(#)==(font_area[#]=otgr_font_flag) -@d is_native_font(#)==(is_aat_font(#) or is_otgr_font(#)) - {native fonts have |font_area| = 65534 or 65535, - which would be a string containing an invalid Unicode character} -@d is_new_mathfont(#)==((font_area[#]=otgr_font_flag) and (isOpenTypeMathFont(font_layout_engine[#]))) +@d is_aat_font(#)==font_area[#]=aat_font_flag +@d is_otgr_font(#)==font_area[#]=otgr_font_flag +@d is_ot_font(#)==usingOpenType(#) +@d is_gr_font(#)==usingGraphite(#) +@d is_native_font(#)==(is_aat_font(#)) or (is_otgr_font(#)) + {native fonts have |font_area| = 65534 or 65535, + which would be a string containing an invalid Unicode character} +@d is_new_mathfont(#)==isOpenTypeMathFont(#) @d non_char==qi(too_big_char) {a |halfword| code that can't match a real character} @d non_address=0 {a spurious |bchar_label|} @@ -12712,7 +12712,7 @@ procedure char_warning(@!f:internal_font_number;@!c:integer); var old_setting: integer; {saved value of |tracing_online|} begin if tracing_lost_chars>0 then begin old_setting:=tracing_online; - if eTeX_ex and(tracing_lost_chars>1) then tracing_online:=1; + if (eTeX_ex) and(tracing_lost_chars>1) then tracing_online:=1; begin begin_diagnostic; print_nl("Missing character: There is no "); @.Missing character@> @@ -13059,11 +13059,11 @@ file. Parameters |i|, |num|, |den|, |mag|, |k|, and |x| are explained below. \yskip\hang|post_post| 249. Ending of the postamble, see below. \yskip\hang|pic_file| 251 |flags[1]| |t[4][6]| |p[2]| |len[2]| |path[l]|. - |flags=0| for raster image, and |1| for \.{PDF}. - |t| is transform matrix. - |p| is page number from the graphic file (0-based). - |len| is length of pathname. - |path| is pathname of graphic file. + |flags=0| for raster image, and |1| for \.{PDF}. + |t| is transform matrix. + |p| is page number from the graphic file (0-based). + |len| is length of pathname. + |path| is pathname of graphic file. \yskip\hang\vbox{\halign{#&#\hfil\cr |define_native_font| 252 & |k[4]| |s[4]| |flags[2]| |lenps[1]| |lenfam[1]| |lensty[1]| |ps[lenps]| |fam[lenfam]| |sty[lensty]|\cr @@ -13116,11 +13116,11 @@ produced by \XeTeX. p\TeX\ uses 255. @ The preamble contains basic information about the file as a whole. As stated above, there are six parameters: $$\hbox{|@!i[1]| |@!num[4]| |@!den[4]| |@!mag[4]| |@!k[1]| |@!x[k]|.}$$ -The |i| byte identifies \.{DVI} format; currently this byte is always set -to~2. (The value |i=3| is currently used for an extended format that -allows a mixture of right-to-left and left-to-right typesetting. -Some day we will set |i=4|, when \.{DVI} format makes another -incompatible change---perhaps in the year 2048.) +The |i| byte identifies \.{DVI} format; in \XeTeX\ this byte is set to~5, as we +have new \.{DVI} opcodes, while in \TeX82 it is always set to~2. (The value +|i=3| is used for an extended format that allows a mixture of right-to-left and +left-to-right typesetting. Prre-1.0 \XeTeX\ releases using Mac~OS~X-specific +data types used |i=4|.) The next two parameters, |num| and |den|, are positive integers that define the units of measurement; they are the numerator and denominator of a @@ -13143,11 +13143,6 @@ users to override the |mag|~setting when a \.{DVI} file is being printed.) Finally, |k| and |x| allow the \.{DVI} writer to include a comment, which is not interpreted further. The length of comment |x| is |k|, where |0<=k<256|. -XeTeX changes the DVI version to 5, -as we have new DVI opcodes like |set_glyph_array| for native font text; -I used version 3 in an earlier extension of TeX, -and 4 in pre-1.0 XeTeX releases using Mac OS-specific data types. - @d id_byte=5 {identifies the kind of \.{DVI} files described here} @ Font definitions for a given font number |k| contain further parameters @@ -13418,8 +13413,8 @@ end; procedure dvi_two(s: UTF16_code); begin - dvi_out(s div @'400); - dvi_out(s mod @'400); + dvi_out(s div @'400); + dvi_out(s mod @'400); end; @ A mild optimization of the output is performed by the |dvi_pop| @@ -13437,12 +13432,12 @@ most 256 different fonts per job, |fnt_def1| is always used as the command code. @p procedure dvi_native_font_def(@!f:internal_font_number); var - font_def_length, i: integer; + font_def_length, i: integer; begin - dvi_out(define_native_font); - dvi_four(f-font_base-1); - font_def_length := make_font_def(f); - for i := 0 to font_def_length - 1 do dvi_out(xdv_buffer[i]); + dvi_out(define_native_font); + dvi_four(f-font_base-1); + font_def_length := make_font_def(f); + for i := 0 to font_def_length - 1 do dvi_out(xdv_buffer[i]); end; procedure dvi_font_def(@!f:internal_font_number); @@ -15588,65 +15583,65 @@ macro capabilities. This seems a bit ugly, but it works. @d total_mathsy_params=22 {the following are OpenType MATH constant indices for use with OT math fonts} -@d scriptPercentScaleDown = 0 -@d scriptScriptPercentScaleDown = 1 -@d delimitedSubFormulaMinHeight = 2 -@d displayOperatorMinHeight = 3 -@d mathLeading = 4 -@d firstMathValueRecord = mathLeading -@d axisHeight = 5 -@d accentBaseHeight = 6 -@d flattenedAccentBaseHeight = 7 -@d subscriptShiftDown = 8 -@d subscriptTopMax = 9 -@d subscriptBaselineDropMin = 10 -@d superscriptShiftUp = 11 -@d superscriptShiftUpCramped = 12 -@d superscriptBottomMin = 13 -@d superscriptBaselineDropMax = 14 -@d subSuperscriptGapMin = 15 -@d superscriptBottomMaxWithSubscript = 16 -@d spaceAfterScript = 17 -@d upperLimitGapMin = 18 -@d upperLimitBaselineRiseMin = 19 -@d lowerLimitGapMin = 20 -@d lowerLimitBaselineDropMin = 21 -@d stackTopShiftUp = 22 -@d stackTopDisplayStyleShiftUp = 23 -@d stackBottomShiftDown = 24 -@d stackBottomDisplayStyleShiftDown = 25 -@d stackGapMin = 26 -@d stackDisplayStyleGapMin = 27 -@d stretchStackTopShiftUp = 28 -@d stretchStackBottomShiftDown = 29 -@d stretchStackGapAboveMin = 30 -@d stretchStackGapBelowMin = 31 -@d fractionNumeratorShiftUp = 32 -@d fractionNumeratorDisplayStyleShiftUp = 33 -@d fractionDenominatorShiftDown = 34 -@d fractionDenominatorDisplayStyleShiftDown = 35 -@d fractionNumeratorGapMin = 36 -@d fractionNumDisplayStyleGapMin = 37 -@d fractionRuleThickness = 38 -@d fractionDenominatorGapMin = 39 -@d fractionDenomDisplayStyleGapMin = 40 -@d skewedFractionHorizontalGap = 41 -@d skewedFractionVerticalGap = 42 -@d overbarVerticalGap = 43 -@d overbarRuleThickness = 44 -@d overbarExtraAscender = 45 -@d underbarVerticalGap = 46 -@d underbarRuleThickness = 47 -@d underbarExtraDescender = 48 -@d radicalVerticalGap = 49 -@d radicalDisplayStyleVerticalGap = 50 -@d radicalRuleThickness = 51 -@d radicalExtraAscender = 52 -@d radicalKernBeforeDegree = 53 -@d radicalKernAfterDegree = 54 -@d lastMathValueRecord = radicalKernAfterDegree -@d radicalDegreeBottomRaisePercent = 55 -@d lastMathConstant = radicalDegreeBottomRaisePercent +@d scriptPercentScaleDown = 0 +@d scriptScriptPercentScaleDown = 1 +@d delimitedSubFormulaMinHeight = 2 +@d displayOperatorMinHeight = 3 +@d mathLeading = 4 +@d firstMathValueRecord = mathLeading +@d axisHeight = 5 +@d accentBaseHeight = 6 +@d flattenedAccentBaseHeight = 7 +@d subscriptShiftDown = 8 +@d subscriptTopMax = 9 +@d subscriptBaselineDropMin = 10 +@d superscriptShiftUp = 11 +@d superscriptShiftUpCramped = 12 +@d superscriptBottomMin = 13 +@d superscriptBaselineDropMax = 14 +@d subSuperscriptGapMin = 15 +@d superscriptBottomMaxWithSubscript = 16 +@d spaceAfterScript = 17 +@d upperLimitGapMin = 18 +@d upperLimitBaselineRiseMin = 19 +@d lowerLimitGapMin = 20 +@d lowerLimitBaselineDropMin = 21 +@d stackTopShiftUp = 22 +@d stackTopDisplayStyleShiftUp = 23 +@d stackBottomShiftDown = 24 +@d stackBottomDisplayStyleShiftDown = 25 +@d stackGapMin = 26 +@d stackDisplayStyleGapMin = 27 +@d stretchStackTopShiftUp = 28 +@d stretchStackBottomShiftDown = 29 +@d stretchStackGapAboveMin = 30 +@d stretchStackGapBelowMin = 31 +@d fractionNumeratorShiftUp = 32 +@d fractionNumeratorDisplayStyleShiftUp = 33 +@d fractionDenominatorShiftDown = 34 +@d fractionDenominatorDisplayStyleShiftDown = 35 +@d fractionNumeratorGapMin = 36 +@d fractionNumDisplayStyleGapMin = 37 +@d fractionRuleThickness = 38 +@d fractionDenominatorGapMin = 39 +@d fractionDenomDisplayStyleGapMin = 40 +@d skewedFractionHorizontalGap = 41 +@d skewedFractionVerticalGap = 42 +@d overbarVerticalGap = 43 +@d overbarRuleThickness = 44 +@d overbarExtraAscender = 45 +@d underbarVerticalGap = 46 +@d underbarRuleThickness = 47 +@d underbarExtraDescender = 48 +@d radicalVerticalGap = 49 +@d radicalDisplayStyleVerticalGap = 50 +@d radicalRuleThickness = 51 +@d radicalExtraAscender = 52 +@d radicalKernBeforeDegree = 53 +@d radicalKernAfterDegree = 54 +@d lastMathValueRecord = radicalKernAfterDegree +@d radicalDegreeBottomRaisePercent = 55 +@d lastMathConstant = radicalDegreeBottomRaisePercent @d mathsy(#)==font_info[#+param_base[f]].sc @@ -15725,348 +15720,348 @@ call |set_native_metrics(node)| if that is required. @<Declare subroutines for |new_character|@>= function new_native_word_node(@!f:internal_font_number;@!n:integer):pointer; var - l: integer; - q: pointer; + l: integer; + q: pointer; begin - l := native_node_size + (n * sizeof(UTF16_code) + sizeof(memory_word) - 1) div sizeof(memory_word); + l := native_node_size + (n * sizeof(UTF16_code) + sizeof(memory_word) - 1) div sizeof(memory_word); - q := get_node(l); - type(q) := whatsit_node; - subtype(q) := native_word_node; + q := get_node(l); + type(q) := whatsit_node; + subtype(q) := native_word_node; - native_size(q) := l; - native_font(q) := f; - native_length(q) := n; + native_size(q) := l; + native_font(q) := f; + native_length(q) := n; - native_glyph_count(q) := 0; - native_glyph_info_ptr(q) := null_ptr; + native_glyph_count(q) := 0; + native_glyph_info_ptr(q) := null_ptr; - new_native_word_node := q; + new_native_word_node := q; end; function new_native_character(@!f:internal_font_number;@!c:UnicodeScalar):pointer; var - p: pointer; - i, len: integer; + p: pointer; + i, len: integer; begin - if font_mapping[f] <> 0 then begin - if c > @"FFFF then begin - str_room(2); - append_char((c - @"10000) div 1024 + @"D800); - append_char((c - @"10000) mod 1024 + @"DC00); - end - else begin - str_room(1); - append_char(c); - end; - len := apply_mapping(font_mapping[f], addressof(str_pool[str_start_macro(str_ptr)]), cur_length); - pool_ptr := str_start_macro(str_ptr); { flush the string, as we'll be using the mapped text instead } - - i := 0; - while i < len do begin - if (mapped_text[i] >= @"D800) and (mapped_text[i] < @"DC00) then begin - c := (mapped_text[i] - @"D800) * 1024 + mapped_text[i+1] - @"DC00 + @"10000; - if map_char_to_glyph(f, c) = 0 then begin - char_warning(f, c); - end; - i := i + 2; - end - else begin - if map_char_to_glyph(f, mapped_text[i]) = 0 then begin - char_warning(f, mapped_text[i]); - end; - i := i + 1; - end; - end; - - p := new_native_word_node(f, len); - for i := 0 to len-1 do begin - set_native_char(p, i, mapped_text[i]); - end - end - else begin - if tracing_lost_chars > 0 then - if map_char_to_glyph(f, c) = 0 then begin - char_warning(f, c); - end; - - p := get_node(native_node_size + 1); - type(p) := whatsit_node; - subtype(p) := native_word_node; - - native_size(p) := native_node_size + 1; - native_glyph_count(p) := 0; - native_glyph_info_ptr(p) := null_ptr; - native_font(p) := f; - - if c > @"FFFF then begin - native_length(p) := 2; - set_native_char(p, 0, (c - @"10000) div 1024 + @"D800); - set_native_char(p, 1, (c - @"10000) mod 1024 + @"DC00); - end - else begin - native_length(p) := 1; - set_native_char(p, 0, c); - end; - end; - - set_native_metrics(p, XeTeX_use_glyph_metrics); - - new_native_character := p; + if font_mapping[f] <> 0 then begin + if c > @"FFFF then begin + str_room(2); + append_char((c - @"10000) div 1024 + @"D800); + append_char((c - @"10000) mod 1024 + @"DC00); + end + else begin + str_room(1); + append_char(c); + end; + len := apply_mapping(font_mapping[f], addressof(str_pool[str_start_macro(str_ptr)]), cur_length); + pool_ptr := str_start_macro(str_ptr); { flush the string, as we'll be using the mapped text instead } + + i := 0; + while i < len do begin + if (mapped_text[i] >= @"D800) and (mapped_text[i] < @"DC00) then begin + c := (mapped_text[i] - @"D800) * 1024 + mapped_text[i+1] - @"DC00 + @"10000; + if map_char_to_glyph(f, c) = 0 then begin + char_warning(f, c); + end; + i := i + 2; + end + else begin + if map_char_to_glyph(f, mapped_text[i]) = 0 then begin + char_warning(f, mapped_text[i]); + end; + i := i + 1; + end; + end; + + p := new_native_word_node(f, len); + for i := 0 to len-1 do begin + set_native_char(p, i, mapped_text[i]); + end + end + else begin + if tracing_lost_chars > 0 then + if map_char_to_glyph(f, c) = 0 then begin + char_warning(f, c); + end; + + p := get_node(native_node_size + 1); + type(p) := whatsit_node; + subtype(p) := native_word_node; + + native_size(p) := native_node_size + 1; + native_glyph_count(p) := 0; + native_glyph_info_ptr(p) := null_ptr; + native_font(p) := f; + + if c > @"FFFF then begin + native_length(p) := 2; + set_native_char(p, 0, (c - @"10000) div 1024 + @"D800); + set_native_char(p, 1, (c - @"10000) mod 1024 + @"DC00); + end + else begin + native_length(p) := 1; + set_native_char(p, 0, c); + end; + end; + + set_native_metrics(p, XeTeX_use_glyph_metrics); + + new_native_character := p; end; procedure font_feature_warning(featureNameP:void_pointer; featLen:integer; - settingNameP:void_pointer; setLen:integer); + settingNameP:void_pointer; setLen:integer); var - i: integer; + i: integer; begin - begin_diagnostic; - print_nl("Unknown "); - if setLen > 0 then begin - print("selector `"); - print_utf8_str(settingNameP, setLen); - print("' for "); - end; - print("feature `"); - print_utf8_str(featureNameP, featLen); - print("' in font `"); - i := 1; - while ord(name_of_file[i]) <> 0 do begin - print_visible_char(name_of_file[i]); { this is already UTF-8 } - incr(i); - end; - print("'."); - end_diagnostic(false); + begin_diagnostic; + print_nl("Unknown "); + if setLen > 0 then begin + print("selector `"); + print_utf8_str(settingNameP, setLen); + print("' for "); + end; + print("feature `"); + print_utf8_str(featureNameP, featLen); + print("' in font `"); + i := 1; + while ord(name_of_file[i]) <> 0 do begin + print_visible_char(name_of_file[i]); { this is already UTF-8 } + incr(i); + end; + print("'."); + end_diagnostic(false); end; procedure font_mapping_warning(mappingNameP:void_pointer; - mappingNameLen:integer; - warningType:integer); { 0: just logging; 1: file not found; 2: can't load } + mappingNameLen:integer; + warningType:integer); { 0: just logging; 1: file not found; 2: can't load } var - i: integer; + i: integer; begin - begin_diagnostic; - if warningType=0 then print_nl("Loaded mapping `") - else print_nl("Font mapping `"); - print_utf8_str(mappingNameP, mappingNameLen); - print("' for font `"); - i := 1; - while ord(name_of_file[i]) <> 0 do begin - print_visible_char(name_of_file[i]); { this is already UTF-8 } - incr(i); - end; - case warningType of - 1: print("' not found."); - 2: begin print("' not usable;"); - print_nl("bad mapping file or incorrect mapping type."); - end; - othercases print("'.") - endcases; - end_diagnostic(false); + begin_diagnostic; + if warningType=0 then print_nl("Loaded mapping `") + else print_nl("Font mapping `"); + print_utf8_str(mappingNameP, mappingNameLen); + print("' for font `"); + i := 1; + while ord(name_of_file[i]) <> 0 do begin + print_visible_char(name_of_file[i]); { this is already UTF-8 } + incr(i); + end; + case warningType of + 1: print("' not found."); + 2: begin print("' not usable;"); + print_nl("bad mapping file or incorrect mapping type."); + end; + othercases print("'.") + endcases; + end_diagnostic(false); end; procedure graphite_warning; var - i: integer; + i: integer; begin - begin_diagnostic; - print_nl("Font `"); - i := 1; - while ord(name_of_file[i]) <> 0 do begin - print_visible_char(name_of_file[i]); { this is already UTF-8 } - incr(i); - end; - print("' does not support Graphite. Trying OpenType layout instead."); - end_diagnostic(false); + begin_diagnostic; + print_nl("Font `"); + i := 1; + while ord(name_of_file[i]) <> 0 do begin + print_visible_char(name_of_file[i]); { this is already UTF-8 } + incr(i); + end; + print("' does not support Graphite. Trying OpenType layout instead."); + end_diagnostic(false); end; function load_native_font(u: pointer; nom, aire:str_number; s: scaled): internal_font_number; label - done; + done; const - first_math_fontdimen = 10; + first_math_fontdimen = 10; var - k, num_font_dimens: integer; - font_engine: void_pointer; {really an CFDictionaryRef or XeTeXLayoutEngine} - actual_size: scaled; {|s| converted to real size, if it was negative} - p: pointer; {for temporary |native_char| node we'll create} - ascent, descent, font_slant, x_ht, cap_ht: scaled; - f: internal_font_number; - full_name: str_number; + k, num_font_dimens: integer; + font_engine: void_pointer; {really an CFDictionaryRef or XeTeXLayoutEngine} + actual_size: scaled; {|s| converted to real size, if it was negative} + p: pointer; {for temporary |native_char| node we'll create} + ascent, descent, font_slant, x_ht, cap_ht: scaled; + f: internal_font_number; + full_name: str_number; begin - { on entry here, the full name is packed into |name_of_file| in UTF8 form } - - load_native_font := null_font; - - font_engine := find_native_font(name_of_file + 1, s); - if font_engine = 0 then goto done; - - if s>=0 then - actual_size := s - else begin - if (s <> -1000) then - actual_size := xn_over_d(loaded_font_design_size,-s,1000) - else - actual_size := loaded_font_design_size; - end; - - { look again to see if the font is already loaded, now that we know its canonical name } - str_room(name_length); - for k := 1 to name_length do - append_char(name_of_file[k]); + { on entry here, the full name is packed into |name_of_file| in UTF8 form } + + load_native_font := null_font; + + font_engine := find_native_font(name_of_file + 1, s); + if font_engine = 0 then goto done; + + if s>=0 then + actual_size := s + else begin + if (s <> -1000) then + actual_size := xn_over_d(loaded_font_design_size,-s,1000) + else + actual_size := loaded_font_design_size; + end; + + { look again to see if the font is already loaded, now that we know its canonical name } + str_room(name_length); + for k := 1 to name_length do + append_char(name_of_file[k]); full_name := make_string; { not |slow_make_string| because we'll flush it if the font was already loaded } - for f:=font_base+1 to font_ptr do - if (font_area[f] = native_font_type_flag) and str_eq_str(font_name[f], full_name) and (font_size[f] = actual_size) then begin - release_font_engine(font_engine, native_font_type_flag); - flush_string; - load_native_font := f; - goto done; + for f:=font_base+1 to font_ptr do + if (font_area[f] = native_font_type_flag) and str_eq_str(font_name[f], full_name) and (font_size[f] = actual_size) then begin + release_font_engine(font_engine, native_font_type_flag); + flush_string; + load_native_font := f; + goto done; end; - if (native_font_type_flag = otgr_font_flag) and isOpenTypeMathFont(font_engine) then - num_font_dimens := first_math_fontdimen + lastMathConstant - else - num_font_dimens := 8; - - if (font_ptr = font_max) or (fmem_ptr + num_font_dimens > font_mem_size) then begin - @<Apologize for not loading the font, |goto done|@>; - end; - - { we've found a valid installed font, and have room } - incr(font_ptr); - font_area[font_ptr] := native_font_type_flag; { set by |find_native_font| to either |aat_font_flag| or |ot_font_flag| } - - { store the canonical name } - font_name[font_ptr] := full_name; - - font_check[font_ptr].b0 := 0; - font_check[font_ptr].b1 := 0; - font_check[font_ptr].b2 := 0; - font_check[font_ptr].b3 := 0; - font_glue[font_ptr] := null; - font_dsize[font_ptr] := loaded_font_design_size; - font_size[font_ptr] := actual_size; - - if (native_font_type_flag = aat_font_flag) then begin - aat_get_font_metrics(font_engine, addressof(ascent), addressof(descent), - addressof(x_ht), addressof(cap_ht), addressof(font_slant)) - end else begin - ot_get_font_metrics(font_engine, addressof(ascent), addressof(descent), - addressof(x_ht), addressof(cap_ht), addressof(font_slant)); - end; - - height_base[font_ptr] := ascent; - depth_base[font_ptr] := -descent; - - font_params[font_ptr] := num_font_dimens; {we add an extra \.{\\fontdimen8} |:= cap_height|; then OT math fonts have a bunch more} - font_bc[font_ptr] := 0; - font_ec[font_ptr] := 65535; - font_used[font_ptr] := false; - hyphen_char[font_ptr] := default_hyphen_char; - skew_char[font_ptr] := default_skew_char; - param_base[font_ptr] := fmem_ptr-1; - - font_layout_engine[font_ptr] := font_engine; - font_mapping[font_ptr] := 0; {don't use the mapping, if any, when measuring space here} - font_letter_space[font_ptr] := loaded_font_letter_space; + if (font_ptr = font_max) or (fmem_ptr + num_font_dimens > font_mem_size) then begin + @<Apologize for not loading the font, |goto done|@>; + end; + + { we've found a valid installed font, and have room } + incr(font_ptr); + font_area[font_ptr] := native_font_type_flag; { set by |find_native_font| to either |aat_font_flag| or |ot_font_flag| } + + { store the canonical name } + font_name[font_ptr] := full_name; + + font_check[font_ptr].b0 := 0; + font_check[font_ptr].b1 := 0; + font_check[font_ptr].b2 := 0; + font_check[font_ptr].b3 := 0; + font_glue[font_ptr] := null; + font_dsize[font_ptr] := loaded_font_design_size; + font_size[font_ptr] := actual_size; + + if native_font_type_flag = aat_font_flag then begin + aat_get_font_metrics(font_engine, addressof(ascent), addressof(descent), + addressof(x_ht), addressof(cap_ht), addressof(font_slant)) + end else begin + ot_get_font_metrics(font_engine, addressof(ascent), addressof(descent), + addressof(x_ht), addressof(cap_ht), addressof(font_slant)); + end; + + height_base[font_ptr] := ascent; + depth_base[font_ptr] := -descent; + + font_layout_engine[font_ptr] := font_engine; + if isOpenTypeMathFont(font_ptr) then + num_font_dimens := first_math_fontdimen + lastMathConstant + else + num_font_dimens := 8; + + font_params[font_ptr] := num_font_dimens; {we add an extra \.{\\fontdimen8} |:= cap_height|; then OT math fonts have a bunch more} + font_bc[font_ptr] := 0; + font_ec[font_ptr] := 65535; + font_used[font_ptr] := false; + hyphen_char[font_ptr] := default_hyphen_char; + skew_char[font_ptr] := default_skew_char; + param_base[font_ptr] := fmem_ptr-1; + + font_mapping[font_ptr] := 0; {don't use the mapping, if any, when measuring space here} + font_letter_space[font_ptr] := loaded_font_letter_space; @# {measure the width of the space character and set up font parameters} - p := new_native_character(font_ptr, " "); - s := width(p) + loaded_font_letter_space; - free_node(p, native_size(p)); - - font_info[fmem_ptr].sc := font_slant; {|slant|} - incr(fmem_ptr); - font_info[fmem_ptr].sc := s; {|space| = width of space character} - incr(fmem_ptr); - font_info[fmem_ptr].sc := s div 2; {|space_stretch| = 1/2 * space} - incr(fmem_ptr); - font_info[fmem_ptr].sc := s div 3; {|space_shrink| = 1/3 * space} - incr(fmem_ptr); - font_info[fmem_ptr].sc := x_ht; {|x_height|} - incr(fmem_ptr); - font_info[fmem_ptr].sc := font_size[font_ptr]; {|quad| = font size} - incr(fmem_ptr); - font_info[fmem_ptr].sc := s div 3; {|extra_space| = 1/3 * space} - incr(fmem_ptr); - font_info[fmem_ptr].sc := cap_ht; {|cap_height|} - incr(fmem_ptr); - - if num_font_dimens = first_math_fontdimen + lastMathConstant then begin - font_info[fmem_ptr].int := num_font_dimens; { \.{\\fontdimen9} |:=| number of assigned fontdimens } - incr(fmem_ptr); - for k := 0 to lastMathConstant do begin - font_info[fmem_ptr].sc := get_ot_math_constant(font_ptr, k); - incr(fmem_ptr); - end; - end; - - font_mapping[font_ptr] := loaded_font_mapping; - font_flags[font_ptr] := loaded_font_flags; - - load_native_font := font_ptr; + p := new_native_character(font_ptr, " "); + s := width(p) + loaded_font_letter_space; + free_node(p, native_size(p)); + + font_info[fmem_ptr].sc := font_slant; {|slant|} + incr(fmem_ptr); + font_info[fmem_ptr].sc := s; {|space| = width of space character} + incr(fmem_ptr); + font_info[fmem_ptr].sc := s div 2; {|space_stretch| = 1/2 * space} + incr(fmem_ptr); + font_info[fmem_ptr].sc := s div 3; {|space_shrink| = 1/3 * space} + incr(fmem_ptr); + font_info[fmem_ptr].sc := x_ht; {|x_height|} + incr(fmem_ptr); + font_info[fmem_ptr].sc := font_size[font_ptr]; {|quad| = font size} + incr(fmem_ptr); + font_info[fmem_ptr].sc := s div 3; {|extra_space| = 1/3 * space} + incr(fmem_ptr); + font_info[fmem_ptr].sc := cap_ht; {|cap_height|} + incr(fmem_ptr); + + if num_font_dimens = first_math_fontdimen + lastMathConstant then begin + font_info[fmem_ptr].int := num_font_dimens; { \.{\\fontdimen9} |:=| number of assigned fontdimens } + incr(fmem_ptr); + for k := 0 to lastMathConstant do begin + font_info[fmem_ptr].sc := get_ot_math_constant(font_ptr, k); + incr(fmem_ptr); + end; + end; + + font_mapping[font_ptr] := loaded_font_mapping; + font_flags[font_ptr] := loaded_font_flags; + + load_native_font := font_ptr; done: end; procedure do_locale_linebreaks(s: integer; len: integer); var - offs, prevOffs, i: integer; - use_penalty, use_skip: boolean; + offs, prevOffs, i: integer; + use_penalty, use_skip: boolean; begin - if (XeTeX_linebreak_locale = 0) or (len = 1) then begin - link(tail) := new_native_word_node(main_f, len); - tail := link(tail); - for i := 0 to len - 1 do - set_native_char(tail, i, native_text[s + i]); - set_native_metrics(tail, XeTeX_use_glyph_metrics); - end else begin - use_skip := XeTeX_linebreak_skip <> zero_glue; - use_penalty := XeTeX_linebreak_penalty <> 0 or not use_skip; - linebreak_start(main_f, XeTeX_linebreak_locale, native_text + s, len); - offs := 0; - repeat - prevOffs := offs; - offs := linebreak_next; - if offs > 0 then begin - if prevOffs <> 0 then begin - if use_penalty then - tail_append(new_penalty(XeTeX_linebreak_penalty)); - if use_skip then - tail_append(new_param_glue(XeTeX_linebreak_skip_code)); - end; - link(tail) := new_native_word_node(main_f, offs - prevOffs); - tail := link(tail); - for i := prevOffs to offs - 1 do - set_native_char(tail, i - prevOffs, native_text[s + i]); - set_native_metrics(tail, XeTeX_use_glyph_metrics); - end; - until offs < 0; - end + if (XeTeX_linebreak_locale = 0) or (len = 1) then begin + link(tail) := new_native_word_node(main_f, len); + tail := link(tail); + for i := 0 to len - 1 do + set_native_char(tail, i, native_text[s + i]); + set_native_metrics(tail, XeTeX_use_glyph_metrics); + end else begin + use_skip := XeTeX_linebreak_skip <> zero_glue; + use_penalty := XeTeX_linebreak_penalty <> 0 or not use_skip; + linebreak_start(main_f, XeTeX_linebreak_locale, native_text + s, len); + offs := 0; + repeat + prevOffs := offs; + offs := linebreak_next; + if offs > 0 then begin + if prevOffs <> 0 then begin + if use_penalty then + tail_append(new_penalty(XeTeX_linebreak_penalty)); + if use_skip then + tail_append(new_param_glue(XeTeX_linebreak_skip_code)); + end; + link(tail) := new_native_word_node(main_f, offs - prevOffs); + tail := link(tail); + for i := prevOffs to offs - 1 do + set_native_char(tail, i - prevOffs, native_text[s + i]); + set_native_metrics(tail, XeTeX_use_glyph_metrics); + end; + until offs < 0; + end end; procedure bad_utf8_warning; begin - begin_diagnostic; - print_nl("Invalid UTF-8 byte or sequence"); - if terminal_input then print(" in terminal input") - else begin - print(" at line "); - print_int(line); - end; - print(" replaced by U+FFFD."); - end_diagnostic(false); + begin_diagnostic; + print_nl("Invalid UTF-8 byte or sequence"); + if terminal_input then print(" in terminal input") + else begin + print(" at line "); + print_int(line); + end; + print(" replaced by U+FFFD."); + end_diagnostic(false); end; function get_input_normalization_state: integer; begin - if eqtb=nil then get_input_normalization_state:=0 { may be called before eqtb is initialized } - else get_input_normalization_state:=XeTeX_input_normalization_state; + if eqtb=nil then get_input_normalization_state:=0 { may be called before eqtb is initialized } + else get_input_normalization_state:=XeTeX_input_normalization_state; end; function get_tracing_fonts_state: integer; begin - get_tracing_fonts_state:=XeTeX_tracing_fonts_state; + get_tracing_fonts_state:=XeTeX_tracing_fonts_state; end; @ We also need to compute the change in style between mlists and their @@ -16939,13 +16934,13 @@ var @!q,@!r:pointer; @!s,@!g:scaled; begin - if (math_type(nucleus(p))=math_char) then begin + if math_type(nucleus(p))=math_char then begin fetch(nucleus(p)); q:=new_native_character(cur_f, qo(cur_c)); g:=get_native_glyph(q, 0); s:=get_ot_math_accent_pos(cur_f, g); end else begin - if (math_type(nucleus(p))=sub_mlist) then begin + if math_type(nucleus(p))=sub_mlist then begin r:=info(nucleus(p)); if (r<>null) and (type(r)=accent_noad) then s:=compute_ot_math_accent_pos(r) @@ -17461,7 +17456,7 @@ if is_native_font(cur_f) then begin set_native_glyph_metrics(p, 1); free_node(z, native_size(z)); delta:=get_ot_math_ital_corr(cur_f, native_glyph(p)); - if (math_type(nucleus(q))=math_text_char)and(not is_new_mathfont(cur_f)<>0) then + if (math_type(nucleus(q))=math_text_char)and(not (is_new_mathfont(cur_f))<>0) then delta:=0; {no italic correction in mid-word of text font} if (math_type(subscr(q))=empty)and(delta<>0) then begin link(p):=new_kern(delta); delta:=0; @@ -17500,12 +17495,13 @@ end; procedure make_scripts(@!q:pointer;@!delta:scaled); var p,@!x,@!y,@!z:pointer; {temporary registers for box construction} @!shift_up,@!shift_down,@!clr,@!sub_kern,@!sup_kern:scaled; {dimensions in the calculation} -@!g:quarterword; {temporary register for native glyph id} +@!script_c:pointer; {temprary native character for sub/superscript} +@!script_g:quarterword; {temporary register for sub/superscript native glyph id} +@!script_f:internal_font_number; {temporary register for sub/superscript font} @!t:integer; {subsidiary size code} @!save_f:internal_font_number; -@!s:pointer; {temprary native character for sub/superscript} begin p:=new_hlist(q); -s:=null; sup_kern:=0; sub_kern:=0; g:=0; +script_c:=null; script_g:=0; script_f:=0; sup_kern:=0; sub_kern:=0; if is_char_node(p) or is_glyph_node(p) then begin shift_up:=0; shift_down:=0; end @@ -17615,33 +17611,43 @@ The following definitions should be kept in sync with \.{XeTeXOTMath.cpp}. @d sub_cmd=1 {subscript kern type for |get_ot_math_kern|} @<Attach subscript OpenType math kerning@>= -begin save_f:=cur_f;@/ -fetch(subscr(q)); -if is_new_mathfont(cur_f) then begin - s:=new_native_character(cur_f, qo(cur_c)); - g:=get_native_glyph(s, 0); +begin if math_type(subscr(q))=math_char then + begin save_f:=cur_f; + fetch(subscr(q)); + if is_new_mathfont(cur_f) then + begin script_c:=new_native_character(cur_f, qo(cur_c)); + script_g:=get_native_glyph(script_c, 0); + script_f:=cur_f; + end else + begin script_g:=0; script_f:=0 + end; + cur_f:=save_f; end; if is_glyph_node(p) then - sub_kern:=get_ot_math_kern(native_font(p), native_glyph(p), cur_f, g, sub_cmd, shift_down); + sub_kern:=get_ot_math_kern(native_font(p), native_glyph(p), script_f, script_g, sub_cmd, shift_down); if sub_kern<>0 then p:=attach_hkern_to_new_hlist(q, sub_kern); -cur_f:=save_f; end; @ @<Attach superscript OpenType math kerning@>= -begin save_f:=cur_f;@/ -fetch(supscr(q)); -if is_new_mathfont(cur_f) then begin - s:=new_native_character(cur_f, qo(cur_c)); - g:=get_native_glyph(s, 0); +begin if math_type(supscr(q))=math_char then + begin save_f:=cur_f; + fetch(supscr(q)); + if is_new_mathfont(cur_f) then + begin script_c:=new_native_character(cur_f, qo(cur_c)); + script_g:=get_native_glyph(script_c, 0); + script_f:=cur_f; + end else + begin script_g:=0; script_f:=0 + end; + cur_f:=save_f; end; if is_glyph_node(p) then - sup_kern:=get_ot_math_kern(native_font(p), native_glyph(p), cur_f, g, sup_cmd, shift_up); + sup_kern:=get_ot_math_kern(native_font(p), native_glyph(p), script_f, script_g, sup_cmd, shift_up); if (sup_kern<>0) and (math_type(subscr(q))=empty) then {if there is a superscript the kern will be added to |shift_amount(x)|} p:=attach_hkern_to_new_hlist(q, sup_kern); -cur_f:=save_f; end; @ We have now tied up all the loose ends of the first pass of |mlist_to_hlist|. @@ -19439,7 +19445,7 @@ else case type(v) of or (subtype(v)=pic_node) or (subtype(v)=pdf_node) then break_width[1]:=break_width[1]-width(v) - else confusion("disc1a"); + else confusion("disc1a"); othercases confusion("disc1") @:this can't happen disc1}{\quad disc1@> endcases @@ -19463,7 +19469,7 @@ else case type(s) of or (subtype(s)=pic_node) or (subtype(s)=pdf_node) then break_width[1]:=break_width[1]+width(s) - else confusion("disc2a"); + else confusion("disc2a"); othercases confusion("disc2") @:this can't happen disc2}{\quad disc2@> endcases @@ -20049,7 +20055,7 @@ else case type(s) of or (subtype(s)=pic_node) or (subtype(s)=pdf_node) then disc_width:=disc_width+width(s) - else confusion("disc3a"); + else confusion("disc3a"); othercases confusion("disc3") @:this can't happen disc3}{\quad disc3@> endcases @@ -20073,7 +20079,7 @@ else case type(s) of or (subtype(s)=pic_node) or (subtype(s)=pdf_node) then act_width:=act_width+width(s) - else confusion("disc4a"); + else confusion("disc4a"); othercases confusion("disc4") @:this can't happen disc4}{\quad disc4@> endcases @@ -20298,7 +20304,7 @@ if XeTeX_protrude_chars > 0 then begin k := new_margin_kern(-w, last_rightmost_char, right_side); link(k) := link(ptmp); link(ptmp) := k; - if (ptmp = q) then + if ptmp = q then q := link(q); end; end; @@ -20585,8 +20591,8 @@ restart: for l := 0 to native_length(ha)-1 do begin c := get_native_usv(ha, l); set_lc_code(c); - if (hc[0] = 0) then begin - if (hn > 0) then begin + if hc[0]=0 then begin + if hn>0 then begin { we've got some letters, and now found a non-letter, so break off the tail of the |native_word| and link it after this node, and goto done3 } @<Split the |native_word_node| at |l| and link the second part after |ha|@>; @@ -20597,7 +20603,7 @@ for l := 0 to native_length(ha)-1 do begin @<Split the |native_word_node| at |l| and link the second part after |ha|@>; ha := link(ha); goto restart; - end else if (hn = 63) then + end else if hn = 63 then { reached max hyphenatable length } goto done3 else begin @@ -20826,21 +20832,21 @@ for j := l_hyf to hn - r_hyf do begin { if this is a valid break.... } if odd(hyf[j]) then begin - { make a |native_word_node| for the fragment before the hyphen } - q := new_native_word_node(hf, j - hyphen_passed); - for i := 0 to j - hyphen_passed - 1 do - set_native_char(q, i, get_native_char(ha, i + hyphen_passed)); - set_native_metrics(q, XeTeX_use_glyph_metrics); - link(s) := q; { append the new node } - s := q; + { make a |native_word_node| for the fragment before the hyphen } + q := new_native_word_node(hf, j - hyphen_passed); + for i := 0 to j - hyphen_passed - 1 do + set_native_char(q, i, get_native_char(ha, i + hyphen_passed)); + set_native_metrics(q, XeTeX_use_glyph_metrics); + link(s) := q; { append the new node } + s := q; - { make the |disc_node| for the hyphenation point } + { make the |disc_node| for the hyphenation point } q := new_disc; - pre_break(q) := new_native_character(hf, hyf_char); - link(s) := q; - s := q; + pre_break(q) := new_native_character(hf, hyf_char); + link(s) := q; + s := q; - hyphen_passed := j; + hyphen_passed := j; end end; @@ -23339,49 +23345,49 @@ are inside the individual sections. @d check_for_inter_char_toks(#)=={check for a spacing token list, goto |#| if found, or |big_switch| in case of the initial letter of a run} - cur_ptr:=null; - space_class:=sf_code(cur_chr) div @"10000; - - if XeTeX_inter_char_tokens_en and space_class <> 256 then begin {class 256 = ignored (for combining marks etc)} - if prev_class = 255 then begin {boundary} - if (state<>token_list) or (token_type<>backed_up_char) then begin - find_sa_element(inter_char_val, 255*@"100 + space_class, false); - if cur_ptr<>null then begin - if cur_cmd<>letter then cur_cmd:=other_char; - cur_tok:=(cur_cmd*max_char_val)+cur_chr; - back_input; token_type:=backed_up_char; - begin_token_list(sa_ptr(cur_ptr), inter_char_text); - goto big_switch; - end - end - end else begin - find_sa_element(inter_char_val, prev_class*@"100 + space_class, false); - if cur_ptr<>null then begin - if cur_cmd<>letter then cur_cmd:=other_char; - cur_tok:=(cur_cmd*max_char_val)+cur_chr; - back_input; token_type:=backed_up_char; - begin_token_list(sa_ptr(cur_ptr), inter_char_text); - prev_class:=255; - goto #; - end; - end; - prev_class:=space_class; - end + cur_ptr:=null; + space_class:=sf_code(cur_chr) div @"10000; + + if XeTeX_inter_char_tokens_en and space_class <> 256 then begin {class 256 = ignored (for combining marks etc)} + if prev_class = 255 then begin {boundary} + if (state<>token_list) or (token_type<>backed_up_char) then begin + find_sa_element(inter_char_val, 255*@"100 + space_class, false); + if cur_ptr<>null then begin + if cur_cmd<>letter then cur_cmd:=other_char; + cur_tok:=(cur_cmd*max_char_val)+cur_chr; + back_input; token_type:=backed_up_char; + begin_token_list(sa_ptr(cur_ptr), inter_char_text); + goto big_switch; + end + end + end else begin + find_sa_element(inter_char_val, prev_class*@"100 + space_class, false); + if cur_ptr<>null then begin + if cur_cmd<>letter then cur_cmd:=other_char; + cur_tok:=(cur_cmd*max_char_val)+cur_chr; + back_input; token_type:=backed_up_char; + begin_token_list(sa_ptr(cur_ptr), inter_char_text); + prev_class:=255; + goto #; + end; + end; + prev_class:=space_class; + end @d check_for_post_char_toks(#)== - if XeTeX_inter_char_tokens_en and (space_class<>256) and (prev_class<>255) then begin - prev_class:=255; - find_sa_element(inter_char_val, space_class*@"100 + 255, false); {boundary} - if cur_ptr<>null then begin - if cur_cs=0 then begin - if cur_cmd=char_num then cur_cmd:=other_char; - cur_tok:=(cur_cmd*max_char_val)+cur_chr; - end else cur_tok:=cs_token_flag+cur_cs; - back_input; - begin_token_list(sa_ptr(cur_ptr), inter_char_text); - goto #; - end; - end + if XeTeX_inter_char_tokens_en and (space_class<>256) and (prev_class<>255) then begin + prev_class:=255; + find_sa_element(inter_char_val, space_class*@"100 + 255, false); {boundary} + if cur_ptr<>null then begin + if cur_cs=0 then begin + if cur_cmd=char_num then cur_cmd:=other_char; + cur_tok:=(cur_cmd*max_char_val)+cur_chr; + end else cur_tok:=cs_token_flag+cur_cs; + back_input; + begin_token_list(sa_ptr(cur_ptr), inter_char_text); + goto #; + end; + end @<Append character |cur_chr|...@>= @@ -23389,201 +23395,201 @@ prev_class := 255; {boundary} { added code for native font support } if is_native_font(cur_font) then begin - if mode>0 then if language<>clang then fix_language; + if mode>0 then if language<>clang then fix_language; - main_h := 0; - main_f := cur_font; - native_len := 0; + main_h := 0; + main_f := cur_font; + native_len := 0; collect_native: - adjust_space_factor; - - check_for_inter_char_toks(collected); - - if (cur_chr > @"FFFF) then begin - native_room(2); - append_native((cur_chr - @"10000) div 1024 + @"D800); - append_native((cur_chr - @"10000) mod 1024 + @"DC00); - end else begin - native_room(1); - append_native(cur_chr); - end; - is_hyph := (cur_chr = hyphen_char[main_f]) - or (XeTeX_dash_break_en and ((cur_chr = @"2014) or (cur_chr = @"2013))); - if (main_h = 0) and is_hyph then main_h := native_len; - - {try to collect as many chars as possible in the same font} - get_next; - if (cur_cmd=letter) or (cur_cmd=other_char) or (cur_cmd=char_given) then goto collect_native; - x_token; - if (cur_cmd=letter) or (cur_cmd=other_char) or (cur_cmd=char_given) then goto collect_native; - if cur_cmd=char_num then begin - scan_usv_num; - cur_chr:=cur_val; - goto collect_native; - end; - - check_for_post_char_toks(collected); + adjust_space_factor; + + check_for_inter_char_toks(collected); + + if (cur_chr > @"FFFF) then begin + native_room(2); + append_native((cur_chr - @"10000) div 1024 + @"D800); + append_native((cur_chr - @"10000) mod 1024 + @"DC00); + end else begin + native_room(1); + append_native(cur_chr); + end; + is_hyph := (cur_chr = hyphen_char[main_f]) + or (XeTeX_dash_break_en and ((cur_chr = @"2014) or (cur_chr = @"2013))); + if (main_h = 0) and is_hyph then main_h := native_len; + + {try to collect as many chars as possible in the same font} + get_next; + if (cur_cmd=letter) or (cur_cmd=other_char) or (cur_cmd=char_given) then goto collect_native; + x_token; + if (cur_cmd=letter) or (cur_cmd=other_char) or (cur_cmd=char_given) then goto collect_native; + if cur_cmd=char_num then begin + scan_usv_num; + cur_chr:=cur_val; + goto collect_native; + end; + + check_for_post_char_toks(collected); collected: - if (font_mapping[main_f] <> 0) then begin - main_k := apply_mapping(font_mapping[main_f], native_text, native_len); - native_len := 0; - native_room(main_k); - main_h := 0; - for main_p := 0 to main_k - 1 do begin - append_native(mapped_text[main_p]); - if (main_h = 0) and ((mapped_text[main_p] = hyphen_char[main_f]) - or (XeTeX_dash_break_en and ((mapped_text[main_p] = @"2014) or (mapped_text[main_p] = @"2013)) ) ) - then main_h := native_len; - end - end; - - if tracing_lost_chars > 0 then begin - temp_ptr := 0; - while (temp_ptr < native_len) do begin - main_k := native_text[temp_ptr]; - incr(temp_ptr); - if (main_k >= @"D800) and (main_k < @"DC00) then begin - main_k := @"10000 + (main_k - @"D800) * 1024; - main_k := main_k + native_text[temp_ptr] - @"DC00; - incr(temp_ptr); - end; - if map_char_to_glyph(main_f, main_k) = 0 then - char_warning(main_f, main_k); - end - end; - - main_k := native_len; - main_pp := tail; - - if mode=hmode then begin - - main_ppp := head; - if main_ppp<>main_pp then { find node preceding tail, skipping discretionaries } - while (link(main_ppp)<>main_pp) do begin - if (not is_char_node(main_ppp)) and (type(main_ppp=disc_node)) then begin - temp_ptr:=main_ppp; - for main_p:=1 to replace_count(temp_ptr) do main_ppp:=link(main_ppp); - end; - if main_ppp<>main_pp then main_ppp:=link(main_ppp); - end; - - temp_ptr := 0; - repeat - if main_h = 0 then main_h := main_k; - - if is_native_word_node(main_pp) - and (native_font(main_pp)=main_f) - and (main_ppp<>main_pp) - and (not is_char_node(main_ppp)) - and (type(main_ppp)<>disc_node) - then begin - - { make a new temp string that contains the concatenated text of |tail| + the current word/fragment } - main_k := main_h + native_length(main_pp); - native_room(main_k); - - save_native_len := native_len; - for main_p := 0 to native_length(main_pp) - 1 do - append_native(get_native_char(main_pp, main_p)); - for main_p := 0 to main_h - 1 do - append_native(native_text[temp_ptr + main_p]); - - do_locale_linebreaks(save_native_len, main_k); - - native_len := save_native_len; { discard the temp string } - main_k := native_len - main_h - temp_ptr; { and set |main_k| to remaining length of new word } - temp_ptr := main_h; { pointer to remaining fragment } - - main_h := 0; - while (main_h < main_k) and (native_text[temp_ptr + main_h] <> hyphen_char[main_f]) - and ( (not XeTeX_dash_break_en) - or ((native_text[temp_ptr + main_h] <> @"2014) and (native_text[temp_ptr + main_h] <> @"2013)) ) - do incr(main_h); { look for next hyphen or end of text } - if (main_h < main_k) then incr(main_h); - - { remove the preceding node from the list } - link(main_ppp) := link(main_pp); - link(main_pp) := null; - flush_node_list(main_pp); - main_pp := tail; - while (link(main_ppp)<>main_pp) do - main_ppp:=link(main_ppp); - - end else begin - - do_locale_linebreaks(temp_ptr, main_h); { append fragment of current word } - - temp_ptr := temp_ptr + main_h; { advance ptr to remaining fragment } - main_k := main_k - main_h; { decrement remaining length } - - main_h := 0; - while (main_h < main_k) and (native_text[temp_ptr + main_h] <> hyphen_char[main_f]) - and ( (not XeTeX_dash_break_en) - or ((native_text[temp_ptr + main_h] <> @"2014) and (native_text[temp_ptr + main_h] <> @"2013)) ) - do incr(main_h); { look for next hyphen or end of text } - if (main_h < main_k) then incr(main_h); - - end; - - if (main_k > 0) or is_hyph then begin - tail_append(new_disc); { add a break if we aren't at end of text (must be a hyphen), - or if last char in original text was a hyphen } - main_pp:=tail; - end; - until main_k = 0; - - end else begin - { must be restricted hmode, so no need for line-breaking or discretionaries } - { but there might already be explicit |disc_node|s in the list } - main_ppp := head; - if main_ppp<>main_pp then { find node preceding tail, skipping discretionaries } - while (link(main_ppp)<>main_pp) do begin - if (not is_char_node(main_ppp)) and (type(main_ppp=disc_node)) then begin - temp_ptr:=main_ppp; - for main_p:=1 to replace_count(temp_ptr) do main_ppp:=link(main_ppp); - end; - if main_ppp<>main_pp then main_ppp:=link(main_ppp); - end; - if is_native_word_node(main_pp) - and (native_font(main_pp)=main_f) - and (main_ppp<>main_pp) - and (not is_char_node(main_ppp)) - and (type(main_ppp)<>disc_node) - then begin - { total string length for the new merged whatsit } - link(main_pp) := new_native_word_node(main_f, main_k + native_length(main_pp)); - tail := link(main_pp); - - { copy text from the old one into the new } - for main_p := 0 to native_length(main_pp) - 1 do - set_native_char(tail, main_p, get_native_char(main_pp, main_p)); - { append the new text } - for main_p := 0 to main_k - 1 do - set_native_char(tail, main_p + native_length(main_pp), native_text[main_p]); - set_native_metrics(tail, XeTeX_use_glyph_metrics); - - { remove the preceding node from the list } - main_p := head; - if main_p<>main_pp then - while link(main_p)<>main_pp do - main_p := link(main_p); - link(main_p) := link(main_pp); - link(main_pp) := null; - flush_node_list(main_pp); - end else begin - { package the current string into a |native_word| whatsit } - link(main_pp) := new_native_word_node(main_f, main_k); - tail := link(main_pp); - for main_p := 0 to main_k - 1 do - set_native_char(tail, main_p, native_text[main_p]); - set_native_metrics(tail, XeTeX_use_glyph_metrics); - end - end; - - if cur_ptr<>null then goto big_switch - else goto reswitch; + if (font_mapping[main_f] <> 0) then begin + main_k := apply_mapping(font_mapping[main_f], native_text, native_len); + native_len := 0; + native_room(main_k); + main_h := 0; + for main_p := 0 to main_k - 1 do begin + append_native(mapped_text[main_p]); + if (main_h = 0) and ((mapped_text[main_p] = hyphen_char[main_f]) + or (XeTeX_dash_break_en and ((mapped_text[main_p] = @"2014) or (mapped_text[main_p] = @"2013)) ) ) + then main_h := native_len; + end + end; + + if tracing_lost_chars > 0 then begin + temp_ptr := 0; + while (temp_ptr < native_len) do begin + main_k := native_text[temp_ptr]; + incr(temp_ptr); + if (main_k >= @"D800) and (main_k < @"DC00) then begin + main_k := @"10000 + (main_k - @"D800) * 1024; + main_k := main_k + native_text[temp_ptr] - @"DC00; + incr(temp_ptr); + end; + if map_char_to_glyph(main_f, main_k) = 0 then + char_warning(main_f, main_k); + end + end; + + main_k := native_len; + main_pp := tail; + + if mode=hmode then begin + + main_ppp := head; + if main_ppp<>main_pp then { find node preceding tail, skipping discretionaries } + while (link(main_ppp)<>main_pp) do begin + if (not is_char_node(main_ppp)) and (type(main_ppp=disc_node)) then begin + temp_ptr:=main_ppp; + for main_p:=1 to replace_count(temp_ptr) do main_ppp:=link(main_ppp); + end; + if main_ppp<>main_pp then main_ppp:=link(main_ppp); + end; + + temp_ptr := 0; + repeat + if main_h = 0 then main_h := main_k; + + if is_native_word_node(main_pp) + and (native_font(main_pp)=main_f) + and (main_ppp<>main_pp) + and (not is_char_node(main_ppp)) + and (type(main_ppp)<>disc_node) + then begin + + { make a new temp string that contains the concatenated text of |tail| + the current word/fragment } + main_k := main_h + native_length(main_pp); + native_room(main_k); + + save_native_len := native_len; + for main_p := 0 to native_length(main_pp) - 1 do + append_native(get_native_char(main_pp, main_p)); + for main_p := 0 to main_h - 1 do + append_native(native_text[temp_ptr + main_p]); + + do_locale_linebreaks(save_native_len, main_k); + + native_len := save_native_len; { discard the temp string } + main_k := native_len - main_h - temp_ptr; { and set |main_k| to remaining length of new word } + temp_ptr := main_h; { pointer to remaining fragment } + + main_h := 0; + while (main_h < main_k) and (native_text[temp_ptr + main_h] <> hyphen_char[main_f]) + and ( (not XeTeX_dash_break_en) + or ((native_text[temp_ptr + main_h] <> @"2014) and (native_text[temp_ptr + main_h] <> @"2013)) ) + do incr(main_h); { look for next hyphen or end of text } + if (main_h < main_k) then incr(main_h); + + { remove the preceding node from the list } + link(main_ppp) := link(main_pp); + link(main_pp) := null; + flush_node_list(main_pp); + main_pp := tail; + while (link(main_ppp)<>main_pp) do + main_ppp:=link(main_ppp); + + end else begin + + do_locale_linebreaks(temp_ptr, main_h); { append fragment of current word } + + temp_ptr := temp_ptr + main_h; { advance ptr to remaining fragment } + main_k := main_k - main_h; { decrement remaining length } + + main_h := 0; + while (main_h < main_k) and (native_text[temp_ptr + main_h] <> hyphen_char[main_f]) + and ( (not XeTeX_dash_break_en) + or ((native_text[temp_ptr + main_h] <> @"2014) and (native_text[temp_ptr + main_h] <> @"2013)) ) + do incr(main_h); { look for next hyphen or end of text } + if (main_h < main_k) then incr(main_h); + + end; + + if (main_k > 0) or is_hyph then begin + tail_append(new_disc); { add a break if we aren't at end of text (must be a hyphen), + or if last char in original text was a hyphen } + main_pp:=tail; + end; + until main_k = 0; + + end else begin + { must be restricted hmode, so no need for line-breaking or discretionaries } + { but there might already be explicit |disc_node|s in the list } + main_ppp := head; + if main_ppp<>main_pp then { find node preceding tail, skipping discretionaries } + while (link(main_ppp)<>main_pp) do begin + if (not is_char_node(main_ppp)) and (type(main_ppp=disc_node)) then begin + temp_ptr:=main_ppp; + for main_p:=1 to replace_count(temp_ptr) do main_ppp:=link(main_ppp); + end; + if main_ppp<>main_pp then main_ppp:=link(main_ppp); + end; + if is_native_word_node(main_pp) + and (native_font(main_pp)=main_f) + and (main_ppp<>main_pp) + and (not is_char_node(main_ppp)) + and (type(main_ppp)<>disc_node) + then begin + { total string length for the new merged whatsit } + link(main_pp) := new_native_word_node(main_f, main_k + native_length(main_pp)); + tail := link(main_pp); + + { copy text from the old one into the new } + for main_p := 0 to native_length(main_pp) - 1 do + set_native_char(tail, main_p, get_native_char(main_pp, main_p)); + { append the new text } + for main_p := 0 to main_k - 1 do + set_native_char(tail, main_p + native_length(main_pp), native_text[main_p]); + set_native_metrics(tail, XeTeX_use_glyph_metrics); + + { remove the preceding node from the list } + main_p := head; + if main_p<>main_pp then + while link(main_p)<>main_pp do + main_p := link(main_p); + link(main_p) := link(main_pp); + link(main_pp) := null; + flush_node_list(main_pp); + end else begin + { package the current string into a |native_word| whatsit } + link(main_pp) := new_native_word_node(main_f, main_k); + tail := link(main_pp); + for main_p := 0 to main_k - 1 do + set_native_char(tail, main_p, native_text[main_p]); + set_native_metrics(tail, XeTeX_use_glyph_metrics); + end + end; + + if cur_ptr<>null then goto big_switch + else goto reswitch; end; { End of added code for native fonts } @@ -24904,11 +24910,11 @@ var p:pointer; {|char_node| at the tail of the current list} begin if tail<>head then begin if is_char_node(tail) then p:=tail else if type(tail)=ligature_node then p:=lig_char(tail) - else if (type(tail)=whatsit_node) then begin - if (subtype(tail)=native_word_node) then begin + else if type(tail)=whatsit_node then begin + if subtype(tail)=native_word_node then begin tail_append(new_kern(get_native_italic_correction(tail))); subtype(tail):=explicit; end - else if (subtype(tail)=glyph_node) then begin + else if subtype(tail)=glyph_node then begin tail_append(new_kern(get_native_glyph_italic_correction(tail))); subtype(tail):=explicit; end; return; @@ -25007,8 +25013,8 @@ q:=head; p:=link(q); n:=0; while p<>null do begin if not is_char_node(p) then if type(p)>rule_node then if type(p)<>kern_node then if type(p)<>ligature_node then - if (type(p)<>whatsit_node) or ((subtype(p)<>native_word_node) - and (subtype(p)<>glyph_node)) then + if (type(p)<>whatsit_node) or ((subtype(p)<>native_word_node) + and (subtype(p)<>glyph_node)) then begin print_err("Improper discretionary list"); @.Improper discretionary list@> help1("Discretionary lists must contain only boxes and kerns.");@/ @@ -25094,7 +25100,7 @@ end; if h<>x then {the accent must be shifted up or down} begin p:=hpack(p,natural); shift_amount(p):=x-h; end; -if is_native_font(f) and (a=0) then { special case for non-spacing marks } +if (is_native_font(f)) and (a=0) then { special case for non-spacing marks } delta:=round((w-lsb+rsb)/float_constant(2)+h*t-x*s) else delta:=round((w-a)/float_constant(2)+h*t-x*s); @^real multiplication@> @@ -26120,11 +26126,11 @@ end; @ @<Check that the necessary fonts...@>= if ((font_params[fam_fnt(2+text_size)]<total_mathsy_params) - and (not is_new_mathfont(fam_fnt(2+text_size)))) or@| + and (not (is_new_mathfont(fam_fnt(2+text_size))))) or@| ((font_params[fam_fnt(2+script_size)]<total_mathsy_params) - and (not is_new_mathfont(fam_fnt(2+script_size)))) or@| + and (not (is_new_mathfont(fam_fnt(2+script_size))))) or@| ((font_params[fam_fnt(2+script_script_size)]<total_mathsy_params) - and (not is_new_mathfont(fam_fnt(2+script_script_size)))) then + and (not (is_new_mathfont(fam_fnt(2+script_script_size))))) then begin print_err("Math formula deleted: Insufficient symbol fonts");@/ @.Math formula deleted...@> help3("Sorry, but I can't typeset math unless \textfont 2")@/ @@ -26133,11 +26139,11 @@ if ((font_params[fam_fnt(2+text_size)]<total_mathsy_params) error; flush_math; danger:=true; end else if ((font_params[fam_fnt(3+text_size)]<total_mathex_params) - and (not is_new_mathfont(fam_fnt(3+text_size)))) or@| + and (not (is_new_mathfont(fam_fnt(3+text_size))))) or@| ((font_params[fam_fnt(3+script_size)]<total_mathex_params) - and (not is_new_mathfont(fam_fnt(3+script_size)))) or@| + and (not (is_new_mathfont(fam_fnt(3+script_size))))) or@| ((font_params[fam_fnt(3+script_script_size)]<total_mathex_params) - and (not is_new_mathfont(fam_fnt(3+script_script_size)))) then + and (not (is_new_mathfont(fam_fnt(3+script_script_size))))) then begin print_err("Math formula deleted: Insufficient extension fonts");@/ help3("Sorry, but I can't typeset math unless \textfont 3")@/ ("and \scriptfont 3 and \scriptscriptfont 3 have all")@/ @@ -26849,7 +26855,7 @@ XeTeX_def_code: begin if cur_chr = sf_code_base then begin p:=cur_chr; scan_usv_num; p:=p+cur_val; - n:=sf_code(cur_val) mod @"10000; + n:=sf_code(cur_val) mod @"10000; scan_optional_equals; scan_char_class; define(p,data,cur_val*@"10000 + n); @@ -27307,7 +27313,7 @@ the new name becomes the font identifier of record. Font names `\.{xyz}' and flushable_string:=str_ptr-1; for f:=font_base+1 to font_ptr do begin if str_eq_str(font_name[f],cur_name) and - (((cur_area = "") and is_native_font(f)) or str_eq_str(font_area[f],cur_area)) then + (((cur_area = "") and (is_native_font(f))) or str_eq_str(font_area[f],cur_area)) then begin if cur_name=flushable_string then begin flush_string; cur_name:=font_name[f]; end; @@ -28712,11 +28718,10 @@ p:=scan_toks(false,true); write_tokens(tail):=def_ref; end @ @d call_func(#) == begin if # <> 0 then do_nothing end -@d flushable(#) == (# = str_ptr - 1) @p procedure flush_str(s: str_number); {flush a string if possible} begin - if flushable(s) then + if s = str_ptr-1 then flush_string; end; @@ -28787,22 +28792,22 @@ end; procedure print_native_word(@!p:pointer); var i,c,cc:integer; begin - for i:=0 to native_length(p) - 1 do begin - c:=get_native_char(p,i); - if (c >= @"D800) and (c <= @"DBFF) then begin - if i < native_length(p) - 1 then begin - cc:=get_native_char(p, i+1); - if (cc >= @"DC00) and (cc <= @"DFFF) then begin - c := @"10000 + (c - @"D800) * @"400 + (cc - @"DC00); - print_char(c); - incr(i); - end else - print("."); - end else - print("."); - end else - print_char(c); - end + for i:=0 to native_length(p) - 1 do begin + c:=get_native_char(p,i); + if (c >= @"D800) and (c <= @"DBFF) then begin + if i < native_length(p) - 1 then begin + cc:=get_native_char(p, i+1); + if (cc >= @"DC00) and (cc <= @"DFFF) then begin + c := @"10000 + (c - @"D800) * @"400 + (cc - @"DC00); + print_char(c); + incr(i); + end else + print("."); + end else + print("."); + end else + print_char(c); + end end; @ @<Display the whatsit...@>= @@ -28823,9 +28828,9 @@ language_node:begin print_esc("setlanguage"); print_int(what_rhm(p)); print_char(")"); end; native_word_node:begin - print_esc(font_id_text(native_font(p))); - print_char(" "); - print_native_word(p); + print_esc(font_id_text(native_font(p))); + print_char(" "); + print_native_word(p); end; glyph_node:begin print_esc(font_id_text(native_font(p))); @@ -28833,12 +28838,12 @@ glyph_node:begin print_int(native_glyph(p)); end; pic_node,pdf_node: begin - if subtype(p) = pic_node then print_esc("XeTeXpicfile") - else print_esc("XeTeXpdffile"); - print(" """); - for i:=0 to pic_path_length(p)-1 do - print_visible_char(pic_path_byte(p, i)); - print(""""); + if subtype(p) = pic_node then print_esc("XeTeXpicfile") + else print_esc("XeTeXpdffile"); + print(" """); + for i:=0 to pic_path_length(p)-1 do + print_visible_char(pic_path_byte(p, i)); + print(""""); end; pdf_save_pos_node: print_esc("pdfsavepos"); othercases print("whatsit?") @@ -28896,107 +28901,107 @@ end @ @<Incorporate a whatsit node into a vbox@>= begin - if (subtype(p)=pic_node) - or (subtype(p)=pdf_node) - then begin - x := x + d + height(p); - d := depth(p); - if width(p) > w then w := width(p); - end; + if (subtype(p)=pic_node) + or (subtype(p)=pdf_node) + then begin + x := x + d + height(p); + d := depth(p); + if width(p) > w then w := width(p); + end; end @ @<Incorporate a whatsit node into an hbox@>= begin - case subtype(p) of - - native_word_node: - begin - { merge with any following word fragments in same font, discarding discretionary breaks } - if type(q) = disc_node then k:=replace_count(q) else k:=0; - while (link(q) <> p) do begin - decr(k); - q := link(q); { bring q up in preparation for deletion of nodes starting at p } - if type(q) = disc_node then k:=replace_count(q); - end; - pp := link(p); - restart: - if (k <= 0) and (pp <> null) and (not is_char_node(pp)) then begin - if (type(pp) = whatsit_node) - and (subtype(pp) = native_word_node) - and (native_font(pp) = native_font(p)) then begin - pp := link(pp); - goto restart; - end - else if (type(pp) = disc_node) then begin - ppp := link(pp); - if is_native_word_node(ppp) - and (native_font(ppp) = native_font(p)) then begin - pp := link(ppp); - goto restart; - end - end - end; - - { now pp points to the non-|native_word| node that ended the chain, or null } - - { we can just check type(p)=|whatsit_node| below, as we know that the chain - contains only discretionaries and |native_word| nodes, no other whatsits or |char_node|s } - - if (pp <> link(p)) then begin - { found a chain of at least two pieces starting at p } - total_chars := 0; - p := link(q); { the first fragment } - while (p <> pp) do begin - if (type(p) = whatsit_node) then - total_chars := total_chars + native_length(p); { accumulate char count } - ppp := p; { remember last node seen } - p := link(p); { point to next fragment or discretionary or terminator } - end; - - p := link(q); { the first fragment again } - pp := new_native_word_node(native_font(p), total_chars); { make new node for merged word } - link(q) := pp; { link to preceding material } - link(pp) := link(ppp); { attach remainder of hlist to it } - link(ppp) := null; { and detach from the old fragments } - - { copy the chars into new node } - total_chars := 0; - ppp := p; - repeat - if (type(ppp) = whatsit_node) then - for k := 0 to native_length(ppp)-1 do begin - set_native_char(pp, total_chars, get_native_char(ppp, k)); - incr(total_chars); - end; - ppp := link(ppp); - until (ppp = null); - - flush_node_list(p); { delete the fragments } - p := link(q); { update p to point to the new node } - set_native_metrics(p, XeTeX_use_glyph_metrics); { and measure it (i.e., re-do the OT layout) } - end; - - { now incorporate the |native_word| node measurements into the box we're packing } - if height(p) > h then - h := height(p); - if depth(p) > d then - d := depth(p); - x := x + width(p); - end; - - glyph_node, pic_node, pdf_node: - begin - if height(p) > h then - h := height(p); - if depth(p) > d then - d := depth(p); - x := x + width(p); - end; - - othercases - do_nothing - - endcases + case subtype(p) of + + native_word_node: + begin + { merge with any following word fragments in same font, discarding discretionary breaks } + if type(q) = disc_node then k:=replace_count(q) else k:=0; + while (link(q) <> p) do begin + decr(k); + q := link(q); { bring q up in preparation for deletion of nodes starting at p } + if type(q) = disc_node then k:=replace_count(q); + end; + pp := link(p); + restart: + if (k <= 0) and (pp <> null) and (not is_char_node(pp)) then begin + if (type(pp) = whatsit_node) + and (subtype(pp) = native_word_node) + and (native_font(pp) = native_font(p)) then begin + pp := link(pp); + goto restart; + end + else if type(pp) = disc_node then begin + ppp := link(pp); + if is_native_word_node(ppp) + and (native_font(ppp) = native_font(p)) then begin + pp := link(ppp); + goto restart; + end + end + end; + + { now pp points to the non-|native_word| node that ended the chain, or null } + + { we can just check type(p)=|whatsit_node| below, as we know that the chain + contains only discretionaries and |native_word| nodes, no other whatsits or |char_node|s } + + if (pp <> link(p)) then begin + { found a chain of at least two pieces starting at p } + total_chars := 0; + p := link(q); { the first fragment } + while p <> pp do begin + if type(p) = whatsit_node then + total_chars := total_chars + native_length(p); { accumulate char count } + ppp := p; { remember last node seen } + p := link(p); { point to next fragment or discretionary or terminator } + end; + + p := link(q); { the first fragment again } + pp := new_native_word_node(native_font(p), total_chars); { make new node for merged word } + link(q) := pp; { link to preceding material } + link(pp) := link(ppp); { attach remainder of hlist to it } + link(ppp) := null; { and detach from the old fragments } + + { copy the chars into new node } + total_chars := 0; + ppp := p; + repeat + if type(ppp) = whatsit_node then + for k := 0 to native_length(ppp)-1 do begin + set_native_char(pp, total_chars, get_native_char(ppp, k)); + incr(total_chars); + end; + ppp := link(ppp); + until (ppp = null); + + flush_node_list(p); { delete the fragments } + p := link(q); { update p to point to the new node } + set_native_metrics(p, XeTeX_use_glyph_metrics); { and measure it (i.e., re-do the OT layout) } + end; + + { now incorporate the |native_word| node measurements into the box we're packing } + if height(p) > h then + h := height(p); + if depth(p) > d then + d := depth(p); + x := x + width(p); + end; + + glyph_node, pic_node, pdf_node: + begin + if height(p) > h then + h := height(p); + if depth(p) > d then + d := depth(p); + x := x + width(p); + end; + + othercases + do_nothing + + endcases end @ @<Let |d| be the width of the whatsit |p|, and |goto found| if ``visible''@>= @@ -29005,8 +29010,8 @@ or (subtype(p)=glyph_node) or (subtype(p)=pic_node) or (subtype(p)=pdf_node) then begin - d:=width(p); - goto found; + d:=width(p); + goto found; end else d := 0 @@ -29034,67 +29039,67 @@ adv_past_prehyph(s) @ @<Prepare to move whatsit |p| to the current page, then |goto contribute|@>= begin - if (subtype(p)=pic_node) - or (subtype(p)=pdf_node) - then begin - page_total := page_total + page_depth + height(p); - page_depth := depth(p); - end; - goto contribute; + if (subtype(p)=pic_node) + or (subtype(p)=pdf_node) + then begin + page_total := page_total + page_depth + height(p); + page_depth := depth(p); + end; + goto contribute; end @ @<Process whatsit |p| in |vert_break| loop, |goto not_found|@>= begin - if (subtype(p)=pic_node) - or (subtype(p)=pdf_node) - then begin - cur_height := cur_height + prev_dp + height(p); prev_dp := depth(p); - end; - goto not_found; + if (subtype(p)=pic_node) + or (subtype(p)=pdf_node) + then begin + cur_height := cur_height + prev_dp + height(p); prev_dp := depth(p); + end; + goto not_found; end @ @<Output the whatsit node |p| in a vlist@>= begin - case subtype(p) of - glyph_node: begin - cur_v:=cur_v+height(p); - cur_h:=left_edge; - - { synch DVI state to TeX state } - synch_h; synch_v; - f := native_font(p); - if f<>dvi_f then @<Change font |dvi_f| to |f|@>; - - dvi_out(set_glyph_string); - dvi_four(0); { width } - dvi_two(1); { glyph count } - dvi_four(0); { x-offset as fixed point } - dvi_two(native_glyph(p)); - - cur_v:=cur_v+depth(p); - cur_h:=left_edge; - end; - pic_node, pdf_node: begin - save_h:=dvi_h; save_v:=dvi_v; - cur_v:=cur_v+height(p); - pic_out(p, subtype(p) = pdf_node); - dvi_h:=save_h; dvi_v:=save_v; - cur_v:=save_v+depth(p); cur_h:=left_edge; - end; - - pdf_save_pos_node: - @<Save current position to |pdf_last_x_pos|, |pdf_last_y_pos|@>; - - othercases - out_what(p) - - endcases + case subtype(p) of + glyph_node: begin + cur_v:=cur_v+height(p); + cur_h:=left_edge; + + { synch DVI state to TeX state } + synch_h; synch_v; + f := native_font(p); + if f<>dvi_f then @<Change font |dvi_f| to |f|@>; + + dvi_out(set_glyph_string); + dvi_four(0); { width } + dvi_two(1); { glyph count } + dvi_four(0); { x-offset as fixed point } + dvi_two(native_glyph(p)); + + cur_v:=cur_v+depth(p); + cur_h:=left_edge; + end; + pic_node, pdf_node: begin + save_h:=dvi_h; save_v:=dvi_v; + cur_v:=cur_v+height(p); + pic_out(p, subtype(p) = pdf_node); + dvi_h:=save_h; dvi_v:=save_v; + cur_v:=save_v+depth(p); cur_h:=left_edge; + end; + + pdf_save_pos_node: + @<Save current position to |pdf_last_x_pos|, |pdf_last_y_pos|@>; + + othercases + out_what(p) + + endcases end @ @<Save current position to |pdf_last_x_pos|, |pdf_last_y_pos|@>= begin pdf_last_x_pos := cur_h + cur_h_offset; - pdf_last_y_pos := cur_page_height - cur_v - cur_v_offset + pdf_last_y_pos := cur_page_height - cur_v - cur_v_offset end @ @<Calculate page dimensions and margins@>= @@ -29117,49 +29122,49 @@ else @ @<Output the whatsit node |p| in an hlist@>= begin - case subtype(p) of - native_word_node, glyph_node: begin - { synch DVI state to TeX state } - synch_h; synch_v; - f := native_font(p); - if f<>dvi_f then @<Change font |dvi_f| to |f|@>; - - if subtype(p) = glyph_node then begin - dvi_out(set_glyph_string); - dvi_four(width(p)); - dvi_two(1); { glyph count } - dvi_four(0); { x-offset as fixed point } - dvi_two(native_glyph(p)); - cur_h := cur_h + width(p); - end else begin - if native_glyph_info_ptr(p) <> null_ptr then begin - len := make_xdv_glyph_array_data(p); - for k := 0 to len-1 do - dvi_out(xdv_buffer_byte(k)); - end; - cur_h := cur_h + width(p); - end; - - dvi_h := cur_h; - end; - - pic_node, pdf_node: begin - save_h:=dvi_h; save_v:=dvi_v; - cur_v:=base_line; - edge:=cur_h+width(p); - if cur_dir=right_to_left then cur_h:=edge; - pic_out(p, subtype(p) = pdf_node); - dvi_h:=save_h; dvi_v:=save_v; - cur_h:=edge; cur_v:=base_line; - end; - - pdf_save_pos_node: - @<Save current position to |pdf_last_x_pos|, |pdf_last_y_pos|@>; - - othercases - out_what(p) - - endcases + case subtype(p) of + native_word_node, glyph_node: begin + { synch DVI state to TeX state } + synch_h; synch_v; + f := native_font(p); + if f<>dvi_f then @<Change font |dvi_f| to |f|@>; + + if subtype(p) = glyph_node then begin + dvi_out(set_glyph_string); + dvi_four(width(p)); + dvi_two(1); { glyph count } + dvi_four(0); { x-offset as fixed point } + dvi_two(native_glyph(p)); + cur_h := cur_h + width(p); + end else begin + if native_glyph_info_ptr(p) <> null_ptr then begin + len := make_xdv_glyph_array_data(p); + for k := 0 to len-1 do + dvi_out(xdv_buffer_byte(k)); + end; + cur_h := cur_h + width(p); + end; + + dvi_h := cur_h; + end; + + pic_node, pdf_node: begin + save_h:=dvi_h; save_v:=dvi_v; + cur_v:=base_line; + edge:=cur_h+width(p); + if cur_dir=right_to_left then cur_h:=edge; + pic_out(p, subtype(p) = pdf_node); + dvi_h:=save_h; dvi_v:=save_v; + cur_h:=edge; cur_v:=base_line; + end; + + pdf_save_pos_node: + @<Save current position to |pdf_last_x_pos|, |pdf_last_y_pos|@>; + + othercases + out_what(p) + + endcases end @ After all this preliminary shuffling, we come finally to the routines @@ -29263,9 +29268,9 @@ begin synch_h; synch_v; dvi_out(pic_file); if is_pdf then - dvi_out(pic_box_type(p)) + dvi_out(pic_box_type(p)) else - dvi_out(0); + dvi_out(0); dvi_four(pic_transform1(p)); dvi_four(pic_transform2(p)); dvi_four(pic_transform3(p)); @@ -29395,224 +29400,224 @@ end @ Load a picture file and handle following keywords. @d calc_min_and_max== - begin - xmin := 1000000.0; - xmax := -xmin; - ymin := xmin; - ymax := xmax; - for i := 0 to 3 do begin - if xCoord(corners[i]) < xmin then xmin := xCoord(corners[i]); - if xCoord(corners[i]) > xmax then xmax := xCoord(corners[i]); - if yCoord(corners[i]) < ymin then ymin := yCoord(corners[i]); - if yCoord(corners[i]) > ymax then ymax := yCoord(corners[i]); - end; - end + begin + xmin := 1000000.0; + xmax := -xmin; + ymin := xmin; + ymax := xmax; + for i := 0 to 3 do begin + if xCoord(corners[i]) < xmin then xmin := xCoord(corners[i]); + if xCoord(corners[i]) > xmax then xmax := xCoord(corners[i]); + if yCoord(corners[i]) < ymin then ymin := yCoord(corners[i]); + if yCoord(corners[i]) > ymax then ymax := yCoord(corners[i]); + end; + end @d update_corners== - for i := 0 to 3 do - transform_point(addressof(corners[i]), addressof(t2)) + for i := 0 to 3 do + transform_point(addressof(corners[i]), addressof(t2)) @d do_size_requests==begin - { calculate current width and height } - calc_min_and_max; - if x_size_req = 0.0 then begin - make_scale(addressof(t2), y_size_req / (ymax - ymin), y_size_req / (ymax - ymin)); - end else if y_size_req = 0.0 then begin - make_scale(addressof(t2), x_size_req / (xmax - xmin), x_size_req / (xmax - xmin)); - end else begin - make_scale(addressof(t2), x_size_req / (xmax - xmin), y_size_req / (ymax - ymin)); - end; - update_corners; - x_size_req := 0.0; - y_size_req := 0.0; - transform_concat(addressof(t), addressof(t2)); + { calculate current width and height } + calc_min_and_max; + if x_size_req = 0.0 then begin + make_scale(addressof(t2), y_size_req / (ymax - ymin), y_size_req / (ymax - ymin)); + end else if y_size_req = 0.0 then begin + make_scale(addressof(t2), x_size_req / (xmax - xmin), x_size_req / (xmax - xmin)); + end else begin + make_scale(addressof(t2), x_size_req / (xmax - xmin), y_size_req / (ymax - ymin)); + end; + update_corners; + x_size_req := 0.0; + y_size_req := 0.0; + transform_concat(addressof(t), addressof(t2)); end @<Declare procedures needed in |do_extension|@>= procedure load_picture(@!is_pdf:boolean); var - pic_path: ^char; - bounds: real_rect; - t, t2: transform; - corners: array[0..3] of real_point; - x_size_req,y_size_req: real; - check_keywords: boolean; - xmin,xmax,ymin,ymax: real; - i: small_number; - page: integer; - pdf_box_type: integer; - result: integer; + pic_path: ^char; + bounds: real_rect; + t, t2: transform; + corners: array[0..3] of real_point; + x_size_req,y_size_req: real; + check_keywords: boolean; + xmin,xmax,ymin,ymax: real; + i: small_number; + page: integer; + pdf_box_type: integer; + result: integer; begin - { scan the filename and pack into |name_of_file| } - scan_file_name; - pack_cur_name; + { scan the filename and pack into |name_of_file| } + scan_file_name; + pack_cur_name; pdf_box_type := 0; - page := 0; - if is_pdf then begin - if scan_keyword("page") then begin - scan_int; - page := cur_val; - end; - pdf_box_type := pdfbox_crop; - if scan_keyword("crop") then do_nothing - else if scan_keyword("media") then pdf_box_type := pdfbox_media - else if scan_keyword("bleed") then pdf_box_type := pdfbox_bleed - else if scan_keyword("trim") then pdf_box_type := pdfbox_trim - else if scan_keyword("art") then pdf_box_type := pdfbox_art; - end; - - { access the picture file and check its size } - result := find_pic_file(addressof(pic_path), addressof(bounds), pdf_box_type, page); - - setPoint(corners[0], xField(bounds), yField(bounds)); - setPoint(corners[1], xField(corners[0]), yField(bounds) + htField(bounds)); - setPoint(corners[2], xField(bounds) + wdField(bounds), yField(corners[1])); - setPoint(corners[3], xField(corners[2]), yField(corners[0])); - - x_size_req := 0.0; - y_size_req := 0.0; - - { look for any scaling requests for this picture } - make_identity(addressof(t)); - - check_keywords := true; - while check_keywords do begin - if scan_keyword("scaled") then begin - scan_int; - if (x_size_req = 0.0) and (y_size_req = 0.0) then begin - make_scale(addressof(t2), float(cur_val) / 1000.0, float(cur_val) / 1000.0); - update_corners; - transform_concat(addressof(t), addressof(t2)); - end - end else if scan_keyword("xscaled") then begin - scan_int; - if (x_size_req = 0.0) and (y_size_req = 0.0) then begin - make_scale(addressof(t2), float(cur_val) / 1000.0, 1.0); - update_corners; - transform_concat(addressof(t), addressof(t2)); - end - end else if scan_keyword("yscaled") then begin - scan_int; - if (x_size_req = 0.0) and (y_size_req = 0.0) then begin - make_scale(addressof(t2), 1.0, float(cur_val) / 1000.0); - update_corners; - transform_concat(addressof(t), addressof(t2)); - end - end else if scan_keyword("width") then begin - scan_normal_dimen; - if cur_val <= 0 then begin - print_err("Improper image "); - print("size ("); - print_scaled(cur_val); - print("pt) will be ignored"); - help2("I can't scale images to zero or negative sizes,")@/ - ("so I'm ignoring this."); - error; - end else - x_size_req := Fix2D(cur_val); - end else if scan_keyword("height") then begin - scan_normal_dimen; - if cur_val <= 0 then begin - print_err("Improper image "); - print("size ("); - print_scaled(cur_val); - print("pt) will be ignored"); - help2("I can't scale images to zero or negative sizes,")@/ - ("so I'm ignoring this."); - error; - end else - y_size_req := Fix2D(cur_val); - end else if scan_keyword("rotated") then begin - scan_decimal; - if (x_size_req <> 0.0) or (y_size_req <> 0.0) then do_size_requests; - make_rotation(addressof(t2), Fix2D(cur_val) * 3.141592653589793 / 180.0); - update_corners; - calc_min_and_max; - setPoint(corners[0], xmin, ymin); - setPoint(corners[1], xmin, ymax); - setPoint(corners[2], xmax, ymax); - setPoint(corners[3], xmax, ymin); - transform_concat(addressof(t), addressof(t2)); - end else - check_keywords := false; - end; - - if (x_size_req <> 0.0) or (y_size_req <> 0.0) then do_size_requests; - - calc_min_and_max; - make_translation(addressof(t2), -xmin * 72 / 72.27, -ymin * 72 / 72.27); - transform_concat(addressof(t), addressof(t2)); - - if result = 0 then begin - - new_whatsit(pic_node, pic_node_size + (strlen(pic_path) + sizeof(memory_word) - 1) div sizeof(memory_word)); - if is_pdf then begin - subtype(tail) := pdf_node; - pic_box_type(tail) := pdf_box_type; - end; - pic_path_length(tail) := strlen(pic_path); - pic_page(tail) := page; - - width(tail) := D2Fix(xmax - xmin); - height(tail) := D2Fix(ymax - ymin); - depth(tail) := 0; - - pic_transform1(tail) := D2Fix(aField(t)); - pic_transform2(tail) := D2Fix(bField(t)); - pic_transform3(tail) := D2Fix(cField(t)); - pic_transform4(tail) := D2Fix(dField(t)); - pic_transform5(tail) := D2Fix(xField(t)); - pic_transform6(tail) := D2Fix(yField(t)); - - memcpy(addressof(mem[tail + pic_node_size]), pic_path, strlen(pic_path)); - libc_free(pic_path); - - end else begin - - print_err("Unable to load picture or PDF file '"); - print_file_name(cur_name,cur_area,cur_ext); print("'"); - if result = -43 then begin { Mac OS file not found error } - help2("The requested image couldn't be read because")@/ - ("the file was not found."); - end - else begin { otherwise assume GraphicImport failed } - help2("The requested image couldn't be read because")@/ - ("it was not a recognized image format."); - end; - error; - - end; + page := 0; + if is_pdf then begin + if scan_keyword("page") then begin + scan_int; + page := cur_val; + end; + pdf_box_type := pdfbox_crop; + if scan_keyword("crop") then do_nothing + else if scan_keyword("media") then pdf_box_type := pdfbox_media + else if scan_keyword("bleed") then pdf_box_type := pdfbox_bleed + else if scan_keyword("trim") then pdf_box_type := pdfbox_trim + else if scan_keyword("art") then pdf_box_type := pdfbox_art; + end; + + { access the picture file and check its size } + result := find_pic_file(addressof(pic_path), addressof(bounds), pdf_box_type, page); + + setPoint(corners[0], xField(bounds), yField(bounds)); + setPoint(corners[1], xField(corners[0]), yField(bounds) + htField(bounds)); + setPoint(corners[2], xField(bounds) + wdField(bounds), yField(corners[1])); + setPoint(corners[3], xField(corners[2]), yField(corners[0])); + + x_size_req := 0.0; + y_size_req := 0.0; + + { look for any scaling requests for this picture } + make_identity(addressof(t)); + + check_keywords := true; + while check_keywords do begin + if scan_keyword("scaled") then begin + scan_int; + if (x_size_req = 0.0) and (y_size_req = 0.0) then begin + make_scale(addressof(t2), float(cur_val) / 1000.0, float(cur_val) / 1000.0); + update_corners; + transform_concat(addressof(t), addressof(t2)); + end + end else if scan_keyword("xscaled") then begin + scan_int; + if (x_size_req = 0.0) and (y_size_req = 0.0) then begin + make_scale(addressof(t2), float(cur_val) / 1000.0, 1.0); + update_corners; + transform_concat(addressof(t), addressof(t2)); + end + end else if scan_keyword("yscaled") then begin + scan_int; + if (x_size_req = 0.0) and (y_size_req = 0.0) then begin + make_scale(addressof(t2), 1.0, float(cur_val) / 1000.0); + update_corners; + transform_concat(addressof(t), addressof(t2)); + end + end else if scan_keyword("width") then begin + scan_normal_dimen; + if cur_val <= 0 then begin + print_err("Improper image "); + print("size ("); + print_scaled(cur_val); + print("pt) will be ignored"); + help2("I can't scale images to zero or negative sizes,")@/ + ("so I'm ignoring this."); + error; + end else + x_size_req := Fix2D(cur_val); + end else if scan_keyword("height") then begin + scan_normal_dimen; + if cur_val <= 0 then begin + print_err("Improper image "); + print("size ("); + print_scaled(cur_val); + print("pt) will be ignored"); + help2("I can't scale images to zero or negative sizes,")@/ + ("so I'm ignoring this."); + error; + end else + y_size_req := Fix2D(cur_val); + end else if scan_keyword("rotated") then begin + scan_decimal; + if (x_size_req <> 0.0) or (y_size_req <> 0.0) then do_size_requests; + make_rotation(addressof(t2), Fix2D(cur_val) * 3.141592653589793 / 180.0); + update_corners; + calc_min_and_max; + setPoint(corners[0], xmin, ymin); + setPoint(corners[1], xmin, ymax); + setPoint(corners[2], xmax, ymax); + setPoint(corners[3], xmax, ymin); + transform_concat(addressof(t), addressof(t2)); + end else + check_keywords := false; + end; + + if (x_size_req <> 0.0) or (y_size_req <> 0.0) then do_size_requests; + + calc_min_and_max; + make_translation(addressof(t2), -xmin * 72 / 72.27, -ymin * 72 / 72.27); + transform_concat(addressof(t), addressof(t2)); + + if result = 0 then begin + + new_whatsit(pic_node, pic_node_size + (strlen(pic_path) + sizeof(memory_word) - 1) div sizeof(memory_word)); + if is_pdf then begin + subtype(tail) := pdf_node; + pic_box_type(tail) := pdf_box_type; + end; + pic_path_length(tail) := strlen(pic_path); + pic_page(tail) := page; + + width(tail) := D2Fix(xmax - xmin); + height(tail) := D2Fix(ymax - ymin); + depth(tail) := 0; + + pic_transform1(tail) := D2Fix(aField(t)); + pic_transform2(tail) := D2Fix(bField(t)); + pic_transform3(tail) := D2Fix(cField(t)); + pic_transform4(tail) := D2Fix(dField(t)); + pic_transform5(tail) := D2Fix(xField(t)); + pic_transform6(tail) := D2Fix(yField(t)); + + memcpy(addressof(mem[tail + pic_node_size]), pic_path, strlen(pic_path)); + libc_free(pic_path); + + end else begin + + print_err("Unable to load picture or PDF file '"); + print_file_name(cur_name,cur_area,cur_ext); print("'"); + if result = -43 then begin { Mac OS file not found error } + help2("The requested image couldn't be read because")@/ + ("the file was not found."); + end + else begin { otherwise assume GraphicImport failed } + help2("The requested image couldn't be read because")@/ + ("it was not a recognized image format."); + end; + error; + + end; end; @ @<Implement \.{\\XeTeXinputencoding}@>= begin - scan_and_pack_name; {scan a filename-like arg for the input encoding} + scan_and_pack_name; {scan a filename-like arg for the input encoding} - i := get_encoding_mode_and_info(addressof(j)); {convert it to |mode| and |encoding| values} - if i = XeTeX_input_mode_auto then begin - print_err("Encoding mode `auto' is not valid for \XeTeXinputencoding"); + i := get_encoding_mode_and_info(addressof(j)); {convert it to |mode| and |encoding| values} + if i = XeTeX_input_mode_auto then begin + print_err("Encoding mode `auto' is not valid for \XeTeXinputencoding"); help2("You can't use `auto' encoding here, only for \XeTeXdefaultencoding.")@/ ("I'll ignore this and leave the current encoding unchanged.");@/ - error; - end else set_input_file_encoding(input_file[in_open], i, j); {apply them to the current input file} + error; + end else set_input_file_encoding(input_file[in_open], i, j); {apply them to the current input file} end @ @<Implement \.{\\XeTeXdefaultencoding}@>= begin - scan_and_pack_name; {scan a filename-like arg for the input encoding} + scan_and_pack_name; {scan a filename-like arg for the input encoding} - i := get_encoding_mode_and_info(addressof(j)); {convert it to |mode| and |encoding| values} - XeTeX_default_input_mode := i; {store them as defaults for new input files} - XeTeX_default_input_encoding := j; + i := get_encoding_mode_and_info(addressof(j)); {convert it to |mode| and |encoding| values} + XeTeX_default_input_mode := i; {store them as defaults for new input files} + XeTeX_default_input_encoding := j; end @ @<Implement \.{\\XeTeXlinebreaklocale}@>= begin - scan_file_name; {scan a filename-like arg for the locale name} - if length(cur_name) = 0 then XeTeX_linebreak_locale := 0 - else XeTeX_linebreak_locale := cur_name; {we ignore the area and extension!} + scan_file_name; {scan a filename-like arg for the locale name} + if length(cur_name) = 0 then XeTeX_linebreak_locale := 0 + else XeTeX_linebreak_locale := cur_name; {we ignore the area and extension!} end @ @<Glob...@>= @@ -30084,7 +30089,7 @@ XeTeX_variation_name_code: XeTeX_feature_name_code: begin scan_font_ident; fnt:=cur_val; - if is_aat_font(fnt) or is_gr_font(fnt) then begin + if (is_aat_font(fnt)) or (is_gr_font(fnt)) then begin scan_int; arg1:=cur_val; arg2:=0; end else not_aat_gr_font_error(convert, c, fnt); @@ -30093,7 +30098,7 @@ XeTeX_feature_name_code: XeTeX_selector_name_code: begin scan_font_ident; fnt:=cur_val; - if is_aat_font(fnt) or is_gr_font(fnt) then begin + if (is_aat_font(fnt)) or (is_gr_font(fnt)) then begin scan_int; arg1:=cur_val; scan_int; arg2:=cur_val; end else not_aat_gr_font_error(convert, c, fnt); @@ -30165,7 +30170,7 @@ right_margin_kern_code: begin print("pt"); end; -@ @d eTeX_ex==(eTeX_mode=1) {is this extended mode?} +@ @d eTeX_ex==eTeX_mode=1 {is this extended mode?} @<Glob...@>= @!eTeX_mode: 0..1; {identifies compatibility and extended mode} diff --git a/Build/source/texk/web2c/xetexdir/xetexextra.h b/Build/source/texk/web2c/xetexdir/xetexextra.h index 0751fbfe4d8..6fb91423fa0 100644 --- a/Build/source/texk/web2c/xetexdir/xetexextra.h +++ b/Build/source/texk/web2c/xetexdir/xetexextra.h @@ -57,7 +57,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include <xetexdir/xetex_version.h> /* for XETEX_VERSION */ #define BANNER "This is XeTeX, Version 3.14159265-" ETEX_VERSION "-" XETEX_VERSION -#define COPYRIGHT_HOLDER "SIL International and Jonathan Kew" +#define COPYRIGHT_HOLDER "SIL International, Jonathan Kew and Khaled Hosny" #define AUTHOR "Jonathan Kew" #define PROGRAM_HELP XETEXHELP #define BUG_ADDRESS "xetex@tug.org" |