From 622bf4a7c90729be28a038c49e4c237ce9f31297 Mon Sep 17 00:00:00 2001 From: Jonathan Kew Date: Wed, 26 Jul 2006 16:19:45 +0000 Subject: added main xetex source directory git-svn-id: svn://tug.org/texlive/trunk@1920 c570f23f-e606-0410-a88d-b1316a301751 --- .../source/texk/web2c/xetexdir/FontTableCache.cpp | 134 + Build/source/texk/web2c/xetexdir/FontTableCache.h | 74 + Build/source/texk/web2c/xetexdir/XeTeXFontInst.cpp | 295 + Build/source/texk/web2c/xetexdir/XeTeXFontInst.h | 205 + .../texk/web2c/xetexdir/XeTeXFontInst_FC.cpp | 217 + .../source/texk/web2c/xetexdir/XeTeXFontInst_FC.h | 76 + .../texk/web2c/xetexdir/XeTeXFontInst_Mac.cpp | 111 + .../source/texk/web2c/xetexdir/XeTeXFontInst_Mac.h | 63 + Build/source/texk/web2c/xetexdir/XeTeXFontMgr.cpp | 621 ++ Build/source/texk/web2c/xetexdir/XeTeXFontMgr.h | 202 + .../texk/web2c/xetexdir/XeTeXFontMgr_Linux.cpp | 317 + .../texk/web2c/xetexdir/XeTeXFontMgr_Linux.h | 59 + .../source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.h | 64 + .../source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.mm | 280 + .../texk/web2c/xetexdir/XeTeXLayoutInterface.cpp | 519 ++ .../texk/web2c/xetexdir/XeTeXLayoutInterface.h | 134 + .../texk/web2c/xetexdir/XeTeXOTLayoutEngine.cpp | 281 + .../texk/web2c/xetexdir/XeTeXOTLayoutEngine.h | 128 + Build/source/texk/web2c/xetexdir/XeTeX_ext.c | 2302 ++++++++ Build/source/texk/web2c/xetexdir/XeTeX_ext.h | 284 + Build/source/texk/web2c/xetexdir/XeTeX_mac.c | 1022 ++++ Build/source/texk/web2c/xetexdir/XeTeX_pic.c | 111 + Build/source/texk/web2c/xetexdir/XeTeXswap.h | 96 + Build/source/texk/web2c/xetexdir/appleGlyphNames.c | 291 + Build/source/texk/web2c/xetexdir/bmpimage.c | 201 + Build/source/texk/web2c/xetexdir/bmpimage.h | 70 + Build/source/texk/web2c/xetexdir/cmaps.cpp | 240 + Build/source/texk/web2c/xetexdir/cmaps.h | 116 + Build/source/texk/web2c/xetexdir/cpl1.0.txt | 213 + Build/source/texk/web2c/xetexdir/jpegimage.c | 410 ++ Build/source/texk/web2c/xetexdir/jpegimage.h | 166 + Build/source/texk/web2c/xetexdir/mfileio.c | 126 + Build/source/texk/web2c/xetexdir/mfileio.h | 61 + Build/source/texk/web2c/xetexdir/numbers.c | 227 + Build/source/texk/web2c/xetexdir/numbers.h | 82 + Build/source/texk/web2c/xetexdir/pdfimage.cpp | 77 + Build/source/texk/web2c/xetexdir/pdfimage.h | 27 + Build/source/texk/web2c/xetexdir/pngimage.c | 161 + Build/source/texk/web2c/xetexdir/pngimage.h | 70 + Build/source/texk/web2c/xetexdir/sfnt.h | 285 + Build/source/texk/web2c/xetexdir/tests.ac | 49 + Build/source/texk/web2c/xetexdir/trans.c | 116 + Build/source/texk/web2c/xetexdir/trans.h | 94 + .../texk/web2c/xetexdir/unicode-char-prep.pl | 116 + Build/source/texk/web2c/xetexdir/xetex-new.ch | 6169 ++++++++++++++++++++ Build/source/texk/web2c/xetexdir/xetex-noenc.ch | 1144 ++++ Build/source/texk/web2c/xetexdir/xetex-upwards.ch | 244 + Build/source/texk/web2c/xetexdir/xetex.defines | 136 + Build/source/texk/web2c/xetexdir/xetex.h | 100 + Build/source/texk/web2c/xetexdir/xetex.mk | 303 + Build/source/texk/web2c/xetexdir/xetexextra.in | 65 + 51 files changed, 18954 insertions(+) create mode 100644 Build/source/texk/web2c/xetexdir/FontTableCache.cpp create mode 100644 Build/source/texk/web2c/xetexdir/FontTableCache.h create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXFontInst.cpp create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXFontInst.h create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXFontInst_FC.cpp create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXFontInst_FC.h create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.cpp create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.h create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXFontMgr.cpp create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXFontMgr.h create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Linux.cpp create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Linux.h create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.h create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.mm create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.cpp create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.h create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXOTLayoutEngine.cpp create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXOTLayoutEngine.h create mode 100644 Build/source/texk/web2c/xetexdir/XeTeX_ext.c create mode 100644 Build/source/texk/web2c/xetexdir/XeTeX_ext.h create mode 100644 Build/source/texk/web2c/xetexdir/XeTeX_mac.c create mode 100644 Build/source/texk/web2c/xetexdir/XeTeX_pic.c create mode 100644 Build/source/texk/web2c/xetexdir/XeTeXswap.h create mode 100644 Build/source/texk/web2c/xetexdir/appleGlyphNames.c create mode 100644 Build/source/texk/web2c/xetexdir/bmpimage.c create mode 100644 Build/source/texk/web2c/xetexdir/bmpimage.h create mode 100644 Build/source/texk/web2c/xetexdir/cmaps.cpp create mode 100644 Build/source/texk/web2c/xetexdir/cmaps.h create mode 100644 Build/source/texk/web2c/xetexdir/cpl1.0.txt create mode 100644 Build/source/texk/web2c/xetexdir/jpegimage.c create mode 100644 Build/source/texk/web2c/xetexdir/jpegimage.h create mode 100644 Build/source/texk/web2c/xetexdir/mfileio.c create mode 100644 Build/source/texk/web2c/xetexdir/mfileio.h create mode 100644 Build/source/texk/web2c/xetexdir/numbers.c create mode 100644 Build/source/texk/web2c/xetexdir/numbers.h create mode 100644 Build/source/texk/web2c/xetexdir/pdfimage.cpp create mode 100644 Build/source/texk/web2c/xetexdir/pdfimage.h create mode 100644 Build/source/texk/web2c/xetexdir/pngimage.c create mode 100644 Build/source/texk/web2c/xetexdir/pngimage.h create mode 100644 Build/source/texk/web2c/xetexdir/sfnt.h create mode 100644 Build/source/texk/web2c/xetexdir/tests.ac create mode 100644 Build/source/texk/web2c/xetexdir/trans.c create mode 100644 Build/source/texk/web2c/xetexdir/trans.h create mode 100644 Build/source/texk/web2c/xetexdir/unicode-char-prep.pl create mode 100644 Build/source/texk/web2c/xetexdir/xetex-new.ch create mode 100644 Build/source/texk/web2c/xetexdir/xetex-noenc.ch create mode 100644 Build/source/texk/web2c/xetexdir/xetex-upwards.ch create mode 100644 Build/source/texk/web2c/xetexdir/xetex.defines create mode 100644 Build/source/texk/web2c/xetexdir/xetex.h create mode 100644 Build/source/texk/web2c/xetexdir/xetex.mk create mode 100644 Build/source/texk/web2c/xetexdir/xetexextra.in diff --git a/Build/source/texk/web2c/xetexdir/FontTableCache.cpp b/Build/source/texk/web2c/xetexdir/FontTableCache.cpp new file mode 100644 index 00000000000..af5cd710a00 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/FontTableCache.cpp @@ -0,0 +1,134 @@ +/* + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +*/ + +/* from ICU sample code, extended by JK for XeTeX */ + +/* + ********************************************************************** + * Copyright (C) 2003, International Business Machines + * Corporation and others. All Rights Reserved. + ********************************************************************** + */ + +#include "LETypes.h" + +#include "FontTableCache.h" + +#define TABLE_CACHE_INIT 5 +#define TABLE_CACHE_GROW 5 + +struct FontTableCacheEntry +{ + LETag tag; + const void *table; +}; + +FontTableCache::FontTableCache() + : fTableCacheCurr(0), fTableCacheSize(TABLE_CACHE_INIT) +{ + initialize(); +} + +void +FontTableCache::initialize() +{ + fTableCache = LE_NEW_ARRAY(FontTableCacheEntry, fTableCacheSize); + + if (fTableCache == NULL) { + fTableCacheSize = 0; + return; + } + + for (int i = 0; i < fTableCacheSize; i += 1) { + fTableCache[i].tag = 0; + fTableCache[i].table = NULL; + } +} + +FontTableCache::~FontTableCache() +{ + dispose(); +} + +void FontTableCache::dispose() +{ + for (int i = fTableCacheCurr - 1; i >= 0; i -= 1) { + LE_DELETE_ARRAY(fTableCache[i].table); + + fTableCache[i].tag = 0; + fTableCache[i].table = NULL; + } + + fTableCacheCurr = 0; +} + +const void *FontTableCache::find(LETag tableTag) const +{ + for (int i = 0; i < fTableCacheCurr; i += 1) { + if (fTableCache[i].tag == tableTag) { + return fTableCache[i].table; + } + } + + const void *table = readFontTable(tableTag); + + ((FontTableCache *) this)->add(tableTag, table); + + return table; +} + +void FontTableCache::add(LETag tableTag, const void *table) +{ + if (fTableCacheCurr >= fTableCacheSize) { + le_int32 newSize = fTableCacheSize + TABLE_CACHE_GROW; + + fTableCache = (FontTableCacheEntry *) LE_GROW_ARRAY(fTableCache, newSize); + + for (le_int32 i = fTableCacheSize; i < newSize; i += 1) { + fTableCache[i].tag = 0; + fTableCache[i].table = NULL; + } + + fTableCacheSize = newSize; + } + + fTableCache[fTableCacheCurr].tag = tableTag; + fTableCache[fTableCacheCurr].table = table; + + fTableCacheCurr += 1; +} + +void FontTableCache::flush() +{ + if (fTableCacheSize > 0) { + dispose(); + initialize(); + } +} diff --git a/Build/source/texk/web2c/xetexdir/FontTableCache.h b/Build/source/texk/web2c/xetexdir/FontTableCache.h new file mode 100644 index 00000000000..03d71ac7110 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/FontTableCache.h @@ -0,0 +1,74 @@ +/* + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +*/ +/* from ICU sample code, extended by JK for XeTeX */ + +/* + ********************************************************************** + * Copyright (C) 2003, International Business Machines + * Corporation and others. All Rights Reserved. + ********************************************************************** + */ + +#ifndef __FONTTABLECACHE_H + +#define __FONTTABLECACHE_H + +#include "LETypes.h" + +struct FontTableCacheEntry; + +class FontTableCache +{ +public: + FontTableCache(); + + virtual ~FontTableCache(); + + const void *find(LETag tableTag) const; + + void flush(); + +protected: + virtual const void *readFontTable(LETag tableTag) const = 0; + +private: + + void initialize(); + void dispose(); + + void add(LETag tableTag, const void *table); + + FontTableCacheEntry *fTableCache; + le_int32 fTableCacheCurr; + le_int32 fTableCacheSize; +}; + +#endif + diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontInst.cpp b/Build/source/texk/web2c/xetexdir/XeTeXFontInst.cpp new file mode 100644 index 00000000000..b11138b920b --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontInst.cpp @@ -0,0 +1,295 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +/* + * file name: XeTeXFontInst.cpp + * + * created on: 2005-10-22 + * created by: Jonathan Kew + * + * originally based on PortableFontInstance.cpp from ICU + */ + + +#include "LETypes.h" +#include "LEFontInstance.h" +#include "LESwaps.h" + +#include "XeTeXFontInst.h" +#include "XeTeXLayoutInterface.h" + +#ifdef XETEX_MAC +#include +#endif + +#include "XeTeX_ext.h" + +#include "sfnt.h" + +#include + + +XeTeXFontInst::XeTeXFontInst(PlatformFontRef fontRef, float pointSize, LEErrorCode &status) + : fFontRef(fontRef) + , fPointSize(pointSize) + , fUnitsPerEM(0) + , fAscent(0) + , fDescent(0) + , fLeading(0) + , fXHeight(0) + , fItalicAngle(0) + , fCMAPMapper(NULL) + , fMetricsTable(NULL) + , fNumLongMetrics(0) + , fNumGlyphs(0) + , fNumGlyphsInited(false) + , fVertical(false) +{ + // the concrete subclass is responsible to call initialize() +} + +XeTeXFontInst::~XeTeXFontInst() +{ + if (fMetricsTable != NULL) + deleteTable(fMetricsTable); + + if (fCMAPMapper != NULL) + delete fCMAPMapper; +} + +void XeTeXFontInst::initialize(LEErrorCode &status) +{ + const LETag headTag = LE_HEAD_TABLE_TAG; + const LETag hheaTag = LE_HHEA_TABLE_TAG; + const LETag vheaTag = LE_VHEA_TABLE_TAG; + const LETag postTag = LE_POST_TABLE_TAG; + const HEADTable *headTable = NULL; + const HHEATable *dirHeadTable = NULL; + const POSTTable *postTable = NULL; + + // dispose of any cached metrics table + if (fMetricsTable != NULL) { + deleteTable(fMetricsTable); + fMetricsTable = NULL; + } + + // read unitsPerEm from 'head' table + headTable = (const HEADTable *) readFontTable(headTag); + + if (headTable == NULL) { + status = LE_MISSING_FONT_TABLE_ERROR; + goto error_exit; + } + + fUnitsPerEM = SWAPW(headTable->unitsPerEm); + deleteTable(headTable); + + // we use the fact that 'hhea' and 'vhea' have the same format! + dirHeadTable = (const HHEATable *) readFontTable(fVertical ? vheaTag : hheaTag); + + if (dirHeadTable == NULL) { + status = LE_MISSING_FONT_TABLE_ERROR; + goto error_exit; + } + + fAscent = yUnitsToPoints((float)(le_int16)SWAPW(dirHeadTable->ascent)); + fDescent = yUnitsToPoints((float)(le_int16)SWAPW(dirHeadTable->descent)); + fLeading = yUnitsToPoints((float)(le_int16)SWAPW(dirHeadTable->lineGap)); + + fNumLongMetrics = SWAPW(dirHeadTable->numOfLongHorMetrics); + + deleteTable(dirHeadTable); + + fCMAPMapper = findUnicodeMapper(); + + if (fCMAPMapper == NULL) { + status = LE_MISSING_FONT_TABLE_ERROR; + goto error_exit; + } + + postTable = (const POSTTable *) readFontTable(postTag); + + if (postTable != NULL) { + fItalicAngle = Fix2X(SWAPL(postTable->italicAngle)); + deleteTable(postTable); + } + + return; + +error_exit: + return; +} + +void XeTeXFontInst::setLayoutDirVertical(bool vertical) +{ + fVertical = vertical; + LEErrorCode status = LE_NO_ERROR; + initialize(status); +} + +void XeTeXFontInst::deleteTable(const void *table) const +{ + LE_DELETE_ARRAY(table); +} + +const void *XeTeXFontInst::getFontTable(LETag tableTag) const +{ + return FontTableCache::find(tableTag); +} + +const void *XeTeXFontInst::readFontTable(LETag tableTag) const +{ + le_uint32 len; + + return readTable(tableTag, &len); +} + +const void *XeTeXFontInst::readFontTable(LETag tableTag, le_uint32& len) const +{ + return readTable(tableTag, &len); +} + +CMAPMapper *XeTeXFontInst::findUnicodeMapper() +{ + LETag cmapTag = LE_CMAP_TABLE_TAG; + const CMAPTable *cmap = (CMAPTable *) readFontTable(cmapTag); + + if (cmap == NULL) { + return NULL; + } + + return CMAPMapper::createUnicodeMapper(cmap); +} + + +le_uint16 XeTeXFontInst::getNumGlyphs() const +{ + if (!fNumGlyphsInited) { + LETag maxpTag = LE_MAXP_TABLE_TAG; + const MAXPTable *maxpTable = (MAXPTable *) readFontTable(maxpTag); + + if (maxpTable != NULL) { + XeTeXFontInst *realThis = (XeTeXFontInst *) this; + realThis->fNumGlyphs = SWAPW(maxpTable->numGlyphs); + deleteTable(maxpTable); + realThis->fNumGlyphsInited = true; + } + } + + return fNumGlyphs; +} + +void XeTeXFontInst::getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const +{ + TTGlyphID ttGlyph = (TTGlyphID) LE_GET_GLYPH(glyph); + + if (fMetricsTable == NULL) { + // we use the fact that 'hmtx' and 'vmtx' have the same format + LETag metricsTag = fVertical ? LE_VMTX_TABLE_TAG : LE_HMTX_TABLE_TAG; + XeTeXFontInst *realThis = (XeTeXFontInst *) this; + realThis->fMetricsTable = (const HMTXTable *) readFontTable(metricsTag); + } + + le_uint16 index = ttGlyph; + + if (ttGlyph >= getNumGlyphs() || fMetricsTable == NULL) { + advance.fX = advance.fY = 0; + return; + } + + if (ttGlyph >= fNumLongMetrics) { + index = fNumLongMetrics - 1; + } + + advance.fX = xUnitsToPoints(SWAPW(fMetricsTable->hMetrics[index].advanceWidth)); + advance.fY = 0; +} + +le_bool XeTeXFontInst::getGlyphPoint(LEGlyphID glyph, le_int32 pointNumber, LEPoint &point) const +{ + return FALSE; +} + +float +XeTeXFontInst::getGlyphWidth(LEGlyphID gid) +{ + LEPoint advance; + getGlyphAdvance(gid, advance); + return advance.fX; +} + +void +XeTeXFontInst::getGlyphHeightDepth(LEGlyphID gid, float* ht, float* dp) +{ + GlyphBBox bbox; + getGlyphBounds(gid, &bbox); + + *ht = bbox.yMax; + *dp = -bbox.yMin; +} + +void +XeTeXFontInst::getGlyphSidebearings(LEGlyphID gid, float* lsb, float* rsb) +{ + LEPoint adv; + getGlyphAdvance(gid, adv); + + GlyphBBox bbox; + getGlyphBounds(gid, &bbox); + + *lsb = bbox.xMin; + *rsb = adv.fX - bbox.xMax; +} + +float +XeTeXFontInst::getGlyphItalCorr(LEGlyphID gid) +{ + float rval = 0.0; + + LEPoint adv; + getGlyphAdvance(gid, adv); + + GlyphBBox bbox; + getGlyphBounds(gid, &bbox); + + if (bbox.xMax > adv.fX) + rval = bbox.xMax - adv.fX; + + return rval; +} + +LEGlyphID +XeTeXFontInst::mapGlyphToIndex(const char* glyphName) const + /* default implementation, may be overridden (e.g. by Freetype-based XeTeXFontInst_ */ +{ + le_uint32 len; + const char *p = (const char*)readFontTable(LE_POST_TABLE_TAG, len); + return findGlyphInPostTable(p, len, glyphName); +} diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontInst.h b/Build/source/texk/web2c/xetexdir/XeTeXFontInst.h new file mode 100644 index 00000000000..d158186b66f --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontInst.h @@ -0,0 +1,205 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +/* + * file name: XeTeXFontInst.h + * + * created on: 2005-10-22 + * created by: Jonathan Kew + * + * originally based on PortableFontInstance.h from ICU + */ + + +#ifndef __XeTeXFontInst_H +#define __XeTeXFontInst_H + +#include + +#include "LETypes.h" +#include "LEFontInstance.h" + +#include "FontTableCache.h" + +#include "sfnt.h" +#include "cmaps.h" + +#include "XeTeXFontMgr.h" +#include "XeTeX_ext.h" + +extern "C" { + void *xmalloc(unsigned); // from kpathsea +}; + +// Abstract superclass that XeTeXOTLayoutEngine uses; +// create specific subclasses for each supported platform + +class XeTeXFontInst : public LEFontInstance, protected FontTableCache +{ +protected: + PlatformFontRef fFontRef; + + float fPointSize; + + le_int32 fUnitsPerEM; + float fAscent; + float fDescent; + float fLeading; + + float fDeviceScaleX; + float fDeviceScaleY; + + float fXHeight; + float fItalicAngle; + + CMAPMapper *fCMAPMapper; + + const HMTXTable *fMetricsTable; + le_uint16 fNumLongMetrics; + le_uint16 fNumGlyphs; + bool fNumGlyphsInited; + + bool fVertical; // false = horizontal, true = vertical + + virtual const void *readTable(LETag tag, le_uint32 *length) const = 0; + void deleteTable(const void *table) const; + void getMetrics(); + + CMAPMapper *findUnicodeMapper(); + + const void *readFontTable(LETag tableTag) const; + const void *readFontTable(LETag tableTag, le_uint32& len) const; + +public: + XeTeXFontInst(PlatformFontRef fontRef, float pointSize, LEErrorCode &status); + + virtual ~XeTeXFontInst(); + + virtual PlatformFontRef getFontRef() const + { return fFontRef; } + + virtual void initialize(LEErrorCode &status); + + virtual const void *getFontTable(LETag tableTag) const; + + virtual void setLayoutDirVertical(bool vertical); + + virtual bool getLayoutDirVertical() const + { + return fVertical; + }; + + virtual le_int32 getUnitsPerEM() const + { + return fUnitsPerEM; + }; + + virtual le_int32 getAscent() const + { + return (le_int32)fAscent; + } + + virtual le_int32 getDescent() const + { + return (le_int32)fDescent; + } + + virtual le_int32 getLeading() const + { + return (le_int32)fLeading; + } + + virtual float getExactAscent() const + { + return fAscent; + } + + virtual float getExactDescent() const + { + return fDescent; + } + + virtual float getExactLeading() const + { + return fLeading; + } + + virtual LEGlyphID mapCharToGlyph(LEUnicode32 ch) const + { + return fCMAPMapper->unicodeToGlyph(ch); + } + + virtual LEGlyphID mapGlyphToIndex(const char* glyphName) const; + + virtual le_uint16 getNumGlyphs() const; + + virtual void getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const; + + virtual le_bool getGlyphPoint(LEGlyphID glyph, le_int32 pointNumber, LEPoint &point) const; + + virtual void getGlyphBounds(LEGlyphID glyph, GlyphBBox *bbox) = 0; /* must be implemented by subclass */ + + float getGlyphWidth(LEGlyphID glyph); + void getGlyphHeightDepth(LEGlyphID glyph, float *ht, float* dp); + void getGlyphSidebearings(LEGlyphID glyph, float* lsb, float* rsb); + float getGlyphItalCorr(LEGlyphID glyph); + + float getXPixelsPerEm() const + { + return fPointSize; + }; + + float getYPixelsPerEm() const + { + return fPointSize; + }; + + float getScaleFactorX() const + { + return 1.0; + } + + float getScaleFactorY() const + { + return 1.0; + } + + float getXHeight() const + { + return fXHeight; + } + + float getItalicAngle() const + { + return fItalicAngle; + } +}; + +#endif diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontInst_FC.cpp b/Build/source/texk/web2c/xetexdir/XeTeXFontInst_FC.cpp new file mode 100644 index 00000000000..499ed7d19b0 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontInst_FC.cpp @@ -0,0 +1,217 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +/* + * file name: XeTeXFontInst_FC.cpp + * + * created on: 2005-10-25 + * created by: Jonathan Kew + */ + + +#include "XeTeXFontInst_FC.h" + +#include FT_TRUETYPE_TABLES_H +#include FT_TYPE1_TABLES_H +#include FT_GLYPH_H + +static FT_Library gLibrary = 0; + + +XeTeXFontInst_FC::XeTeXFontInst_FC(FcPattern* pattern, float pointSize, LEErrorCode &status) + : XeTeXFontInst(pattern, pointSize, status) + , face(0) + , fFreeTypeOnly(false) +{ + if (LE_FAILURE(status)) { + return; + } + + FT_Error err; + if (!gLibrary) { + err = FT_Init_FreeType(&gLibrary); + if (err != 0) { + fprintf(stderr, "FreeType initialization failed! (%d)\n", err); + exit(1); + } + } + + FcChar8* pathname = 0; + FcPatternGetString(pattern, FC_FILE, 0, &pathname); + int index; + FcPatternGetInteger(pattern, FC_INDEX, 0, &index); + + err = FT_New_Face(gLibrary, (char*)pathname, index, &face); + + if (err != 0) { + status = LE_FONT_FILE_NOT_FOUND_ERROR; + return; + } + + initialize(status); +} + +XeTeXFontInst_FC::~XeTeXFontInst_FC() +{ + if (face != 0) { + FT_Done_Face(face); + face = 0; + } +} + +void XeTeXFontInst_FC::initialize(LEErrorCode &status) +{ + if (face == 0) { + status = LE_FONT_FILE_NOT_FOUND_ERROR; + return; + } + + XeTeXFontInst::initialize(status); + + if (LE_FAILURE(status)) { + /* font can ONLY be used via FreeType APIs, not direct table access */ + fFreeTypeOnly = true; + status = LE_NO_ERROR; + + /* fill in fields that XeTeXFontInst::initialize failed to get for us */ + fUnitsPerEM = face->units_per_EM; + fAscent = yUnitsToPoints(face->ascender); + fDescent = yUnitsToPoints(face->descender); +// fLeading = ; + fItalicAngle = 0; + PS_FontInfoRec font_info; + if (FT_Get_PS_Font_Info(face, &font_info) == 0) { + // will return error if it wasn't a PS font + fItalicAngle = font_info.italic_angle; + } + } + + return; +} + +const void *XeTeXFontInst_FC::readTable(LETag tag, le_uint32 *length) const +{ + *length = 0; + FT_ULong tmpLength = 0; + FT_Error err = FT_Load_Sfnt_Table(face, tag, 0, NULL, &tmpLength); + if (err != 0) + return NULL; + + void* table = LE_NEW_ARRAY(char, tmpLength); + if (table != NULL) { + err = FT_Load_Sfnt_Table(face, tag, 0, (FT_Byte*)table, &tmpLength); + if (err != 0) { + LE_DELETE_ARRAY(table); + return NULL; + } + *length = tmpLength; + } + + return table; +} + +char* XeTeXFontInst_FC::getPSName() const +{ + if (face == NULL) + return NULL; + + const char* facePSName = FT_Get_Postscript_Name(face); + if (facePSName == NULL) + return NULL; + + le_uint32 length = strlen(facePSName); + char* name = (char*)xmalloc(length + 1); + strcpy(name, facePSName); + + return name; +} + +void +XeTeXFontInst_FC::getGlyphBounds(LEGlyphID gid, GlyphBBox* bbox) +{ + bbox->xMin = bbox->yMin = bbox->xMax = bbox->yMax = 0.0; + + FT_Error err = FT_Load_Glyph(face, gid, FT_LOAD_NO_SCALE); + if (err != 0) + return; + + FT_Glyph glyph; + err = FT_Get_Glyph(face->glyph, &glyph); + if (err == 0) { + FT_BBox ft_bbox; + FT_Glyph_Get_CBox(glyph, FT_GLYPH_BBOX_UNSCALED, &ft_bbox); + bbox->xMin = ft_bbox.xMin * fPointSize / fUnitsPerEM; + bbox->yMin = ft_bbox.yMin * fPointSize / fUnitsPerEM; + bbox->xMax = ft_bbox.xMax * fPointSize / fUnitsPerEM; + bbox->yMax = ft_bbox.yMax * fPointSize / fUnitsPerEM; + FT_Done_Glyph(glyph); + } +} + +LEGlyphID +XeTeXFontInst_FC::mapCharToGlyph(LEUnicode32 ch) const +{ + if (!fFreeTypeOnly) + return XeTeXFontInst::mapCharToGlyph(ch); + + return FT_Get_Char_Index(face, ch); +} + +le_uint16 +XeTeXFontInst_FC::getNumGlyphs() const +{ + return face->num_glyphs; +} + +void +XeTeXFontInst_FC::getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const +{ + if (!fFreeTypeOnly) + XeTeXFontInst::getGlyphAdvance(glyph, advance); + else { + FT_Error err = FT_Load_Glyph(face, glyph, FT_LOAD_NO_SCALE); + if (err != 0) { + advance.fX = advance.fY = 0; + } + else { + advance.fX = fVertical ? 0 : face->glyph->metrics.horiAdvance * fPointSize / fUnitsPerEM; + advance.fY = fVertical ? face->glyph->metrics.vertAdvance * fPointSize / fUnitsPerEM : 0; + } + } +} + +LEGlyphID +XeTeXFontInst_FC::mapGlyphToIndex(const char* glyphName) const +{ + LEGlyphID rval = FT_Get_Name_Index(face, const_cast(glyphName)); + if (rval == 0) + rval = XeTeXFontInst::mapGlyphToIndex(glyphName); + return rval; +} diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontInst_FC.h b/Build/source/texk/web2c/xetexdir/XeTeXFontInst_FC.h new file mode 100644 index 00000000000..fc88f509c13 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontInst_FC.h @@ -0,0 +1,76 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +/* + * file name: XeTeXFontInst_FC.h + * + * created on: 2005-10-25 + * created by: Jonathan Kew + */ + + +#ifndef __XeTeXFontInst_FC_H +#define __XeTeXFontInst_FC_H + +#include "XeTeXFontInst.h" + +#include + +#include +#include FT_FREETYPE_H + +class XeTeXFontInst_FC : public XeTeXFontInst +{ +protected: + + const void * readTable(LETag tag, le_uint32 *length) const; + + FT_Face face; + bool fFreeTypeOnly; + +public: + XeTeXFontInst_FC(FcPattern* pattern, float pointSize, LEErrorCode &status); + + virtual ~XeTeXFontInst_FC(); + + virtual void initialize(LEErrorCode &status); + + virtual char* getPSName() const; // returns a malloced string + + virtual void getGlyphBounds(LEGlyphID gid, GlyphBBox* bbox); + + // overrides of XeTeXFontInst methods, in case it's not an sfnt + virtual le_uint16 getNumGlyphs() const; + virtual void getGlyphAdvance(LEGlyphID glyph, LEPoint &advance) const; + virtual LEGlyphID mapCharToGlyph(LEUnicode32 ch) const; + virtual LEGlyphID mapGlyphToIndex(const char* glyphName) const; +}; + +#endif diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.cpp b/Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.cpp new file mode 100644 index 00000000000..2fb44248152 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.cpp @@ -0,0 +1,111 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +/* + * file name: XeTeXFontInst_Mac.cpp + * + * created on: 2005-10-22 + * created by: Jonathan Kew + */ + + +#include "XeTeXFontInst_Mac.h" +#include "XeTeX_ext.h" + +XeTeXFontInst_Mac::XeTeXFontInst_Mac(ATSFontRef atsFont, float pointSize, LEErrorCode &status) + : XeTeXFontInst(atsFont, pointSize, status) + , fStyle(0) +{ + if (LE_FAILURE(status)) { + return; + } + + initialize(status); +} + +XeTeXFontInst_Mac::~XeTeXFontInst_Mac() +{ + if (fStyle != 0) + ATSUDisposeStyle(fStyle); +} + +void XeTeXFontInst_Mac::initialize(LEErrorCode &status) +{ + if (fFontRef == 0) { + status = LE_FONT_FILE_NOT_FOUND_ERROR; + return; + } + + XeTeXFontInst::initialize(status); + + if (status != LE_NO_ERROR) + fFontRef = 0; + + if (ATSUCreateStyle(&fStyle) == noErr) { + ATSUFontID font = FMGetFontFromATSFontRef(fFontRef); + Fixed size = X2Fix(fPointSize * 72.0 / 72.27); /* convert TeX to Quartz points */ + ATSStyleRenderingOptions options = kATSStyleNoHinting; + ATSUAttributeTag tags[3] = { kATSUFontTag, kATSUSizeTag, kATSUStyleRenderingOptionsTag }; + ByteCount valueSizes[3] = { sizeof(ATSUFontID), sizeof(Fixed), sizeof(ATSStyleRenderingOptions) }; + ATSUAttributeValuePtr values[3] = { &font, &size, &options }; + ATSUSetAttributes(fStyle, 3, tags, valueSizes, values); + } + else { + status = LE_FONT_FILE_NOT_FOUND_ERROR; + fFontRef = 0; + } + + return; +} + +const void *XeTeXFontInst_Mac::readTable(LETag tag, le_uint32 *length) const +{ + OSStatus status = ATSFontGetTable(fFontRef, tag, 0, 0, 0, (ByteCount*)length); + if (status != noErr) { + *length = 0; + return NULL; + } + void* table = LE_NEW_ARRAY(char, *length); + if (table != NULL) { + status = ATSFontGetTable(fFontRef, tag, 0, *length, table, (ByteCount*)length); + if (status != noErr) { + *length = 0; + LE_DELETE_ARRAY(table); + return NULL; + } + } + + return table; +} + +void XeTeXFontInst_Mac::getGlyphBounds(LEGlyphID gid, GlyphBBox* bbox) +{ + GetGlyphBBox_AAT(fStyle, gid, bbox); +} diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.h b/Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.h new file mode 100644 index 00000000000..bc3b8831e8b --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontInst_Mac.h @@ -0,0 +1,63 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +/* + * file name: XeTeXFontInst_Mac.h + * + * created on: 2005-10-22 + * created by: Jonathan Kew + */ + + +#ifndef __XeTeXFontInst_Mac_H +#define __XeTeXFontInst_Mac_H + +#include "XeTeXFontInst.h" + +#include + +class XeTeXFontInst_Mac : public XeTeXFontInst +{ +protected: + const void *readTable(LETag tag, le_uint32 *length) const; + + ATSUStyle fStyle; + +public: + XeTeXFontInst_Mac(ATSFontRef atsFont, float pointSize, LEErrorCode &status); + + virtual ~XeTeXFontInst_Mac(); + + virtual void initialize(LEErrorCode &status); + + virtual void getGlyphBounds(LEGlyphID gid, GlyphBBox* bbox); +}; + +#endif diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr.cpp b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr.cpp new file mode 100644 index 00000000000..e6a3efdbdbb --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr.cpp @@ -0,0 +1,621 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +#ifdef XETEX_MAC +#include "XeTeXFontMgr_Mac.h" +#else +#include "XeTeXFontMgr_Linux.h" +#endif + +#include "XeTeXLayoutInterface.h" +#include "XeTeXswap.h" + +#include "Features.h" +#include "GlyphPositioningTables.h" + +#include "sfnt.h" + +#include + +XeTeXFontMgr* XeTeXFontMgr::sFontManager = NULL; +char XeTeXFontMgr::sReqEngine = 0; + +/* use our own fmax function because it seems to be missing on certain platforms + (solaris2.9, at least) */ +static inline double +my_fmax(double x, double y) +{ + return (x > y) ? x : y; +} + +XeTeXFontMgr* +XeTeXFontMgr::GetFontManager() +{ + if (sFontManager == NULL) { +#ifdef XETEX_MAC + sFontManager = new XeTeXFontMgr_Mac; +#else + sFontManager = new XeTeXFontMgr_Linux; +#endif + 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 + } +} + +PlatformFontRef +XeTeXFontMgr::findFont(const char* name, char* variant, double ptSize) + // ptSize is in TeX points + // "variant" string will be shortened (in-place) by removal of /B and /I if present +{ + std::string nameStr(name); + Font* font = NULL; + + for (int pass = 0; pass < 2; ++pass) { + // try full name as given + std::map::iterator i = nameToFont.find(nameStr); + if (i != nameToFont.end()) { + font = i->second; + 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::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; + break; + } + } + } + + // try as PostScript name + i = psNameToFont.find(nameStr); + if (i != psNameToFont.end()) { + font = i->second; + break; + } + + // try for the name as a family name + std::map::iterator f = nameToFamily.find(nameStr); + + if (f != nameToFamily.end()) { + // look for a family member with the "regular" bit set in OS/2 + for (i = f->second->styles->begin(); i != f->second->styles->end(); ++i) + if (i->second->isReg) { + font = i->second; + break; + } + + if (font == NULL) { + // try for style "Regular", "Plain", or "Normal" + 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; + } + } + } + + 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 or I codes from the string + sReqEngine = 0; + bool reqBold = false; + bool reqItal = false; + if (font != NULL && 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) { + sReqEngine = 'I'; + cp += 3; + if (varString.length() > 0 && *(varString.end() - 1) != '/') + varString.append("/"); + varString.append("ICU"); + goto skip_to_slash; + } +/* + if (strncmp(cp, "USP", 3) == 0) { + sReqEngine = 'U'; + cp += 3; + if (varString.length() > 0 && *(varString.end() - 1) != '/') + varString.append("/"); + varString.append("USP"); + goto skip_to_slash; + } + if (strncmp(cp, "PAN", 5) == 0) { + sReqEngine = 'P'; + cp += 3; + if (varString.length() > 0 && *(varString.end() - 1) != '/') + varString.append("/"); + varString.append("PAN"); + goto skip_to_slash; + } + if (strncmp(cp, "GRA", 8) == 0) { + sReqEngine = 'G'; + cp += 3; + if (varString.length() > 0 && *(varString.end() - 1) != '/') + varString.append("/"); + varString.append("GRA"); + 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; + } + } + if (varString.length() > 0 && *(varString.end() - 1) != '/') + varString.append("/"); + varString.append(start, 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::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) { + bestMatch = bestMatchFromFamily(parent, parent->maxWeight, 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 (font != NULL && font->opSizeInfo.subFamilyID != 0 && ptSize != 0.0) { + ptSize = ptSize * 720 / 72.27; // convert TeX points to PS 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::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; + } + } + + return font->fontRef; +} + +const char* +XeTeXFontMgr::getPSName(PlatformFontRef font) const +{ + std::map::const_iterator i = platformRefToFont.find(font); + if (i == platformRefToFont.end()) + die("internal error %d in XeTeXFontMgr", 1); + return i->second->psName->c_str(); +} + +const char* +XeTeXFontMgr::getFullName(PlatformFontRef font) const +{ + std::map::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 +{ + std::map::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(); +} + +char +XeTeXFontMgr::getReqEngine() const +{ + return sReqEngine; +} + +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; +} + +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; +} + +XeTeXFontMgr::Font* +XeTeXFontMgr::bestMatchFromFamily(const Family* fam, int wt, int wd, int slant) const +{ + Font* bestMatch = NULL; + for (std::map::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; +} + +void +XeTeXFontMgr::getOpSizeRecAndStyleFlags(Font* theFont) +{ + XeTeXFont font = createFont(theFont->fontRef, 655360); + if (font != 0) { + const GlyphPositioningTableHeader* gposTable = (const GlyphPositioningTableHeader*)getFontTablePtr(font, LE_GPOS_TABLE_TAG); + if (gposTable != NULL) { + FeatureListTable* featureListTable = (FeatureListTable*)((char*)gposTable + SWAP(gposTable->featureListOffset)); + for (int i = 0; i < SWAP(featureListTable->featureCount); ++i) { + UInt32 tag = SWAPT(featureListTable->featureRecordArray[i].featureTag); + if (tag == LE_SIZE_FEATURE_TAG) { + FeatureTable* feature = (FeatureTable*)((char*)featureListTable + SWAP(featureListTable->featureRecordArray[i].featureTableOffset)); + OpSizeRec* pSizeRec = (OpSizeRec*)((char*)featureListTable + SWAP(feature->featureParamsOffset)); + theFont->opSizeInfo.designSize = SWAP(pSizeRec->designSize); + theFont->opSizeInfo.subFamilyID = SWAP(pSizeRec->subFamilyID); + theFont->opSizeInfo.nameCode = SWAP(pSizeRec->nameCode); + theFont->opSizeInfo.minSize = SWAP(pSizeRec->minSize); + theFont->opSizeInfo.maxSize = SWAP(pSizeRec->maxSize); + break; + } + } + } + + const OS2TableHeader* os2Table = (const OS2TableHeader*)getFontTablePtr(font, LE_OS_2_TABLE_TAG); + if (os2Table != NULL) { + theFont->weight = SWAP(os2Table->usWeightClass); + theFont->width = SWAP(os2Table->usWidthClass); + UInt16 sel = SWAP(os2Table->fsSelection); + theFont->isReg = (sel & (1 << 6)) != 0; + theFont->isBold = (sel & (1 << 5)) != 0; + theFont->isItalic = (sel & (1 << 0)) != 0; + } + + const HEADTable* headTable = (const HEADTable*)getFontTablePtr(font, LE_HEAD_TABLE_TAG); + if (headTable != NULL) { + UInt16 ms = SWAP(headTable->macStyle); + if ((ms & (1 << 0)) != 0) + theFont->isBold = true; + if ((ms & (1 << 1)) != 0) + theFont->isItalic = true; + } + + const POSTTable* postTable = (const POSTTable*)getFontTablePtr(font, LE_POST_TABLE_TAG); + if (postTable != NULL) { + theFont->slant = (int)(1000 * (tan(Fix2X(-SWAP(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* list, const char* str) +{ + for (std::list::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* list, const char* str) +{ + for (std::list::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 (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::const_iterator i; + for (i = names->familyNames.begin(); i != names->familyNames.end(); ++i) { + std::map::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::const_iterator j = names->styleNames.begin(); j != names->styleNames.end(); ++j) { + std::map::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()); +*/ + } + } + + for (i = names->fullNames.begin(); i != names->fullNames.end(); ++i) { + std::map::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()); +*/ + } +} + +void +XeTeXFontMgr::die(const char*s, int i) const +{ + fprintf(stderr, s, i); + fprintf(stderr, " - exiting\n"); + exit(3); +} + +void +XeTeXFontMgr::terminate() +{ +} + diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr.h b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr.h new file mode 100644 index 00000000000..4a540fc644a --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr.h @@ -0,0 +1,202 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +#ifndef __XETEX_FONT_MANAGER_H +#define __XETEX_FONT_MANAGER_H + +#include "XeTeX_ext.h" + +#ifdef XETEX_MAC +#include +typedef ATSFontRef PlatformFontRef; +#else +#include +#include +#include FT_FREETYPE_H +typedef FcPattern* PlatformFontRef; +#endif + +#ifdef __cplusplus /* allow inclusion in plain C files just to get the typedefs above */ + +#include +#include +#include +#include + +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) + + 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/ICU[/USP]/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 'I' [or 'U'] if appropriate, + // else clears it to 0 + + // 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* getPSName(PlatformFontRef font) const; + // return PostScript name of a font, suitable for use in the .xdv file + + const char* getFullName(PlatformFontRef font) const; + // return the full name of the font, suitable for use in XeTeX source + // without requiring style qualifiers + + 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 the requested rendering technology for the most recent findFont + // or 0 if no specific technology was requested + +protected: + static XeTeXFontMgr* sFontManager; + static char sReqEngine; + + XeTeXFontMgr() + { } + virtual ~XeTeXFontMgr() + { } + + virtual void initialize() = 0; + virtual void terminate(); + + class Font; + class Family; + + struct OpSizeRec { + unsigned short designSize; + unsigned short subFamilyID; + unsigned short nameCode; + unsigned short minSize; + unsigned short 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; } + ~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 weight; + UInt16 width; + SInt16 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; + } + ~Family() + { + delete styles; + } + + std::map* styles; + UInt16 minWeight; + UInt16 maxWeight; + UInt16 minWidth; + UInt16 maxWidth; + SInt16 minSlant; + SInt16 maxSlant; + }; + + class NameCollection { + public: + std::list familyNames; + std::list styleNames; + std::list fullNames; + std::string psName; + std::string subFamily; + }; + + std::map nameToFont; // maps full name (as used in TeX source) to font record + std::map nameToFamily; + std::map platformRefToFont; + std::map 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* list, const char* str); + void prependToList(std::list* list, const char* str); + void addToMaps(PlatformFontRef platformFont, const NameCollection* names); + + virtual void getOpSizeRecAndStyleFlags(Font* theFont); + virtual void searchForHostPlatformFonts(const std::string& name) = 0; + +#ifdef XETEX_MAC + virtual NameCollection* readNames(ATSUFontID fontID) = 0; +#else + virtual NameCollection* readNames(PlatformFontRef fontRef) = 0; +#endif + + void die(const char*s, int i) const; /* for fatal internal errors! */ +}; + +#endif /* __cplusplus */ + + +#endif /* __XETEX_FONT_MANAGER_H */ diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Linux.cpp b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Linux.cpp new file mode 100644 index 00000000000..c10fc81f985 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Linux.cpp @@ -0,0 +1,317 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +#include "XeTeXFontMgr_Linux.h" + +#include FT_SFNT_NAMES_H +#include FT_TRUETYPE_IDS_H + +#include "unicode/ucnv.h" + +#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 char* +convertToUtf8(UConverter* conv, const unsigned char* name, int len) +{ +static char* buffer1 = NULL; +static char* buffer2 = NULL; +static 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; +} + +XeTeXFontMgr::NameCollection* +XeTeXFontMgr_Linux::readNames(FcPattern* pat) +{ + NameCollection* names = new NameCollection; + + char* pathname; + if (FcPatternGetString(pat, FC_FILE, 0, (FcChar8**)&pathname) == FcTrue) + return names; + int index; + if (FcPatternGetInteger(pat, FC_INDEX, 0, &index) == FcTrue) + return names; + + FT_Face face; + if (FT_New_Face(ftLib, 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 familyNames; + std::list 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* 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) == FcFalse) + appendToList(&names->fullNames, name); + index = 0; + while (FcPatternGetString(pat, FC_FAMILY, index++, (FcChar8**)&name) == FcFalse) + appendToList(&names->familyNames, name); + index = 0; + while (FcPatternGetString(pat, FC_STYLE, index++, (FcChar8**)&name) == FcFalse) + 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_Linux::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) == FcFalse) + theFont->weight = value; + if (FcPatternGetInteger(pat, FC_WIDTH, 0, &value) == FcFalse) + theFont->width = value; + if (FcPatternGetInteger(pat, FC_SLANT, 0, &value) == FcFalse) + theFont->slant = value; + } +} + +void +XeTeXFontMgr_Linux::searchForHostPlatformFonts(const std::string& name) +{ + static bool cacheAll = false; + static FcFontSet* allFonts = NULL; + + if (cacheAll) // we've already loaded everything on an earlier search + return; + + if (allFonts == NULL) { + 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, NULL); + + allFonts = FcFontList(FcConfigGetCurrent(), pat, os); + + FcObjectSetDestroy(os); + FcPatternDestroy(pat); + } + + 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 (cacheAll) { + // 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) == FcFalse; ++i) { + if (name == s) { + NameCollection* names = readNames(pat); + addToMaps(pat, names); + delete names; + found = true; + goto next_font; + } + } + + for (i = 0; FcPatternGetString(pat, FC_FAMILY, i, (FcChar8**)&s) == FcFalse; ++i) { + if (name == s || (hyph && famName == s)) { + NameCollection* names = readNames(pat); + addToMaps(pat, names); + delete names; + found = true; + goto next_font; + } + char* t; + for (int j = 0; FcPatternGetString(pat, FC_STYLE, j, (FcChar8**)&t) == FcFalse; ++j) { + std::string full(s); + full += " "; + full += t; + if (name == full) { + // need to ensure we'll pick up the whole family + famName = s; + hyph = 1; + f = 0; + goto restart; + } + } + } + + next_font: + ; + } + + if (found || cacheAll) + break; + cacheAll = true; + } +} + +void +XeTeXFontMgr_Linux::initialize() +{ + if (FcInit() == FcFalse) { + fprintf(stderr, "fontconfig initialization failed!\n"); + exit(9); + } + + if (FT_Init_FreeType(&ftLib) != 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); + } +} + +void +XeTeXFontMgr_Linux::terminate() +{ + if (macRomanConv != NULL) + ucnv_close(macRomanConv); + if (utf16beConv != NULL) + ucnv_close(utf16beConv); + if (utf8Conv != NULL) + ucnv_close(utf8Conv); +} diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Linux.h b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Linux.h new file mode 100644 index 00000000000..bea40c3deea --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Linux.h @@ -0,0 +1,59 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +#ifndef __XETEX_FONT_MGR_LINUX_H +#define __XETEX_FONT_MGR_LINUX_H + +#include "XeTeXFontMgr.h" + +class XeTeXFontMgr_Linux + : public XeTeXFontMgr +{ +public: + XeTeXFontMgr_Linux() + { } + virtual ~XeTeXFontMgr_Linux() + { } + +protected: + + virtual void initialize(); + virtual void terminate(); + + virtual void getOpSizeRecAndStyleFlags(Font* theFont); + virtual void searchForHostPlatformFonts(const std::string& name); + + virtual NameCollection* readNames(FcPattern* pat); + +private: + FT_Library ftLib; +}; + +#endif /* __XETEX_FONT_MGR_LINUX_H */ diff --git a/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.h b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.h new file mode 100644 index 00000000000..e889d62102d --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.h @@ -0,0 +1,64 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +#ifndef __XETEX_FONT_MGR_MAC_H +#define __XETEX_FONT_MGR_MAC_H + +#include "XeTeXFontMgr.h" + +#include + +class XeTeXFontMgr_Mac + : public XeTeXFontMgr +{ +public: + XeTeXFontMgr_Mac() + { } + virtual ~XeTeXFontMgr_Mac() + { } + +protected: + + virtual void initialize(); + virtual void terminate(); + + virtual void searchForHostPlatformFonts(const std::string& name); + + virtual NameCollection* readNames(ATSUFontID fontID); + +private: + void addFontsToCaches(CFArrayRef fonts); + + void addFamilyToCaches(ATSFontFamilyRef familyRef); + + void addFontAndSiblingsToCaches(ATSFontRef fontRef); +}; + +#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 new file mode 100644 index 00000000000..c7c7652a10c --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXFontMgr_Mac.mm @@ -0,0 +1,280 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +#ifdef XETEX_MAC // this file only for Mac OS X + +#include "XeTeXFontMgr_Mac.h" + +#include + +XeTeXFontMgr::NameCollection* +XeTeXFontMgr_Mac::readNames(ATSFontRef fontRef) +{ + const int BUFUNIT = 256; + static int bufSize = BUFUNIT; + static char* buffer = new char[bufSize]; + + NameCollection* names = new NameCollection; + + CFStringRef psName; + OSStatus status = ATSFontGetPostScriptName(fontRef, kATSOptionFlagsDefault, &psName); + if (status != noErr) + return names; + + // extract UTF-8 form of name + CFIndex length = CFStringGetLength(psName); // in 16-bit character units + if (length > 0) { + length = length * 6 + 1; + if (length >= bufSize) { + delete[] buffer; + bufSize = ((length / BUFUNIT) + 1) * BUFUNIT; + buffer = new char[bufSize]; + } + if (CFStringGetCString(psName, buffer, bufSize, kCFStringEncodingUTF8)) + names->psName = buffer; + } + CFRelease(psName); + + ATSUFontID fontID = FMGetFontFromATSFontRef(fontRef); + + ItemCount nameCount; + status = ATSUCountFontNames(fontID, &nameCount); + if (status != noErr) + die("ATSUCountFontNames failed, status=%d", status); + + std::list familyNames; + std::list subFamilyNames; + + for (int n = 0; n < nameCount; ++n) { + ByteCount nameLength; + FontNameCode nameCode; + FontPlatformCode namePlatform; + FontScriptCode nameScript; + FontLanguageCode nameLang; + status = ATSUGetIndFontName(fontID, n, 0, 0, &nameLength, + &nameCode, &namePlatform, &nameScript, &nameLang); + if (status != noErr && status != kATSUNoFontNameErr) + die("ATSUGetIndFontName failed, status=%d", status); + if (status == noErr && nameLength > 0) { + switch (nameCode) { + case kFontFullName: + case kFontFamilyName: + case kFontStyleName: + case 16: // preferred family -- use instead of family, if present + case 17: // preferred subfamily -- use instead of style, if present + { + bool preferredName = false; + TextEncoding encoding; + CFStringRef nameStr = 0; + if (nameLength >= bufSize) { + delete[] buffer; + bufSize = ((nameLength / BUFUNIT) + 1) * BUFUNIT; + buffer = new char[bufSize]; + } + status = ATSUGetIndFontName(fontID, n, bufSize, buffer, &nameLength, + &nameCode, &namePlatform, &nameScript, &nameLang); + if (namePlatform == kFontMacintoshPlatform) { + GetTextEncodingFromScriptInfo(nameScript, nameLang, 0, &encoding); + nameStr = CFStringCreateWithBytes(0, (UInt8*)buffer, nameLength, encoding, false); + if (nameScript == kFontRomanScript && nameLang == kFontEnglishLanguage) + preferredName = true; + } + else if ((namePlatform == kFontUnicodePlatform) || (namePlatform == kFontMicrosoftPlatform)) + nameStr = CFStringCreateWithCharacters(0, (UniChar*)buffer, nameLength / 2); + if (nameStr != 0) { + std::list* nameList = NULL; + switch (nameCode) { + case kFontFullName: + nameList = &names->fullNames; + break; + case kFontFamilyName: + nameList = &names->familyNames; + break; + case kFontStyleName: + nameList = &names->styleNames; + break; + case 16: + nameList = &familyNames; + break; + case 17: + nameList = &subFamilyNames; + break; + } + + // extract UTF-8 form of name + length = CFStringGetLength(nameStr); // in 16-bit character units + if (length > 0) { + length = length * 6 + 1; + if (length >= bufSize) { + delete[] buffer; + bufSize = ((length / BUFUNIT) + 1) * BUFUNIT; + buffer = new char[bufSize]; + } + if (CFStringGetCString(nameStr, buffer, bufSize, kCFStringEncodingUTF8)) { + if (buffer[0] != 0) { + if (nameList != NULL) { + if (preferredName) + prependToList(nameList, buffer); + else + appendToList(nameList, buffer); + } + } + } + } + + CFRelease(nameStr); + } + } + break; + } + } + } + + if (familyNames.size() > 0) + names->familyNames = familyNames; + if (subFamilyNames.size() > 0) + names->styleNames = subFamilyNames; + + return names; +} + +void +XeTeXFontMgr_Mac::addFontsToCaches(CFArrayRef fonts) +{ + NSEnumerator* enumerator = [(NSArray*)fonts objectEnumerator]; + while (id aFont = [enumerator nextObject]) { + ATSFontRef fontRef = ATSFontFindFromPostScriptName((CFStringRef)[aFont objectAtIndex: 0], kATSOptionFlagsDefault); + NameCollection* names = readNames(fontRef); + addToMaps(fontRef, names); + delete names; + } +} + +void +XeTeXFontMgr_Mac::addFamilyToCaches(ATSFontFamilyRef familyRef) +{ + CFStringRef nameStr; + OSStatus status = ATSFontFamilyGetName(familyRef, kATSOptionFlagsDefault, &nameStr); + if (status == noErr) { + NSArray* members = [[NSFontManager sharedFontManager] + availableMembersOfFontFamily: (NSString*)nameStr]; + CFRelease(nameStr); + addFontsToCaches((CFArrayRef)members); + } +} + +void +XeTeXFontMgr_Mac::addFontAndSiblingsToCaches(ATSFontRef fontRef) +{ + CFStringRef name; + OSStatus status = ATSFontGetPostScriptName(fontRef, kATSOptionFlagsDefault, &name); + if (status == noErr) { + 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); + ATSFontRef fontRef = ATSFontFindFromName(nameStr, kATSOptionFlagsDefault); + if (fontRef != kATSFontRefUnspecified) { + // found it, so locate the family, and add all members to the caches + addFontAndSiblingsToCaches(fontRef); + 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; + } + + ATSFontFamilyRef familyRef = ATSFontFamilyFindFromName(familyStr, kATSOptionFlagsDefault); + if (familyRef != 0xffffffff) { + addFamilyToCaches(familyRef); + return; + } + } + + fontRef = ATSFontFindFromPostScriptName(nameStr, kATSOptionFlagsDefault); + if (fontRef != kATSFontRefUnspecified) { + addFontAndSiblingsToCaches(fontRef); + return; + } + + NSArray* familyMembers = [[NSFontManager sharedFontManager] + availableMembersOfFontFamily: (NSString*)nameStr]; + if ([familyMembers count] > 0) { + addFontsToCaches((CFArrayRef)familyMembers); + return; + } + + ATSFontFamilyRef familyRef = ATSFontFamilyFindFromName(nameStr, kATSOptionFlagsDefault); + if (familyRef != 0xffffffff) { + addFamilyToCaches(familyRef); + return; + } +} + +NSAutoreleasePool* pool = NULL; + +void +XeTeXFontMgr_Mac::initialize() +{ + pool = [[NSAutoreleasePool alloc] init]; +} + +void +XeTeXFontMgr_Mac::terminate() +{ + if (pool != NULL) { + [pool release]; + } +} + +#endif // XETEX_MAC diff --git a/Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.cpp b/Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.cpp new file mode 100644 index 00000000000..9a9a48713a7 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.cpp @@ -0,0 +1,519 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +#include "XeTeXLayoutInterface.h" + +#include "XeTeXOTLayoutEngine.h" +#include "XeTeXFontInst.h" +#ifdef XETEX_MAC +#include "XeTeXFontInst_Mac.h" +#else +#include "XeTeXFontInst_FC.h" +#endif + +#include "XeTeXFontMgr.h" + +#include "XeTeXswap.h" + +#include "Features.h" +#include "ScriptAndLanguage.h" + +#include "unicode/ubidi.h" + +#include + +struct XeTeXLayoutEngine_rec +{ + LayoutEngine* layoutEngine; + XeTeXFontInst* font; + UInt32 scriptTag; + UInt32 languageTag; + UInt32* addedFeatures; + UInt32* removedFeatures; + UInt32 rgbValue; +}; + +/*******************************************************************/ +/* Glyph bounding box cache to speed up \XeTeXuseglyphmetrics mode */ +/*******************************************************************/ +#include + +// key is combined value representing (font_id << 16) + glyph +// value is glyph bounding box in TeX points +static std::map sGlyphBoxes; + +int +getCachedGlyphBBox(UInt16 fontID, UInt16 glyphID, GlyphBBox* bbox) +{ + UInt32 key = ((UInt32)fontID << 16) + glyphID; + std::map::const_iterator i = sGlyphBoxes.find(key); + if (i == sGlyphBoxes.end()) { + return 0; + } + *bbox = i->second; + return 1; +} + +void +cacheGlyphBBox(UInt16 fontID, UInt16 glyphID, const GlyphBBox* bbox) +{ + UInt32 key = ((UInt32)fontID << 16) + glyphID; + sGlyphBoxes[key] = *bbox; +} +/*******************************************************************/ + +void terminatefontmanager() +{ + XeTeXFontMgr::Terminate(); +} + +XeTeXFont createFont(PlatformFontRef fontRef, Fixed pointSize) +{ + LEErrorCode status = LE_NO_ERROR; +#ifdef XETEX_MAC + XeTeXFontInst* font = new XeTeXFontInst_Mac((ATSFontRef)fontRef, Fix2X(pointSize), status); +#else + XeTeXFontInst* font = new XeTeXFontInst_FC((FcPattern*)fontRef, Fix2X(pointSize), status); +#endif + if (LE_FAILURE(status)) { + delete font; + return NULL; + } + return (XeTeXFont)font; +} + +void setFontLayoutDir(XeTeXFont font, int vertical) +{ + ((XeTeXFontInst*)font)->setLayoutDirVertical(vertical != 0); +} + +PlatformFontRef getFontRef(XeTeXLayoutEngine engine) +{ + return engine->font->getFontRef(); +} + +PlatformFontRef findFontByName(const char* name, char* var, double size) +{ + return (XeTeXFontMgr::GetFontManager()->findFont(name, var, size)); +} + +char getReqEngine() +{ + return XeTeXFontMgr::GetFontManager()->getReqEngine(); +} + +const char* getFullName(PlatformFontRef fontRef) +{ + return XeTeXFontMgr::GetFontManager()->getFullName(fontRef); +} + +const char* getPSName(PlatformFontRef fontRef) +{ + return XeTeXFontMgr::GetFontManager()->getPSName(fontRef); +} + +void getNames(PlatformFontRef fontRef, const char** psName, const char** famName, const char** styName) +{ + XeTeXFontMgr::GetFontManager()->getNames(fontRef, psName, famName, styName); +} + +void deleteFont(XeTeXFont font) +{ + delete (XeTeXFontInst*)font; +} + +void* getFontTablePtr(XeTeXFont font, UInt32 tableTag) +{ + return const_cast(((XeTeXFontInst*)font)->getFontTable(tableTag)); +} + +/* apparently M_PI isn't defined by under VC++ */ +#ifdef WIN32 +#ifndef M_PI +#define M_PI 3.1415926535898 +#endif +#endif + +Fixed getSlant(XeTeXFont font) +{ + float italAngle = ((XeTeXFontInst*)font)->getItalicAngle(); + return X2Fix(tan(-italAngle * M_PI / 180.0)); +} + +static const ScriptListTable* +getLargerScriptListTable(XeTeXFont font) +{ + const ScriptListTable* scriptListSub = NULL; + const ScriptListTable* scriptListPos = NULL; + + const GlyphSubstitutionTableHeader* gsubTable = (const GlyphSubstitutionTableHeader*)((XeTeXFontInst*)font)->getFontTable(kGSUB); + UInt32 scriptCountSub = 0; + if (gsubTable != NULL) { + scriptListSub = (const ScriptListTable*)((const char*)gsubTable + SWAP(gsubTable->scriptListOffset)); + scriptCountSub = SWAP(scriptListSub->scriptCount); + } + + const GlyphPositioningTableHeader* gposTable = (const GlyphPositioningTableHeader*)((XeTeXFontInst*)font)->getFontTable(kGPOS); + UInt32 scriptCountPos = 0; + if (gposTable != NULL) { + scriptListPos = (const ScriptListTable*)((const char*)gposTable + SWAP(gposTable->scriptListOffset)); + scriptCountPos = SWAP(scriptListPos->scriptCount); + } + + return scriptCountPos > scriptCountSub ? scriptListPos : scriptListSub; +} + +UInt32 countScripts(XeTeXFont font) +{ + const ScriptListTable* scriptList = getLargerScriptListTable(font); + if (scriptList == NULL) + return 0; + + return SWAP(scriptList->scriptCount); +} + +UInt32 getIndScript(XeTeXFont font, UInt32 index) +{ + const ScriptListTable* scriptList = getLargerScriptListTable(font); + if (scriptList == NULL) + return 0; + + if (index < SWAP(scriptList->scriptCount)) + return SWAPT(scriptList->scriptRecordArray[index].tag); + + return 0; +} + +UInt32 countScriptLanguages(XeTeXFont font, UInt32 script) +{ + const ScriptListTable* scriptList = getLargerScriptListTable(font); + if (scriptList == NULL) + return 0; + + const ScriptTable* scriptTable = scriptList->findScript(script); + if (scriptTable == NULL) + return 0; + + UInt32 langCount = SWAP(scriptTable->langSysCount); + + return langCount; +} + +UInt32 getIndScriptLanguage(XeTeXFont font, UInt32 script, UInt32 index) +{ + const ScriptListTable* scriptList = getLargerScriptListTable(font); + if (scriptList == NULL) + return 0; + + const ScriptTable* scriptTable = scriptList->findScript(script); + if (scriptTable == NULL) + return 0; + + if (index < SWAP(scriptTable->langSysCount)) + return SWAPT(scriptTable->langSysRecordArray[index].tag); + + return 0; +} + +UInt32 countFeatures(XeTeXFont font, UInt32 script, UInt32 language) +{ + UInt32 total = 0; + const GlyphLookupTableHeader* table; + for (int i = 0; i < 2; ++i) { + table = (const GlyphLookupTableHeader*)((XeTeXFontInst*)font)->getFontTable(i == 0 ? kGSUB : kGPOS); + if (table != NULL) { + const ScriptListTable* scriptList = (const ScriptListTable*)((const char*)table + SWAP(table->scriptListOffset)); + const ScriptTable* scriptTable = scriptList->findScript(script); + if (scriptTable != NULL) { + const LangSysTable* langTable = scriptTable->findLanguage(language, (language != 0)); + if (langTable != NULL) { + total += SWAP(langTable->featureCount); + if (langTable->reqFeatureIndex != 0xffff) + total += 1; + } + } + } + } + + return total; +} + +UInt32 getIndFeature(XeTeXFont font, UInt32 script, UInt32 language, UInt32 index) +{ + const GlyphLookupTableHeader* table; + UInt16 featureIndex = 0xffff; + for (int i = 0; i < 2; ++i) { + table = (const GlyphLookupTableHeader*)((XeTeXFontInst*)font)->getFontTable(i == 0 ? kGSUB : kGPOS); + if (table != NULL) { + const ScriptListTable* scriptList = (const ScriptListTable*)((const char*)table + SWAP(table->scriptListOffset)); + const ScriptTable* scriptTable = scriptList->findScript(script); + if (scriptTable != NULL) { + const LangSysTable* langTable = scriptTable->findLanguage(language, (language != 0)); + if (langTable != NULL) { + if (SWAP(langTable->reqFeatureIndex) != 0xffff) + if (index == 0) + featureIndex = SWAP(langTable->reqFeatureIndex); + else + index -= 1; + if (index < SWAP(langTable->featureCount)) + featureIndex = SWAP(langTable->featureIndexArray[index]); + index -= SWAP(langTable->featureCount); + } + } + if (featureIndex != 0xffff) { + LETag featureTag; + const FeatureListTable* featureListTable = (const FeatureListTable*)((const char*)table + SWAP(table->featureListOffset)); + (void)featureListTable->getFeatureTable(featureIndex, &featureTag); + return featureTag; + } + } + } + + return 0; +} + +float getGlyphWidth(XeTeXFont font, UInt32 gid) +{ + LEPoint adv; + ((XeTeXFontInst*)font)->getGlyphAdvance(gid, adv); + return adv.fX; +} + +UInt32 +countGlyphs(XeTeXFont font) +{ + return ((XeTeXFontInst*)font)->getNumGlyphs(); +} + +XeTeXFont getFont(XeTeXLayoutEngine engine) +{ + return (XeTeXFont)(engine->font); +} + +XeTeXLayoutEngine createLayoutEngine(XeTeXFont font, UInt32 scriptTag, UInt32 languageTag, + UInt32* addFeatures, UInt32* removeFeatures, UInt32 rgbValue) +{ + LEErrorCode status = LE_NO_ERROR; + XeTeXLayoutEngine result = new XeTeXLayoutEngine_rec; + result->font = (XeTeXFontInst*)font; + result->scriptTag = scriptTag; + result->languageTag = languageTag; + result->addedFeatures = addFeatures; + result->removedFeatures = removeFeatures; + result->rgbValue = rgbValue; + result->layoutEngine = XeTeXOTLayoutEngine::LayoutEngineFactory((XeTeXFontInst*)font, + scriptTag, languageTag, (LETag*)addFeatures, (LETag*)removeFeatures, status); + if (LE_FAILURE(status) || result->layoutEngine == NULL) { + delete result; + return NULL; + } + + return result; +} + +void deleteLayoutEngine(XeTeXLayoutEngine engine) +{ + delete engine->layoutEngine; + delete engine->font; +} + +SInt32 layoutChars(XeTeXLayoutEngine engine, UInt16 chars[], SInt32 offset, SInt32 count, SInt32 max, + char rightToLeft, float x, float y, SInt32* status) +{ + LEErrorCode success = (LEErrorCode)*status; + le_int32 glyphCount = engine->layoutEngine->layoutChars(chars, offset, count, max, rightToLeft, x, y, success); + *status = success; + return glyphCount; +} + +void getGlyphs(XeTeXLayoutEngine engine, UInt32 glyphs[], SInt32* status) +{ + LEErrorCode success = (LEErrorCode)*status; + engine->layoutEngine->getGlyphs((LEGlyphID*)glyphs, success); + *status = success; +} + +void getGlyphPositions(XeTeXLayoutEngine engine, float positions[], SInt32* status) +{ + LEErrorCode success = (LEErrorCode)*status; + engine->layoutEngine->getGlyphPositions(positions, success); + *status = success; +} + +void getGlyphPosition(XeTeXLayoutEngine engine, SInt32 index, float* x, float* y, SInt32* status) +{ + LEErrorCode success = (LEErrorCode)*status; + engine->layoutEngine->getGlyphPosition(index, *x, *y, success); + *status = success; +} + +UInt32 getScriptTag(XeTeXLayoutEngine engine) +{ + return engine->scriptTag; +} + +UInt32 getLanguageTag(XeTeXLayoutEngine engine) +{ + return engine->languageTag; +} + +float getPointSize(XeTeXLayoutEngine engine) +{ + return engine->font->getXPixelsPerEm(); +} + +void getAscentAndDescent(XeTeXLayoutEngine engine, float* ascent, float* descent) +{ + *ascent = engine->font->getExactAscent(); + *descent = engine->font->getExactDescent(); +} + +UInt32* getAddedFeatures(XeTeXLayoutEngine engine) +{ + return engine->addedFeatures; +} + +UInt32* getRemovedFeatures(XeTeXLayoutEngine engine) +{ + return engine->removedFeatures; +} + +int getDefaultDirection(XeTeXLayoutEngine engine) +{ + switch (engine->scriptTag) { + case kArabic: + case kSyriac: + case kThaana: + case kHebrew: + return UBIDI_DEFAULT_RTL; + } + return UBIDI_DEFAULT_LTR; +} + +UInt32 getRgbValue(XeTeXLayoutEngine engine) +{ + return engine->rgbValue; +} + +void getGlyphBounds(XeTeXLayoutEngine engine, UInt32 glyphID, GlyphBBox* bbox) +{ + engine->font->getGlyphBounds(glyphID, bbox); +} + +float getGlyphWidthFromEngine(XeTeXLayoutEngine engine, UInt32 glyphID) +{ + return engine->font->getGlyphWidth(glyphID); +} + +void getGlyphHeightDepth(XeTeXLayoutEngine engine, UInt32 glyphID, float* height, float* depth) +{ + engine->font->getGlyphHeightDepth(glyphID, height, depth); +} + +void getGlyphSidebearings(XeTeXLayoutEngine engine, UInt32 glyphID, float* lsb, float* rsb) +{ + engine->font->getGlyphSidebearings(glyphID, lsb, rsb); +} + +float getGlyphItalCorr(XeTeXLayoutEngine engine, UInt32 glyphID) +{ + return engine->font->getGlyphItalCorr(glyphID); +} + +UInt32 mapCharToGlyph(XeTeXLayoutEngine engine, UInt32 charCode) +{ + return engine->font->mapCharToGlyph(charCode); +} + +#include "appleGlyphNames.c" + +int +findGlyphInPostTable(const char* buffer, int tableSize, const char* glyphName) +{ + const postTable* p = (const postTable*)buffer; + UInt16 g = 0; + switch (SWAP(p->format)) { + case 0x00010000: + { + char* cp; + while ((cp = appleGlyphNames[g]) != 0) { + if (strcmp(glyphName, cp) == 0) + return g; + ++g; + } + } + break; + + case 0x00020000: + { + const UInt16* n = (UInt16*)(p + 1); + UInt16 numGlyphs = SWAP(*n++); + const UInt8* ps = (const UInt8*)(n + numGlyphs); + std::vector newNames; + while (ps < (const UInt8*)buffer + tableSize) { + newNames.push_back(std::string((char*)ps + 1, *ps)); + ps += *ps + 1; + } + for (g = 0; g < numGlyphs; ++g) { + if (SWAP(*n) < 258) { + if (strcmp(appleGlyphNames[SWAP(*n)], glyphName) == 0) + return g; + } + else { + if (strcmp(newNames[SWAP(*n) - 258].c_str(), glyphName) == 0) + return g; + } + ++n; + } + } + break; + + case 0x00028000: + break; + + case 0x00030000: + // TODO: see if it's a CFF OpenType font, and if so, get the glyph names from the CFF data + break; + + case 0x00040000: + break; + + default: + break; + } + + return 0; +} + +int +mapGlyphToIndex(XeTeXLayoutEngine engine, const char* glyphName) +{ + return engine->font->mapGlyphToIndex(glyphName); +} diff --git a/Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.h b/Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.h new file mode 100644 index 00000000000..ccfbbe531ec --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXLayoutInterface.h @@ -0,0 +1,134 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +#ifdef XETEX_MAC +#include +#endif + +#include "XeTeX_ext.h" +#include "XeTeXFontMgr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct XeTeXFont_rec* XeTeXFont; +typedef struct XeTeXLayoutEngine_rec* XeTeXLayoutEngine; + +extern char gPrefEngine; + +int getCachedGlyphBBox(UInt16 fontID, UInt16 glyphID, GlyphBBox* bbox); +void cacheGlyphBBox(UInt16 fontID, UInt16 glyphID, const GlyphBBox* bbox); + +void terminatefontmanager(); + +#ifdef XETEX_MAC +XeTeXFont createFont(ATSFontRef atsFont, Fixed pointSize); +#else +// appropriate functions for other platforms +XeTeXFont createFont(PlatformFontRef fontRef, Fixed pointSize); +#endif + +void setFontLayoutDir(XeTeXFont font, int vertical); + +PlatformFontRef getFontRef(XeTeXLayoutEngine engine); +PlatformFontRef findFontByName(const char* name, char* var, double size); + +char getReqEngine(); +const char* getFullName(PlatformFontRef fontRef); +const char* getPSName(PlatformFontRef fontRef); +void getNames(PlatformFontRef fontRef, const char** psName, const char** famName, const char** styName); + +void deleteFont(XeTeXFont font); + +void* getFontTablePtr(XeTeXFont font, UInt32 tableTag); + +Fixed getSlant(XeTeXFont font); + +UInt32 countScripts(XeTeXFont font); +UInt32 getIndScript(XeTeXFont font, UInt32 index); +UInt32 countScriptLanguages(XeTeXFont font, UInt32 script); +UInt32 getIndScriptLanguage(XeTeXFont font, UInt32 script, UInt32 index); +UInt32 countFeatures(XeTeXFont font, UInt32 script, UInt32 language); +UInt32 getIndFeature(XeTeXFont font, UInt32 script, UInt32 language, UInt32 index); +float getGlyphWidth(XeTeXFont font, UInt32 gid); +UInt32 countGlyphs(XeTeXFont font); + +XeTeXLayoutEngine createLayoutEngine(XeTeXFont font, UInt32 scriptTag, UInt32 languageTag, + UInt32* addFeatures, UInt32* removeFeatures, UInt32 rgbValue); + +void deleteLayoutEngine(XeTeXLayoutEngine engine); + +XeTeXFont getFont(XeTeXLayoutEngine engine); + +SInt32 layoutChars(XeTeXLayoutEngine engine, UInt16* chars, SInt32 offset, SInt32 count, SInt32 max, + char rightToLeft, float x, float y, SInt32* status); + +void getGlyphs(XeTeXLayoutEngine engine, UInt32* glyphs, SInt32* status); + +void getGlyphPositions(XeTeXLayoutEngine engine, float* positions, SInt32* status); + +void getGlyphPosition(XeTeXLayoutEngine engine, SInt32 index, float* x, float* y, SInt32* status); + +UInt32 getScriptTag(XeTeXLayoutEngine engine); + +UInt32 getLanguageTag(XeTeXLayoutEngine engine); + +float getPointSize(XeTeXLayoutEngine engine); + +void getAscentAndDescent(XeTeXLayoutEngine engine, float* ascent, float* descent); + +UInt32* getAddedFeatures(XeTeXLayoutEngine engine); + +UInt32* getRemovedFeatures(XeTeXLayoutEngine engine); + +int getDefaultDirection(XeTeXLayoutEngine engine); + +UInt32 getRgbValue(XeTeXLayoutEngine engine); + +void getGlyphBounds(XeTeXLayoutEngine engine, UInt32 glyphID, GlyphBBox* bbox); + +float getGlyphWidthFromEngine(XeTeXLayoutEngine engine, UInt32 glyphID); + +void getGlyphHeightDepth(XeTeXLayoutEngine engine, UInt32 glyphID, float* height, float* depth); + +void getGlyphSidebearings(XeTeXLayoutEngine engine, UInt32 glyphID, float* lsb, float* rsb); + +float getGlyphItalCorr(XeTeXLayoutEngine engine, UInt32 glyphID); + +UInt32 mapCharToGlyph(XeTeXLayoutEngine engine, UInt32 charCode); + +int mapGlyphToIndex(XeTeXLayoutEngine engine, const char* glyphName); + +int findGlyphInPostTable(const char* p, int tableSize, const char* glyphName); + +#ifdef __cplusplus +}; +#endif diff --git a/Build/source/texk/web2c/xetexdir/XeTeXOTLayoutEngine.cpp b/Build/source/texk/web2c/xetexdir/XeTeXOTLayoutEngine.cpp new file mode 100644 index 00000000000..8eedae283ce --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXOTLayoutEngine.cpp @@ -0,0 +1,281 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +#include "XeTeXOTLayoutEngine.h" + +#include "ThaiLayoutEngine.h" +#include "KhmerLayoutEngine.h" + +#include "LEScripts.h" +#include "LELanguages.h" + +const LETag emptyTag = 0x00000000; + +static le_int32 getScriptCode(LETag scriptTag) +{ + for (le_int32 i = 0; i < scriptCodeCount; ++i) + if (OpenTypeLayoutEngine::getScriptTag(i) == scriptTag) + return i; + return -1; +} + +static le_int32 getLanguageCode(LETag languageTag) +{ + for (le_int32 i = 0; i < languageCodeCount; ++i) + if (OpenTypeLayoutEngine::getLangSysTag(i) == languageTag) + return i; + return -1; +} + +LayoutEngine* XeTeXOTLayoutEngine::LayoutEngineFactory + (const XeTeXFontInst* fontInstance, + LETag scriptTag, LETag languageTag, + const LETag* addFeatures, const LETag* removeFeatures, + LEErrorCode &success) +{ + static le_uint32 gsubTableTag = LE_GSUB_TABLE_TAG; + + if (LE_FAILURE(success)) + return NULL; + + const GlyphSubstitutionTableHeader* gsubTable = (const GlyphSubstitutionTableHeader*)fontInstance->getFontTable(gsubTableTag); + LayoutEngine *result = NULL; + + le_uint32 scriptCode = getScriptCode(scriptTag); + le_uint32 languageCode = getLanguageCode(languageTag); + + le_int32 typoFlags = 3; + + if (gsubTable != NULL && gsubTable->coversScript(scriptTag)) { + switch (scriptCode) { + case bengScriptCode: + case devaScriptCode: + case gujrScriptCode: + case kndaScriptCode: + case mlymScriptCode: + case oryaScriptCode: + case guruScriptCode: + case tamlScriptCode: + case teluScriptCode: +// result = new XeTeXIndicLayoutEngine(fontInstance, scriptTag, languageTag, gsubTable, addFeatures, removeFeatures); + result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + + case arabScriptCode: + case syrcScriptCode: + case mongScriptCode: +// result = new XeTeXArabicLayoutEngine(fontInstance, scriptTag, languageTag, gsubTable, addFeatures, removeFeatures); + result = new ArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + + case bopoScriptCode: + case haniScriptCode: + case hangScriptCode: + case hiraScriptCode: + case kanaScriptCode: + case hrktScriptCode: + result = new XeTeXHanLayoutEngine(fontInstance, scriptTag, languageTag, gsubTable, addFeatures, removeFeatures); + break; + + case khmrScriptCode: + result = new KhmerOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags, gsubTable); + break; + + default: + result = new XeTeXOTLayoutEngine(fontInstance, scriptTag, languageTag, gsubTable, addFeatures, removeFeatures); + break; + } + } + else { + switch (scriptCode) { + case bengScriptCode: + case devaScriptCode: + case gujrScriptCode: + case kndaScriptCode: + case mlymScriptCode: + case oryaScriptCode: + case guruScriptCode: + case tamlScriptCode: + case teluScriptCode: + result = new IndicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); + break; + + case arabScriptCode: + case hebrScriptCode: + result = new UnicodeArabicOpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); + break; + + case thaiScriptCode: + result = new ThaiLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); + break; + + default: + result = new OpenTypeLayoutEngine(fontInstance, scriptCode, languageCode, typoFlags); + break; + } + } + + if (result == NULL) + success = LE_MEMORY_ALLOCATION_ERROR; + + return result; +} + +/* + * XeTeXOTLayoutEngine + */ + +const char XeTeXOTLayoutEngine::fgClassID=0; + +XeTeXOTLayoutEngine::XeTeXOTLayoutEngine( + const LEFontInstance* fontInstance, LETag scriptTag, LETag languageTag, + const GlyphSubstitutionTableHeader* gsubTable, + const LETag* addFeatures, const LETag* removeFeatures) + : OpenTypeLayoutEngine(fontInstance, getScriptCode(scriptTag), getLanguageCode(languageTag), 3, gsubTable) +{ + static le_uint32 gposTableTag = LE_GPOS_TABLE_TAG; + + fDefaultFeatures = fFeatureList; + + // check the result of setScriptAndLanguageTags(), in case they were unknown to ICU + if (fScriptTag != scriptTag || fLangSysTag != languageTag) { + fScriptTag = scriptTag; + fLangSysTag = languageTag; + + // reset the GPOS if the tags changed + fGPOSTable = NULL; + const GlyphPositioningTableHeader *gposTable = (const GlyphPositioningTableHeader *) getFontTable(gposTableTag); + if (gposTable != NULL && gposTable->coversScriptAndLanguage(fScriptTag, fLangSysTag)) { + fGPOSTable = gposTable; + } + } + + adjustFeatures(addFeatures, removeFeatures); +} + +XeTeXOTLayoutEngine::~XeTeXOTLayoutEngine() +{ + if (fFeatureList != NULL && fFeatureList != fDefaultFeatures) + LE_DELETE_ARRAY(fFeatureList); +} + +void XeTeXOTLayoutEngine::adjustFeatures(const LETag* addTags, const LETag* removeTags) +{ + // bail out if nothing was requested! + if ((addTags == NULL || *addTags == emptyTag) && (removeTags == NULL || *removeTags == emptyTag)) + return; + + // count the max possible number of tags we might end up with + le_uint32 count = 0; + const LETag* pTag = fFeatureList; + while (*pTag++ != emptyTag) + count++; + if (addTags != NULL && *addTags != emptyTag) { + pTag = addTags; + while (*pTag++ != emptyTag) + count++; + } + + // allocate new array for the tag list, big enough for max count + LETag* newList = LE_NEW_ARRAY(LETag, count + 1); + + // copy the existing tags, skipping any in the remove list + LETag* dest = newList; + pTag = fFeatureList; + while (*pTag != emptyTag) { + const LETag* t = removeTags; + if (t != NULL) + while (*t != emptyTag) + if (*t == *pTag) + break; + else + t++; + if (t == NULL || *t == emptyTag) + *dest++ = *pTag; + pTag++; + } + + // copy the added tags, skipping any already present + pTag = addTags; + if (pTag != NULL) + while (*pTag != emptyTag) { + const LETag* t = newList; + while (t < dest) + if (*t == *pTag) + break; + else + t++; + if (t == dest) + *dest++ = *pTag; + pTag++; + } + + // terminate the new list + *dest = emptyTag; + + // delete the previous list, unless it was the static default array + if (fFeatureList != fDefaultFeatures) + LE_DELETE_ARRAY(fFeatureList); + + fFeatureList = newList; +} + + +/* + * XeTeXHanLayoutEngine + */ + +const char XeTeXHanLayoutEngine::fgClassID=0; + +static const LETag loclFeatureTag = LE_LOCL_FEATURE_TAG; +static const LETag smplFeatureTag = LE_SMPL_FEATURE_TAG; +static const LETag tradFeatureTag = LE_TRAD_FEATURE_TAG; +static const LETag vertFeatureTag = LE_VERT_FEATURE_TAG; +static const LETag vrt2FeatureTag = LE_VRT2_FEATURE_TAG; + +static const LETag horizontalFeatures[] = {loclFeatureTag, emptyTag}; +static const LETag verticalFeatures[] = {loclFeatureTag, vrt2FeatureTag, vertFeatureTag, emptyTag}; + +XeTeXHanLayoutEngine::XeTeXHanLayoutEngine(const XeTeXFontInst *fontInstance, LETag scriptTag, LETag languageTag, + const GlyphSubstitutionTableHeader *gsubTable, + const LETag *addFeatures, const LETag *removeFeatures) + : XeTeXOTLayoutEngine(fontInstance, scriptTag, languageTag, gsubTable, NULL, NULL) +{ + // reset the default feature list + fFeatureList = fontInstance->getLayoutDirVertical() ? verticalFeatures : horizontalFeatures; + fDefaultFeatures = fFeatureList; + + // then apply any adjustments + adjustFeatures(addFeatures, removeFeatures); +} + +XeTeXHanLayoutEngine::~XeTeXHanLayoutEngine() +{ +} diff --git a/Build/source/texk/web2c/xetexdir/XeTeXOTLayoutEngine.h b/Build/source/texk/web2c/xetexdir/XeTeXOTLayoutEngine.h new file mode 100644 index 00000000000..9e29f475963 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXOTLayoutEngine.h @@ -0,0 +1,128 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +#ifndef __XeTeXOTLayoutEngine_h +#define __XeTeXOTLayoutEngine_h + +#include "OpenTypeLayoutEngine.h" +#include "ArabicLayoutEngine.h" +#include "IndicLayoutEngine.h" +#include "HanLayoutEngine.h" + +#include "XeTeXFontInst.h" + +class XeTeXOTLayoutEngine : public OpenTypeLayoutEngine +{ +public: + XeTeXOTLayoutEngine(const LEFontInstance* fontInstance, LETag scriptTag, LETag languageTag, + const GlyphSubstitutionTableHeader* gsubTable, + const LETag* addFeatures, const LETag* removeFeatures); + + virtual ~XeTeXOTLayoutEngine(); + + virtual void adjustFeatures(const LETag* addTags, const LETag* removeTags); + + virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); } + static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; } + + static LayoutEngine* LayoutEngineFactory + (const XeTeXFontInst* fontInstance, + LETag scriptTag, LETag languageTag, + const LETag* addFeatures, const LETag* removeFeatures, + LEErrorCode &success); + +protected: + const LETag* fDefaultFeatures; + +private: + static const char fgClassID; + +}; + +class XeTeXArabicLayoutEngine : public ArabicOpenTypeLayoutEngine +{ +public: + XeTeXArabicLayoutEngine(const LEFontInstance *fontInstance, LETag scriptTag, LETag languageTag, + const GlyphSubstitutionTableHeader *gsubTable, + const LETag *addFeatures, const LETag *removeFeatures); + + virtual ~XeTeXArabicLayoutEngine(); + + virtual void adjustFeatures(const LETag* addTags, const LETag* removeTags); + + virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); } + static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; } + +private: + static const char fgClassID; + + const LETag* fDefaultFeatures; +}; + +class XeTeXIndicLayoutEngine : public IndicOpenTypeLayoutEngine +{ +public: + XeTeXIndicLayoutEngine(const LEFontInstance *fontInstance, LETag scriptTag, LETag languageTag, + const GlyphSubstitutionTableHeader *gsubTable, + const LETag *addFeatures, const LETag *removeFeatures); + + virtual ~XeTeXIndicLayoutEngine(); + + virtual void adjustFeatures(const LETag* addTags, const LETag* removeTags); + + virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); } + static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; } + +private: + static const char fgClassID; + + const LETag* fDefaultFeatures; +}; + +class XeTeXHanLayoutEngine : public XeTeXOTLayoutEngine +{ +public: + XeTeXHanLayoutEngine(const XeTeXFontInst *fontInstance, LETag scriptTag, LETag languageTag, + const GlyphSubstitutionTableHeader *gsubTable, + const LETag *addFeatures, const LETag *removeFeatures); + + virtual ~XeTeXHanLayoutEngine(); + +// virtual void adjustFeatures(const LETag* addTags, const LETag* removeTags); + + virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); } + static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; } + +private: + static const char fgClassID; +}; + +#endif + diff --git a/Build/source/texk/web2c/xetexdir/XeTeX_ext.c b/Build/source/texk/web2c/xetexdir/XeTeX_ext.c new file mode 100644 index 00000000000..99db577faca --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeX_ext.c @@ -0,0 +1,2302 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +/* XeTeX_ext.c + * additional plain C extensions for XeTeX - mostly platform-neutral + */ + +#define EXTERN extern +#include "xetexd.h" + +#ifdef XETEX_MAC +#undef input /* this is defined in texmfmp.h, but we don't need it and it confuses the carbon headers */ +#include +#endif + +#include "XeTeX_ext.h" + +#include "TECkit_Engine.h" + +#include +#include +#include +#include +#include + +#include /* for fabs() */ + +#include /* For `struct tm'. */ +#if defined (HAVE_SYS_TIME_H) +#include +#elif defined (HAVE_SYS_TIMEB_H) +#include +#endif + +#if defined(__STDC__) +#include +#endif + +#include /* Catch interrupts. */ + +#include "XeTeXLayoutInterface.h" + +#include "XeTeXswap.h" + +#include "unicode/ubidi.h" +#include "unicode/ubrk.h" +#include "unicode/ucnv.h" + +/* +#include "sfnt.h" + doesn't work in plain C files :( +*/ + +typedef struct +{ + Fixed version; + UInt16 numGlyphs; + UInt16 maxPoints; + UInt16 maxContours; + UInt16 maxComponentPoints; + UInt16 maxComponentContours; + UInt16 maxZones; + UInt16 maxTwilightPoints; + UInt16 maxStorage; + UInt16 maxFunctionDefs; + UInt16 maxInstructionDefs; + UInt16 maxStackElements; + UInt16 maxSizeOfInstructions; + UInt16 maxComponentElements; + UInt16 maxComponentDepth; +} MAXPTable; + +typedef struct +{ + Fixed version; + Fixed italicAngle; + SInt16 underlinePosition; + UInt16 underlineThickness; + UInt32 isFixedPitch; + UInt32 minMemType42; + UInt32 maxMemType42; + UInt32 minMemType1; + UInt32 maxMemType1; +} POSTTable; + +enum { + LE_MAXP_TABLE_TAG = 0x6D617870UL, /**< 'maxp' */ + LE_POST_TABLE_TAG = 0x706F7374UL, /**< 'post' */ +}; + +/* tables/values used in UTF-8 interpretation - + code is based on ConvertUTF.[ch] sample code + published by the Unicode consortium */ +const UInt32 +offsetsFromUTF8[6] = { + 0x00000000UL, + 0x00003080UL, + 0x000E2080UL, + 0x03C82080UL, + 0xFA082080UL, + 0x82082080UL +}; + +const UInt8 +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 +}; + +const UInt8 +firstByteMark[7] = { + 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC +}; + +const int halfShift = 10; +const UInt32 halfBase = 0x0010000UL; +const UInt32 halfMask = 0x3FFUL; +const UInt32 kSurrogateHighStart = 0xD800UL; +const UInt32 kSurrogateHighEnd = 0xDBFFUL; +const UInt32 kSurrogateLowStart = 0xDC00UL; +const UInt32 kSurrogateLowEnd = 0xDFFFUL; +const UInt32 byteMask = 0x000000BFUL; +const UInt32 byteMark = 0x00000080UL; + + +/* if the user specifies a paper size or output driver program */ +string papersize; +#ifdef XETEX_MAC +string outputdriver = "xdv2pdf"; /* default for backward compatibility on Mac OS X */ +#else +string outputdriver = "xdvipdfmx"; /* for linux version with preliminary dvipdfmx-based driver */ +#endif + + +extern char* gettexstring(int strNumber); +void +setinputfileencoding(UFILE* f, int mode, int 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) { + fprintf(stderr, "! Error %d creating Unicode converter for %s\n", err, name); + 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); + } +} + +int +input_line_icu(UFILE* f) +{ +static char* byteBuffer = NULL; + + UInt32 bytesRead = 0; + int i; + UConverter* cnv; + long 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 && last == first) + return false; + + if (i != EOF && i != '\n' && i != '\r') { + 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); + } + + /* If line ended with CR, remember to skip following LF. */ + if (i == '\r') + f->skipNextLF = 1; + + /* now apply the mapping to turn external bytes into Unicode characters in buffer */ + cnv = (UConverter*)(f->conversionData); + outLen = ucnv_toUChars(cnv, &buffer[first], (bufsize - first), byteBuffer, bytesRead, &errorCode); + if (errorCode != 0) { + fprintf(stderr, "! Unicode conversion failed: error code = %d\n", (int)errorCode); + return false; + } + last = first + outLen; + buffer[last] = ' '; + + if (last >= maxbufstack) + maxbufstack = last; + + /* Trim trailing whitespace. */ + while (last > first && ISBLANK(buffer[last - 1])) + --last; + + return true; +} + +static void die(char*s, int i) +{ + fprintf(stderr, s, i); + fprintf(stderr, " - exiting\n"); + exit(3); +} + +static UBreakIterator* brkIter = NULL; +static int brkLocaleStrNum = 0; + +void +linebreakstart(int localeStrNum, const UniChar* text, int textLength) +{ + UErrorCode status = 0; + int i; + + if ((localeStrNum != brkLocaleStrNum) && (brkIter != NULL)) { + ubrk_close(brkIter); + brkIter = NULL; + } + + if (brkIter == NULL) { + char* locale = (char*)gettexstring(localeStrNum); + brkIter = ubrk_open(UBRK_LINE, locale, NULL, 0, &status); + if (U_FAILURE(status)) { + fprintf(stderr, "\n! error %d creating linebreak iterator for locale \"%s\", trying default. ", status, locale); + 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); +} + +int +linebreaknext() +{ + return ubrk_next((UBreakIterator*)brkIter); +} + +long +getencodingmodeandinfo(long* 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 */ +#ifdef WORDS_BIGENDIAN + return UTF16BE; +#else + 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) { + fprintf(stderr, "! unknown encoding \"%s\"; reading as raw bytes\n", name); + return RAW; + } + else { + ucnv_close(cnv); + *info = maketexstring(name); + return ICUMAPPING; + } +} + +void +printutf8str(const unsigned char* str, int len) +{ + while (len-- > 0) + printvisiblechar(*(str++)); /* bypass utf-8 encoding done in print_char() */ +} + +void +printchars(const unsigned short* str, int len) +{ + while (len-- > 0) + printchar(*(str++)); +} + +void* +load_mapping_file(const char* s, const char* e) +{ + 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, "rb"); + free(mapPath); + if (mapFile) { + UInt32 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); + status = TECkit_CreateConverter(mapping, mappingSize, + true, +#ifdef WORDS_BIGENDIAN + kForm_UTF16BE, kForm_UTF16BE, +#else + kForm_UTF16LE, kForm_UTF16LE, +#endif + &cnv); + free(mapping); + } + } + else + fontmappingwarning(buffer, strlen(buffer)); + + free(buffer); + + return cnv; +} + +static UInt32 +read_tag(const char* cp) +{ + UInt32 tag = 0; + int i; + for (i = 0; i < 4; ++i) { + tag <<= 8; + if (*cp && /* *cp < 128 && */ *cp != ',' && *cp != ';' && *cp != ':') { + tag += *(unsigned char*)cp; + ++cp; + } + else + tag += ' '; + } + return tag; +} + +static void* +loadOTfont(XeTeXFont font, Fixed scaled_size, const char* cp1) +{ + XeTeXLayoutEngine engine; + UInt32 scriptTag = kLatin; + UInt32 languageTag = 0; + + UInt32* addFeatures = 0; + UInt32* removeFeatures = 0; + + int nAdded = 0; + int nRemoved = 0; + + const char* cp2; + const char* cp3; + + UInt32 tag; + + UInt32 rgbValue = 0x000000FF; + + /* 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; + scriptTag = read_tag(cp3 + 1); + goto next_option; + } + + if (strncmp(cp1, "language", 8) == 0) { + cp3 = cp1 + 8; + if (*cp3 != '=') + goto bad_option; + languageTag = read_tag(cp3 + 1); + goto next_option; + } + + if (strncmp(cp1, "mapping", 7) == 0) { + cp3 = cp1 + 7; + if (*cp3 != '=') + goto bad_option; + loadedfontmapping = load_mapping_file(cp3 + 1, cp2); + goto next_option; + } + + if (strncmp(cp1, "color", 5) == 0) { + unsigned alpha = 0; + int i; + cp3 = cp1 + 5; + if (*cp3 != '=') + goto bad_option; + ++cp3; + + rgbValue = 0; + for (i = 0; i < 6; ++i) { + if ((*cp3 >= '0') && (*cp3 <= '9')) + rgbValue = (rgbValue << 4) + *cp3 - '0'; + else if ((*cp3 >= 'A') && (*cp3 <= 'F')) + rgbValue = (rgbValue << 4) + *cp3 - 'A' + 10; + else if ((*cp3 >= 'a') && (*cp3 <= 'f')) + rgbValue = (rgbValue << 4) + *cp3 - 'a' + 10; + else + goto bad_option; + ++cp3; + } + rgbValue <<= 8; + for (i = 0; i < 2; ++i) { + if ((*cp3 >= '0') && (*cp3 <= '9')) + alpha = (alpha << 4) + *cp3 - '0'; + else if ((*cp3 >= 'A') && (*cp3 <= 'F')) + alpha = (alpha << 4) + *cp3 - 'A' + 10; + else if ((*cp3 >= 'a') && (*cp3 <= 'f')) + alpha = (alpha << 4) + *cp3 - 'a' + 10; + else + break; + ++cp3; + } + if (i == 2) + rgbValue += alpha; + else + rgbValue += 0xFF; + + loadedfontflags |= FONT_FLAGS_COLORED; + + goto next_option; + } + + if (strncmp(cp1, "letterspace", 11) == 0) { + int sign = 1; + double val = 0.0; + + cp3 = cp1 + 11; + if (*cp3 != '=') + goto bad_option; + ++cp3; + + if (*cp3 == '-') { + sign = -1; + ++cp3; + } + else if (*cp3 == '+') { + ++cp3; + } + + while (*cp3 >= '0' && *cp3 <= '9') { + val = val * 10.0 + *cp3 - '0'; + ++cp3; + } + if (*cp3 == '.' || *cp3 == ',') { + double dec = 10.0; + ++cp3; + while (*cp3 >= '0' && *cp3 <= '9') { + val = val + (*cp3 - '0') / dec; + ++cp3; + dec = dec * 10.0; + } + } + + loadedfontletterspace = sign * (val / 100.0) * scaled_size; + + goto next_option; + } + + if (*cp1 == '+') { + tag = read_tag(cp1 + 1); + ++nAdded; + if (nAdded == 1) + addFeatures = xmalloc(sizeof(UInt32)); + else + addFeatures = xrealloc(addFeatures, nAdded * sizeof(UInt32)); + addFeatures[nAdded-1] = tag; + goto next_option; + } + + if (*cp1 == '-') { + tag = read_tag(cp1 + 1); + ++nRemoved; + if (nRemoved == 1) + removeFeatures = xmalloc(sizeof(UInt32)); + else + removeFeatures = xrealloc(removeFeatures, nRemoved * sizeof(UInt32)); + removeFeatures[nRemoved-1] = tag; + goto next_option; + } + + if (strncmp(cp1, "vertical", 8) == 0) { + cp3 = cp2; + if (*cp3 == ';' || *cp3 == ':') + --cp3; + while (*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 (addFeatures != 0) { + addFeatures = realloc(addFeatures, (nAdded + 1) * sizeof(UInt32)); + addFeatures[nAdded] = 0; + } + if (removeFeatures != 0) { + removeFeatures = realloc(removeFeatures, (nRemoved + 1) * sizeof(UInt32)); + removeFeatures[nRemoved] = 0; + } + } + + if ((loadedfontflags & FONT_FLAGS_COLORED) == 0) + rgbValue = 0x000000FF; + + if ((loadedfontflags & FONT_FLAGS_VERTICAL) != 0) + setFontLayoutDir(font, 1); + + engine = createLayoutEngine(font, scriptTag, languageTag, addFeatures, removeFeatures, rgbValue); + if (engine == 0) { + deleteFont(font); + if (addFeatures) + free(addFeatures); + if (removeFeatures) + free(removeFeatures); + } + else + nativefonttypeflag = OT_FONT_FLAG; + + return engine; +} + +static void +splitFontName(char* name, char** var, char** feat, char** end) +{ + *var = NULL; + *feat = NULL; + 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, long scaled_size) + /* scaled_size here is in TeX points */ +{ + void* rval = 0; + char* nameString; + char* var; + char* feat; + char* end; + char* name = (char*)uname; + char* varString = NULL; + char* featString = NULL; + PlatformFontRef fontRef; + XeTeXFont font; + + loadedfontmapping = NULL; + loadedfontflags = 0; + loadedfontletterspace = 0; + + splitFontName(name, &var, &feat, &end); + + 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; + } + + fontRef = findFontByName(nameString, varString, Fix2X(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); + +#ifdef XETEX_MAC + /* decide whether to use AAT or OpenType rendering with this font */ + if (getReqEngine() == 'A') + goto load_aat; +#endif + + font = createFont(fontRef, scaled_size); + if (font != 0) { +#ifdef XETEX_MAC + if (getReqEngine() == 'I' || getFontTablePtr(font, kGSUB) != 0 || getFontTablePtr(font, kGPOS) != 0) +#endif + rval = loadOTfont(font, scaled_size, featString); + if (rval == 0) + deleteFont(font); + } + +#ifdef XETEX_MAC + if (rval == 0) { + load_aat: + rval = loadAATfont(fontRef, scaled_size, featString); + } +#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; +} + +void +releasefontengine(void* engine, int type_flag) +{ +#ifdef XETEX_MAC + if (type_flag == AAT_FONT_FLAG) { + ATSUDisposeStyle((ATSUStyle)engine); + } + else +#endif + if (type_flag == OT_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; + long rval = 0; + float a, d; + int glyphID; + + getAscentAndDescent(engine, &a, &d); + *ascent = X2Fix(a); + *descent = X2Fix(d); + + *slant = getSlant(getFont(engine)); + + glyphID = mapCharToGlyph(engine, 'x'); + if (glyphID != 0) { + getGlyphHeightDepth(engine, glyphID, &a, &d); + *xheight = X2Fix(a); + } + else + *xheight = *ascent / 2; /* arbitrary figure if there's no 'x' in the font */ + + glyphID = mapCharToGlyph(engine, 'X'); + if (glyphID != 0) { + getGlyphHeightDepth(engine, glyphID, &a, &d); + *capheight = X2Fix(a); + } + else + *capheight = *ascent; /* arbitrary figure if there's no 'X' in the font */ +} + +long +otfontget(int what, void* pEngine) +{ + 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; +} + + +long +otfontget1(int what, void* pEngine, long param) +{ + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; + XeTeXFont fontInst = getFont(engine); + switch (what) { + case XeTeX_OT_count_languages: + return countScriptLanguages(fontInst, param); + break; + + case XeTeX_OT_script_code: + return getIndScript(fontInst, param); + break; + } + return 0; +} + + +long +otfontget2(int what, void* pEngine, long param1, long param2) +{ + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)pEngine; + XeTeXFont fontInst = getFont(engine); + switch (what) { + case XeTeX_OT_language_code: + return getIndScriptLanguage(fontInst, param1, param2); + break; + + case XeTeX_OT_count_features: + return countFeatures(fontInst, param1, param2); + break; + } + + return 0; +} + + +long +otfontget3(int what, void* pEngine, long param1, long param2, long 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; +} + +#define XDV_FLAG_FONTTYPE_ATSUI 0x0001 +#define XDV_FLAG_FONTTYPE_ICU 0x0002 + +#define XDV_FLAG_VERTICAL 0x0100 +#define XDV_FLAG_COLORED 0x0200 +#define XDV_FLAG_FEATURES 0x0400 +#define XDV_FLAG_VARIATIONS 0x0800 + +#ifdef XETEX_MAC +static UInt32 +atsuColorToRGBA32(ATSURGBAlphaColor a) +{ + UInt32 rval = (UInt8)(a.red * 255.0 + 0.5); + rval <<= 8; + rval += (UInt8)(a.green * 255.0 + 0.5); + rval <<= 8; + rval += (UInt8)(a.blue * 255.0 + 0.5); + rval <<= 8; + rval += (UInt8)(a.alpha * 255.0 + 0.5); + return rval; +} +#endif + +static int xdvBufSize = 0; + +int +makeXDVGlyphArrayData(void* pNode) +{ + unsigned char* cp; + UInt16* glyphIDs; + memoryword* p = pNode; + void* glyph_info; + FixedPoint* locations; + int opcode; + Fixed wid; + UInt16 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 = (void*)native_glyph_info_ptr(p); + locations = (FixedPoint*)glyph_info; + glyphIDs = (UInt16*)(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; + + wid = node_width(p); + *cp++ = (wid >> 24) & 0xff; + *cp++ = (wid >> 16) & 0xff; + *cp++ = (wid >> 8) & 0xff; + *cp++ = wid & 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 g = glyphIDs[i]; + *cp++ = (g >> 8) & 0xff; + *cp++ = g & 0xff; + } + + return ((char*)cp - xdvbuffer); +} + +long +makefontdef(long f) +{ + PlatformFontRef fontRef; + + UInt16 flags = 0; + UInt32 variationCount = 0; + UInt32 rgba; + Fixed size; + const char* psName; + const char* famName; + const char* styName; + UInt8 psLen; + UInt8 famLen; + UInt8 styLen; + int fontDefLength; + char* cp; + +#ifdef XETEX_MAC + ATSUStyle style = NULL; + if (fontarea[f] == AAT_FONT_FLAG) { + flags = XDV_FLAG_FONTTYPE_ATSUI; + + style = (ATSUStyle)fontlayoutengine[f]; + ATSUGetAllFontVariations(style, 0, 0, 0, &variationCount); + + ATSUFontID fontID; + ATSUGetAttribute(style, kATSUFontTag, sizeof(ATSUFontID), &fontID, 0); + + fontRef = FMGetATSFontRefFromFont(fontID); + + ATSUVerticalCharacterType vert; + ATSUGetAttribute(style, kATSUVerticalCharacterTag, sizeof(ATSUVerticalCharacterType), &vert, 0); + if (vert == kATSUStronglyVertical) + flags |= XDV_FLAG_VERTICAL; + + ATSURGBAlphaColor atsuColor; + ATSUGetAttribute(style, kATSURGBAlphaColorTag, sizeof(ATSURGBAlphaColor), &atsuColor, 0); + rgba = atsuColorToRGBA32(atsuColor); + + ATSUGetAttribute(style, kATSUSizeTag, sizeof(Fixed), &size, 0); + } + else +#endif + if (fontarea[f] == OT_FONT_FLAG) { + XeTeXLayoutEngine engine; + flags = XDV_FLAG_FONTTYPE_ICU; + + engine = (XeTeXLayoutEngine)fontlayoutengine[f]; + fontRef = getFontRef(engine); + + rgba = getRgbValue(engine); + if ((fontflags[f] & FONT_FLAGS_VERTICAL) != 0) + flags |= XDV_FLAG_VERTICAL; + + size = X2Fix(getPointSize(engine)); + } + else { + fprintf(stderr, "\n! Internal error: bad native font flag\n"); + exit(3); + } + + getNames(fontRef, &psName, &famName, &styName); + /* returns ptrs to strings that belong to the font - do not free! */ + + 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; + } + +#ifdef XETEX_MAC + if (variationCount > 0) { + fontDefLength += + 2 /* number of variations */ + + 4 * variationCount + + 4 * variationCount; /* axes and values */ + flags |= XDV_FLAG_VARIATIONS; + } +#endif + + 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*)cp = SWAP16(flags); + cp += 2; + + *(UInt8*)cp = psLen; + cp += 1; + *(UInt8*)cp = famLen; + cp += 1; + *(UInt8*)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*)cp = SWAP32(rgba); + cp += 4; + } + +#ifdef XETEX_MAC + if (variationCount > 0) { + *(UInt16*)cp = SWAP16(variationCount); + cp += 2; + if (variationCount > 0) { + ATSUGetAllFontVariations(style, variationCount, + (UInt32*)(cp), + (SInt32*)(cp + 4 * variationCount), + 0); + while (variationCount > 0) { + /* (potentially) swap two 32-bit values per variation setting, + and advance cp past them all */ + *(UInt32*)(cp) = SWAP32(*(UInt32*)(cp)); + cp += 4; + *(UInt32*)(cp) = SWAP32(*(UInt32*)(cp)); + cp += 4; + --variationCount; + } + } + } +#endif + + return fontDefLength; +} + +int +applymapping(void* pCnv, const UniChar* 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 */ +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; + } +} + +static void +snap_zone(scaled* value, scaled snap_value, scaled fuzz) +{ + scaled difference = *value - snap_value; + if (difference <= fuzz && difference >= -fuzz) + *value = snap_value; +} + +void +getnativecharheightdepth(int font, int 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 + + float ht = 0.0; + float dp = 0.0; + Fixed fuzz; + +#ifdef XETEX_MAC + if (fontarea[font] == AAT_FONT_FLAG) { + ATSUStyle style = (ATSUStyle)(fontlayoutengine[font]); + int gid = MapCharToGlyph_AAT(style, ch); + GetGlyphHeightDepth_AAT(style, gid, &ht, &dp); + } + else +#endif + if (fontarea[font] == OT_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\n"); + exit(3); + } + + *height = X2Fix(ht); + *depth = X2Fix(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(int f, int c) +{ + scaled h, d; + getnativecharheightdepth(f, c, &h, &d); + return h; +} + +scaled +getnativechardp(int f, int c) +{ + scaled h, d; + getnativecharheightdepth(f, c, &h, &d); + return d; +} + +void +getnativecharsidebearings(int font, int ch, scaled* lsb, scaled* rsb) +{ + float l, r; + +#ifdef XETEX_MAC + if (fontarea[font] == AAT_FONT_FLAG) { + ATSUStyle style = (ATSUStyle)(fontlayoutengine[font]); + int gid = MapCharToGlyph_AAT(style, ch); + GetGlyphSidebearings_AAT(style, gid, &l, &r); + } + else +#endif + if (fontarea[font] == OT_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\n"); + exit(3); + } + + *lsb = X2Fix(l); + *rsb = X2Fix(r); +} + +scaled +getnativecharic(int f, int c) +{ + scaled lsb, rsb; + getnativecharsidebearings(f, c, &lsb, &rsb); + if (rsb < 0) + return fontletterspace[f] - rsb; + else + return fontletterspace[f]; +} + +scaled +getnativecharwd(int f, int c) +{ + scaled wd = 0; +#ifdef XETEX_MAC + if (fontarea[f] == AAT_FONT_FLAG) { + ATSUStyle style = (ATSUStyle)(fontlayoutengine[f]); + int gid = MapCharToGlyph_AAT(style, c); + wd = X2Fix(GetGlyphWidth_AAT(style, gid)); + } + else +#endif + if (fontarea[f] == OT_FONT_FLAG) { + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[f]; + int gid = mapCharToGlyph(engine, c); + wd = X2Fix(getGlyphWidthFromEngine(engine, gid)); + } + else { + fprintf(stderr, "\n! Internal error: bad native font flag\n"); + exit(3); + } + return wd; +} + +void +store_justified_native_glyphs(void* node) +{ +#ifdef XETEX_MAC /* this is only called for fonts used via ATSUI */ + (void)DoAtsuiLayout(node, 1); +#endif +} + +void +measure_native_node(void* pNode, int use_glyph_metrics) +{ + memoryword* node = (memoryword*)pNode; + int txtLen = native_length(node); + const UniChar* txtPtr = (UniChar*)(node + native_node_size); + + 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 an ATSUStyle */ + DoAtsuiLayout(node, 0); + } + else +#endif + if (fontarea[f] == OT_FONT_FLAG) { + /* using this font in OT Layout mode, so fontlayoutengine[f] is actually a XeTeXLayoutEngine */ + + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)(fontlayoutengine[f]); + + /* need to find direction runs within the text, and call layoutChars separately for each */ + + int nGlyphs; + UBiDiDirection dir; + float x, y; + void* glyph_info = 0; + static float* positions = 0; + static UInt32* glyphs = 0; + static long maxGlyphs = 0; + + FixedPoint* locations; + UInt16* glyphIDs; + int realGlyphCount = 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 wid = 0; + long totalGlyphs = 0; + int i, runIndex; + int32_t logicalStart, length; + OSStatus status = 0; + for (runIndex = 0; runIndex < nRuns; ++runIndex) { + dir = ubidi_getVisualRun(pBiDi, runIndex, &logicalStart, &length); + nGlyphs = layoutChars(engine, (UniChar*)txtPtr, logicalStart, length, txtLen, (dir == UBIDI_RTL), 0.0, 0.0, &status); + totalGlyphs += nGlyphs; + + if (nGlyphs >= maxGlyphs) { + if (glyphs != 0) { + free(glyphs); + free(positions); + } + maxGlyphs = nGlyphs + 20; + glyphs = xmalloc(maxGlyphs * sizeof(UInt32)); + positions = xmalloc((maxGlyphs * 2 + 2) * sizeof(float)); + } + + getGlyphs(engine, glyphs, &status); + for (i = 0; i < nGlyphs; ++i) + if (glyphs[i] < 0xfffe) + ++realGlyphCount; + } + + if (realGlyphCount > 0) { + double x, y; + glyph_info = xmalloc(realGlyphCount * native_glyph_info_size); + locations = (FixedPoint*)glyph_info; + glyphIDs = (UInt16*)(locations + realGlyphCount); + realGlyphCount = 0; + + x = y = 0.0; + for (runIndex = 0; runIndex < nRuns; ++runIndex) { + dir = ubidi_getVisualRun(pBiDi, runIndex, &logicalStart, &length); + nGlyphs = layoutChars(engine, (UniChar*)txtPtr, logicalStart, length, txtLen, + (dir == UBIDI_RTL), x, y, &status); + + getGlyphs(engine, glyphs, &status); + getGlyphPositions(engine, positions, &status); + + for (i = 0; i < nGlyphs; ++i) { + if (glyphs[i] < 0xfffe) { + glyphIDs[realGlyphCount] = glyphs[i]; + locations[realGlyphCount].x = X2Fix(positions[2*i]); + locations[realGlyphCount].y = X2Fix(positions[2*i+1]); + ++realGlyphCount; + } + } + x = positions[2*i]; + y = positions[2*i+1]; + } + wid = x; + } + + node_width(node) = X2Fix(wid); + native_glyph_count(node) = realGlyphCount; + native_glyph_info_ptr(node) = (long)glyph_info; + } + else { + int i; + OSStatus status = 0; + nGlyphs = layoutChars(engine, (UniChar*)txtPtr, 0, txtLen, txtLen, (dir == UBIDI_RTL), 0.0, 0.0, &status); + getGlyphPosition(engine, nGlyphs, &x, &y, &status); + node_width(node) = X2Fix(x); + + if (nGlyphs >= maxGlyphs) { + if (glyphs != 0) { + free(glyphs); + free(positions); + } + maxGlyphs = nGlyphs + 20; + glyphs = xmalloc(maxGlyphs * sizeof(UInt32)); + positions = xmalloc((maxGlyphs * 2 + 2) * sizeof(float)); + } + getGlyphs(engine, glyphs, &status); + getGlyphPositions(engine, positions, &status); + + for (i = 0; i < nGlyphs; ++i) + if (glyphs[i] < 0xfffe) + ++realGlyphCount; + + if (realGlyphCount > 0) { + glyph_info = xmalloc(realGlyphCount * native_glyph_info_size); + locations = (FixedPoint*)glyph_info; + glyphIDs = (UInt16*)(locations + realGlyphCount); + realGlyphCount = 0; + for (i = 0; i < nGlyphs; ++i) { + if (glyphs[i] < 0xfffe) { + glyphIDs[realGlyphCount] = glyphs[i]; + locations[realGlyphCount].x = X2Fix(positions[2*i]); + locations[realGlyphCount].y = X2Fix(positions[2*i+1]); + ++realGlyphCount; + } + } + } + + native_glyph_count(node) = realGlyphCount; + native_glyph_info_ptr(node) = (long)glyph_info; + } + + ubidi_close(pBiDi); + + if (fontletterspace[f] != 0) { + Fixed lsDelta = 0; + Fixed lsUnit = fontletterspace[f]; + int i; + for (i = 0; i < realGlyphCount; ++i) { + if (getGlyphWidth(getFont(engine), glyphIDs[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\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 ATSUI or ICU layout */ + FixedPoint* locations = (FixedPoint*)native_glyph_info_ptr(node); + UInt16* glyphIDs = (UInt16*)(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 = Fix2X(-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((ATSUStyle)(fontlayoutengine[f]), glyphIDs[i], &bbox); + else +#endif + if (fontarea[f] == OT_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) = X2Fix(yMax); + node_depth(node) = -X2Fix(yMin); + } +} + +Fixed +get_native_ital_corr(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* glyphIDs = (UInt16*)(locations + n); + +#ifdef XETEX_MAC + if (fontarea[f] == AAT_FONT_FLAG) + return X2Fix(GetGlyphItalCorr_AAT((ATSUStyle)(fontlayoutengine[f]), glyphIDs[n-1])) + + fontletterspace[f]; +#endif + if (fontarea[f] == OT_FONT_FLAG) + return X2Fix(getGlyphItalCorr((XeTeXLayoutEngine)(fontlayoutengine[f]), glyphIDs[n-1])) + + fontletterspace[f]; + } + + return 0; +} + + +Fixed +get_native_glyph_ital_corr(void* pNode) +{ + memoryword* node = pNode; + UInt16 gid = native_glyph(node); + unsigned f = native_font(node); + +#ifdef XETEX_MAC + if (fontarea[f] == AAT_FONT_FLAG) + return X2Fix(GetGlyphItalCorr_AAT((ATSUStyle)(fontlayoutengine[f]), gid)); +#endif + if (fontarea[f] == OT_FONT_FLAG) + return X2Fix(getGlyphItalCorr((XeTeXLayoutEngine)(fontlayoutengine[f]), gid)); + + return 0; /* can't actually happen */ +} + +void +measure_native_glyph(void* pNode, int use_glyph_metrics) +{ + memoryword* node = pNode; + UInt16 gid = native_glyph(node); + unsigned f = native_font(node); + + float ht = 0.0; + float dp = 0.0; + +#ifdef XETEX_MAC + if (fontarea[f] == AAT_FONT_FLAG) { + ATSUStyle style = (ATSUStyle)(fontlayoutengine[f]); + ATSGlyphIdealMetrics metrics; + OSStatus status = ATSUGlyphGetIdealMetrics(style, 1, &gid, 0, &metrics); + /* returns values in Quartz points, so we need to convert to TeX points */ + node_width(node) = X2Fix(metrics.advance.x * 72.27 / 72.0); + if (use_glyph_metrics) + GetGlyphHeightDepth_AAT(style, gid, &ht, &dp); + } + else +#endif + if (fontarea[f] == OT_FONT_FLAG) { + XeTeXLayoutEngine engine = (XeTeXLayoutEngine)fontlayoutengine[f]; + XeTeXFont fontInst = getFont(engine); + node_width(node) = X2Fix(getGlyphWidth(fontInst, gid)); + if (use_glyph_metrics) + getGlyphHeightDepth(engine, gid, &ht, &dp); + } + else { + fprintf(stderr, "\n! Internal error: bad native font flag\n"); + exit(3); + } + + if (use_glyph_metrics) { + node_height(node) = X2Fix(ht); + node_depth(node) = X2Fix(dp); + } + else { + node_height(node) = heightbase[f]; + node_depth(node) = depthbase[f]; + } +} + +int +mapchartoglyph(int font, unsigned int ch) +{ + if (ch > 0x10ffff || ((ch >= 0xd800) && (ch <= 0xdfff))) + return 0; +#ifdef XETEX_MAC + if (fontarea[font] == AAT_FONT_FLAG) + return MapCharToGlyph_AAT((ATSUStyle)(fontlayoutengine[font]), ch); + else +#endif + if (fontarea[font] == OT_FONT_FLAG) + return mapCharToGlyph((XeTeXLayoutEngine)(fontlayoutengine[font]), ch); + else { + fprintf(stderr, "\n! Internal error: bad native font flag\n"); + exit(3); + } +} + +int +mapglyphtoindex(int font) + /* glyph name is at nameoffile+1 */ +{ +#ifdef XETEX_MAC + if (fontarea[font] == AAT_FONT_FLAG) + return MapGlyphToIndex_AAT((ATSUStyle)(fontlayoutengine[font]), (const char*)nameoffile + 1); + else +#endif + if (fontarea[font] == OT_FONT_FLAG) + return mapGlyphToIndex((XeTeXLayoutEngine)(fontlayoutengine[font]), (const char*)nameoffile + 1); + else { + fprintf(stderr, "\n! Internal error: bad native font flag\n"); + exit(3); + } +} + +#ifndef XETEX_MAC +Fixed X2Fix(double d) +{ + Fixed rval = (int)(d * 65536.0 + 0.5); + return rval; +} + +double Fix2X(Fixed f) +{ + double rval = f / 65536.0; + return rval; +} +#endif + +/* these are here, not XeTeX_mac.c, because we need stubs on other platforms */ +#ifndef XETEX_MAC +typedef void* ATSUStyle; /* dummy declaration just so the stubs can compile */ +#endif + +void +atsugetfontmetrics(ATSUStyle style, Fixed* ascent, Fixed* descent, Fixed* xheight, Fixed* capheight, Fixed* slant) +{ +#ifdef XETEX_MAC + *ascent = *descent = *xheight = *capheight = *slant = 0; + + ATSUFontID fontID; + OSStatus status = ATSUGetAttribute(style, kATSUFontTag, sizeof(ATSUFontID), &fontID, 0); + if (status != noErr) + return; + + ATSFontRef fontRef = FMGetATSFontRefFromFont(fontID); + + Fixed size; + status = ATSUGetAttribute(style, kATSUSizeTag, sizeof(Fixed), &size, 0); + if (status != noErr) + return; + /* size from the ATSUStyle is in Quartz points; convert to TeX points here */ + double floatSize = Fix2X(size) * 72.27 / 72.0; + + ATSFontMetrics metrics; + status = ATSFontGetHorizontalMetrics(fontRef, kATSOptionFlagsDefault, &metrics); + if (status != noErr) + return; + + *ascent = X2Fix(metrics.ascent * floatSize); + *descent = X2Fix(metrics.descent * floatSize); + + if (metrics.italicAngle != 0.0) { + if (fabs(metrics.italicAngle) < 0.090) + metrics.italicAngle *= 1000.0; /* hack around apparent ATS bug */ + *slant = X2Fix(tan(-metrics.italicAngle * M_PI / 180.0)); + } + else { + /* try to get a (possibly synthetic) POST table, as ATSFontGetHorizontalMetrics + doesn't seem to return this value for OT/CFF fonts */ + ByteCount tableSize; + if (ATSFontGetTable(fontRef, LE_POST_TABLE_TAG, 0, 0, 0, &tableSize) == noErr) { + POSTTable* post = xmalloc(tableSize); + ATSFontGetTable(fontRef, LE_POST_TABLE_TAG, 0, tableSize, post, 0); + *slant = X2Fix(tan(Fix2X( - SWAP32(post->italicAngle)) * M_PI / 180.0)); + free(post); + } + } + + if (0 && metrics.xHeight != 0.0) { + /* currently not using this, as the values from ATS don't seem quite what I'd expect */ + *xheight = X2Fix(metrics.xHeight * floatSize); + *capheight = X2Fix(metrics.capHeight * floatSize); + } + else { + int glyphID = MapCharToGlyph_AAT(style, 'x'); + float ht, dp; + if (glyphID != 0) { + GetGlyphHeightDepth_AAT(style, glyphID, &ht, &dp); + *xheight = X2Fix(ht); + } + else + *xheight = *ascent / 2; /* arbitrary figure if there's no 'x' in the font */ + + glyphID = MapCharToGlyph_AAT(style, 'X'); + if (glyphID != 0) { + GetGlyphHeightDepth_AAT(style, glyphID, &ht, &dp); + *capheight = X2Fix(ht); + } + else + *capheight = *ascent; /* arbitrary figure if there's no 'X' in the font */ + } +#endif +} + +long +atsufontget(int what, ATSUStyle style) +{ + long rval = -1; + +#ifdef XETEX_MAC + ATSUFontID fontID; + ATSUGetAttribute(style, kATSUFontTag, sizeof(ATSUFontID), &fontID, 0); + ItemCount count; + + switch (what) { + case XeTeX_count_glyphs: + { + ByteCount tableSize; + ATSFontRef fontRef = FMGetATSFontRefFromFont(fontID); + if (ATSFontGetTable(fontRef, LE_MAXP_TABLE_TAG, 0, 0, 0, &tableSize) == noErr) { + MAXPTable* table = xmalloc(tableSize); + ATSFontGetTable(fontRef, LE_MAXP_TABLE_TAG, 0, tableSize, table, 0); + rval = SWAP16(table->numGlyphs); + free(table); + } + } + break; + + case XeTeX_count_variations: + if (ATSUCountFontVariations(fontID, &count) == noErr) + rval = count; + break; + + case XeTeX_count_features: + if (ATSUCountFontFeatureTypes(fontID, &count) == noErr) + rval = count; + break; + } +#endif + return rval; +} + +long +atsufontget1(int what, ATSUStyle style, int param) +{ + long rval = -1; + +#ifdef XETEX_MAC + ATSUFontID fontID; + ATSUGetAttribute(style, kATSUFontTag, sizeof(ATSUFontID), &fontID, 0); + + ATSUFontVariationAxis axis; + ATSUFontVariationValue value; + ItemCount count; + Boolean exclusive; + switch (what) { + case XeTeX_variation: + if (ATSUGetIndFontVariation(fontID, param, &axis, 0, 0, 0) == noErr) + rval = axis; + break; + + case XeTeX_variation_min: + case XeTeX_variation_max: + case XeTeX_variation_default: + if (ATSUCountFontVariations(fontID, &count) == noErr) + while (count-- > 0) + if (ATSUGetIndFontVariation(fontID, count, &axis, + (what == XeTeX_variation_min) ? &value : 0, + (what == XeTeX_variation_max) ? &value : 0, + (what == XeTeX_variation_default) ? &value : 0) == noErr) + if (axis == param) { + rval = value; + break; + } + break; + + case XeTeX_feature_code: + if (ATSUCountFontFeatureTypes(fontID, &count) == noErr) { + if (param < count) { + ATSUFontFeatureType* types = xmalloc(count * sizeof(ATSUFontFeatureType)); + if (ATSUGetFontFeatureTypes(fontID, count, types, 0) == noErr) + rval = types[param]; + free(types); + } + } + break; + + case XeTeX_is_exclusive_feature: + if (ATSUGetFontFeatureSelectors(fontID, param, 0, 0, 0, 0, &exclusive) == noErr) + rval = exclusive ? 1 : 0; + break; + + case XeTeX_count_selectors: + if (ATSUCountFontFeatureSelectors(fontID, param, &count) == noErr) + rval = count; + break; + } +#endif + + return rval; +} + +long +atsufontget2(int what, ATSUStyle style, int param1, int param2) +{ + long rval = -1; + +#ifdef XETEX_MAC + ATSUFontID fontID; + ATSUGetAttribute(style, kATSUFontTag, sizeof(ATSUFontID), &fontID, 0); + + ItemCount count; + if (ATSUCountFontFeatureSelectors(fontID, param1, &count) == noErr) { + ATSUFontFeatureSelector* selectors = xmalloc(count * sizeof(ATSUFontFeatureSelector)); + Boolean* isDefault = xmalloc(count * sizeof(Boolean)); + if (ATSUGetFontFeatureSelectors(fontID, param1, count, selectors, isDefault, 0, 0) == noErr) { + switch (what) { + case XeTeX_selector_code: + if (param2 < count) + rval = selectors[param2]; + break; + + case XeTeX_is_default_selector: + while (count-- > 0) + if (selectors[count] == param2) { + rval = isDefault[count] ? 1 : 0; + break; + } + break; + } + } + free(isDefault); + free(selectors); + } +#endif + + return rval; +} + +long +atsufontgetnamed(int what, ATSUStyle style) +{ + long rval = -1; + +#ifdef XETEX_MAC + ATSUFontID fontID; + ATSUGetAttribute(style, kATSUFontTag, sizeof(ATSUFontID), &fontID, 0); + + switch (what) { + case XeTeX_find_variation_by_name: + rval = find_axis_by_name(fontID, nameoffile + 1, namelength); + if (rval == 0) + rval = -1; + break; + + case XeTeX_find_feature_by_name: + rval = find_feature_by_name(fontID, nameoffile + 1, namelength); + if (rval == 0x0000FFFF) + rval = -1; + break; + } +#endif + + return rval; +} + +long +atsufontgetnamed1(int what, ATSUStyle style, int param) +{ + long rval = -1; + +#ifdef XETEX_MAC + ATSUFontID fontID; + ATSUGetAttribute(style, kATSUFontTag, sizeof(ATSUFontID), &fontID, 0); + + switch (what) { + case XeTeX_find_selector_by_name: + rval = find_selector_by_name(fontID, param, nameoffile + 1, namelength); + if (rval == 0x0000FFFF) + rval = -1; + break; + } +#endif + + return rval; +} + +void +atsuprintfontname(int what, ATSUStyle style, int param1, int param2) +{ +#ifdef XETEX_MAC + ATSUFontID fontID; + ATSUGetAttribute(style, kATSUFontTag, sizeof(ATSUFontID), &fontID, 0); + + FontNameCode code; + OSStatus status = -1; + ItemCount count, i; + Boolean found = 0; + + switch (what) { + case XeTeX_variation_name: + status = ATSUCountFontVariations(fontID, &count); + if (status == noErr) { + for (i = 0; i < count; ++i) { + ATSUFontVariationAxis axis; + ATSUFontVariationValue min, max, def; + status = ATSUGetIndFontVariation(fontID, i, &axis, &min, &max, &def); + if (status == noErr && axis == param1) { + status = ATSUGetFontVariationNameCode(fontID, param1, &code); + found = 1; + break; + } + } + } + break; + + case XeTeX_feature_name: + case XeTeX_selector_name: + status = ATSUCountFontFeatureTypes(fontID, &count); + if (status == noErr) { + ATSUFontFeatureType* features = xmalloc(count * sizeof(ATSUFontFeatureType)); + status = ATSUGetFontFeatureTypes(fontID, count, features, &count); + if (status == noErr) { + for (i = 0; i < count; ++i) { + if (features[i] == param1) { + /* the requested feature code is valid */ + if (what == XeTeX_feature_name) { + status = ATSUGetFontFeatureNameCode(fontID, param1, kATSUNoSelector, &code); + found = 1; + } + else { + status = ATSUCountFontFeatureSelectors(fontID, param1, &count); + if (status == noErr) { + ATSUFontFeatureSelector* selectors = xmalloc(count * sizeof(ATSUFontFeatureSelector)); + Boolean* onByDefault = xmalloc(count * sizeof(Boolean)); + Boolean exclusive; + status = ATSUGetFontFeatureSelectors(fontID, param1, count, selectors, onByDefault, &count, &exclusive); + if (status == noErr) { + for (i = 0; i < count; ++i) { + if (selectors[i] == param2) { + /* feature/selector combination is valid */ + status = ATSUGetFontFeatureNameCode(fontID, param1, param2, &code); + found = 1; + break; + } + } + } + free(onByDefault); + free(selectors); + } + } + break; + } + } + } + free(features); + } + break; + } + + if (found && status == noErr) { +#define NAME_BUF_SIZE 1024 + ByteCount len = 0; + char name[NAME_BUF_SIZE]; /* should be more than enough for any sensible font name */ + do { + if (ATSUFindFontName(fontID, code, kFontMacintoshPlatform, kFontRomanScript, kFontEnglishLanguage, NAME_BUF_SIZE, name, &len, 0) == noErr) break; + if (ATSUFindFontName(fontID, code, kFontMacintoshPlatform, kFontRomanScript, kFontNoLanguageCode, NAME_BUF_SIZE, name, &len, 0) == noErr) break; + } while (0); + if (len > 0) { + /* need to convert MacRoman name to Unicode */ + CFStringRef str = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8*)name, len, kCFStringEncodingMacRoman, false); + if (str != NULL) { + len = CFStringGetLength(str); + UniChar* buf = xmalloc(len * sizeof(UniChar)); + CFStringGetCharacters(str, CFRangeMake(0, len), buf); + printchars(buf, len); + free(buf); + CFRelease(str); + } + } + else { + do { + if (ATSUFindFontName(fontID, code, kFontUnicodePlatform, kFontNoScriptCode, kFontEnglishLanguage, NAME_BUF_SIZE, name, &len, 0) == noErr) break; + if (ATSUFindFontName(fontID, code, kFontMicrosoftPlatform, kFontNoScriptCode, kFontEnglishLanguage, NAME_BUF_SIZE, name, &len, 0) == noErr) break; + if (ATSUFindFontName(fontID, code, kFontUnicodePlatform, kFontNoScriptCode, kFontNoLanguageCode, NAME_BUF_SIZE, name, &len, 0) == noErr) break; + if (ATSUFindFontName(fontID, code, kFontMicrosoftPlatform, kFontNoScriptCode, kFontNoLanguageCode, NAME_BUF_SIZE, name, &len, 0) == noErr) break; + } while (0); + if (len > 0) { + printchars((unsigned short*)(&name[0]), len / 2); + } + } + } +#endif +} + +#ifdef XETEX_OTHER +#if 0 +#include +int +find_pic_file(char** path, realrect* bounds, int pdfBoxType, int page) + /* FIXME: not yet handling /page/ parameter or PDFs properly */ +{ + int err = -1; + MagickBooleanType status; + MagickWand *wand; + ResolutionType units; + double xRes, yRes; + char* pic_path = kpse_find_file((char*)nameoffile + 1, kpse_pict_format, 1); + + *path = NULL; + + wand = NewMagickWand(); + status = MagickPingImage(wand, pic_path); + if (status == MagickTrue) { + status = MagickGetImageResolution(wand, &xRes, &yRes); + if (status == MagickTrue) { + bounds->x = bounds->y = 0; + units = MagickGetImageUnits(wand); + switch (units) { + default: + /* treat unknown as 72 pixels per inch horiz, and proportionately vertical */ + bounds->wd = MagickGetImageWidth(wand); + if (xRes != 0.0 && yRes != 0.0) + bounds->ht = MagickGetImageHeight(wand) * xRes / yRes; + else + bounds->ht = MagickGetImageHeight(wand); + break; + case PixelsPerInchResolution: + bounds->wd = MagickGetImageWidth(wand) * 72.0 / xRes; + bounds->ht = MagickGetImageHeight(wand) * 72.0 / yRes; + break; + case PixelsPerCentimeterResolution: + bounds->wd = MagickGetImageWidth(wand) * 72.0 / (xRes * 2.54); + bounds->ht = MagickGetImageHeight(wand) * 72.0 / (yRes * 2.54); + break; + } + err = 0; + } + } + + /* current API returns wand, but formerly returned void; + we don't need the result, and this allows XeTeX to build with older libraries */ + (void)DestroyMagickWand(wand); + + if (err != 0) + free(pic_path); + else + *path = pic_path; + + return err; +} +#endif +#endif + +boolean +u_open_in(unicodefile* f, int filefmt, const_string fopen_mode, int mode, int encodingData) +{ + boolean rval; + *f = malloc(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; + fseek((*f)->f, SEEK_SET, 0); + } + else if (B2 == 0 && B1 != 0) { + mode = UTF16LE; + fseek((*f)->f, SEEK_SET, 0); + } + else if (B1 == 0xef && B2 == 0xbb) { + int B3 = getc((*f)->f); + if (B3 == 0xbf) + mode = UTF8; + } + if (mode == AUTO) { + fseek((*f)->f, SEEK_SET, 0); + mode = UTF8; + } + } + + setinputfileencoding(*f, mode, encodingData); + } + return rval; +} + +boolean +open_dvi_output(FILE** fptr) +{ + if (nopdfoutput) { + return open_output(fptr, FOPEN_WBIN_MODE); + } + else { + char* cmd2 = concat(outputdriver, " -o \""); + char* cmd = concat3(cmd2, (char*)nameoffile+1, "\""); + free(cmd2); + if (papersize != 0) { + cmd2 = concat3(cmd, " -p ", papersize); + free(cmd); + cmd = cmd2; + } + *fptr = popen(cmd, "w"); + free(cmd); + return (*fptr != 0); + } +} + +void +dviclose(FILE* fptr) +{ + if (nopdfoutput) + fclose(fptr); + else + pclose(fptr); +} + +int +get_uni_c(UFILE* f) +{ + int rval; + + if (f->savedChar != -1) { + rval = f->savedChar; + f->savedChar = -1; + return rval; + } + + switch (f->encodingMode) { + case UTF8: + /* FIXME: we don't currently check for malformed UTF-8 */ + rval = getc(f->f); + if (rval != EOF) { + UInt16 extraBytes = bytesFromUTF8[rval]; + switch (extraBytes) { /* note: code falls through cases! */ + case 5: rval <<= 6; rval += getc(f->f); + case 4: rval <<= 6; rval += getc(f->f); + case 3: rval <<= 6; rval += getc(f->f); + case 2: rval <<= 6; rval += getc(f->f); + case 1: rval <<= 6; rval += getc(f->f); + case 0: ; + }; + rval -= offsetsFromUTF8[extraBytes]; + if (rval > 0xFFFF) { + rval -= 0x10000; + f->savedChar = 0xdc00 + rval % 0x0400; + rval = 0xd800 + rval / 0x0400; + } + } + break; + + case UTF16BE: + rval = getc(f->f); + rval <<= 8; + rval += getc(f->f); + break; + + case UTF16LE: + rval = getc(f->f); + rval += (getc(f->f) << 8); + 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); + } + + return rval; +} + +boolean +input_line(UFILE* f) +{ + int i; + + if (f->encodingMode == ICUMAPPING) + return input_line_icu(f); + + /* 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); + } + + last = first; + 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') { + 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); + } + + buffer[last] = ' '; + if (last >= maxbufstack) + maxbufstack = last; + + /* If line ended with CR, remember to skip following LF. */ + if (i == '\r') + f->skipNextLF = 1; + + /* Trim trailing whitespace. */ + while (last > first && ISBLANK (buffer[last - 1])) + --last; + + return true; +} + +void +makeutf16name() +{ + unsigned char* s = nameoffile + 1; + UInt32 rval; + UInt16* t; + static int name16len = 0; + if (name16len <= namelength) { + if (nameoffile16 != 0) + free(nameoffile16); + name16len = namelength + 10; + nameoffile16 = xmalloc(name16len * sizeof(UInt16)); + } + t = nameoffile16; + while (s <= nameoffile + namelength) { + rval = *(s++); + UInt16 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; +} + diff --git a/Build/source/texk/web2c/xetexdir/XeTeX_ext.h b/Build/source/texk/web2c/xetexdir/XeTeX_ext.h new file mode 100644 index 00000000000..5a0bc59db50 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeX_ext.h @@ -0,0 +1,284 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +#ifndef __XETEXEXT_H +#define __XETEXEXT_H + +/***** copied from TeX/texk/web2c/config.h -- difficult to include in C++ source files ******/ +#ifndef INTEGER_TYPE + +#if SIZEOF_LONG > 4 && !defined (NO_DUMP_SHARE) +/* If we have 64-bit longs and want to share format files (with 32-bit + machines), use `int'. */ +#define INTEGER_IS_INT +#endif + +#ifdef INTEGER_IS_INT +#define INTEGER_TYPE int +#define INTEGER_MAX INT_MAX +#define INTEGER_MIN INT_MIN +#else +#define INTEGER_TYPE long +#define INTEGER_MAX LONG_MAX +#define INTEGER_MIN LONG_MIN +#endif /* not INTEGER_IS_INT */ + +typedef INTEGER_TYPE integer; +#endif /* not INTEGER_TYPE */ +/***** end of config.h stuff *****/ + +#ifndef XETEX_UNICODE_FILE_DEFINED +typedef struct UFILE* unicodefile; +#endif + +#define AAT_FONT_FLAG 65535 +#define OT_FONT_FLAG 65534 + +#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 */ + +#ifdef XETEX_MAC +#include +#else +#ifndef __TECkit_Common_H__ +typedef unsigned char UInt8; +typedef unsigned short UInt16; +typedef unsigned int UInt32; +typedef UInt16 UniChar; +#endif + +typedef signed char SInt8; +typedef short SInt16; +typedef int SInt32; + +typedef SInt32 OSStatus; +typedef SInt32 Fixed; +typedef struct { + Fixed x; + Fixed y; +} FixedPoint; +#endif + + +/* these are also in xetex-new.ch and must correspond! */ + +#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_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_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_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-new.ch */ +#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].hh.v.RH +#define native_font(node) node[native_info_offset].hh.b1 +#define native_glyph_count(node) node[native_glyph_info_offset].hh.v.LH +#define native_glyph_info_ptr(node) node[native_glyph_info_offset].hh.v.RH +#define native_glyph_info_size 10 /* info for each glyph is location (FixedPoint) + glyph ID (UInt16) */ + +#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 0x47535542 +#define kGPOS 0x47504f53 + +#define kLatin 0x6c61746e +#define kSyriac 0x73797263 +#define kArabic 0x61726162 +#define kThaana 0x74686161 +#define kHebrew 0x68656272 + + +struct postTable { + Fixed format; + Fixed italicAngle; + SInt16 underlinePosition; + SInt16 underlineThickness; + UInt16 isFixedPitch; + UInt16 reserved; + UInt32 minMemType42; + UInt32 maxMemType42; + UInt32 minMemType1; + UInt32 maxMemType1; +}; + +#define kPost 0x706f7374 + + +typedef struct +{ + float xMin; + float yMin; + float xMax; + float yMax; +} GlyphBBox; + + +extern char *outputdriver; +extern char *papersize; + +/* For Unicode encoding form interpretation... */ +extern const UInt32 offsetsFromUTF8[6]; +extern const UInt8 bytesFromUTF8[256]; +extern const UInt8 firstByteMark[7]; + +extern const int halfShift; +extern const UInt32 halfBase; +extern const UInt32 halfMask; +extern const UInt32 kSurrogateHighStart; +extern const UInt32 kSurrogateHighEnd; +extern const UInt32 kSurrogateLowStart; +extern const UInt32 kSurrogateLowEnd; +extern const UInt32 byteMask; +extern const UInt32 byteMark; + +#include "trans.h" + +#ifdef __cplusplus +extern "C" { +#endif + void setinputfileencoding(unicodefile f, int mode, int encodingData); + void uclose(unicodefile f); + int input_line_icu(unicodefile f); + void linebreakstart(int localeStrNum, const UniChar* text, int textLength); + int linebreaknext(); + long getencodingmodeandinfo(long* info); + void printutf8str(const unsigned char* str, int len); + void printchars(const unsigned short* str, int len); + void* load_mapping_file(const char* s, const char* e); + void* findnativefont(unsigned char* name, long scaled_size); + void releasefontengine(void* engine, int type_flag); + + /* 'integer' 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(int font, int ch, integer* height, integer* depth); + void getnativecharsidebearings(int font, int ch, integer* lsb, integer* rsb); + + /* single-purpose metrics accessors */ + integer getnativecharwd(int font, int ch); + integer getnativecharht(int font, int ch); + integer getnativechardp(int font, int ch); + integer getnativecharic(int font, int ch); + + long otfontget(int what, void* engine); + long otfontget1(int what, void* engine, long param); + long otfontget2(int what, void* engine, long param1, long param2); + long otfontget3(int what, void* engine, long param1, long param2, long param3); + int makeXDVGlyphArrayData(void* p); + long makefontdef(long f); + int applymapping(void* cnv, const UniChar* txtPtr, int txtLen); + void store_justified_native_glyphs(void* node); + void measure_native_node(void* node, int use_glyph_metrics); + Fixed get_native_ital_corr(void* node); + Fixed get_native_glyph_ital_corr(void* node); + void measure_native_glyph(void* node, int use_glyph_metrics); + int mapchartoglyph(int font, unsigned int ch); + int mapglyphtoindex(int font); + + int find_pic_file(char** path, realrect* bounds, int pdfBoxType, int page); + +#ifdef XETEX_MAC +/* functions in XeTeX_mac.c */ + void* loadAATfont(ATSFontRef fontRef, long scaled_size, const char* cp1); + void DoAtsuiLayout(void* node, int justify); + void GetGlyphBBox_AAT(ATSUStyle style, UInt16 gid, GlyphBBox* bbox); + float GetGlyphWidth_AAT(ATSUStyle style, UInt16 gid); + void GetGlyphHeightDepth_AAT(ATSUStyle style, UInt16 gid, float* ht, float* dp); + void GetGlyphSidebearings_AAT(ATSUStyle style, UInt16 gid, float* lsb, float* rsb); + int MapCharToGlyph_AAT(ATSUStyle style, UInt32 ch); + int MapGlyphToIndex_AAT(ATSUStyle style, const char* glyphName); + float GetGlyphItalCorr_AAT(ATSUStyle style, UInt16 gid); +#endif +#ifdef __cplusplus +}; +#endif + + +/* some Mac OS X functions that we provide ourselves for other platforms */ +#ifndef XETEX_MAC +#ifdef __cplusplus +extern "C" { +#endif + double Fix2X(Fixed f); + Fixed X2Fix(double d); +#ifdef __cplusplus +}; +#endif +#endif + +#endif /* __XETEX_EXT_H */ + diff --git a/Build/source/texk/web2c/xetexdir/XeTeX_mac.c b/Build/source/texk/web2c/xetexdir/XeTeX_mac.c new file mode 100644 index 00000000000..8a892be8fc4 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeX_mac.c @@ -0,0 +1,1022 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +/* XeTeX_mac.c + * additional plain C extensions for XeTeX - MacOS-specific routines + */ + +#ifdef __POWERPC__ +#define MAC_OS_X_VERSION_MIN_REQUIRED MAC_OS_X_VERSION_10_2 +#else +#define MAC_OS_X_VERSION_MIN_REQUIRED MAC_OS_X_VERSION_10_4 +#endif + +#define EXTERN extern +#include "xetexd.h" + +#undef input /* this is defined in texmfmp.h, but we don't need it and it confuses the carbon headers */ +#include +#include + +#include "TECkit_Engine.h" +#include "XeTeX_ext.h" + +#include "XeTeXswap.h" + +static ATSUTextLayout sTextLayout = 0; + +static void +InitializeLayout() +{ + OSStatus status = ATSUCreateTextLayout(&sTextLayout); + ATSUFontFallbacks fallbacks; + status = ATSUCreateFontFallbacks(&fallbacks); + status = ATSUSetObjFontFallbacks(fallbacks, 0, 0, kATSULastResortOnlyFallback); + ATSUAttributeTag tag = kATSULineFontFallbacksTag; + ByteCount valueSize = sizeof(fallbacks); + ATSUAttributeValuePtr value = &fallbacks; + status = ATSUSetLayoutControls(sTextLayout, 1, &tag, &valueSize, &value); + status = ATSUSetTransientFontMatching(sTextLayout, true); +} + +static inline double +TeXtoPSPoints(double pts) +{ + return pts * 72.0 / 72.27; +} + +static inline double +PStoTeXPoints(double pts) +{ + return pts * 72.27 / 72.0; +} + +static inline Fixed +FixedTeXtoPSPoints(Fixed pts) +{ + return X2Fix(TeXtoPSPoints(Fix2X(pts))); +} + +static inline Fixed +FixedPStoTeXPoints(Fixed pts) +{ + return X2Fix(PStoTeXPoints(Fix2X(pts))); +} + +void +DoAtsuiLayout(void* p, int justify) +{ + memoryword* node = (memoryword*)p; + + unsigned f = native_font(node); + if (fontarea[f] != AAT_FONT_FLAG) { + fprintf(stderr, "internal error: do_atsui_layout called for non-ATSUI font\n"); + exit(1); + } + + if (sTextLayout == 0) + InitializeLayout(); + + OSStatus status = noErr; + + long txtLen = native_length(node); + const UniChar* txtPtr = (UniChar*)(node + native_node_size); + + status = ATSUSetTextPointerLocation(sTextLayout, txtPtr, 0, txtLen, txtLen); + + // we're using this font in AAT mode, so fontlayoutengine[f] is actually an ATSUStyle + ATSUStyle style = (ATSUStyle)(fontlayoutengine[native_font(node)]); + status = ATSUSetRunStyle(sTextLayout, style, 0, txtLen); + + ATSUAttributeTag tags[] = { kATSULineWidthTag, kATSULineJustificationFactorTag }; + ItemCount numTags = sizeof(tags) / sizeof(ATSUAttributeTag); + if (justify) { + ByteCount valSizes[] = { sizeof(Fixed), sizeof(Fract) }; + Fixed wid = FixedTeXtoPSPoints(node_width(node)); + Fract just = fract1; + ATSUAttributeValuePtr valPtrs[] = { &wid, &just }; + status = ATSUSetLayoutControls(sTextLayout, numTags, tags, valSizes, valPtrs); + } + + ItemCount count; + ATSLayoutRecord* layoutRec = NULL; + status = ATSUDirectGetLayoutDataArrayPtrFromTextLayout(sTextLayout, 0, + kATSUDirectDataLayoutRecordATSLayoutRecordCurrent, (void*)&layoutRec, &count); + + int i; + int realGlyphCount = 0; + int lastRealGlyph = 0; + for (i = 0; i < count; ++i) + if (layoutRec[i].glyphID < 0xfffe) { + lastRealGlyph = i; + ++realGlyphCount; + } + + void* glyph_info = xmalloc(realGlyphCount * native_glyph_info_size); + FixedPoint* locations = (FixedPoint*)glyph_info; + UInt16* glyphIDs = (UInt16*)(locations + realGlyphCount); + + Fixed lsUnit = justify ? 0 : fontletterspace[f]; + Fixed lsDelta = 0; + + realGlyphCount = 0; + for (i = 0; i < count; ++i) { + if (layoutRec[i].glyphID < 0xfffe) { + if ((layoutRec[i].flags & kATSGlyphInfoIsAttachment) && (lsDelta != 0)) + lsDelta -= lsUnit; + glyphIDs[realGlyphCount] = layoutRec[i].glyphID; + locations[realGlyphCount].y = 0; /* FIXME: won't handle baseline offsets */ + locations[realGlyphCount].x = FixedPStoTeXPoints(layoutRec[i].realPos) + lsDelta; + lsDelta += lsUnit; + ++realGlyphCount; + } + } + if (lsDelta != 0) + lsDelta -= lsUnit; + + native_glyph_count(node) = realGlyphCount; + native_glyph_info_ptr(node) = (long)glyph_info; + + if (!justify) + node_width(node) = FixedPStoTeXPoints(layoutRec[count-1].realPos) + lsDelta; + + ATSUDirectReleaseLayoutDataArrayPtr(NULL, kATSUDirectDataLayoutRecordATSLayoutRecordCurrent, (void*)&layoutRec); + + if (justify) + ATSUClearLayoutControls(sTextLayout, numTags, tags); +} + +static OSStatus QuadraticClosePath(void *callBackDataPtr) +{ + return 0; +} + +static OSStatus QuadraticCurve(const Float32Point *pt1, const Float32Point *controlPt, const Float32Point *pt2, void *callBackDataPtr) +{ + GlyphBBox* data = (GlyphBBox*)callBackDataPtr; + + if (pt1->x < data->xMin) + data->xMin = pt1->x; + if (pt1->x > data->xMax) + data->xMax = pt1->x; + if (pt1->y < data->yMin) + data->yMin = pt1->y; + if (pt1->y > data->yMax) + data->yMax = pt1->y; + + if (pt2->x < data->xMin) + data->xMin = pt2->x; + if (pt2->x > data->xMax) + data->xMax = pt2->x; + if (pt2->y < data->yMin) + data->yMin = pt2->y; + if (pt2->y > data->yMax) + data->yMax = pt2->y; + + if (controlPt->x < data->xMin) + data->xMin = controlPt->x; + if (controlPt->x > data->xMax) + data->xMax = controlPt->x; + if (controlPt->y < data->yMin) + data->yMin = controlPt->y; + if (controlPt->y > data->yMax) + data->yMax = controlPt->y; + + return 0; +} + +static OSStatus QuadraticLine(const Float32Point *pt1, const Float32Point *pt2, void *callBackDataPtr) +{ + GlyphBBox* data = (GlyphBBox*)callBackDataPtr; + + if (pt1->x < data->xMin) + data->xMin = pt1->x; + if (pt1->x > data->xMax) + data->xMax = pt1->x; + if (pt1->y < data->yMin) + data->yMin = pt1->y; + if (pt1->y > data->yMax) + data->yMax = pt1->y; + + if (pt2->x < data->xMin) + data->xMin = pt2->x; + if (pt2->x > data->xMax) + data->xMax = pt2->x; + if (pt2->y < data->yMin) + data->yMin = pt2->y; + if (pt2->y > data->yMax) + data->yMax = pt2->y; + + return 0; +} + +static OSStatus QuadraticNewPath(void *callBackDataPtr) +{ + return 0; +} + +static OSStatus CubicMoveTo(const Float32Point *pt, void *callBackDataPtr) +{ + GlyphBBox* data = (GlyphBBox*)callBackDataPtr; + + if (pt->x < data->xMin) + data->xMin = pt->x; + if (pt->x > data->xMax) + data->xMax = pt->x; + if (pt->y < data->yMin) + data->yMin = pt->y; + if (pt->y > data->yMax) + data->yMax = pt->y; + + return 0; +} + +static OSStatus CubicLineTo(const Float32Point *pt, void *callBackDataPtr) +{ + GlyphBBox* data = (GlyphBBox*)callBackDataPtr; + + if (pt->x < data->xMin) + data->xMin = pt->x; + if (pt->x > data->xMax) + data->xMax = pt->x; + if (pt->y < data->yMin) + data->yMin = pt->y; + if (pt->y > data->yMax) + data->yMax = pt->y; + + return 0; +} + +static OSStatus CubicCurveTo(const Float32Point *pt1, const Float32Point *pt2, const Float32Point *pt3, void *callBackDataPtr) +{ + GlyphBBox* data = (GlyphBBox*)callBackDataPtr; + + if (pt1->x < data->xMin) + data->xMin = pt1->x; + if (pt1->x > data->xMax) + data->xMax = pt1->x; + if (pt1->y < data->yMin) + data->yMin = pt1->y; + if (pt1->y > data->yMax) + data->yMax = pt1->y; + + if (pt2->x < data->xMin) + data->xMin = pt2->x; + if (pt2->x > data->xMax) + data->xMax = pt2->x; + if (pt2->y < data->yMin) + data->yMin = pt2->y; + if (pt2->y > data->yMax) + data->yMax = pt2->y; + + if (pt3->x < data->xMin) + data->xMin = pt3->x; + if (pt3->x > data->xMax) + data->xMax = pt3->x; + if (pt3->y < data->yMin) + data->yMin = pt3->y; + if (pt3->y > data->yMax) + data->yMax = pt3->y; + + return 0; +} + +static OSStatus CubicClosePath(void *callBackDataPtr) +{ + return 0; +} + +void GetGlyphBBox_AAT(ATSUStyle style, UInt16 gid, GlyphBBox* bbox) + /* returns glyph bounding box in TeX points */ +{ + ATSCurveType curveType; + OSStatus status; + + bbox->xMin = 65536.0; + bbox->yMin = 65536.0; + bbox->xMax = -65536.0; + bbox->yMax = -65536.0; + + status = ATSUGetNativeCurveType(style, &curveType); + if (status == noErr) { + OSStatus cbStatus; + + if (curveType == kATSCubicCurveType) { + static ATSCubicMoveToUPP cubicMoveToProc; + static ATSCubicLineToUPP cubicLineToProc; + static ATSCubicCurveToUPP cubicCurveToProc; + static ATSCubicClosePathUPP cubicClosePathProc; + if (cubicMoveToProc == NULL) { + cubicMoveToProc = NewATSCubicMoveToUPP(&CubicMoveTo); + cubicLineToProc = NewATSCubicLineToUPP(&CubicLineTo); + cubicCurveToProc = NewATSCubicCurveToUPP(&CubicCurveTo); + cubicClosePathProc = NewATSCubicClosePathUPP(&CubicClosePath); + } + status = ATSUGlyphGetCubicPaths(style, gid, + cubicMoveToProc, cubicLineToProc, cubicCurveToProc, cubicClosePathProc, + bbox, &cbStatus); + } + else { + static ATSQuadraticNewPathUPP quadraticNewPathProc; + static ATSQuadraticLineUPP quadraticLineProc; + static ATSQuadraticCurveUPP quadraticCurveProc; + static ATSQuadraticClosePathUPP quadraticClosePathProc; + if (quadraticNewPathProc == NULL) { + quadraticNewPathProc = NewATSQuadraticNewPathUPP(&QuadraticNewPath); + quadraticLineProc = NewATSQuadraticLineUPP(&QuadraticLine); + quadraticCurveProc = NewATSQuadraticCurveUPP(&QuadraticCurve); + quadraticClosePathProc = NewATSQuadraticClosePathUPP(&QuadraticClosePath); + } + status = ATSUGlyphGetQuadraticPaths(style, gid, + quadraticNewPathProc, quadraticLineProc, quadraticCurveProc, quadraticClosePathProc, + bbox, &cbStatus); + } + } + + if (status != noErr || bbox->xMin == 65536.0) + bbox->xMin = bbox->yMin = bbox->xMax = bbox->yMax = 0; + else { + // convert PS to TeX points and flip y-axis + float tmp = bbox->yMin; + bbox->yMin = -bbox->yMax * 72.27 / 72.0; + bbox->yMax = -tmp * 72.27 / 72.0; + bbox->xMin *= 72.27 / 72.0; + bbox->xMax *= 72.27 / 72.0; + } +} + +float GetGlyphWidth_AAT(ATSUStyle style, UInt16 gid) + /* returns TeX points */ +{ + ATSGlyphIdealMetrics metrics; + OSStatus status = ATSUGlyphGetIdealMetrics(style, 1, &gid, 0, &metrics); + return PStoTeXPoints(metrics.advance.x); +} + +void GetGlyphHeightDepth_AAT(ATSUStyle style, UInt16 gid, float* ht, float* dp) + /* returns TeX points */ +{ + GlyphBBox bbox; + + GetGlyphBBox_AAT(style, gid, &bbox); + + *ht = bbox.yMax; + *dp = -bbox.yMin; +} + +void GetGlyphSidebearings_AAT(ATSUStyle style, UInt16 gid, float* lsb, float* rsb) + /* returns TeX points */ +{ + ATSGlyphIdealMetrics metrics; + OSStatus status = ATSUGlyphGetIdealMetrics(style, 1, &gid, 0, &metrics); + GlyphBBox bbox; + GetGlyphBBox_AAT(style, gid, &bbox); + *lsb = bbox.xMin; + *rsb = PStoTeXPoints(metrics.advance.x) - bbox.xMax; +} + +float GetGlyphItalCorr_AAT(ATSUStyle style, UInt16 gid) +{ + float rval = 0.0; + ATSGlyphIdealMetrics metrics; + OSStatus status = ATSUGlyphGetIdealMetrics(style, 1, &gid, 0, &metrics); + GlyphBBox bbox; + GetGlyphBBox_AAT(style, gid, &bbox); + if (bbox.xMax > PStoTeXPoints(metrics.advance.x)) + rval = bbox.xMax - PStoTeXPoints(metrics.advance.x); + return rval; +} + +int MapCharToGlyph_AAT(ATSUStyle style, UInt32 ch) +{ + UniChar txt[2]; + int len = 1; + + if (sTextLayout == 0) + InitializeLayout(); + + if (ch > 0xffff) { + ch -= 0x10000; + txt[0] = 0xd800 + ch / 1024; + txt[1] = 0xdc00 + ch % 1024; + len = 2; + } + else + txt[0] = ch; + + OSStatus status = ATSUSetTextPointerLocation(sTextLayout, &txt[0], 0, len, len); + status = ATSUSetRunStyle(sTextLayout, style, 0, len); + + ByteCount bufferSize = sizeof(ATSUGlyphInfoArray); + ATSUGlyphInfoArray info; + status = ATSUGetGlyphInfo(sTextLayout, 0, len, &bufferSize, &info); + if (bufferSize > 0 && info.numGlyphs > 0) + return info.glyphs[0].glyphID; + else + return 0; +} + +int MapGlyphToIndex_AAT(ATSUStyle style, const char* glyphName) +{ + ATSUFontID fontID; + ATSUGetAttribute(style, kATSUFontTag, sizeof(ATSUFontID), &fontID, 0); + + ATSFontRef fontRef = FMGetATSFontRefFromFont(fontID); + + ByteCount length; + OSStatus status = ATSFontGetTable(fontRef, kPost, 0, 0, 0, &length); + if (status != noErr) + return 0; + + void* table = xmalloc(length); + status = ATSFontGetTable(fontRef, kPost, 0, length, table, &length); + if (status != noErr) { + free(table); + return 0; + } + + int rval = findGlyphInPostTable(table, length, glyphName); + free(table); + + return rval; +} + +ATSUFontVariationAxis +find_axis_by_name(ATSUFontID fontID, const char* name, int nameLength) +{ + ATSUFontVariationAxis result = 0; + + Str255 inName; + inName[0] = nameLength; + int i; + for (i = 0; i < inName[0]; ++i) + inName[i + 1] = name[i]; + + ItemCount varCount; + ATSUCountFontVariations(fontID, &varCount); + if (varCount > 0) { + for (i = 0; i < varCount; ++i) { + ATSUFontVariationAxis axis; + ATSUGetIndFontVariation(fontID, i, &axis, 0, 0, 0); + FontNameCode nameCode; + ATSUGetFontVariationNameCode(fontID, axis, &nameCode); + Str255 name; + ByteCount nameLen; + ATSUFindFontName(fontID, nameCode, kFontMacintoshPlatform, kFontNoScript, kFontNoLanguage, + 255, (Ptr)&name[1], &nameLen, 0); + name[0] = nameLen; + if (EqualString(inName, name, false, true)) { + result = axis; + break; + } + } + } + + return result; +} + +ATSUFontFeatureType +find_feature_by_name(ATSUFontID fontID, const char* name, int nameLength) +{ + ATSUFontFeatureType result = 0x0000FFFF; + + Str255 inName; + inName[0] = nameLength; + int i; + for (i = 0; i < inName[0]; ++i) + inName[i + 1] = name[i]; + + ItemCount typeCount; + ATSUCountFontFeatureTypes(fontID, &typeCount); + if (typeCount > 0) { + ATSUFontFeatureType* types = (ATSUFontFeatureType*)xmalloc(typeCount * sizeof(ATSUFontFeatureType)); + ATSUGetFontFeatureTypes(fontID, typeCount, types, 0); + for (i = 0; i < typeCount; ++i) { + FontNameCode nameCode; + ATSUGetFontFeatureNameCode(fontID, types[i], 0x0000FFFF, &nameCode); + Str255 name; + ByteCount nameLen; + ATSUFindFontName(fontID, nameCode, kFontMacintoshPlatform, kFontNoScript, kFontNoLanguage, + 255, (Ptr)&name[1], &nameLen, 0); + name[0] = nameLen; + if (EqualString(inName, name, false, true)) { + result = types[i]; + break; + } + } + free((char*)types); + } + + return result; +} + +ATSUFontFeatureSelector +find_selector_by_name(ATSUFontID fontID, ATSUFontFeatureType featureType, const char* name, int nameLength) +{ + ATSUFontFeatureSelector result = 0x0000FFFF; + + Str255 inName; + inName[0] = nameLength; + int i; + for (i = 0; i < inName[0]; ++i) + inName[i + 1] = name[i]; + + ItemCount selectorCount; + ATSUCountFontFeatureSelectors(fontID, featureType, &selectorCount); + if (selectorCount > 0) { + ATSUFontFeatureSelector* selectors = (ATSUFontFeatureSelector*)xmalloc(selectorCount * sizeof(ATSUFontFeatureSelector)); + ATSUGetFontFeatureSelectors(fontID, featureType, selectorCount, selectors, 0, 0, 0); + for (i = 0; i < selectorCount; ++i) { + FontNameCode nameCode; + ATSUGetFontFeatureNameCode(fontID, featureType, selectors[i], &nameCode); + Str255 name; + ByteCount nameLen; + ATSUFindFontName(fontID, nameCode, kFontMacintoshPlatform, kFontNoScript, kFontNoLanguage, + 255, (Ptr)&name[1], &nameLen, 0); + name[0] = nameLen; + if (EqualString(inName, name, false, true)) { + result = selectors[i]; + break; + } + } + free((char*)selectors); + } + + return result; +} + +void* +loadAATfont(ATSFontRef fontRef, long scaled_size, const char* cp1) +{ + ATSUFontID fontID = FMGetFontFromATSFontRef(fontRef); + ATSUStyle style = 0; + OSStatus status = ATSUCreateStyle(&style); + if (status == noErr) { + UInt32 rgbValue; + Fixed tracking = 0x80000000; + Fixed atsuSize = FixedTeXtoPSPoints(scaled_size); + + ATSStyleRenderingOptions options = kATSStyleNoHinting; + Fract hangInhibit = fract1; + ATSUAttributeTag tags[] = { kATSUFontTag, kATSUSizeTag, kATSUStyleRenderingOptionsTag, kATSUHangingInhibitFactorTag }; + ByteCount sizes[] = { sizeof(ATSUFontID), sizeof(Fixed), sizeof(ATSStyleRenderingOptions), sizeof(Fract) }; + ATSUAttributeValuePtr attrs[] = { &fontID, &atsuSize, &options, &hangInhibit }; + ATSUSetAttributes(style, sizeof(tags) / sizeof(ATSUAttributeTag), tags, sizes, attrs); + +#define FEAT_ALLOC_CHUNK 8 +#define VAR_ALLOC_CHUNK 4 + + if (cp1 != NULL) { + int allocFeats = FEAT_ALLOC_CHUNK; + UInt16* featureTypes = (UInt16*)xmalloc(allocFeats * sizeof(UInt16)); + UInt16* selectorValues = (UInt16*)xmalloc(allocFeats * sizeof(UInt16)); + int numFeatures = 0; + + int allocVars = VAR_ALLOC_CHUNK; + UInt32* axes = (UInt32*)xmalloc(allocVars * sizeof(UInt32)); + SInt32* values = (SInt32*)xmalloc(allocVars * sizeof(SInt32)); + int numVariations = 0; + + // interpret features & variations following ":" + while (*cp1) { + // 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 + const char* cp2 = cp1; + while (*cp2 && *cp2 != ';' && *cp2 != ':') + ++cp2; + + // look for the '=' separator + const char* 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 + ATSUFontFeatureType featureType; + featureType = find_feature_by_name(fontID, cp1, cp3 - cp1); + if (featureType != 0x0000FFFF) { + // look past the '=' separator for setting names + int featLen = cp3 - cp1; + ++cp3; + while (cp3 < cp2) { + // skip leading whitespace + while (*cp3 == ' ' || *cp3 == '\t') + ++cp3; + + // possibly multiple settings... + int disable = 0; + if (*cp3 == '!') { // check for negation + disable = 1; + ++cp3; + } + + // scan for end of setting name + const char* cp4 = cp3; + while (cp4 < cp2 && *cp4 != ',') + ++cp4; + + // now cp3 points to name, cp4 to ',' or ';' or null + ATSUFontFeatureSelector selectorValue = find_selector_by_name(fontID, featureType, cp3, cp4 - cp3); + if (selectorValue != 0x0000FFFF) { + if (numFeatures == allocFeats) { + allocFeats += FEAT_ALLOC_CHUNK; + featureTypes = xrealloc(featureTypes, allocFeats * sizeof(UInt16)); + selectorValues = xrealloc(selectorValues, allocFeats * sizeof(UInt16)); + } + featureTypes[numFeatures] = featureType; + selectorValues[numFeatures] = selectorValue + disable; + ++numFeatures; + } + else { + fontfeaturewarning(cp1, featLen, cp3, cp4 - cp3); + } + + // point beyond setting name terminator + cp3 = cp4 + 1; + } + + goto next_option; + } + + // try to find a variation by this name + ATSUFontVariationAxis axis; + axis = find_axis_by_name(fontID, cp1, cp3 - cp1); + if (axis != 0) { + // look past the '=' separator for the value + ++cp3; + double value = 0.0, decimal = 1.0; + bool negate = false; + 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; + if (numVariations == allocVars) { + allocVars += VAR_ALLOC_CHUNK; + axes = xrealloc(axes, allocVars * sizeof(UInt32)); + values = xrealloc(values, allocVars * sizeof(SInt32)); + } + axes[numVariations] = axis; + values[numVariations] = value * 65536.0; // X2Fix(value); + ++numVariations; + + goto next_option; + } + + // didn't find feature or variation, try other options.... + + if (strncmp(cp1, "mapping", 7) == 0) { + cp3 = cp1 + 7; + if (*cp3 != '=') + goto bad_option; + loadedfontmapping = load_mapping_file(cp3 + 1, cp2); + goto next_option; + } + + if (strncmp(cp1, "color", 5) == 0) { + cp3 = cp1 + 5; + if (*cp3 != '=') + goto bad_option; + ++cp3; + rgbValue = 0; + unsigned alpha = 0; + int i; + for (i = 0; i < 6; ++i) { + if (*cp3 >= '0' && *cp3 <= '9') + rgbValue = (rgbValue << 4) + *cp3 - '0'; + else if (*cp3 >= 'A' && *cp3 <= 'F') + rgbValue = (rgbValue << 4) + *cp3 - 'A' + 10; + else if (*cp3 >= 'a' && *cp3 <= 'f') + rgbValue = (rgbValue << 4) + *cp3 - 'a' + 10; + else + goto bad_option; + ++cp3; + } + rgbValue <<= 8; + for (i = 0; i < 2; ++i) { + if (*cp3 >= '0' && *cp3 <= '9') + alpha = (alpha << 4) + *cp3 - '0'; + else if (*cp3 >= 'A' && *cp3 <= 'F') + alpha = (alpha << 4) + *cp3 - 'A' + 10; + else if (*cp3 >= 'a' && *cp3 <= 'f') + alpha = (alpha << 4) + *cp3 - 'a' + 10; + else + break; + ++cp3; + } + if (i == 2) + rgbValue += alpha; + else + rgbValue += 0xFF; + + loadedfontflags |= FONT_FLAGS_COLORED; + + goto next_option; + } + + if (strncmp(cp1, "tracking", 8) == 0) { + cp3 = cp1 + 8; + if (*cp3 != '=') + goto bad_option; + ++cp3; + + int sign = 1; + if (*cp3 == '-') { + sign = -1; + ++cp3; + } + else if (*cp3 == '+') { + ++cp3; + } + + double val = 0.0; + while (*cp3 >= '0' && *cp3 <= '9') { + val = val * 10.0 + *cp3 - '0'; + ++cp3; + } + if (*cp3 == '.' || *cp3 == ',') { + ++cp3; + double dec = 10.0; + while (*cp3 >= '0' && *cp3 <= '9') { + val = val + (*cp3 - '0') / dec; + ++cp3; + dec = dec * 10.0; + } + } + + tracking = sign * X2Fix(val); + + goto next_option; + } + + if (strncmp(cp1, "letterspace", 11) == 0) { + cp3 = cp1 + 11; + if (*cp3 != '=') + goto bad_option; + ++cp3; + + int sign = 1; + if (*cp3 == '-') { + sign = -1; + ++cp3; + } + else if (*cp3 == '+') { + ++cp3; + } + + double val = 0.0; + while (*cp3 >= '0' && *cp3 <= '9') { + val = val * 10.0 + *cp3 - '0'; + ++cp3; + } + if (*cp3 == '.' || *cp3 == ',') { + ++cp3; + double dec = 10.0; + while (*cp3 >= '0' && *cp3 <= '9') { + val = val + (*cp3 - '0') / dec; + ++cp3; + dec = dec * 10.0; + } + } + + loadedfontletterspace = sign * (val / 100.0) * scaled_size; + + 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 == ' ' || *cp3 == '\t') + --cp3; + if (*cp3) + ++cp3; + if (cp3 == cp1 + 8) { + ATSUVerticalCharacterType vert = kATSUStronglyVertical; + tags[0] = kATSUVerticalCharacterTag; + sizes[0] = sizeof(ATSUVerticalCharacterType); + attrs[0] = | + ATSUSetAttributes(style, 1, tags, sizes, attrs); + goto next_option; + } + } + + fontfeaturewarning(cp1, cp2 - cp1, 0, 0); + + next_option: + // go to next name=value pair + cp1 = cp2; + } + + if (numFeatures > 0) + ATSUSetFontFeatures(style, numFeatures, featureTypes, selectorValues); + + if (numVariations > 0) + ATSUSetVariations(style, numVariations, axes, values); + + if ((loadedfontflags & FONT_FLAGS_COLORED) != 0) { + ATSURGBAlphaColor rgba; + rgba.red = ((rgbValue & 0xFF000000) >> 24) / 255.0; + rgba.green = ((rgbValue & 0x00FF0000) >> 16) / 255.0; + rgba.blue = ((rgbValue & 0x0000FF00) >> 8 ) / 255.0; + rgba.alpha = ((rgbValue & 0x000000FF) ) / 255.0; + tags[0] = kATSURGBAlphaColorTag; + sizes[0] = sizeof(ATSURGBAlphaColor); + attrs[0] = &rgba; + ATSUSetAttributes(style, 1, tags, sizes, attrs); + } + + if (tracking != 0x80000000) { + tags[0] = kATSUTrackingTag; + sizes[0] = sizeof(Fixed); + attrs[0] = &tracking; + ATSUSetAttributes(style, 1, tags, sizes, attrs); + } + + free((char*)featureTypes); + free((char*)selectorValues); + free((char*)axes); + free((char*)values); + } + } + + nativefonttypeflag = AAT_FONT_FLAG; + return style; +} + +int +find_pic_file(char** path, realrect* bounds, int pdfBoxType, int page) +{ + *path = NULL; + + OSStatus result = fnfErr; + 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) { + /* get an FSRef for the URL we constructed */ + FSRef picFileRef; + CFURLGetFSRef(picFileURL, &picFileRef); + + if (pdfBoxType > 0) { + CGPDFDocumentRef document = CGPDFDocumentCreateWithURL(picFileURL); + if (document != NULL) { + int nPages = CGPDFDocumentGetNumberOfPages(document); + if (page < 0) + page = nPages + 1 + page; + if (page < 1) + page = 1; + if (page > nPages) + page = nPages; + + CGRect r; +#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_3 + if (&CGPDFDocumentGetPage == NULL) { + switch (pdfBoxType) { + case pdfbox_crop: + default: + r = CGPDFDocumentGetCropBox(document, page); + break; + case pdfbox_media: + r = CGPDFDocumentGetMediaBox(document, page); + break; + case pdfbox_bleed: + r = CGPDFDocumentGetBleedBox(document, page); + break; + case pdfbox_trim: + r = CGPDFDocumentGetTrimBox(document, page); + break; + case pdfbox_art: + r = CGPDFDocumentGetArtBox(document, page); + break; + } + } + else +#endif + { + CGPDFPageRef pageRef = CGPDFDocumentGetPage(document, page); + CGPDFBox boxType; + 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; + bounds->y = r.origin.y; + bounds->wd = r.size.width; + bounds->ht = r.size.height; + CGPDFDocumentRelease(document); + result = noErr; + } + } + else { + /* make an FSSpec for the file, and try to import it as a pic */ + FSSpec picFileSpec; + result = FSGetCatalogInfo(&picFileRef, kFSCatInfoNone, NULL, NULL, &picFileSpec, NULL); + if (result == noErr) { + ComponentInstance ci; + result = GetGraphicsImporterForFile(&picFileSpec, &ci); + if (result == noErr) { + ImageDescriptionHandle desc = NULL; + result = GraphicsImportGetImageDescription(ci, &desc); + bounds->x = 0; + bounds->y = 0; + bounds->wd = (*desc)->width * 72.0 / Fix2X((*desc)->hRes); + bounds->ht = (*desc)->height * 72.0 / Fix2X((*desc)->vRes); + DisposeHandle((Handle)desc); + (void)CloseComponent(ci); + } + } + } + + 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; +} diff --git a/Build/source/texk/web2c/xetexdir/XeTeX_pic.c b/Build/source/texk/web2c/xetexdir/XeTeX_pic.c new file mode 100644 index 00000000000..a511b848038 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeX_pic.c @@ -0,0 +1,111 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2005 by SIL International + written by Jonathan Kew + + This software is distributed under the terms of the Common Public License, + version 1.0. + For details, see or the file + cpl1.0.txt included with the software. +\****************************************************************************/ + +/* +XeTeX_pic.c + interface between xetex and graphics files + (not used on OS X -- we use QuickTime graphics importers instead) + only needs to get image dimensions, not actually load/process the file +*/ + +#define EXTERN extern +#include "xetexd.h" + +#include "XeTeX_ext.h" + +#include +#include +#include +#include +#include + +#include "pdfimage.h" +#include "pngimage.h" +#include "jpegimage.h" +#include "bmpimage.h" + +/* + locate picture file from /nameoffile+1/ using kpathsearch + pdfBoxType indicates which pdf bounding box to use (0 for \XeTeXpicfile) + page indicates which page is wanted (0-based) + return 0 for success, or non-zero error code for failure + return full path in *path + return bounds (tex points) in *bounds +*/ +int +find_pic_file(char** path, realrect* bounds, int pdfBoxType, int page) +{ + int err = -1; + FILE* fp = NULL; + char* pic_path = kpse_find_file((char*)nameoffile + 1, kpse_pict_format, 1); + + *path = NULL; + bounds->x = bounds->y = bounds->wd = bounds->ht = 0.0; + + if (pic_path == NULL) + goto done; + + /* if cmd was \XeTeXpdffile, use xpdflib to read it */ + if (pdfBoxType != 0) { + err = pdf_get_rect(pic_path, page, pdfBoxType, bounds); + goto done; + } + + /* otherwise try graphics formats that we know */ + fp = fopen(pic_path, FOPEN_RBIN_MODE); + if (fp == NULL) + goto done; + + if (check_for_jpeg(fp)) { + struct JPEG_info info; + err = JPEG_scan_file(&info, fp); + if (err == 0) { + bounds->wd = (info.width * 72.27) / info.xdpi; + bounds->ht = (info.height * 72.27) / info.ydpi; + } + goto done; + } + + if (check_for_bmp(fp)) { + struct bmp_info info; + err = bmp_scan_file(&info, fp); + if (err == 0) { + bounds->wd = (info.width * 72.27) / info.xdpi; + bounds->ht = (info.height * 72.27) / info.ydpi; + } + goto done; + } + + if (check_for_png(fp)) { + struct png_info info; + err = png_scan_file(&info, fp); + if (err == 0) { + bounds->wd = (info.width * 72.27) / info.xdpi; + 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); + + if (err == 0) + *path = pic_path; + else { + if (pic_path != NULL) + free(pic_path); + } + + return err; +} diff --git a/Build/source/texk/web2c/xetexdir/XeTeXswap.h b/Build/source/texk/web2c/xetexdir/XeTeXswap.h new file mode 100644 index 00000000000..311b8a791f8 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/XeTeXswap.h @@ -0,0 +1,96 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +#ifndef __XeTeXswap_H +#define __XeTeXswap_H + +#include "unicode/platform.h" // ICU's platform.h defines U_IS_BIG_ENDIAN for us + +#ifdef WIN32 +#define inline __inline /* for VC++ (non-C99); not sure about other compilers on W32 */ +#endif + +static inline UInt16 +SWAP16(const UInt16 p) +{ +#if U_IS_BIG_ENDIAN + return p; +#else + return (p >> 8) + (p << 8); +#endif +} + +static inline UInt32 +SWAP32(const UInt32 p) +{ +#if U_IS_BIG_ENDIAN + return p; +#else + return (p >> 24) + ((p >> 8) & 0x0000ff00) + ((p << 8) & 0x00ff0000) + (p << 24); +#endif +} + +#ifdef __cplusplus + +#ifdef XETEX_MAC +#include "sfnt.h" /* for the 'fixed' typedef */ +static inline fixed +SWAP(fixed p) +{ + return (fixed)SWAP32((UInt32)p); +} +#endif + +static inline UInt16 +SWAP(UInt16 p) +{ + return SWAP16(p); +} + +static inline UInt32 +SWAP(UInt32 p) +{ + return SWAP32(p); +} + +static inline SInt16 +SWAP(SInt16 p) +{ + return (SInt16)SWAP16((UInt16)p); +} + +static inline SInt32 +SWAP(SInt32 p) +{ + return (SInt32)SWAP32((UInt32)p); +} +#endif + +#endif diff --git a/Build/source/texk/web2c/xetexdir/appleGlyphNames.c b/Build/source/texk/web2c/xetexdir/appleGlyphNames.c new file mode 100644 index 00000000000..21fe6cc6719 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/appleGlyphNames.c @@ -0,0 +1,291 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +char* appleGlyphNames[] = { + ".notdef", + ".null", + "nonmarkingreturn", + "space", + "exclam", + "quotedbl", + "numbersign", + "dollar", + "percent", + "ampersand", + "quotesingle", + "parenleft", + "parenright", + "asterisk", + "plus", + "comma", + "hyphen", + "period", + "slash", + "zero", + "one", + "two", + "three", + "four", + "five", + "six", + "seven", + "eight", + "nine", + "colon", + "semicolon", + "less", + "equal", + "greater", + "question", + "at", + "A", + "B", + "C", + "D", + "E", + "F", + "G", + "H", + "I", + "J", + "K", + "L", + "M", + "N", + "O", + "P", + "Q", + "R", + "S", + "T", + "U", + "V", + "W", + "X", + "Y", + "Z", + "bracketleft", + "backslash", + "bracketright", + "asciicircum", + "underscore", + "grave", + "a", + "b", + "c", + "d", + "e", + "f", + "g", + "h", + "i", + "j", + "k", + "l", + "m", + "n", + "o", + "p", + "q", + "r", + "s", + "t", + "u", + "v", + "w", + "x", + "y", + "z", + "braceleft", + "bar", + "braceright", + "asciitilde", + "Adieresis", + "Aring", + "Ccedilla", + "Eacute", + "Ntilde", + "Odieresis", + "Udieresis", + "aacute", + "agrave", + "acircumflex", + "adieresis", + "atilde", + "aring", + "ccedilla", + "eacute", + "egrave", + "ecircumflex", + "edieresis", + "iacute", + "igrave", + "icircumflex", + "idieresis", + "ntilde", + "oacute", + "ograve", + "ocircumflex", + "odieresis", + "otilde", + "uacute", + "ugrave", + "ucircumflex", + "udieresis", + "dagger", + "degree", + "cent", + "sterling", + "section", + "bullet", + "paragraph", + "germandbls", + "registered", + "copyright", + "trademark", + "acute", + "dieresis", + "notequal", + "AE", + "Oslash", + "infinity", + "plusminus", + "lessequal", + "greaterequal", + "yen", + "mu", + "partialdiff", + "summation", + "product", + "pi", + "integral", + "ordfeminine", + "ordmasculine", + "Omega", + "ae", + "oslash", + "questiondown", + "exclamdown", + "logicalnot", + "radical", + "florin", + "approxequal", + "Delta", + "guillemotleft", + "guillemotright", + "ellipsis", + "nonbreakingspace", + "Agrave", + "Atilde", + "Otilde", + "OE", + "oe", + "endash", + "emdash", + "quotedblleft", + "quotedblright", + "quoteleft", + "quoteright", + "divide", + "lozenge", + "ydieresis", + "Ydieresis", + "fraction", + "currency", + "guilsinglleft", + "guilsinglright", + "fi", + "fl", + "daggerdbl", + "periodcentered", + "quotesinglbase", + "quotedblbase", + "perthousand", + "Acircumflex", + "Ecircumflex", + "Aacute", + "Edieresis", + "Egrave", + "Iacute", + "Icircumflex", + "Idieresis", + "Igrave", + "Oacute", + "Ocircumflex", + "apple", + "Ograve", + "Uacute", + "Ucircumflex", + "Ugrave", + "dotlessi", + "circumflex", + "tilde", + "macron", + "breve", + "dotaccent", + "ring", + "cedilla", + "hungarumlaut", + "ogonek", + "caron", + "Lslash", + "lslash", + "Scaron", + "scaron", + "Zcaron", + "zcaron", + "brokenbar", + "Eth", + "eth", + "Yacute", + "yacute", + "Thorn", + "thorn", + "minus", + "multiply", + "onesuperior", + "twosuperior", + "threesuperior", + "onehalf", + "onequarter", + "threequarters", + "franc", + "Gbreve", + "gbreve", + "Idotaccent", + "Scedilla", + "scedilla", + "Cacute", + "cacute", + "Ccaron", + "ccaron", + "dcroat", + 0 +}; diff --git a/Build/source/texk/web2c/xetexdir/bmpimage.c b/Build/source/texk/web2c/xetexdir/bmpimage.c new file mode 100644 index 00000000000..03846e4b932 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/bmpimage.c @@ -0,0 +1,201 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +\****************************************************************************/ + +/* this file is derived from the dvipdfmx project; + the original header follows... */ + +/* $Header: /home/cvsroot/dvipdfmx/src/bmpimage.c,v 1.2 2004/07/27 12:08:46 hirata Exp $ + + This is dvipdfmx, an eXtended version of dvipdfm by Mark A. Wicks. + + Copyright (C) 2002 by Jin-Hwan Cho and Shunsaku Hirata, + the dvipdfmx project team + + Copyright (C) 1998, 1999 by Mark A. Wicks + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +*/ + +/* + * BMP SUPPORT: + */ + +#include "bmpimage.h" + +#define DIB_FILE_HEADER_SIZE 14 +#define DIB_CORE_HEADER_SIZE 14 +#define DIB_INFO_HEADER_SIZE 40 + +#define DIB_COMPRESS_NONE 0 +#define DIB_COMPRESS_RLE8 1 +#define DIB_COMPRESS_RLE4 2 + +#define DIB_HEADER_SIZE_MAX (DIB_FILE_HEADER_SIZE+DIB_INFO_HEADER_SIZE) + +static void +WARN(const char *fmt, ...) +{ + va_list argp; + + fprintf(stderr, "** WARNING ** "); + va_start(argp, fmt); + vfprintf(stderr, fmt, argp); + va_end(argp); + fprintf(stderr, "\n"); +} + +int +check_for_bmp (FILE *fp) +{ + unsigned char sigbytes[2]; + + if (!fp) + return 0; + + rewind(fp); + if (fread(sigbytes, 1, sizeof(sigbytes), fp) != sizeof(sigbytes) || + sigbytes[0] != 'B' || sigbytes[1] != 'M') + return 0; + else + return 1; + + return 0; +} + +int +bmp_scan_file(struct bmp_info *info, FILE *fp) +{ + unsigned char buf[DIB_HEADER_SIZE_MAX+4]; + unsigned char *p; + long offset, fsize, hsize, compression; + long psize; /* Bytes per palette color: 3 for OS2, 4 for Win */ + unsigned short bit_count; /* Bits per pix */ + int num_palette, flip; + int i; + unsigned long biXPelsPerMeter, biYPelsPerMeter; + + p = buf; + + rewind(fp); + if (fread(buf, 1, DIB_FILE_HEADER_SIZE + 4, fp) + != DIB_FILE_HEADER_SIZE + 4) { + WARN("Could not read BMP file header..."); + } + + if (p[0] != 'B' || p[1] != 'M') { + WARN("File not starting with \'B\' \'M\'... Not a BMP file?"); + return -1; + } + p += 2; + +#define ULONG_LE(b) ((b)[0] + ((b)[1] << 8) +\ + ((b)[2] << 16) + ((b)[3] << 24)) +#define USHORT_LE(b) ((b)[0] + ((b)[1] << 8)) + + fsize = ULONG_LE(p); p += 4; + if (ULONG_LE(p) != 0) { + WARN("Not a BMP file???"); + return -1; + } + p += 4; + offset = ULONG_LE(p); p += 4; + + /* info header */ + hsize = ULONG_LE(p); p += 4; + if (fread(p, sizeof(char), hsize - 4, fp) != hsize - 4) { + WARN("Could not read BMP file header..."); + return -1; + } + flip = 1; + if (hsize == DIB_CORE_HEADER_SIZE) { + info->width = USHORT_LE(p); p += 2; + info->height = USHORT_LE(p); p += 2; + if (USHORT_LE(p) != 1) { + WARN("Unknown bcPlanes value in BMP COREHEADER."); + return -1; + } + p += 2; + bit_count = USHORT_LE(p); p += 2; + compression = DIB_COMPRESS_NONE; + psize = 3; + } else if (hsize == DIB_INFO_HEADER_SIZE) { + info->width = ULONG_LE(p); p += 4; + info->height = ULONG_LE(p); p += 4; + if (USHORT_LE(p) != 1) { + WARN("Unknown biPlanes value in BMP INFOHEADER."); + return -1; + } + p += 2; + bit_count = USHORT_LE(p); p += 2; + compression = ULONG_LE(p); p += 4; + /* ignore biSizeImage */ p += 4; + biXPelsPerMeter = ULONG_LE(p); p += 4; + biYPelsPerMeter = ULONG_LE(p); p += 4; + info->xdpi = biXPelsPerMeter * 0.0254; /* convert pixels per meter to DPI */ + info->ydpi = biYPelsPerMeter * 0.0254; + if (info->height < 0) { + info->height = -info->height; + flip = 0; + } + psize = 4; + } else { + WARN("Unknown BMP header type."); + return -1; + } + + if (bit_count < 24) { + if (bit_count != 1 && + bit_count != 4 && bit_count != 8) { + WARN("Unsupported palette size: %ld", bit_count); + return -1; + } + num_palette = (offset - hsize - DIB_FILE_HEADER_SIZE) / psize; + info->bits_per_component = bit_count; + info->num_components = 1; + } else if (bit_count == 24) { /* full color */ + num_palette = 1; /* dummy */ + info->bits_per_component = 8; + info->num_components = 3; + } else { + WARN("Unkown BMP bitCount: %ld", bit_count); + return -1; + } + + if (info->width == 0 || info->height == 0 || num_palette < 1) { + WARN("Invalid BMP file: width=%ld, height=%ld, #palette=%d", + info->width, info->height, num_palette); + return -1; + } + + return 0; +} + diff --git a/Build/source/texk/web2c/xetexdir/bmpimage.h b/Build/source/texk/web2c/xetexdir/bmpimage.h new file mode 100644 index 00000000000..9c55b0c20f8 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/bmpimage.h @@ -0,0 +1,70 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +\****************************************************************************/ + +/* this file is derived from the dvipdfmx project; + the original header follows... */ + +/* $Header: /home/cvsroot/dvipdfmx/src/bmpimage.h,v 1.1 2004/07/25 11:54:20 hirata Exp $ + + This is dvipdfmx, an eXtended version of dvipdfm by Mark A. Wicks. + + Copyright (C) 2002 by Jin-Hwan Cho and Shunsaku Hirata, + the dvipdfmx project team + + Copyright (C) 1998, 1999 by Mark A. Wicks + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +*/ + + +#ifndef _BMPIMAGE_H_ +#define _BMPIMAGE_H_ + +#if HAVE_CONFIG_H +#include "config.h" +#endif + +#include "mfileio.h" + +struct bmp_info { + int width; + int height; + double xdpi; + double ydpi; + int bits_per_component; + int num_components; +}; + +extern int bmp_scan_file(struct bmp_info *info, FILE *file); +extern int check_for_bmp(FILE *file); + +#endif /* _BMPIMAGE_H_ */ diff --git a/Build/source/texk/web2c/xetexdir/cmaps.cpp b/Build/source/texk/web2c/xetexdir/cmaps.cpp new file mode 100644 index 00000000000..2b52ef50015 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/cmaps.cpp @@ -0,0 +1,240 @@ +/* + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +*/ + +/* from ICU sample code, extended by JK for XeTeX */ + +/*************************************************************************** +* +* Copyright (C) 1998-2003, International Business Machines +* Corporation and others. All Rights Reserved. +* +************************************************************************/ + +#include "LETypes.h" +#include "LESwaps.h" + +#include "sfnt.h" +#include "cmaps.h" + +#define SWAPU16(code) ((LEUnicode16) SWAPW(code)) +#define SWAPU32(code) ((LEUnicode32) SWAPL(code)) + +// read a 32-bit value that might only be 16-bit-aligned in memory +#define READ_LONG(code) (le_uint32)((SWAPW(*(le_uint16*)&code) << 16) + SWAPW(*(((le_uint16*)&code) + 1))) + +// +// Finds the high bit by binary searching +// through the bits in value. +// +le_int8 highBit(le_uint32 value) +{ + le_uint8 bit = 0; + + if (value >= 1 << 16) { + value >>= 16; + bit += 16; + } + + if (value >= 1 << 8) { + value >>= 8; + bit += 8; + } + + if (value >= 1 << 4) { + value >>= 4; + bit += 4; + } + + if (value >= 1 << 2) { + value >>= 2; + bit += 2; + } + + if (value >= 1 << 1) { + value >>= 1; + bit += 1; + } + + return bit; +} + +CMAPMapper *CMAPMapper::createUnicodeMapper(const CMAPTable *cmap) +{ + le_uint16 i; + le_uint16 nSubtables = SWAPW(cmap->numberSubtables); + const CMAPEncodingSubtable *subtable = NULL; + le_uint32 offset1 = 0, offset10 = 0; + + for (i = 0; i < nSubtables; i += 1) { + const CMAPEncodingSubtableHeader *esh = &cmap->encodingSubtableHeaders[i]; + + switch (SWAPW(esh->platformID)) { + case 3: // Microsoft encodings + switch (SWAPW(esh->platformSpecificID)) { + case 1: // Unicode (really UCS-2?) + offset1 = READ_LONG(esh->encodingOffset); + break; + + case 10: // UCS-4 + offset10 = READ_LONG(esh->encodingOffset); + break; + } + break; + + case 0: // Apple Unicode + offset10 = READ_LONG(esh->encodingOffset); // we ignore the unicode version + break; + } + } + + + if (offset10 != 0) { + subtable = (const CMAPEncodingSubtable *) ((const char *) cmap + offset10); + } else if (offset1 != 0) { + subtable = (const CMAPEncodingSubtable *) ((const char *) cmap + offset1); + } else { + return NULL; + } + + switch (SWAPW(subtable->format)) { + case 4: + return new CMAPFormat4Mapper(cmap, (const CMAPFormat4Encoding *) subtable); + + case 12: + { + const CMAPFormat12Encoding *encoding = (const CMAPFormat12Encoding *) subtable; + + return new CMAPGroupMapper(cmap, encoding->groups, READ_LONG(encoding->nGroups)); + } + + default: + break; + } + + return NULL; +} + +CMAPFormat4Mapper::CMAPFormat4Mapper(const CMAPTable *cmap, const CMAPFormat4Encoding *header) + : CMAPMapper(cmap) +{ + le_uint16 segCount = SWAPW(header->segCountX2) / 2; + + fEntrySelector = SWAPW(header->entrySelector); + fRangeShift = SWAPW(header->rangeShift) / 2; + fEndCodes = &header->endCodes[0]; + fStartCodes = &header->endCodes[segCount + 1]; // + 1 for reservedPad... + fIdDelta = &fStartCodes[segCount]; + fIdRangeOffset = &fIdDelta[segCount]; +} + +LEGlyphID CMAPFormat4Mapper::unicodeToGlyph(LEUnicode32 unicode32) const +{ + if (unicode32 >= 0x10000) { + return 0; + } + + LEUnicode16 unicode = (LEUnicode16) unicode32; + le_uint16 index = 0; + le_uint16 probe = 1 << fEntrySelector; + TTGlyphID result = 0; + + if (SWAPU16(fStartCodes[fRangeShift]) <= unicode) { + index = fRangeShift; + } + + while (probe > (1 << 0)) { + probe >>= 1; + + if (SWAPU16(fStartCodes[index + probe]) <= unicode) { + index += probe; + } + } + + if (unicode >= SWAPU16(fStartCodes[index]) && unicode <= SWAPU16(fEndCodes[index])) { + if (fIdRangeOffset[index] == 0) { + result = (TTGlyphID) unicode; + } else { + le_uint16 offset = unicode - SWAPU16(fStartCodes[index]); + le_uint16 rangeOffset = SWAPW(fIdRangeOffset[index]); + le_uint16 *glyphIndexTable = (le_uint16 *) ((char *) &fIdRangeOffset[index] + rangeOffset); + + result = SWAPW(glyphIndexTable[offset]); + } + + result += SWAPW(fIdDelta[index]); + } else { + result = 0; + } + + return LE_SET_GLYPH(0, result); +} + +CMAPFormat4Mapper::~CMAPFormat4Mapper() +{ + // parent destructor does it all +} + +CMAPGroupMapper::CMAPGroupMapper(const CMAPTable *cmap, const CMAPGroup *groups, le_uint32 nGroups) + : CMAPMapper(cmap), fGroups(groups) +{ + le_uint8 bit = highBit(nGroups); + fPower = 1 << bit; + fRangeOffset = nGroups - fPower; +} + +LEGlyphID CMAPGroupMapper::unicodeToGlyph(LEUnicode32 unicode32) const +{ + le_int32 probe = fPower; + le_int32 range = 0; + + if (READ_LONG(fGroups[fRangeOffset].startCharCode) <= unicode32) { + range = fRangeOffset; + } + + while (probe > (1 << 0)) { + probe >>= 1; + + if (READ_LONG(fGroups[range + probe].startCharCode) <= unicode32) { + range += probe; + } + } + + if (READ_LONG(fGroups[range].startCharCode) <= unicode32 && READ_LONG(fGroups[range].endCharCode) >= unicode32) { + return (LEGlyphID) (READ_LONG(fGroups[range].startGlyphCode) + unicode32 - READ_LONG(fGroups[range].startCharCode)); + } + + return 0; +} + +CMAPGroupMapper::~CMAPGroupMapper() +{ + // parent destructor does it all +} + diff --git a/Build/source/texk/web2c/xetexdir/cmaps.h b/Build/source/texk/web2c/xetexdir/cmaps.h new file mode 100644 index 00000000000..5f7dd81aeec --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/cmaps.h @@ -0,0 +1,116 @@ +/* + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +*/ + +/* from ICU sample code, extended by JK for XeTeX */ + +/*************************************************************************** +* +* Copyright (C) 1998-2003, International Business Machines +* Corporation and others. All Rights Reserved. +* +************************************************************************/ + + +#ifndef __CMAPS_H +#define __CMAPS_H + +#include "LETypes.h" +#include "sfnt.h" + +class CMAPMapper +{ +public: + virtual LEGlyphID unicodeToGlyph(LEUnicode32 unicode32) const = 0; + + virtual ~CMAPMapper(); + + static CMAPMapper *createUnicodeMapper(const CMAPTable *cmap); + +protected: + CMAPMapper(const CMAPTable *cmap); + + CMAPMapper() {}; + +private: + const CMAPTable *fcmap; +}; + +class CMAPFormat4Mapper : public CMAPMapper +{ +public: + CMAPFormat4Mapper(const CMAPTable *cmap, const CMAPFormat4Encoding *header); + + virtual ~CMAPFormat4Mapper(); + + virtual LEGlyphID unicodeToGlyph(LEUnicode32 unicode32) const; + +protected: + CMAPFormat4Mapper() {}; + +private: + le_uint16 fEntrySelector; + le_uint16 fRangeShift; + const le_uint16 *fEndCodes; + const le_uint16 *fStartCodes; + const le_uint16 *fIdDelta; + const le_uint16 *fIdRangeOffset; +}; + +class CMAPGroupMapper : public CMAPMapper +{ +public: + CMAPGroupMapper(const CMAPTable *cmap, const CMAPGroup *groups, le_uint32 nGroups); + + virtual ~CMAPGroupMapper(); + + virtual LEGlyphID unicodeToGlyph(LEUnicode32 unicode32) const; + +protected: + CMAPGroupMapper() {}; + +private: + le_int32 fPower; + le_int32 fRangeOffset; + const CMAPGroup *fGroups; +}; + +inline CMAPMapper::CMAPMapper(const CMAPTable *cmap) + : fcmap(cmap) +{ + // nothing else to do +} + +inline CMAPMapper::~CMAPMapper() +{ + LE_DELETE_ARRAY(fcmap); +} + +#endif + diff --git a/Build/source/texk/web2c/xetexdir/cpl1.0.txt b/Build/source/texk/web2c/xetexdir/cpl1.0.txt new file mode 100644 index 00000000000..c9990a7ea45 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/cpl1.0.txt @@ -0,0 +1,213 @@ +Common Public License Version 1.0 + +THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS COMMON PUBLIC +LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM +CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. + +1. DEFINITIONS + +"Contribution" means: + + a) in the case of the initial Contributor, the initial code and +documentation distributed under this Agreement, and + + b) in the case of each subsequent Contributor: + + i) changes to the Program, and + + ii) additions to the Program; + + where such changes and/or additions to the Program originate from and are +distributed by that particular Contributor. A Contribution 'originates' from a +Contributor if it was added to the Program by such Contributor itself or anyone +acting on such Contributor's behalf. Contributions do not include additions to +the Program which: (i) are separate modules of software distributed in +conjunction with the Program under their own license agreement, and (ii) are not +derivative works of the Program. + +"Contributor" means any person or entity that distributes the Program. + +"Licensed Patents " mean patent claims licensable by a Contributor which are +necessarily infringed by the use or sale of its Contribution alone or when +combined with the Program. + +"Program" means the Contributions distributed in accordance with this Agreement. + +"Recipient" means anyone who receives the Program under this Agreement, +including all Contributors. + +2. GRANT OF RIGHTS + + a) Subject to the terms of this Agreement, each Contributor hereby grants +Recipient a non-exclusive, worldwide, royalty-free copyright license to +reproduce, prepare derivative works of, publicly display, publicly perform, +distribute and sublicense the Contribution of such Contributor, if any, and such +derivative works, in source code and object code form. + + b) Subject to the terms of this Agreement, each Contributor hereby grants +Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed +Patents to make, use, sell, offer to sell, import and otherwise transfer the +Contribution of such Contributor, if any, in source code and object code form. +This patent license shall apply to the combination of the Contribution and the +Program if, at the time the Contribution is added by the Contributor, such +addition of the Contribution causes such combination to be covered by the +Licensed Patents. The patent license shall not apply to any other combinations +which include the Contribution. No hardware per se is licensed hereunder. + + c) Recipient understands that although each Contributor grants the licenses +to its Contributions set forth herein, no assurances are provided by any +Contributor that the Program does not infringe the patent or other intellectual +property rights of any other entity. Each Contributor disclaims any liability to +Recipient for claims brought by any other entity based on infringement of +intellectual property rights or otherwise. As a condition to exercising the +rights and licenses granted hereunder, each Recipient hereby assumes sole +responsibility to secure any other intellectual property rights needed, if any. +For example, if a third party patent license is required to allow Recipient to +distribute the Program, it is Recipient's responsibility to acquire that license +before distributing the Program. + + d) Each Contributor represents that to its knowledge it has sufficient +copyright rights in its Contribution, if any, to grant the copyright license set +forth in this Agreement. + +3. REQUIREMENTS + +A Contributor may choose to distribute the Program in object code form under its +own license agreement, provided that: + + a) it complies with the terms and conditions of this Agreement; and + + b) its license agreement: + + i) effectively disclaims on behalf of all Contributors all warranties and +conditions, express and implied, including warranties or conditions of title and +non-infringement, and implied warranties or conditions of merchantability and +fitness for a particular purpose; + + ii) effectively excludes on behalf of all Contributors all liability for +damages, including direct, indirect, special, incidental and consequential +damages, such as lost profits; + + iii) states that any provisions which differ from this Agreement are offered +by that Contributor alone and not by any other party; and + + iv) states that source code for the Program is available from such +Contributor, and informs licensees how to obtain it in a reasonable manner on or +through a medium customarily used for software exchange. + +When the Program is made available in source code form: + + a) it must be made available under this Agreement; and + + b) a copy of this Agreement must be included with each copy of the Program. + +Contributors may not remove or alter any copyright notices contained within the +Program. + +Each Contributor must identify itself as the originator of its Contribution, if +any, in a manner that reasonably allows subsequent Recipients to identify the +originator of the Contribution. + +4. COMMERCIAL DISTRIBUTION + +Commercial distributors of software may accept certain responsibilities with +respect to end users, business partners and the like. While this license is +intended to facilitate the commercial use of the Program, the Contributor who +includes the Program in a commercial product offering should do so in a manner +which does not create potential liability for other Contributors. Therefore, if +a Contributor includes the Program in a commercial product offering, such +Contributor ("Commercial Contributor") hereby agrees to defend and indemnify +every other Contributor ("Indemnified Contributor") against any losses, damages +and costs (collectively "Losses") arising from claims, lawsuits and other legal +actions brought by a third party against the Indemnified Contributor to the +extent caused by the acts or omissions of such Commercial Contributor in +connection with its distribution of the Program in a commercial product +offering. The obligations in this section do not apply to any claims or Losses +relating to any actual or alleged intellectual property infringement. In order +to qualify, an Indemnified Contributor must: a) promptly notify the Commercial +Contributor in writing of such claim, and b) allow the Commercial Contributor to +control, and cooperate with the Commercial Contributor in, the defense and any +related settlement negotiations. The Indemnified Contributor may participate in +any such claim at its own expense. + +For example, a Contributor might include the Program in a commercial product +offering, Product X. That Contributor is then a Commercial Contributor. If that +Commercial Contributor then makes performance claims, or offers warranties +related to Product X, those performance claims and warranties are such +Commercial Contributor's responsibility alone. Under this section, the +Commercial Contributor would have to defend claims against the other +Contributors related to those performance claims and warranties, and if a court +requires any other Contributor to pay any damages as a result, the Commercial +Contributor must pay those damages. + +5. NO WARRANTY + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN +"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR +IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, +NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each +Recipient is solely responsible for determining the appropriateness of using and +distributing the Program and assumes all risks associated with its exercise of +rights under this Agreement, including but not limited to the risks and costs of +program errors, compliance with applicable laws, damage to or loss of data, +programs or equipment, and unavailability or interruption of operations. + +6. DISCLAIMER OF LIABILITY + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY +CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST +PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS +GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +7. GENERAL + +If any provision of this Agreement is invalid or unenforceable under applicable +law, it shall not affect the validity or enforceability of the remainder of the +terms of this Agreement, and without further action by the parties hereto, such +provision shall be reformed to the minimum extent necessary to make such +provision valid and enforceable. + +If Recipient institutes patent litigation against a Contributor with respect to +a patent applicable to software (including a cross-claim or counterclaim in a +lawsuit), then any patent licenses granted by that Contributor to such Recipient +under this Agreement shall terminate as of the date such litigation is filed. In +addition, if Recipient institutes patent litigation against any entity +(including a cross-claim or counterclaim in a lawsuit) alleging that the Program +itself (excluding combinations of the Program with other software or hardware) +infringes such Recipient's patent(s), then such Recipient's rights granted under +Section 2(b) shall terminate as of the date such litigation is filed. + +All Recipient's rights under this Agreement shall terminate if it fails to +comply with any of the material terms or conditions of this Agreement and does +not cure such failure in a reasonable period of time after becoming aware of +such noncompliance. If all Recipient's rights under this Agreement terminate, +Recipient agrees to cease use and distribution of the Program as soon as +reasonably practicable. However, Recipient's obligations under this Agreement +and any licenses granted by Recipient relating to the Program shall continue and +survive. + +Everyone is permitted to copy and distribute copies of this Agreement, but in +order to avoid inconsistency the Agreement is copyrighted and may only be +modified in the following manner. The Agreement Steward reserves the right to +publish new versions (including revisions) of this Agreement from time to time. +No one other than the Agreement Steward has the right to modify this Agreement. +IBM is the initial Agreement Steward. IBM may assign the responsibility to serve +as the Agreement Steward to a suitable separate entity. Each new version of the +Agreement will be given a distinguishing version number. The Program (including +Contributions) may always be distributed subject to the version of the Agreement +under which it was received. In addition, after a new version of the Agreement +is published, Contributor may elect to distribute the Program (including its +Contributions) under the new version. Except as expressly stated in Sections +2(a) and 2(b) above, Recipient receives no rights or licenses to the +intellectual property of any Contributor under this Agreement, whether +expressly, by implication, estoppel or otherwise. All rights in the Program not +expressly granted under this Agreement are reserved. + +This Agreement is governed by the laws of the State of New York and the +intellectual property laws of the United States of America. No party to this +Agreement will bring a legal action under this Agreement more than one year +after the cause of action arose. Each party waives its rights to a jury trial in +any resulting litigation. diff --git a/Build/source/texk/web2c/xetexdir/jpegimage.c b/Build/source/texk/web2c/xetexdir/jpegimage.c new file mode 100644 index 00000000000..165a675f6f6 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/jpegimage.c @@ -0,0 +1,410 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +\****************************************************************************/ + +/* this file is derived from the dvipdfmx project; + the original header follows... */ + +/* $Header: /home/cvsroot/dvipdfmx/src/jpegimage.c,v 1.8 2004/09/05 13:30:05 hirata Exp $ + + This is dvipdfmx, an eXtended version of dvipdfm by Mark A. Wicks. + + Copyright (C) 2002 by Jin-Hwan Cho and Shunsaku Hirata, + the dvipdfmx project team + + Copyright (C) 1998, 1999 by Mark A. Wicks + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +*/ + + +/* + * JPEG SUPPORT + * + * Accroding to Libjpeg document: + * + * CAUTION: it appears that Adobe Photoshop writes inverted data in CMYK + * JPEG files: 0 represents 100% ink coverage, rather than 0% ink as you'd + * expect.... + * + * To wrok with this problem, we must detect whether CMYK JPEG file is + * created by Photoshop. But there are no reliable way to determine this. + * + * According to Adobe Technical Note #5516, + * "Supporting the DCT Filters in PostScript Level 2", Section 18, p.27. + * + * DCTDecode ignores and skips any APPE marker segment does not begin with + * the `Adobe' 5-character string. + * + * PDF Reference Manual 4th ed., p.61-62. + * + * The JPEG filter implementation in Adobe Acrobat products does not + * support features of the JPEG standard that are irrelevant to images. + * In addition, certain choices have been made regarding reserved marker + * codes and other optional features of the standard. For details, see + * Adobe Technical Note #5116, Supporting the DCT Filters in PostScript + * Level 2. + */ + +#include "mfileio.h" +#include "numbers.h" + +#include "jpegimage.h" + +#include + +#define JPEG_DEBUG_STR "JPEG" +#define JPEG_DEBUG 3 + + +#define HAVE_APPn_JFIF (1 << 0) +#define HAVE_APPn_ADOBE (1 << 1) +#define HAVE_APPn_ICC (1 << 2) + +static void JPEG_info_init (struct JPEG_info *j_info); +static void JPEG_info_clear (struct JPEG_info *j_info); + +#define RELEASE(p) free(p) +#define NEW(n, t) (t*)xmalloc(n * sizeof(t)) +#define RENEW(p, n, t) ((p) ? (t*)xrealloc(p, (n) * sizeof(t)) : NEW(n, t)) + +int +check_for_jpeg (FILE *fp) +{ + unsigned char jpeg_sig[2]; + + rewind(fp); + if (fread(jpeg_sig, sizeof(unsigned char), 2, fp) != 2) + return 0; + else if (jpeg_sig[0] != 0xff || jpeg_sig[1] != JM_SOI) + return 0; + + return 1; +} + +static void +JPEG_info_init (struct JPEG_info *j_info) +{ + j_info->width = 0; + j_info->height = 0; + j_info->bits_per_component = 0; + j_info->num_components = 0; + + j_info->xdpi = 0; + j_info->ydpi = 0; + + j_info->flags = 0; + j_info->num_appn = 0; + j_info->max_appn = 0; + j_info->appn = NULL; + + memset(j_info->skipbits, 0, MAX_COUNT / 8 + 1); +} + +static void +JPEG_release_APPn_data (JPEG_marker marker, JPEG_APPn_sig app_sig, void *app_data) +{ + if (marker == JM_APP0 && + app_sig == JS_APPn_JFIF) { + struct JPEG_APPn_JFIF *data; + + data = (struct JPEG_APPn_JFIF *) app_data; + if (data->thumbnail) + RELEASE(data->thumbnail); + data->thumbnail = NULL; + + RELEASE(data); + } else if (marker == JM_APP2 && + app_sig == JS_APPn_ICC) { + struct JPEG_APPn_ICC *data; + + data = (struct JPEG_APPn_ICC *) app_data; + if (data->chunk) + RELEASE(data->chunk); + data->chunk = NULL; + + RELEASE(data); + } else if (marker == JM_APP14 && + app_sig == JS_APPn_ADOBE) { + struct JPEG_APPn_Adobe *data; + + data = (struct JPEG_APPn_Adobe *) app_data; + + RELEASE(data); + } +} + +static void +JPEG_info_clear (struct JPEG_info *j_info) +{ + if (j_info->num_appn > 0 && + j_info->appn != NULL) { + int i; + + for (i = 0; i < j_info->num_appn; i++) + JPEG_release_APPn_data(j_info->appn[i].marker, + j_info->appn[i].app_sig, j_info->appn[i].app_data); + RELEASE(j_info->appn); + } + j_info->appn = NULL; + j_info->num_appn = 0; + j_info->max_appn = 0; + j_info->flags = 0; +} + +static JPEG_marker +JPEG_get_marker (FILE *fp) +{ + int c; + + c = fgetc(fp); + if (c != 255) + return -1; + + for (;;) { + c = fgetc(fp); + if (c < 0) + return -1; + else if (c > 0 && c < 255) { + return c; + } + } + + return -1; +} + +static int +add_APPn_marker (struct JPEG_info *j_info, + JPEG_marker marker, int app_sig, void *app_data) +{ + int n; + + if (j_info->num_appn >= j_info->max_appn) { + j_info->max_appn += 16; + j_info->appn = RENEW(j_info->appn, j_info->max_appn, struct JPEG_ext); + } + n = j_info->num_appn; + + j_info->appn[n].marker = marker; + j_info->appn[n].app_sig = app_sig; + j_info->appn[n].app_data = app_data; + + j_info->num_appn += 1; + + return n; +} + +static unsigned short +read_APP14_Adobe (struct JPEG_info *j_info, FILE *fp, unsigned short length) +{ + struct JPEG_APPn_Adobe *app_data; + + app_data = NEW(1, struct JPEG_APPn_Adobe); + app_data->version = get_unsigned_pair(fp); + app_data->flag0 = get_unsigned_pair(fp); + app_data->flag1 = get_unsigned_pair(fp); + app_data->transform = get_unsigned_byte(fp); + + add_APPn_marker(j_info, JM_APP14, JS_APPn_ADOBE, app_data); + + return 7; +} + +static unsigned short +read_APP0_JFIF (struct JPEG_info *j_info, FILE *fp, unsigned short length) +{ + struct JPEG_APPn_JFIF *app_data; + unsigned short thumb_data_len; + + app_data = NEW(1, struct JPEG_APPn_JFIF); + app_data->version = get_unsigned_pair(fp); + app_data->units = get_unsigned_byte(fp); + app_data->Xdensity = get_unsigned_pair(fp); + app_data->Ydensity = get_unsigned_pair(fp); + app_data->Xthumbnail = get_unsigned_byte(fp); + app_data->Ythumbnail = get_unsigned_byte(fp); + thumb_data_len = 3 * app_data->Xthumbnail * app_data->Ythumbnail; + if (thumb_data_len > 0) { + app_data->thumbnail = NEW(thumb_data_len, unsigned char); + fread(app_data->thumbnail, 1, thumb_data_len, fp); + } else { + app_data->thumbnail = NULL; + } + + add_APPn_marker(j_info, JM_APP0, JS_APPn_JFIF, app_data); + + switch (app_data->units) { + case 1: + j_info->xdpi = app_data->Xdensity; + j_info->ydpi = app_data->Ydensity; + break; + case 2: /* density is in pixels per cm */ + j_info->xdpi = app_data->Xdensity * 2.54; + j_info->ydpi = app_data->Ydensity * 2.54; + break; + default: /* FIXME: not sure what to do with this.... */ + j_info->xdpi = 72.0; + j_info->ydpi = 72.0 * app_data->Ydensity / app_data->Xdensity; + break; + } + + return (9 + thumb_data_len); +} + +static unsigned short +read_APP0_JFXX (struct JPEG_info *j_info, FILE *fp, unsigned short length) +{ + unsigned char extension_code; + + extension_code = get_unsigned_byte(fp); + /* Extension Code: + * + * 0x10: Thumbnail coded using JPEG + * 0x11: Thumbnail stored using 1 byte/pixel + * 0x13: Thumbnail stored using 3 bytes/pixel + */ + seek_relative(fp, length-1); /* Thunbnail image */ + + /* Ignore */ + + return length; +} + +static unsigned short +read_APP2_ICC (struct JPEG_info *j_info, FILE *fp, unsigned short length) +{ + struct JPEG_APPn_ICC *app_data; + + app_data = NEW(1, struct JPEG_APPn_ICC); + app_data->seq_id = get_unsigned_byte(fp); /* Starting at 1 */ + app_data->num_chunks = get_unsigned_byte(fp); + app_data->length = length - 2; + app_data->chunk = NEW(app_data->length, unsigned char); + fread(app_data->chunk, 1, app_data->length, fp); + + add_APPn_marker(j_info, JM_APP2, JS_APPn_ICC, app_data); + + return length; +} + + +int +JPEG_scan_file (struct JPEG_info *j_info, FILE *fp) +{ + JPEG_marker marker; + unsigned short length; + int found_SOFn, count; + char app_sig[128]; + + JPEG_info_init(j_info); + + rewind(fp); + count = 0; + found_SOFn = 0; + while (!found_SOFn && + (marker = JPEG_get_marker(fp)) >= 0) { + if (marker == JM_SOI || + (marker >= JM_RST0 && marker <= JM_RST7)) { + count++; + continue; + } + length = get_unsigned_pair(fp) - 2; + switch (marker) { + case JM_SOF0: case JM_SOF1: case JM_SOF2: case JM_SOF3: + case JM_SOF5: case JM_SOF6: case JM_SOF7: case JM_SOF9: + case JM_SOF10: case JM_SOF11: case JM_SOF13: case JM_SOF14: + case JM_SOF15: + j_info->bits_per_component = get_unsigned_byte(fp); + j_info->height = get_unsigned_pair(fp); + j_info->width = get_unsigned_pair(fp); + j_info->num_components = get_unsigned_byte(fp); + found_SOFn = 1; + break; + case JM_APP0: + if (length > 5) { + if (fread(app_sig, sizeof(char), 5, fp) != 5) + return -1; + length -= 5; + if (!memcmp(app_sig, "JFIF\000", 5)) { + j_info->flags |= HAVE_APPn_JFIF; + length -= read_APP0_JFIF(j_info, fp, length); + } else if (!memcmp(app_sig, "JFXX", 5)) { + length -= read_APP0_JFXX(j_info, fp, length); + } + } + seek_relative(fp, length); + break; + case JM_APP2: + if (length >= 14) { + if (fread(app_sig, sizeof(char), 12, fp) != 12) + return -1; + length -= 12; + if (!memcmp(app_sig, "ICC_PROFILE\000", 12)) { + j_info->flags |= HAVE_APPn_ICC; + length -= read_APP2_ICC(j_info, fp, length); + if (count < MAX_COUNT) { + j_info->skipbits[count / 8] |= (1 << (7 - (count % 8))); + } + } + } + seek_relative(fp, length); + break; + case JM_APP14: + if (length > 5) { + if (fread(app_sig, sizeof(char), 5, fp) != 5) + return -1; + length -= 5; + if (!memcmp(app_sig, "Adobe", 5)) { + j_info->flags |= HAVE_APPn_ADOBE; + length -= read_APP14_Adobe(j_info, fp, length); + } else { + if (count < MAX_COUNT) { + j_info->skipbits[count/8] |= (1 << (7 - (count % 8))); + } + } + } + seek_relative(fp, length); + break; + default: + seek_relative(fp, length); + if (marker >= JM_APP0 && + marker <= JM_APP15) { + if (count < MAX_COUNT) { + j_info->skipbits[count / 8] |= (1 << (7 - (count % 8))); + } + } + break; + } + count++; + } + + return (found_SOFn ? 0 : -1); +} diff --git a/Build/source/texk/web2c/xetexdir/jpegimage.h b/Build/source/texk/web2c/xetexdir/jpegimage.h new file mode 100644 index 00000000000..03ef4ea56a3 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/jpegimage.h @@ -0,0 +1,166 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +\****************************************************************************/ + +/* this file is derived from the dvipdfmx project; + the original header follows... */ + +/* $Header: /home/cvsroot/dvipdfmx/src/jpegimage.h,v 1.2 2004/03/11 11:50:21 hirata Exp $ + + This is dvipdfmx, an eXtended version of dvipdfm by Mark A. Wicks. + + Copyright (C) 2002 by Jin-Hwan Cho and Shunsaku Hirata, + the dvipdfmx project team + + Copyright (C) 1998, 1999 by Mark A. Wicks + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +*/ + +#ifndef _JPEGIMAGE_H_ +#define _JPEGIMAGE_H_ + +#include "mfileio.h" + +/* JPEG Markers */ +typedef enum { + JM_SOF0 = 0xc0, + JM_SOF1 = 0xc1, + JM_SOF2 = 0xc2, + JM_SOF3 = 0xc3, + JM_SOF5 = 0xc5, + JM_DHT = 0xc4, + JM_SOF6 = 0xc6, + JM_SOF7 = 0xc7, + JM_SOF9 = 0xc9, + JM_SOF10 = 0xca, + JM_SOF11 = 0xcb, + JM_DAC = 0xcc, + JM_SOF13 = 0xcd, + JM_SOF14 = 0xce, + JM_SOF15 = 0xcf, + + JM_RST0 = 0xd0, + JM_RST1 = 0xd1, + JM_RST2 = 0xd2, + JM_RST3 = 0xd3, + JM_RST4 = 0xd4, + JM_RST5 = 0xd5, + JM_RST6 = 0xd6, + JM_RST7 = 0xd7, + + JM_SOI = 0xd8, + JM_EOI = 0xd9, + JM_SOS = 0xda, + JM_DQT = 0xdb, + JM_DNL = 0xdc, + JM_DRI = 0xdd, + JM_DHP = 0xde, + JM_EXP = 0xdf, + + JM_APP0 = 0xe0, + JM_APP2 = 0xe2, + JM_APP14 = 0xee, + JM_APP15 = 0xef, + + JM_COM = 0xfe +} JPEG_marker; + +typedef enum { + JS_APPn_JFIF, + JS_APPn_ADOBE, + JS_APPn_ICC +} JPEG_APPn_sig; + +struct JPEG_APPn_JFIF /* APP0 */ +{ + unsigned short version; + unsigned char units; /* 0: only aspect ratio + * 1: dots per inch + * 2: dots per cm + */ + unsigned short Xdensity; + unsigned short Ydensity; + unsigned char Xthumbnail; + unsigned char Ythumbnail; + unsigned char *thumbnail; /* Thumbnail data. */ +}; + +struct JPEG_APPn_ICC /* APP2 */ +{ + unsigned char seq_id; + unsigned char num_chunks; + unsigned char *chunk; + + /* Length of ICC profile data in this chunk. */ + unsigned short length; +}; + +struct JPEG_APPn_Adobe /* APP14 */ +{ + unsigned short version; + unsigned short flag0; + unsigned short flag1; + unsigned char transform; /* color transform code */ +}; + +struct JPEG_ext +{ + JPEG_marker marker; + JPEG_APPn_sig app_sig; + void *app_data; +}; + +#define MAX_COUNT 1024 +struct JPEG_info +{ + unsigned short height; + unsigned short width; + + unsigned char bits_per_component; + unsigned char num_components; + + double xdpi; + double ydpi; + + /* Application specific extensions */ + int flags; + int num_appn, max_appn; + struct JPEG_ext *appn; + + /* Skip chunks not necessary. */ + char skipbits[MAX_COUNT / 8 + 1]; +}; + +extern int check_for_jpeg(FILE *fp); +extern int JPEG_scan_file(struct JPEG_info *info, FILE *fp); + +#endif /* _JPEGIMAGE_H_ */ diff --git a/Build/source/texk/web2c/xetexdir/mfileio.c b/Build/source/texk/web2c/xetexdir/mfileio.c new file mode 100644 index 00000000000..e6c1a229850 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/mfileio.c @@ -0,0 +1,126 @@ +/* $Header: /home/cvsroot/dvipdfmx/src/mfileio.c,v 1.3 2002/10/30 02:27:11 chofchof Exp $ + + This is dvipdfmx, an eXtended version of dvipdfm by Mark A. Wicks. + + Copyright (C) 2002 by Jin-Hwan Cho and Shunsaku Hirata, + the dvipdfmx project team + + Copyright (C) 1998, 1999 by Mark A. Wicks + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +*/ + +#include +#include +#include "mfileio.h" + +#ifdef IODEBUG +static FILE *iodebug_file = NULL; +static long event = 0; +static void io_debug_init(void) +{ + if (!iodebug_file) { + iodebug_file = fopen ("fopen.log", "wb"); + fprintf (stderr, "\n*** File IO debugging started ***\n"); + } + if (!iodebug_file) { + fprintf (stderr, "\nError opening io log\n"); + } +} +#endif + +#ifdef IODEBUG +FILE *mfopen(const char *name, const char *mode, const char *function, int line) +{ + FILE *tmp; + io_debug_init(); + tmp = fopen (name, mode); + event += 1; + fprintf(iodebug_file, "%p %07ld [fopen] %s:%d\n", tmp, event, + function, line); + return tmp; +} +int mfclose(FILE *file, const char *function, int line) +{ + io_debug_init(); + event += 1; + fprintf(iodebug_file, "%p %07ld [fclose] %s:%d\n", file, event, + function, line); + return fclose(file); +} +#endif + +static void os_error() +{ + fprintf (stderr, "io: An OS command failed that should not have.\n"); + exit(-1); +} + +void seek_absolute (FILE *file, long pos) +{ + if (fseek(file, pos, SEEK_SET)) { + os_error(); + } +} + +void seek_relative (FILE *file, long pos) +{ + if (fseek(file, pos, SEEK_CUR)) { + os_error(); + } +} + + +void seek_end (FILE *file) +{ + if (fseek(file, 0L, SEEK_END)) { + os_error(); + } +} + +long tell_position (FILE *file) +{ + long size; + if ((size = ftell (file)) < 0) { + os_error(); + } + return size; +} + +long file_size (FILE *file) +{ + long size; + /* Seek to end */ + seek_end (file); + size = tell_position (file); + rewind (file); + return (size); +} + +/* Unlike fgets, mfgets works with \r, \n, or \r\n end of lines. */ +char *mfgets (char *buffer, unsigned long length, FILE *file) +{ + int ch = 0, i = 0; + while (i < length-1 && (ch = fgetc (file)) >= 0 && ch != '\n' && ch != '\r') + buffer[i++] = ch; + buffer[i] = 0; + if (ch < 0 && i == 0) + return NULL; + if (ch == '\r' && (ch = fgetc (file)) >= 0 && (ch != '\n')) + ungetc (ch, file); + return buffer; +} + +char work_buffer[WORK_BUFFER_SIZE]; diff --git a/Build/source/texk/web2c/xetexdir/mfileio.h b/Build/source/texk/web2c/xetexdir/mfileio.h new file mode 100644 index 00000000000..e31fef23244 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/mfileio.h @@ -0,0 +1,61 @@ +/* $Header: /home/cvsroot/dvipdfmx/src/mfileio.h,v 1.3 2002/10/30 02:27:12 chofchof Exp $ + + This is dvipdfmx, an eXtended version of dvipdfm by Mark A. Wicks. + + Copyright (C) 2002 by Jin-Hwan Cho and Shunsaku Hirata, + the dvipdfmx project team + + Copyright (C) 1998, 1999 by Mark A. Wicks + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +*/ + +#ifndef _MFILEIO_H_ +#define _MFILEIO_H_ + +#include +#include "numbers.h" + +#ifdef IODEBUG +FILE *mfopen (const char *name, const char *mode, + const char *function, int line); +int mfclose (FILE *file, const char *function, int line); +#define MFOPEN(name,mode) \ + mfopen((name),(mode),__FUNCTION__,__LINE__) +#define MFCLOSE(file) \ + mfclose((file),__FUNCTION__,__LINE__) +#else +#define MFOPEN(name,mode) fopen((name),(mode)) +#define MFCLOSE(file) fclose(file) +#endif + +extern UNSIGNED_BYTE read_byte (FILE *); + +extern void seek_absolute (FILE *file, long pos); +extern void seek_relative (FILE *file, long pos); + +extern void seek_end (FILE *file); + +extern long tell_position (FILE *file); + +extern long file_size (FILE *file); + +extern char *mfgets (char *buffer, unsigned long size, FILE *file); + +extern char work_buffer[]; + +#define WORK_BUFFER_SIZE 1024 + +#endif /* _MFILEIO_H_ */ diff --git a/Build/source/texk/web2c/xetexdir/numbers.c b/Build/source/texk/web2c/xetexdir/numbers.c new file mode 100644 index 00000000000..06864f1e2bb --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/numbers.c @@ -0,0 +1,227 @@ +/* $Header: /home/cvsroot/dvipdfmx/src/numbers.c,v 1.8 2004/03/03 13:19:00 hirata Exp $ + + This is dvipdfmx, an eXtended version of dvipdfm by Mark A. Wicks. + + Copyright (C) 2002 by Jin-Hwan Cho and Shunsaku Hirata, + the dvipdfmx project team + + Copyright (C) 1998, 1999 by Mark A. Wicks + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +*/ + +#include + +#include "mfileio.h" +#include "numbers.h" + +UNSIGNED_BYTE get_unsigned_byte (FILE *file) +{ + int ch; + if ((ch = fgetc (file)) < 0) { + fprintf (stderr, "File ended prematurely\n"); + exit(-1); + } + return (UNSIGNED_BYTE) ch; +} + +UNSIGNED_BYTE sget_unsigned_byte (char *s) +{ + return *((unsigned char *) s); +} + +SIGNED_BYTE get_signed_byte (FILE *file) +{ + int byte; + byte = get_unsigned_byte(file); + if (byte >= 0x80) + byte -= 0x100; + return (SIGNED_BYTE) byte; +} + +UNSIGNED_PAIR get_unsigned_pair (FILE *file) +{ + int i; + UNSIGNED_BYTE byte; + UNSIGNED_PAIR pair = 0; + for (i=0; i<2; i++) { + byte = get_unsigned_byte(file); + pair = pair*0x100u + byte; + } + return pair; +} + +UNSIGNED_PAIR sget_unsigned_pair (unsigned char *s) +{ + int i; + UNSIGNED_BYTE byte; + UNSIGNED_PAIR pair = 0; + for (i=0; i<2; i++) { + byte = *(s++); + pair = pair*0x100u + byte; + } + return pair; +} + +SIGNED_PAIR get_signed_pair (FILE *file) +{ + int i; + long pair = 0; + for (i=0; i<2; i++) { + pair = pair*0x100 + get_unsigned_byte(file); + } + if (pair >= 0x8000) { + pair -= 0x10000l; + } + return (SIGNED_PAIR) pair; +} + + +UNSIGNED_TRIPLE get_unsigned_triple(FILE *file) +{ + int i; + long triple = 0; + for (i=0; i<3; i++) { + triple = triple*0x100u + get_unsigned_byte(file); + } + return (UNSIGNED_TRIPLE) triple; +} + +SIGNED_TRIPLE get_signed_triple(FILE *file) +{ + int i; + long triple = 0; + for (i=0; i<3; i++) { + triple = triple*0x100 + get_unsigned_byte(file); + } + if (triple >= 0x800000l) + triple -= 0x1000000l; + return (SIGNED_TRIPLE) triple; +} + +SIGNED_QUAD get_signed_quad(FILE *file) +{ + int byte, i; + long quad = 0; + + /* Check sign on first byte before reading others */ + byte = get_unsigned_byte(file); + quad = byte; + if (quad >= 0x80) + quad = byte - 0x100; + for (i=0; i<3; i++) { + quad = quad*0x100 + get_unsigned_byte(file); + } + return (SIGNED_QUAD) quad; +} + +UNSIGNED_QUAD get_unsigned_quad(FILE *file) +{ + int i; + unsigned long quad = 0; + for (i=0; i<4; i++) { + quad = quad*0x100u + get_unsigned_byte(file); + } + return (UNSIGNED_QUAD) quad; +} + +#if 0 +SIGNED_QUAD sqxfw (SIGNED_QUAD sq, fixword fw) +{ + int sign = 1; + unsigned long a, b, c, d, ad, bd, bc, ac; + unsigned long e, f, g, h, i, j, k; + unsigned long result; + /* Make positive. */ + if (sq < 0) { + sign = -sign; + sq = -sq; + } + if (fw < 0) { + sign = -sign; + fw = -fw; + } + a = ((unsigned long) sq) >> 16u; + b = ((unsigned long) sq) & 0xffffu; + c = ((unsigned long) fw) >> 16u; + d = ((unsigned long) fw) & 0xffffu; + ad = a*d; bd = b*d; bc = b*c; ac = a*c; + e = bd >> 16u; + f = ad >> 16u; + g = ad & 0xffffu; + h = bc >> 16u; + i = bc & 0xffffu; + j = ac >> 16u; + k = ac & 0xffffu; + result = (e+g+i + (1<<3)) >> 4u; /* 1<<3 is for rounding */ + result += (f+h+k) << 12u; + result += j << 28u; + return (sign > 0) ? result : result * -1L; +} + +SIGNED_QUAD axboverc (SIGNED_QUAD n1, SIGNED_QUAD n2, SIGNED_QUAD divide) +{ + int sign = 1; + unsigned long a, b, c, d, ad, bd, bc, ac, e, f, g, h, i, j, o; + unsigned long high, low; + SIGNED_QUAD result = 0; + /* Make positive. */ + if (n1 < 0) { + sign = -sign; + n1 = -n1; + } + if (n2 < 0) { + sign = -sign; + n2 = -n2; + } + if (divide < 0) { + sign = -sign; + divide = -divide; + } + a = ((unsigned long) n1) >> 16u; + b = ((unsigned long) n1) & 0xffffu; + c = ((unsigned long) n2) >> 16u; + d = ((unsigned long) n2) & 0xffffu; + ad = a*d; bd = b*d; bc = b*c; ac = a*c; + e = bd >> 16u; f = bd & 0xffffu; + g = ad >> 16u; h = ad & 0xffffu; + i = bc >> 16u; j = bc & 0xffffu; + o = e+h+j; + high = g+i+(o>>16u)+ac; o &= 0xffffu; + low = (o << 16) + f; + if (high >= divide) + ERROR ("Overflow in axboc"); + { + int k; + for (k=0; k<32; k++) { + high *= 2; + result *= 2; + if (low >= 0x80000000) { + low -= 0x80000000; + high += 1; + } + low *= 2; + if (high > divide) { + high -= divide; + result += 1; + } + } + } + high *= 2; + if (high >= divide) + result += 1; + return (sign>0)?result:-result; +} +#endif diff --git a/Build/source/texk/web2c/xetexdir/numbers.h b/Build/source/texk/web2c/xetexdir/numbers.h new file mode 100644 index 00000000000..9e6b2306508 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/numbers.h @@ -0,0 +1,82 @@ +/* $Header: /home/cvsroot/dvipdfmx/src/numbers.h,v 1.9 2005/07/20 10:41:54 hirata Exp $ + + This is dvipdfmx, an eXtended version of dvipdfm by Mark A. Wicks. + + Copyright (C) 2002 by Jin-Hwan Cho and Shunsaku Hirata, + the dvipdfmx project team + + Copyright (C) 1998, 1999 by Mark A. Wicks + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +*/ + +#ifndef _NUMBERS_H_ +#define _NUMBERS_H_ + +#include +#include + +typedef unsigned char Ubyte; +typedef int UNSIGNED_BYTE, SIGNED_BYTE, SIGNED_PAIR; +typedef unsigned UNSIGNED_PAIR; +typedef long UNSIGNED_TRIPLE, SIGNED_TRIPLE, SIGNED_QUAD; +typedef unsigned long UNSIGNED_QUAD; + +extern UNSIGNED_BYTE get_unsigned_byte (FILE *); +extern UNSIGNED_BYTE sget_unsigned_byte (char *); +extern SIGNED_BYTE get_signed_byte (FILE *); +extern UNSIGNED_PAIR get_unsigned_pair (FILE *); +extern UNSIGNED_PAIR sget_unsigned_pair (unsigned char *); +extern SIGNED_PAIR get_signed_pair (FILE *); +extern UNSIGNED_TRIPLE get_unsigned_triple (FILE *); +extern SIGNED_TRIPLE get_signed_triple (FILE *); +extern SIGNED_QUAD get_signed_quad (FILE *); +extern UNSIGNED_QUAD get_unsigned_quad (FILE *); + +typedef signed long fixword; + +extern SIGNED_QUAD sqxfw (SIGNED_QUAD sq, fixword fw); +extern SIGNED_QUAD axboverc (SIGNED_QUAD n1, SIGNED_QUAD n2, SIGNED_QUAD divide); + +#ifndef MAX +# define MAX(a,b) ((a)>(b)?(a):(b)) +#endif +#ifndef MIN +# define MIN(a,b) ((a)<(b)?(a):(b)) +#endif +#define ISODD(n) (((n)/2)*2!=(n)) +#define ISEVEN(n) (((n)/2)*2==(n)) + +#ifndef M_PI +# define M_PI (4.0*atan(1.0)) +#endif + +#define ROUND(n,acc) (floor(((double)n)/(acc)+0.5)*(acc)) + +#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +# define __C99__ +#endif + +#ifndef __C99__ +# ifndef round +# define round(v) (floor((v) + 0.5)) +# endif +# ifndef trunc +# define trunc(v) ((v) > 0.0 ? floor((v)) : ceil((v))) +# endif +#endif +#define round_at(v,acc) (round(((double)(v))/(acc))*(acc)) + +#endif /* _NUMBERS_H_ */ diff --git a/Build/source/texk/web2c/xetexdir/pdfimage.cpp b/Build/source/texk/web2c/xetexdir/pdfimage.cpp new file mode 100644 index 00000000000..26d1bc79196 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/pdfimage.cpp @@ -0,0 +1,77 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 2006 by SIL International + written by Jonathan Kew + + This software is distributed under the terms of the Common Public License, + version 1.0. + For details, see or the file + cpl1.0.txt included with the software. +\****************************************************************************/ + +#include "pdfimage.h" + +#include "PDFDoc.h" +#include "Catalog.h" +#include "Page.h" +#include "GString.h" + +#include "XeTeX_ext.h" + +int +pdf_get_rect(char* filename, int page_num, int pdf_box, realrect* box) +{ + GString* name = new GString(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; + if (page_num < 0) + page_num = pages + 1 - page_num; + if (page_num < 1) + page_num = 1; + + Page* page = doc->getCatalog()->getPage(page_num); + + PDFRectangle* r; + switch (pdf_box) { + default: + case pdfbox_crop: + r = page->getCropBox(); + break; + case pdfbox_media: + r = page->getMediaBox(); + break; + case pdfbox_bleed: + r = page->getBleedBox(); + break; + case pdfbox_trim: + r = page->getTrimBox(); + break; + case pdfbox_art: + r = page->getArtBox(); + break; + } + + box->x = 72 / 72.27 * fmin(r->x1, r->x2); + box->y = 72 / 72.27 * fmin(r->y1, r->y2); + box->wd = 72 / 72.27 * fabs(r->x2 - r->x1); + box->ht = 72 / 72.27 * fabs(r->y2 - r->y1); + + delete doc; + + return 0; +} diff --git a/Build/source/texk/web2c/xetexdir/pdfimage.h b/Build/source/texk/web2c/xetexdir/pdfimage.h new file mode 100644 index 00000000000..0869c03aa1e --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/pdfimage.h @@ -0,0 +1,27 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 2006 by SIL International + written by Jonathan Kew + + This software is distributed under the terms of the Common Public License, + version 1.0. + For details, see or the file + cpl1.0.txt included with the software. +\****************************************************************************/ + +#ifndef __PDF_IMAGE_H__ +#define __PDF_IMAGE_H__ + +#include "trans.h" + +#ifdef __cplusplus +extern "C" { +#endif + +extern int pdf_get_rect(char* filename, int page_num, int pdf_box, realrect* box); + +#ifdef __cplusplus +}; +#endif + +#endif diff --git a/Build/source/texk/web2c/xetexdir/pngimage.c b/Build/source/texk/web2c/xetexdir/pngimage.c new file mode 100644 index 00000000000..9408fbabc39 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/pngimage.c @@ -0,0 +1,161 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +\****************************************************************************/ + +/* this file is derived from the dvipdfmx project; + the original header follows... */ + +/* $Header: /home/cvsroot/dvipdfmx/src/pngimage.c,v 1.24 2004/09/11 14:50:29 hirata Exp $ + + This is dvipdfmx, an eXtended version of dvipdfm by Mark A. Wicks. + + Copyright (C) 2002 by Jin-Hwan Cho and Shunsaku Hirata, + the dvipdfmx project team + + Copyright (C) 1998, 1999 by Mark A. Wicks + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +*/ + +#if HAVE_CONFIG_H +#include "config.h" +#endif + +/* + * PNG SUPPORT + * + * All bitdepth less than 16 is supported. + * Supported color types are: PALETTE, RGB, GRAY, RGB_ALPHA, GRAY_ALPHA. + * Supported ancillary chunks: tRNS, cHRM + gAMA, (sRGB), (iCCP) + * + * gAMA support is available only when cHRM exists. cHRM support is not + * tested well. CalRGB/CalGray colorspace is used for PNG images that + * have cHRM chunk (but not sRGB). + * + * LIMITATIONS + * + * Recent version of PDF (>= 1.5) support 16 bpc, but 16 bit bitdepth PNG + * images are automatically converted to 8 bit bitpedth image. + * + * TODO + * + * sBIT ? iTXT, tEXT and tIME as MetaData ?, pHYS (see below) + * 16 bpc support for PDF-1.5. JBIG compression for monochrome image. + * Predictor for deflate ? + */ + +#define PNG_DEBUG_STR "PNG" +#define PNG_DEBUG 3 + +/* + * Write, MNG, Progressive not required. + */ +#define PNG_NO_WRITE_SUPPORTED +#define PNG_NO_MNG_FEATURES +#define PNG_NO_PROGRESSIVE_READ +#if 0 +/* 16_TO_8 required. */ +#define PNG_NO_READ_TRANSFORMS +#endif + +#include +#include "pngimage.h" + +#define PDF_TRANS_TYPE_NONE 0 +#define PDF_TRANS_TYPE_BINARY 1 +#define PDF_TRANS_TYPE_ALPHA 2 + +int +check_for_png (FILE *png_file) +{ + unsigned char sigbytes[4]; + + rewind (png_file); + if (fread (sigbytes, 1, sizeof(sigbytes), png_file) != + sizeof(sigbytes) || + (!png_check_sig (sigbytes, sizeof(sigbytes)))) + return 0; + else + return 1; +} + +int +png_scan_file (struct png_info *info, FILE *png_file) +{ + png_bytep stream_data_ptr; + int trans_type; + /* Libpng stuff */ + png_structp png_ptr; + png_infop png_info_ptr; + png_byte bpc, color_type; + png_uint_32 width, height, rowbytes; + + rewind (png_file); + png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); + if (png_ptr == NULL || + (png_info_ptr = png_create_info_struct (png_ptr)) == NULL) { + fprintf(stderr, "WARNING: %s: Creating Libpng read/info struct failed.", PNG_DEBUG_STR); + if (png_ptr) + png_destroy_read_struct(&png_ptr, NULL, NULL); + return -1; + } + + /* Inititializing file IO. */ + png_init_io (png_ptr, png_file); + + /* Read PNG info-header and get some info. */ + png_read_info(png_ptr, png_info_ptr); + color_type = png_get_color_type (png_ptr, png_info_ptr); + width = png_get_image_width (png_ptr, png_info_ptr); + height = png_get_image_height(png_ptr, png_info_ptr); + bpc = png_get_bit_depth (png_ptr, png_info_ptr); + + info->xdpi = png_get_x_pixels_per_meter(png_ptr, png_info_ptr) * 0.0254; + info->ydpi = png_get_y_pixels_per_meter(png_ptr, png_info_ptr) * 0.0254; + + if (info->xdpi == 0) + info->xdpi = 72; + if (info->ydpi == 0) + info->ydpi = 72; + + /* Values listed below will not be modified in the remaining process. */ + info->width = width; + info->height = height; + info->bits_per_component = bpc; + + /* Cleanup */ + if (png_info_ptr) + png_destroy_info_struct(png_ptr, &png_info_ptr); + if (png_ptr) + png_destroy_read_struct(&png_ptr, NULL, NULL); + + return 0; +} diff --git a/Build/source/texk/web2c/xetexdir/pngimage.h b/Build/source/texk/web2c/xetexdir/pngimage.h new file mode 100644 index 00000000000..c00387ca4f0 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/pngimage.h @@ -0,0 +1,70 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +\****************************************************************************/ + +/* this file is derived from the dvipdfmx project; + the original header follows... */ + +/* $Header: /home/cvsroot/dvipdfmx/src/pngimage.h,v 1.4 2004/03/11 11:50:25 hirata Exp $ + + This is dvipdfmx, an eXtended version of dvipdfm by Mark A. Wicks. + + Copyright (C) 2002 by Jin-Hwan Cho and Shunsaku Hirata, + the dvipdfmx project team + + Copyright (C) 1998, 1999 by Mark A. Wicks + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +*/ + + +#ifndef _PNGIMAGE_H_ +#define _PNGIMAGE_H_ + +#if HAVE_CONFIG_H +#include "config.h" +#endif + +#include "mfileio.h" + +struct png_info { + int width; + int height; + double xdpi; + double ydpi; + int bits_per_component; + int num_components; +}; + +extern int png_scan_file (struct png_info *info, FILE *file); +extern int check_for_png (FILE *file); + +#endif /* _PNGIMAGE_H_ */ diff --git a/Build/source/texk/web2c/xetexdir/sfnt.h b/Build/source/texk/web2c/xetexdir/sfnt.h new file mode 100644 index 00000000000..05403a37d69 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/sfnt.h @@ -0,0 +1,285 @@ +/* + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +*/ + +/* from ICU sample code, extended by JK for XeTeX */ + +/*************************************************************************** +* +* Copyright (C) 1998-2002, International Business Machines +* Corporation and others. All Rights Reserved. +* +************************************************************************/ + +#ifndef __SFNT_H +#define __SFNT_H + +#include "LETypes.h" + + +#ifndef ANY_NUMBER +#define ANY_NUMBER 1 +#endif + +struct DirectoryEntry +{ + le_uint32 tag; + le_uint32 checksum; + le_uint32 offset; + le_uint32 length; +}; + +struct SFNTDirectory +{ + le_uint32 scalerType; + le_uint16 numTables; + le_uint16 searchRange; + le_uint16 entrySelector; + le_uint16 rangeShift; + DirectoryEntry tableDirectory[ANY_NUMBER]; +}; + + +struct CMAPEncodingSubtableHeader +{ + le_uint16 platformID; + le_uint16 platformSpecificID; + le_uint32 encodingOffset; +}; + +struct CMAPTable +{ + le_uint16 version; + le_uint16 numberSubtables; + CMAPEncodingSubtableHeader encodingSubtableHeaders[ANY_NUMBER]; +}; + +struct CMAPEncodingSubtable +{ + le_uint16 format; + le_uint16 length; + le_uint16 language; +}; + +struct CMAPFormat0Encoding : CMAPEncodingSubtable +{ + le_uint8 glyphIndexArray[256]; +}; + +struct CMAPFormat2Subheader +{ + le_uint16 firstCode; + le_uint16 entryCount; + le_int16 idDelta; + le_uint16 idRangeOffset; +}; + +struct CMAPFormat2Encoding : CMAPEncodingSubtable +{ + le_uint16 subHeadKeys[256]; + CMAPFormat2Subheader subheaders[ANY_NUMBER]; +}; + +struct CMAPFormat4Encoding : CMAPEncodingSubtable +{ + le_uint16 segCountX2; + le_uint16 searchRange; + le_uint16 entrySelector; + le_uint16 rangeShift; + le_uint16 endCodes[ANY_NUMBER]; +// le_uint16 reservedPad; +// le_uint16 startCodes[ANY_NUMBER]; +// le_uint16 idDelta[ANY_NUMBER]; +// le_uint16 idRangeOffset[ANY_NUMBER]; +// le_uint16 glyphIndexArray[ANY_NUMBER]; +}; + +struct CMAPFormat6Encoding : CMAPEncodingSubtable +{ + le_uint16 firstCode; + le_uint16 entryCount; + le_uint16 glyphIndexArray[ANY_NUMBER]; +}; + +struct CMAPEncodingSubtable32 +{ + le_uint16 format; + le_uint16 reserved; + le_uint32 length; + le_uint32 language; +}; + +struct CMAPGroup +{ + le_uint32 startCharCode; + le_uint32 endCharCode; + le_uint32 startGlyphCode; +}; + +struct CMAPFormat8Encoding : CMAPEncodingSubtable32 +{ + le_uint32 is32[65536/32]; + le_uint32 nGroups; + CMAPGroup groups[ANY_NUMBER]; +}; + +struct CMAPFormat10Encoding : CMAPEncodingSubtable32 +{ + le_uint32 startCharCode; + le_uint32 numCharCodes; + le_uint16 glyphs[ANY_NUMBER]; +}; + +struct CMAPFormat12Encoding : CMAPEncodingSubtable32 +{ + le_uint32 nGroups; + CMAPGroup groups[ANY_NUMBER]; +}; + +typedef le_int32 fixed; + +struct BigDate +{ + le_uint32 bc; + le_uint32 ad; +}; + +struct HEADTable +{ + fixed version; + fixed fontRevision; + le_uint32 checksumAdjustment; + le_uint32 magicNumber; + le_uint16 flags; + le_uint16 unitsPerEm; + BigDate created; + BigDate modified; + le_int16 xMin; + le_int16 yMin; + le_int16 xMax; + le_int16 yMax; + le_uint16 macStyle; + le_uint16 lowestRecPPEM; + le_int16 fontDirectionHint; + le_int16 indexToLocFormat; + le_int16 glyphDataFormat; +}; + +struct MAXPTable +{ + fixed version; + le_uint16 numGlyphs; + le_uint16 maxPoints; + le_uint16 maxContours; + le_uint16 maxComponentPoints; + le_uint16 maxComponentContours; + le_uint16 maxZones; + le_uint16 maxTwilightPoints; + le_uint16 maxStorage; + le_uint16 maxFunctionDefs; + le_uint16 maxInstructionDefs; + le_uint16 maxStackElements; + le_uint16 maxSizeOfInstructions; + le_uint16 maxComponentElements; + le_uint16 maxComponentDepth; +}; + +struct HHEATable +{ + fixed version; + le_int16 ascent; + le_int16 descent; + le_int16 lineGap; + le_uint16 advanceWidthMax; + le_int16 minLeftSideBearing; + le_int16 minRightSideBearing; + le_int16 xMaxExtent; + le_int16 caretSlopeRise; + le_int16 caretSlopeRun; + le_int16 caretOffset; + le_int16 reserved1; + le_int16 reserved2; + le_int16 reserved3; + le_int16 reserved4; + le_int16 metricDataFormat; + le_uint16 numOfLongHorMetrics; +}; + +struct LongHorMetric +{ + le_uint16 advanceWidth; + le_int16 leftSideBearing; +}; + +struct HMTXTable +{ + LongHorMetric hMetrics[ANY_NUMBER]; // ANY_NUMBER = numOfLongHorMetrics from hhea table +// le_int16 leftSideBearing[ANY_NUMBER]; // ANY_NUMBER = numGlyphs - numOfLongHorMetrics +}; + +struct POSTTable +{ + fixed version; + fixed italicAngle; + le_int16 underlinePosition; + le_uint16 underlineThickness; + le_uint32 isFixedPitch; + le_uint32 minMemType42; + le_uint32 maxMemType42; + le_uint32 minMemType1; + le_uint32 maxMemType1; +}; + +struct OS2TableHeader { + le_uint16 version; + le_int16 xAvgCharWidth; + le_uint16 usWeightClass; + le_uint16 usWidthClass; + le_int16 fsType; + le_int16 ySubscriptXSize; + le_int16 ySubscriptYSize; + le_int16 ySubscriptXOffset; + le_int16 ySubscriptYOffset; + le_int16 ySuperscriptXSize; + le_int16 ySuperscriptYSize; + le_int16 ySuperscriptXOffset; + le_int16 ySuperscriptYOffset; + le_int16 yStrikeoutSize; + le_int16 yStrikeoutPosition; + le_int16 sFamilyClass; + le_uint8 panose[10]; + le_uint8 ulCharRange[16]; // spec'd as 4 longs, but do this to keep structure packed + le_int8 achVendID[4]; + le_uint16 fsSelection; + le_uint16 fsFirstCharIndex; + le_uint16 fsLastCharIndex; +}; + +#endif + diff --git a/Build/source/texk/web2c/xetexdir/tests.ac b/Build/source/texk/web2c/xetexdir/tests.ac new file mode 100644 index 00000000000..552aea23dc0 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/tests.ac @@ -0,0 +1,49 @@ +# Extra configure tests to support XeTeX + +AC_DEFUN([AC_HAS_CARBON], [ +# +# Check for Carbon framework on Mac OS X +# + _cppflags=$CPPFLAGS _ldflags=$LDFLAGS + AC_MSG_CHECKING([for Apple Carbon framework]) + AC_TRY_COMPILE( + [ +#include + ], [ +ATSUStyle style; + ], + [ AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_CARBON, 1, [Define if you have Carbon]) + LDCARBON="-framework Carbon" + has_carbon=yes + ], + [ AC_MSG_RESULT(no) + LDCARBON= + has_carbon=no + ] + ) +]) + +AC_DEFUN([AC_HAS_QUICKTIME], [ +# +# Check for QuickTime framework on Mac OS X +# + _cppflags=$CPPFLAGS _ldflags=$LDFLAGS + AC_MSG_CHECKING([for Apple QuickTime framework]) + AC_TRY_COMPILE( + [ +#include + ], [ +ImageDescriptionHandle h; + ], + [ AC_MSG_RESULT(yes) + AC_DEFINE(HAVE_QUICKTIME, 1, [Define if you have QuickTime]) + LDQUICKTIME="-framework QuickTime" + has_quicktime=yes + ], + [ AC_MSG_RESULT(no) + LDQUICKTIME= + has_quicktime=no + ] + ) +]) diff --git a/Build/source/texk/web2c/xetexdir/trans.c b/Build/source/texk/web2c/xetexdir/trans.c new file mode 100644 index 00000000000..7ac31c1616a --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/trans.c @@ -0,0 +1,116 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +#include "trans.h" + +void makeidentity(transform* t) +{ +#ifdef XETEX_MAC + *t = CGAffineTransformMake(1.0, 0.0, 0.0, 1.0, 0.0, 0.0); +#else + t->a = 1.0; + t->b = 0.0; + t->c = 0.0; + t->d = 1.0; + t->x = 0.0; + t->y = 0.0; +#endif +} + +void makescale(transform* t, double xscale, double yscale) +{ +#ifdef XETEX_MAC + *t = CGAffineTransformMakeScale(xscale, yscale); +#else + t->a = xscale; + t->b = 0.0; + t->c = 0.0; + t->d = yscale; + t->x = 0.0; + t->y = 0.0; +#endif +} + +void maketranslation(transform* t, double dx, double dy) +{ +#ifdef XETEX_MAC + *t = CGAffineTransformMakeTranslation(dx, dy); +#else + t->a = 1.0; + t->b = 0.0; + t->c = 0.0; + t->d = 1.0; + t->x = dx; + t->y = dy; +#endif +} +#include +void makerotation(transform* t, double a) +{ +#ifdef XETEX_MAC + *t = CGAffineTransformMakeRotation(a); +#else + t->a = cos(a); + t->b = sin(a); + t->c = -sin(a); + t->d = cos(a); + t->x = 0.0; + t->y = 0.0; +#endif +} + +void transformpoint(realpoint* p, const transform* t) +{ +#ifdef XETEX_MAC + CGPoint r = CGPointApplyAffineTransform(*(CGPoint*)p, *t); + *p = *(realpoint*)&r; +#else + realpoint r; + r.x = t->a * p->x + t->c * p->y + t->x; + r.y = t->b * p->x + t->d * p->y + t->y; + *p = r; +#endif +} + +void transformconcat(transform* t1, const transform* t2) +{ +#ifdef XETEX_MAC + *t1 = CGAffineTransformConcat(*t1, *t2); +#else + transform r; + r.a = t1->a * t2->a + t1->b * t2->c + 0.0 * t2->x; + r.b = t1->a * t2->b + t1->b * t2->d + 0.0 * t2->y; + r.c = t1->c * t2->a + t1->d * t2->c + 0.0 * t2->x; + r.d = t1->c * t2->b + t1->d * t2->d + 0.0 * t2->y; + r.x = t1->x * t2->a + t1->y * t2->c + 1.0 * t2->x; + r.y = t1->x * t2->b + t1->y * t2->d + 1.0 * t2->y; + *t1 = r; +#endif +} diff --git a/Build/source/texk/web2c/xetexdir/trans.h b/Build/source/texk/web2c/xetexdir/trans.h new file mode 100644 index 00000000000..2a24a60f7ee --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/trans.h @@ -0,0 +1,94 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +#ifndef _TRANS_H_ +#define _TRANS_H_ + +#ifdef XETEX_MAC + +#include + +typedef CGAffineTransform transform; + +#else + +#include + +typedef struct { + double a; + double b; + double c; + double d; + double x; + double y; +} transform; + +#endif + +typedef struct { + float x; + float y; +} realpoint; + +typedef struct { + float x; + float y; + float wd; + float ht; +} realrect; + +#define xCoord(p) p.x +#define yCoord(p) p.y + +#define wdField(r) r.wd +#define htField(r) r.ht + +#define aField(t) t.a +#define bField(t) t.b +#define cField(t) t.c +#define dField(t) t.d +#ifdef XETEX_MAC +#define xField(t) t.tx +#define yField(t) t.ty +#else +#define xField(t) t.x +#define yField(t) t.y +#endif + +#define setPoint(P,X,Y) do { P.x = X; P.y = Y; } while (0) + +void makeidentity(transform* t); +void makescale(transform* t, double xscale, double yscale); +void maketranslation(transform* t, double dx, double dy); +void makerotation(transform* t, double a); +void transformpoint(realpoint* p, const transform* t); +void transformconcat(transform* t1, const transform* t2); + +#endif /* _TRANS_H_ */ diff --git a/Build/source/texk/web2c/xetexdir/unicode-char-prep.pl b/Build/source/texk/web2c/xetexdir/unicode-char-prep.pl new file mode 100644 index 00000000000..31b27de7dc9 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/unicode-char-prep.pl @@ -0,0 +1,116 @@ +#!/usr/bin/perl + +# /****************************************************************************\ +# Part of the XeTeX typesetting system +# copyright (c) 1994-2006 by SIL International +# written by Jonathan Kew +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +# CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +# Except as contained in this notice, the name of SIL International +# shall not be used in advertising or otherwise to promote the sale, +# use or other dealings in this Software without prior written +# authorization from SIL International. +# \****************************************************************************/ + +# script to create unicode-letters.tex by processing UnicodeData.txt + +while (<>) { + chomp; + @u = split(/;/); + last if length($u[0]) > 4; + if ($u[1] =~ /First>/) { + $start = hex "0x$u[0]"; + $_ = <>; + chomp; + @u = split(/;/); + if ($u[1] =~ /Last>/) { + $end = hex "0x$u[0]"; + if ($u[2] =~ /^L/) { + foreach ($start .. $end) { + push(@letters, sprintf("%04X", $_)); + } + } + } + } + else { + $lccode{$u[0]} = $u[13] if $u[13] ne '' and length($u[13]) <= 4; + $lccode{$u[0]} = $u[0] if $u[13] eq '' and $u[2] =~ /^L/; + $uccode{$u[0]} = $u[12] if $u[12] ne '' and length($u[12]) <= 4; + $uccode{$u[0]} = $u[0] if $u[12] eq '' and $u[2] =~ /^L/; + if ($u[2] =~ /^L/) { + push(@letters, $u[0]); + } + elsif ($u[2] =~ /^M/) { + push(@marks, $u[0]); + } + elsif (exists $lccode{$u[0]} or exists $uccode{$u[0]}) { + push(@casesym, $u[0]); + } + } +} + +$date = `date`; +chomp $date; +print << "__EOT__"; +% Do not edit this file! +% Created from UnicodeData.txt by unicode-char-prep.pl on $date. +% In case of errors, fix the Perl script instead. +__EOT__ + +print << '__EOT__'; +\begingroup +\catcode`\{=1 \catcode`\}=2 \catcode`\#=6 +\def\C #1 #2 #3 {\global\uccode"#1="#2 \global\lccode"#1="#3 } % case mappings (non-letter) +\def\L #1 #2 #3 {\global\catcode"#1=11 \C #1 #2 #3 % letter with case mappings + \global\XeTeXextmathcode"#1="7"01"#1 } % letters default to class 7 (var), fam 1 +\def\l #1 {\L #1 #1 #1 } % letter without case mappings +\let\m=\l % combining mark - treated as uncased letter +__EOT__ +for (@letters) { + if (exists $uccode{$_} or exists $lccode{$_}) { + if (($lccode{$_} eq $_) and ($uccode{$_} eq $_)) { + print "\\l $_\n"; + } + else { + print "\\L $_ "; + print exists $uccode{$_} ? $uccode{$_} : "0"; + print " "; + print exists $lccode{$_} ? $lccode{$_} : "0"; + print "\n"; + } + } + else { + print "\\l $_\n"; + } +} +for (@casesym) { + print "\\C $_ "; + print exists $uccode{$_} ? $uccode{$_} : "0"; + print " "; + print exists $lccode{$_} ? $lccode{$_} : "0"; + print "\n"; +} +for (@marks) { + print "\\m $_\n"; +} +print << '__EOT__'; +\endgroup +__EOT__ diff --git a/Build/source/texk/web2c/xetexdir/xetex-new.ch b/Build/source/texk/web2c/xetexdir/xetex-new.ch new file mode 100644 index 00000000000..8c8bf117e14 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/xetex-new.ch @@ -0,0 +1,6169 @@ +% /****************************************************************************\ +% Part of the XeTeX typesetting system +% copyright (c) 1994-2006 by SIL International +% written by Jonathan Kew +% +% Permission is hereby granted, free of charge, to any person obtaining +% a copy of this software and associated documentation files (the +% "Software"), to deal in the Software without restriction, including +% without limitation the rights to use, copy, modify, merge, publish, +% distribute, sublicense, and/or sell copies of the Software, and to +% permit persons to whom the Software is furnished to do so, subject to +% the following conditions: +% +% The above copyright notice and this permission notice shall be +% included in all copies or substantial portions of the Software. +% +% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +% EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +% MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +% NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +% ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +% CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +% WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +% +% Except as contained in this notice, the name of SIL International +% shall not be used in advertising or otherwise to promote the sale, +% use or other dealings in this Software without prior written +% authorization from SIL International. +% \****************************************************************************/ + +% Changes for XeTeX +% ================= +% +% Procedure to build xetex from web sources: +% +% (1) build etex-web2c.web: +% ./tie -m etex.web ../../../../TeX/texk/web2c/tex.web ../../../../TeX/texk/web2c/etexdir/etex.ch ../../../../TeX/texk/web2c/etexdir/etex.fix +% +% (2) add xetex features, and remove enctex ones +% ./tie -m xetex.web etex.web xetex-new.ch xetex-noenc.ch +% +% (4) use otangle, web2c, etc.... +% ./otangle xetex.web +% ./web2c ........ + +@x +@* \[1] Introduction. +@y +@* \[1] Introduction. +@z + +@x +@d eTeX_version_string=='-2.2' {current \eTeX\ version} +@y +@d eTeX_version_string=='-2.2' {current \eTeX\ version} + +@d XeTeX_version=0 +@d XeTeX_revision==".995" +@d XeTeX_version_string=='-0.995' {current \eTeX\ version} +@z + +@x +@d eTeX_banner_k=='This is e-TeXk, Version 3.141592',eTeX_version_string +@d eTeX_banner=='This is e-TeX, Version 3.141592',eTeX_version_string + {printed when \eTeX\ starts} +@# +@d TeX_banner_k=='This is TeXk, Version 3.141592' {printed when \TeX\ starts} +@d TeX_banner=='This is TeX, Version 3.141592' {printed when \TeX\ starts} +@# +@d banner==eTeX_banner +@d banner_k==eTeX_banner_k +@y +@d XeTeX_banner=='This is XeTeX, Version 3.141592',eTeX_version_string,XeTeX_version_string + {printed when \XeTeX\ starts} +@d XeTeX_banner_k=='This is XeTeXk, Version 3.141592',eTeX_version_string,XeTeX_version_string +@# +@d banner==XeTeX_banner +@d banner_k==XeTeX_banner_k +@z + +@x +@d TEX==ETEX {change program name into |ETEX|} +@y +@d TEX==XETEX {change program name into |XETEX|} +@z + +@x +@d TeXXeT_code=0 {the \TeXXeT\ feature is optional} +@# +@d eTeX_states=1 {number of \eTeX\ state variables in |eqtb|} +@y +@d TeXXeT_code=0 {the \TeXXeT\ feature is optional} +@# +@d XeTeX_dash_break_code = 1 {non-zero to enable breaks after en- and em-dashes} +@# +@d XeTeX_default_input_mode_code = 2 {input mode for newly opened files} +@d XeTeX_input_mode_auto = 0 +@d XeTeX_input_mode_utf8 = 1 +@d XeTeX_input_mode_utf16be = 2 +@d XeTeX_input_mode_utf16le = 3 +@d XeTeX_input_mode_raw = 4 +@d XeTeX_input_mode_icu_mapping = 5 +@# +@d XeTeX_default_input_encoding_code = 3 {str_number of encoding name if mode = ICU} +@# +@d eTeX_states=4 {number of \eTeX\ state variables in |eqtb|} +@z + +@x +@d hyph_prime=607 {another prime for hashing \.{\\hyphenation} exceptions; + if you change this, you should also change |iinf_hyphen_size|.} +@y +@d hyph_prime=607 {another prime for hashing \.{\\hyphenation} exceptions; + if you change this, you should also change |iinf_hyphen_size|.} + +@d biggest_char=65535 {the largest allowed character number; + must be |<=max_quarterword|} +@d too_big_char=65536 {|biggest_char+1|} +@d special_char=65537 {|biggest_char+2|} +@d number_chars=65536 {|biggest_char+1|} +@d biggest_reg=255 {the largest allowed register number; + must be |<=max_quarterword|} +@d number_regs=256 {|biggest_reg+1|} +@d font_biggest=255 {the real biggest font} +@d number_fonts=font_biggest-font_base+2 +@d number_math_families=256 +@d number_math_fonts=number_math_families+number_math_families+number_math_families +@d math_font_biggest=number_math_fonts-1 +@d text_size=0 {size code for the largest size in a family} +@d script_size=number_math_families {size code for the medium size in a family} +@d script_script_size=number_math_families+number_math_families {size code for the smallest size in a family} +@d biggest_lang=255 +@d too_big_lang=256 +@z + +@x +@* \[2] The character set. +@y +@* \[2] The character set. +@z + +@x +@ Characters of text that have been converted to \TeX's internal form +are said to be of type |ASCII_code|, which is a subrange of the integers. + +@= +@!ASCII_code=0..255; {eight-bit numbers} +@y +@ Characters of text that have been converted to \TeX's internal form +are said to be of type |ASCII_code|, which is a subrange of the integers. +For xetex, we rename |ASCII_code| as |UTF16_code|. But we also have a +new type |UTF8_code|, used when we construct filenames to pass to the +system libraries. + +@d ASCII_code==UTF16_code +@d packed_ASCII_code==packed_UTF16_code + +@= +@!ASCII_code=0..biggest_char; {16-bit numbers} +@!UTF8_code=0..255; {8-bit numbers} +@!UnicodeScalar=0..@"10FFFF; {Unicode scalars} +@z + +@x +@d last_text_char=255 {ordinal number of the largest element of |text_char|} +@y +@d last_text_char=biggest_char {ordinal number of the largest element of |text_char|} +@z + +@x +@* \[3] Input and output. +@y +@* \[3] Input and output. +@z + +@x +@!name_of_file:^text_char; +@!name_length:0..file_name_size;@/{this many characters are actually + relevant in |name_of_file| (the rest are blank)} +@y +@!name_of_file:^UTF8_code; {we build filenames in utf8 to pass to the OS} +@!name_of_file16:^UTF16_code; {but sometimes we need a utf16 version of the name} +@!name_length:0..file_name_size;@/{this many characters are actually + relevant in |name_of_file| (the rest are blank)} +@!name_length16:0..file_name_size; +@z + +@x +@d term_in==stdin {the terminal as an input file} +@y +@z + +@x +@!bound_default:integer; {temporary for setup} +@y +@!term_in:unicode_file; +@# +@!bound_default:integer; {temporary for setup} +@z + +@x +@!eight_bit_p:c_int_type; {make all characters printable by default} +@!halt_on_error_p:c_int_type; {stop at first error} +@!quoted_filename:boolean; {current filename is quoted} +@y +@!eight_bit_p:c_int_type; {make all characters printable by default} +@!halt_on_error_p:c_int_type; {stop at first error} +@z + +@x +@* \[4] String handling. +@y +@* \[4] String handling. +@z + +@x +|str_start[s]<=j=@"10000) then length:=str_start_macro(s+1)-str_start_macro(s) +else if (s>=@"20) and (s<@"7F) then length:=1 +else if (s<=@"7F) then length:=3 +else if (s<@"100) then length:=4 +else length:=8 +end; +@z + +@x +@d cur_length == (pool_ptr - str_start[str_ptr]) +@y +@d cur_length == (pool_ptr - str_start_macro(str_ptr)) +@z + +@x +incr(str_ptr); str_start[str_ptr]:=pool_ptr; +@y +incr(str_ptr); str_start_macro(str_ptr):=pool_ptr; +@z + +@x +@d flush_string==begin decr(str_ptr); pool_ptr:=str_start[str_ptr]; +@y +@d flush_string==begin decr(str_ptr); pool_ptr:=str_start_macro(str_ptr); +@z + +@x +begin j:=str_start[s]; +while jstr_pool[k] then goto not_found; + incr(j); incr(k); +@y +if (length(s)=1) then begin + if s<65536 then begin + if t<65536 then begin + if s<>t then goto not_found; + end + else begin + if s<>str_pool[str_start_macro(t)] then goto not_found; + end; + end + else begin + if t<65536 then begin + if str_pool[str_start_macro(s)]<>t then goto not_found; + end + else begin + if str_pool[str_start_macro(s)]<>str_pool[str_start_macro(t)] then + goto not_found; + end; + end; + end +else begin + j:=str_start_macro(s); k:=str_start_macro(t); + while jstr_pool[k] then goto not_found; + incr(j); incr(k); + end; +@z + +@x +begin pool_ptr:=0; str_ptr:=0; str_start[0]:=0; +@y +begin pool_ptr:=0; str_ptr:=0; {str_start_macro(0):=0;} +@z + +@x +@ @d app_lc_hex(#)==l:=#; + if l<10 then append_char(l+"0")@+else append_char(l-10+"a") +@y +@ The first 65536 strings will consist of a single character only. +But we don't actually make them; they're simulated on the fly. +@z + +@x +for k:=0 to 255 do + begin if (@) then + begin append_char("^"); append_char("^"); + if k<@'100 then append_char(k+@'100) + else if k<@'200 then append_char(k-@'100) + else begin app_lc_hex(k div 16); app_lc_hex(k mod 16); + end; + end + else append_char(k); + g:=make_string; + end +@y +begin +str_ptr:=too_big_char; +end +@z + +@x +@= + (k<" ")or(k>"~") +@y +@= +{ this module is not used } +@z + +@x +name_of_file := xmalloc_array (ASCII_code, name_length + 1); +@y +name_of_file := xmalloc_array (UTF8_code, name_length + 1); +@z + +@x +else begin if (xord[m]<"0")or(xord[m]>"9")or@| + (xord[n]<"0")or(xord[n]>"9") then +@y +else begin if (m<"0")or(m>"9")or@| + (n<"0")or(n>"9") then +@z + +@x + l:=xord[m]*10+xord[n]-"0"*11; {compute the length} +@y + l:=m*10+n-"0"*11; {compute the length} +@z + +@x + append_char(xord[m]); +@y + append_char(m); +@z + +@x +loop@+ begin if (xord[n]<"0")or(xord[n]>"9") then +@y +loop@+ begin if (n<"0")or(n>"9") then +@z + +@x + a:=10*a+xord[n]-"0"; +@y + a:=10*a+n-"0"; +@z + +@x +@* \[5] On-line and off-line printing. +@y +@* \[5] On-line and off-line printing. +@z + +@x +procedure print_char(@!s:ASCII_code); {prints a single character} +label exit; +begin if @ then + if selector= +procedure print_char(@!s:ASCII_code); {prints a single character} +label exit; +var l: small_number; +begin if (selector>pseudo) and (not doing_special) then {"printing" to a new string, don't encode chars} + begin print_visible_char(s); return; + end; +if @ then + if selector= 128: encode as UTF8 } + if s<@"800 then begin + print_visible_char(@"C0 + s div @"40); + print_visible_char(@"80 + s mod @"40); + end + else begin + print_visible_char(@"E0 + s div @"1000); + print_visible_char(@"80 + (s mod @"1000) div @"40); + print_visible_char(@"80 + (s mod @"1000) mod @"40); + end +end; +exit:end; + +@ @= +doing_special: boolean; + +@ @= +doing_special:=false; +@z + +@x +procedure print(@!s:integer); {prints string |s|} +label exit; +var j:pool_pointer; {current character code position} +@!nl:integer; {new-line character to restore} +begin if s>=str_ptr then s:="???" {this can't happen} +@.???@> +else if s<256 then + if s<0 then s:="???" {can't happen} + else begin if (selector>pseudo) and (not special_printing) + and (not message_printing) then + begin print_char(s); return; {internal strings are not expanded} + end; + if (@) then + if selector0) and (not no_convert) and (mubyte_write[s]>0) then + s := mubyte_write[s] + else if xprn[s] or special_printing then + begin print_char(s); no_convert := false; return; end; + no_convert := false; + nl:=new_line_char; new_line_char:=-1; + {temporarily disable new-line character} + j:=str_start[s]; + while j=str_ptr then s:="???" {this can't happen} +@.???@> +else if spseudo then + begin print_char(s); return; {internal strings are not expanded} + end; + if (@) then + if selector= +procedure slow_print(@!s:integer); {prints string |s|} +var j:pool_pointer; {current character code position} +begin if (s>=str_ptr) or (s<256) then print(s) +else begin j:=str_start[s]; + while j; +if c>=0 then if c<256 then print(c); +@y +begin @; +if c>=0 then if c<=biggest_char then print_char(c); +@z + +@x +begin j:=str_start["m2d5c2l5x2v5i"]; v:=1000; +@y +begin j:=str_start_macro("m2d5c2l5x2v5i"); v:=1000; +@z + +@x +@p procedure print_current_string; {prints a yet-unmade string} +var j:pool_pointer; {points to current character code} +begin j:=str_start[str_ptr]; +@y +@p procedure print_current_string; {prints a yet-unmade string} +var j:pool_pointer; {points to current character code} +begin j:=str_start_macro(str_ptr); +@z + +@x +k:=first; while k < last do begin print_buffer(k) end; +@y +if last<>first then for k:=first to last-1 do print(buffer[k]); +@z + +@x +@* \[6] Reporting errors. +@y +@* \[6] Reporting errors. +@z + +@x + begin edit_name_start:=str_start[edit_file.name_field]; + edit_name_length:=str_start[edit_file.name_field+1] - + str_start[edit_file.name_field]; +@y + begin edit_name_start:=str_start_macro(edit_file.name_field); + edit_name_length:=str_start_macro(edit_file.name_field+1) - + str_start_macro(edit_file.name_field); +@z + +@x +@* \[7] Arithmetic with scaled dimensions. +@y +@* \[7] Arithmetic with scaled dimensions. +@z + +@x +@* \[8] Packed data. +@y +@* \[8] Packed data. +@z + +@x +@d min_quarterword=0 {smallest allowable value in a |quarterword|} +@d max_quarterword=255 {largest allowable value in a |quarterword|} +@d min_halfword==-@"FFFFFFF {smallest allowable value in a |halfword|} +@d max_halfword==@"FFFFFFF {largest allowable value in a |halfword|} +@y +@d min_quarterword=0 {smallest allowable value in a |quarterword|} +@d max_quarterword=@"FFFF {largest allowable value in a |quarterword|} +@d min_halfword==-@"FFFFFFF {smallest allowable value in a |halfword|} +@d max_halfword==@"3FFFFFFF {largest allowable value in a |halfword|} +@z + +@x +if (min_quarterword>0)or(max_quarterword<127) then bad:=11; +if (min_halfword>0)or(max_halfword<32767) then bad:=12; +@y +if (min_quarterword>0)or(max_quarterword<@"7FFF) then bad:=11; +if (min_halfword>0)or(max_halfword<@"3FFFFFFF) then bad:=12; +@z + +@x +if max_quarterword-min_quarterword<255 then bad:=19; +@y +if max_quarterword-min_quarterword<@"FFFF then bad:=19; +@z + +@x +@* \[9] Dynamic memory allocation. +@y +@* \[9] Dynamic memory allocation. +@z + +@x +@* \[10] Data structures for boxes and their friends. +@y +@* \[10] Data structures for boxes and their friends. +@z + +@x +@d whatsit_node=8 {|type| of special extension nodes} +@y +@d whatsit_node=8 {|type| of special extension nodes} + +{ added stuff here for native_word and picture nodes } +@d native_word_node=40 {|subtype| in whatsits that hold native_font words + (0-3 are used for open, write, close, special; 4 is language; pdfTeX uses up through 30-something) + +To support ``native'' fonts, we build |native_word_nodes|, which are variable size whatsits. +These have the same |width|, |depth|, and |height| fields as a |box_node|, at offsets 1-3, +and then a word containing a size field for the node, a font number, and a length. +Then there is a field containing two halfwords, a glyph count and a C pointer to a glyph info array; +these are set by |set_native_metrics|. Copying and freeing of these nodes needs to take account of this! +This is followed by |length| bytes, for the actual characters of the string. +(Yes, we count in bytes, even though what we store there is UTF-16.) + +So |native_node_size|, which does not include any space for the actual text, is 6.} + +@d deleted_native_node=41 {native words that have been superseded by their successors} + +@d native_node_size=6 {size of a native_word node (plus the actual chars) -- see also xetex.h} +@d native_size(#)==mem[#+4].hh.b0 +@d native_font(#)==mem[#+4].hh.b1 +@d native_length(#)==mem[#+4].hh.rh +@d native_glyph_count(#)==mem[#+5].hh.lh +@d native_glyph_info_ptr(#)==mem[#+5].hh.rh +@d native_glyph_info_size=10 { number of bytes of info per glyph: 16-bit glyph ID, 32-bit x and y coords } + +@d free_native_glyph_info(#) == + begin + if native_glyph_info_ptr(#) <> 0 then begin + libc_free(cast_to_ptr(native_glyph_info_ptr(#))); + native_glyph_info_ptr(#) := 0; + native_glyph_count(#) := 0; + end + end + +@p procedure copy_native_glyph_info(src:pointer; dest:pointer); +var glyph_count:integer; +begin + if native_glyph_info_ptr(src) <> 0 then begin + glyph_count := native_glyph_count(src); + native_glyph_info_ptr(dest) := cast_to_integer(xmalloc_array(char, glyph_count * native_glyph_info_size)); + memcpy(cast_to_ptr(native_glyph_info_ptr(dest)), cast_to_ptr(native_glyph_info_ptr(src)), glyph_count * native_glyph_info_size); + native_glyph_count(dest) := glyph_count; + end +end; + +@ There are also |glyph_nodes|; these are like |native_word_nodes| in having |width|, |depth|, and |height| fields, +but then they contain a glyph ID rather than size and length fields, and there's no subsidiary C pointer. + +@d glyph_node_size=5 +@d native_glyph==native_length {in |glyph_node|s, we store the glyph number here} + +@d pic_node=42 {|subtype| in whatsits that hold picture file references} +@d pdf_node=43 {|subtype| in whatsits that hold PDF page references} +@d glyph_node=44 {|subtype| in whatsits that hold glyph numbers} + +@d pdfbox_crop = 1 { |pic_box_type| values in PDF nodes } +@d pdfbox_media = 2 +@d pdfbox_bleed = 3 +@d pdfbox_trim = 4 +@d pdfbox_art = 5 + + +{Picture files are handled with nodes that include fields for the transform associated +with the picture, and a pathname for the picture file itself. +They also have +the |width|, |depth|, and |height| fields of a |box_node| at offsets 1-3. (|depth| will +always be zero, as it happens.) + +So |pic_node_size|, which does not include any space for the picture file pathname, is 7. + +pdf_nodes are just like pic_nodes, but generate a different xdv file code.} + +@d pic_node_size=8 { must sync with xetex.h } +@d pic_path_length(#)==mem[#+4].hh.b0 +@d pic_page(#)==mem[#+4].hh.b1 +@d pic_box_type(#)==mem[#+4].hh.rh { for PDF, unused in picfile } +@d pic_transform1(#)==mem[#+5].hh.lh +@d pic_transform2(#)==mem[#+5].hh.rh +@d pic_transform3(#)==mem[#+6].hh.lh +@d pic_transform4(#)==mem[#+6].hh.rh +@d pic_transform5(#)==mem[#+7].hh.lh +@d pic_transform6(#)==mem[#+7].hh.rh +@z + +@x +@* \[11] Memory layout. +@y +@* \[11] Memory layout. +@z + +@x +@* \[12] Displaying boxes. +@y +@* \[12] Displaying boxes. +@z + +@x +@ @= +case type(p) of +hlist_node,vlist_node,ins_node,whatsit_node,mark_node,adjust_node, + unset_node: print("[]"); +@y +@ @= +case type(p) of +hlist_node,vlist_node,ins_node,mark_node,adjust_node, + unset_node: print("[]"); +whatsit_node: if subtype(p)=native_word_node then 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 else + print("[]"); +@z + +@x +@p procedure show_node_list(@!p:integer); {prints a node list symbolically} +label exit; +var n:integer; {the number of items already printed at this level} +@y +@p procedure show_node_list(@!p:integer); {prints a node list symbolically} +label exit; +var n:integer; {the number of items already printed at this level} +i:integer; {temp index for printing chars of picfile paths} +@z + +@x +@* \[15] The command codes. +@y +@* \[15] The command codes. +@z + +@x +@d math_given=69 {math code defined by \.{\\mathchardef}} +@d last_item=70 {most recent item ( \.{\\lastpenalty}, + \.{\\lastkern}, \.{\\lastskip} )} +@d max_non_prefixed_command=70 {largest command code that can't be \.{\\global}} + +@ The next codes are special; they all relate to mode-independent +assignment of values to \TeX's internal registers or tables. +Codes that are |max_internal| or less represent internal quantities +that might be expanded by `\.{\\the}'. + +@d toks_register=71 {token list register ( \.{\\toks} )} +@d assign_toks=72 {special token list ( \.{\\output}, \.{\\everypar}, etc.~)} +@d assign_int=73 {user-defined integer ( \.{\\tolerance}, \.{\\day}, etc.~)} +@d assign_dimen=74 {user-defined length ( \.{\\hsize}, etc.~)} +@d assign_glue=75 {user-defined glue ( \.{\\baselineskip}, etc.~)} +@d assign_mu_glue=76 {user-defined muglue ( \.{\\thinmuskip}, etc.~)} +@d assign_font_dimen=77 {user-defined font dimension ( \.{\\fontdimen} )} +@d assign_font_int=78 {user-defined font integer ( \.{\\hyphenchar}, + \.{\\skewchar} )} +@d set_aux=79 {specify state info ( \.{\\spacefactor}, \.{\\prevdepth} )} +@d set_prev_graf=80 {specify state info ( \.{\\prevgraf} )} +@d set_page_dimen=81 {specify state info ( \.{\\pagegoal}, etc.~)} +@d set_page_int=82 {specify state info ( \.{\\deadcycles}, + \.{\\insertpenalties} )} + {( or \.{\\interactionmode} )} +@d set_box_dimen=83 {change dimension of box ( \.{\\wd}, \.{\\ht}, \.{\\dp} )} +@d set_shape=84 {specify fancy paragraph shape ( \.{\\parshape} )} + {(or \.{\\interlinepenalties}, etc.~)} +@d def_code=85 {define a character code ( \.{\\catcode}, etc.~)} +@d def_family=86 {declare math fonts ( \.{\\textfont}, etc.~)} +@d set_font=87 {set current font ( font identifiers )} +@d def_font=88 {define a font file ( \.{\\font} )} +@d register=89 {internal register ( \.{\\count}, \.{\\dimen}, etc.~)} +@d max_internal=89 {the largest code that can follow \.{\\the}} +@d advance=90 {advance a register or parameter ( \.{\\advance} )} +@d multiply=91 {multiply a register or parameter ( \.{\\multiply} )} +@d divide=92 {divide a register or parameter ( \.{\\divide} )} +@d prefix=93 {qualify a definition ( \.{\\global}, \.{\\long}, \.{\\outer} )} + {( or \.{\\protected} )} +@d let=94 {assign a command code ( \.{\\let}, \.{\\futurelet} )} +@d shorthand_def=95 {code definition ( \.{\\chardef}, \.{\\countdef}, etc.~)} + {or \.{\\charsubdef}} +@d read_to_cs=96 {read into a control sequence ( \.{\\read} )} + {( or \.{\\readline} )} +@d def=97 {macro definition ( \.{\\def}, \.{\\gdef}, \.{\\xdef}, \.{\\edef} )} +@d set_box=98 {set a box ( \.{\\setbox} )} +@d hyph_data=99 {hyphenation data ( \.{\\hyphenation}, \.{\\patterns} )} +@d set_interaction=100 {define level of interaction ( \.{\\batchmode}, etc.~)} +@d max_command=100 {the largest command code seen at |big_switch|} +@y +@d math_given=69 {math code defined by \.{\\mathchardef}} +@d XeTeX_math_given=70 +@d last_item=71 {most recent item ( \.{\\lastpenalty}, + \.{\\lastkern}, \.{\\lastskip} )} +@d max_non_prefixed_command=71 {largest command code that can't be \.{\\global}} + +@ The next codes are special; they all relate to mode-independent +assignment of values to \TeX's internal registers or tables. +Codes that are |max_internal| or less represent internal quantities +that might be expanded by `\.{\\the}'. + +@d toks_register=72 {token list register ( \.{\\toks} )} +@d assign_toks=73 {special token list ( \.{\\output}, \.{\\everypar}, etc.~)} +@d assign_int=74 {user-defined integer ( \.{\\tolerance}, \.{\\day}, etc.~)} +@d assign_dimen=75 {user-defined length ( \.{\\hsize}, etc.~)} +@d assign_glue=76 {user-defined glue ( \.{\\baselineskip}, etc.~)} +@d assign_mu_glue=77 {user-defined muglue ( \.{\\thinmuskip}, etc.~)} +@d assign_font_dimen=78 {user-defined font dimension ( \.{\\fontdimen} )} +@d assign_font_int=79 {user-defined font integer ( \.{\\hyphenchar}, + \.{\\skewchar} )} +@d set_aux=80 {specify state info ( \.{\\spacefactor}, \.{\\prevdepth} )} +@d set_prev_graf=81 {specify state info ( \.{\\prevgraf} )} +@d set_page_dimen=82 {specify state info ( \.{\\pagegoal}, etc.~)} +@d set_page_int=83 {specify state info ( \.{\\deadcycles}, + \.{\\insertpenalties} )} + {( or \.{\\interactionmode} )} +@d set_box_dimen=84 {change dimension of box ( \.{\\wd}, \.{\\ht}, \.{\\dp} )} +@d set_shape=85 {specify fancy paragraph shape ( \.{\\parshape} )} + {(or \.{\\interlinepenalties}, etc.~)} +@d def_code=86 {define a character code ( \.{\\catcode}, etc.~)} +@d XeTeX_def_code=87 {\.{\\XeTeXmathcode}, \.{\\XeTeXdelcode}} +@d def_family=88 {declare math fonts ( \.{\\textfont}, etc.~)} +@d set_font=89 {set current font ( font identifiers )} +@d def_font=90 {define a font file ( \.{\\font} )} +@d register=91 {internal register ( \.{\\count}, \.{\\dimen}, etc.~)} +@d max_internal=91 {the largest code that can follow \.{\\the}} +@d advance=92 {advance a register or parameter ( \.{\\advance} )} +@d multiply=93 {multiply a register or parameter ( \.{\\multiply} )} +@d divide=94 {divide a register or parameter ( \.{\\divide} )} +@d prefix=95 {qualify a definition ( \.{\\global}, \.{\\long}, \.{\\outer} )} + {( or \.{\\protected} )} +@d let=96 {assign a command code ( \.{\\let}, \.{\\futurelet} )} +@d shorthand_def=97 {code definition ( \.{\\chardef}, \.{\\countdef}, etc.~)} + {or \.{\\charsubdef}} +@d read_to_cs=98 {read into a control sequence ( \.{\\read} )} + {( or \.{\\readline} )} +@d def=99 {macro definition ( \.{\\def}, \.{\\gdef}, \.{\\xdef}, \.{\\edef} )} +@d set_box=100 {set a box ( \.{\\setbox} )} +@d hyph_data=101 {hyphenation data ( \.{\\hyphenation}, \.{\\patterns} )} +@d set_interaction=102 {define level of interaction ( \.{\\batchmode}, etc.~)} +@d max_command=102 {the largest command code seen at |big_switch|} +@z + +@x +@* \[17] The table of equivalents. +@y +@* \[17] The table of equivalents. +@z + +@x +In the first region we have 256 equivalents for ``active characters'' that +act as control sequences, followed by 256 equivalents for single-character +control sequences. +@y +In the first region we have |number_chars| equivalents for ``active characters'' +that act as control sequences, followed by |number_chars| equivalents for +single-character control sequences. +@z + +@x +@d single_base=active_base+256 {equivalents of one-character control sequences} +@d null_cs=single_base+256 {equivalent of \.{\\csname\\endcsname}} +@y +@d single_base=active_base+number_chars + {equivalents of one-character control sequences} +@d null_cs=single_base+number_chars {equivalent of \.{\\csname\\endcsname}} +@z + +@x +@ Region 3 of |eqtb| contains the 256 \.{\\skip} registers, as well as the +glue parameters defined here. It is important that the ``muskip'' +parameters have larger numbers than the others. +@y +@ Region 3 of |eqtb| contains the |number_regs| \.{\\skip} registers, +as well as the glue parameters defined here. It is important that the +``muskip'' parameters have larger numbers than the others. +@z + +@x +@d par_fill_skip_code=14 {glue on last line of paragraph} +@d thin_mu_skip_code=15 {thin space in math formula} +@d med_mu_skip_code=16 {medium space in math formula} +@d thick_mu_skip_code=17 {thick space in math formula} +@d glue_pars=18 {total number of glue parameters} +@y +@d par_fill_skip_code=14 {glue on last line of paragraph} +@d XeTeX_linebreak_skip_code=15 {glue introduced at potential linebreak location} +@d thin_mu_skip_code=16 {thin space in math formula} +@d med_mu_skip_code=17 {medium space in math formula} +@d thick_mu_skip_code=18 {thick space in math formula} +@d glue_pars=19 {total number of glue parameters} +@z + +@x +@d skip_base=glue_base+glue_pars {table of 256 ``skip'' registers} +@d mu_skip_base=skip_base+256 {table of 256 ``muskip'' registers} +@d local_base=mu_skip_base+256 {beginning of region 4} +@y +@d skip_base=glue_base+glue_pars {table of |number_regs| ``skip'' registers} +@d mu_skip_base=skip_base+number_regs + {table of |number_regs| ``muskip'' registers} +@d local_base=mu_skip_base+number_regs {beginning of region 4} +@z + +@x +@d par_fill_skip==glue_par(par_fill_skip_code) +@y +@d par_fill_skip==glue_par(par_fill_skip_code) +@d XeTeX_linebreak_skip==glue_par(XeTeX_linebreak_skip_code) +@z + +@x +par_fill_skip_code: print_esc("parfillskip"); +@y +par_fill_skip_code: print_esc("parfillskip"); +XeTeX_linebreak_skip_code: print_esc("XeTeXlinebreakskip"); +@z + +@x +primitive("parfillskip",assign_glue,glue_base+par_fill_skip_code);@/ +@!@:par_fill_skip_}{\.{\\parfillskip} primitive@> +@y +primitive("parfillskip",assign_glue,glue_base+par_fill_skip_code);@/ +@!@:par_fill_skip_}{\.{\\parfillskip} primitive@> +primitive("XeTeXlinebreakskip",assign_glue,glue_base+XeTeX_linebreak_skip_code);@/ +@z + +@x +@d toks_base=etex_toks {table of 256 token list registers} +@# +@d etex_pen_base=toks_base+256 {start of table of \eTeX's penalties} +@d inter_line_penalties_loc=etex_pen_base {additional penalties between lines} +@d club_penalties_loc=etex_pen_base+1 {penalties for creating club lines} +@d widow_penalties_loc=etex_pen_base+2 {penalties for creating widow lines} +@d display_widow_penalties_loc=etex_pen_base+3 {ditto, just before a display} +@d etex_pens=etex_pen_base+4 {end of table of \eTeX's penalties} +@# +@d box_base=etex_pens {table of 256 box registers} +@d cur_font_loc=box_base+256 {internal font number outside math mode} +@d xord_code_base=cur_font_loc+1 +@d xchr_code_base=xord_code_base+1 +@d xprn_code_base=xchr_code_base+1 +@d math_font_base=xprn_code_base+1 +@d cat_code_base=math_font_base+48 + {table of 256 command codes (the ``catcodes'')} +@d lc_code_base=cat_code_base+256 {table of 256 lowercase mappings} +@d uc_code_base=lc_code_base+256 {table of 256 uppercase mappings} +@d sf_code_base=uc_code_base+256 {table of 256 spacefactor mappings} +@d math_code_base=sf_code_base+256 {table of 256 math mode mappings} +@d char_sub_code_base=math_code_base+256 {table of character substitutions} +@d int_base=char_sub_code_base+256 {beginning of region 5} +@y +@d toks_base=etex_toks {table of number_regs token list registers} +@# +@d etex_pen_base=toks_base+number_regs {start of table of \eTeX's penalties} +@d inter_line_penalties_loc=etex_pen_base {additional penalties between lines} +@d club_penalties_loc=etex_pen_base+1 {penalties for creating club lines} +@d widow_penalties_loc=etex_pen_base+2 {penalties for creating widow lines} +@d display_widow_penalties_loc=etex_pen_base+3 {ditto, just before a display} +@d etex_pens=etex_pen_base+4 {end of table of \eTeX's penalties} +@# +@d box_base=etex_pens {table of number_regs box registers} +@d cur_font_loc=box_base+number_regs {internal font number outside math mode} +@d xord_code_base=cur_font_loc+1 +@d xchr_code_base=xord_code_base+1 +@d xprn_code_base=xchr_code_base+1 +@d math_font_base=xprn_code_base+1 +@d cat_code_base=math_font_base+number_math_fonts + {table of number_chars command codes (the ``catcodes'')} +@d lc_code_base=cat_code_base+number_chars {table of number_chars lowercase mappings} +@d uc_code_base=lc_code_base+number_chars {table of number_chars uppercase mappings} +@d sf_code_base=uc_code_base+number_chars {table of number_chars spacefactor mappings} +@d math_code_base=sf_code_base+number_chars {table of number_chars math mode mappings} +@d char_sub_code_base=math_code_base+number_chars {table of character substitutions} +@d int_base=char_sub_code_base+number_chars {beginning of region 5} +@z + +@x +@d var_code==@'70000 {math code meaning ``use the current family''} +@y +@d var_fam_class = 7 +@d active_math_char = @"1FFFFF +@d is_active_math_char(#) == math_char_field(#) = active_math_char +@d is_var_family(#) == math_class_field(#) = 7 +@z + +@x +for k:=output_routine_loc to toks_base+255 do +@y +for k:=output_routine_loc to toks_base+number_regs-1 do +@z + +@x +for k:=box_base+1 to box_base+255 do eqtb[k]:=eqtb[box_base]; +@y +for k:=box_base+1 to box_base+number_regs-1 do eqtb[k]:=eqtb[box_base]; +@z + +@x +for k:=math_font_base to math_font_base+47 do eqtb[k]:=eqtb[cur_font_loc]; +@y +for k:=math_font_base to math_font_base+number_math_fonts-1 do eqtb[k]:=eqtb[cur_font_loc]; +@z + +@x +for k:=0 to 255 do +@y +for k:=0 to number_chars-1 do +@z + +@x +for k:="0" to "9" do math_code(k):=hi(k+var_code); +@y +for k:="0" to "9" do math_code(k):=hi(k + set_class_field(var_fam_class)); +@z + +@x + math_code(k):=hi(k+var_code+@"100); + math_code(k+"a"-"A"):=hi(k+"a"-"A"+var_code+@"100);@/ +@y + math_code(k) := hi(k + set_family_field(1) + set_class_field(var_fam_class)); + math_code(k+"a"-"A") := hi(k+"a"-"A" + set_family_field(1) + set_class_field(var_fam_class));@/ +@z + +@x +begin if n=cur_font_loc then print("current font") +else if n= +xetex_del_code_base:integer; { a hack, because WEB defined constants don't make it through to C } + +@ @= +xetex_del_code_base:=del_code_base; + +@ New sections slipped in above here. +@z + +@x +error_context_lines_code:print_esc("errorcontextlines"); +@y +error_context_lines_code:print_esc("errorcontextlines"); +{XeTeX_linebreak_locale_code:print_esc("XeTeXlinebreaklocale");} +XeTeX_linebreak_penalty_code:print_esc("XeTeXlinebreakpenalty"); +@z + +@x +primitive("errorcontextlines",assign_int,int_base+error_context_lines_code);@/ +@!@:error_context_lines_}{\.{\\errorcontextlines} primitive@> +@y +primitive("errorcontextlines",assign_int,int_base+error_context_lines_code);@/ +@!@:error_context_lines_}{\.{\\errorcontextlines} primitive@> +primitive("XeTeXlinebreakpenalty",assign_int,int_base+XeTeX_linebreak_penalty_code);@/ +@z + +@x +for k:=0 to 255 do del_code(k):=-1; +del_code("."):=0; {this null delimiter is used in error recovery} +@y +for k:=0 to number_chars-1 do del_code(k):=-1; +del_code("."):=0; {this null delimiter is used in error recovery} +set_del_code1(".",0); +@z + +@x +@ The final region of |eqtb| contains the dimension parameters defined +here, and the 256 \.{\\dimen} registers. +@y +@ The final region of |eqtb| contains the dimension parameters defined +here, and the |number_regs| \.{\\dimen} registers. +@z + +@x +@d emergency_stretch_code=20 {reduces badnesses on final pass of line-breaking} +@d dimen_pars=21 {total number of dimension parameters} +@y +@d emergency_stretch_code=20 {reduces badnesses on final pass of line-breaking} +@d pdf_page_width_code=21 {page width of the PDF output} +@d pdf_page_height_code=22 {page height of the PDF output} +@d dimen_pars=23 {total number of dimension parameters} +@z + +@x +@d scaled_base=dimen_base+dimen_pars + {table of 256 user-defined \.{\\dimen} registers} +@d eqtb_size=scaled_base+255 {largest subscript of |eqtb|} +@y +@d scaled_base=dimen_base+dimen_pars + {table of |number_regs| user-defined \.{\\dimen} registers} +@d eqtb_size=scaled_base+biggest_reg {largest subscript of |eqtb|} +@z + +@x +@d emergency_stretch==dimen_par(emergency_stretch_code) +@y +@d emergency_stretch==dimen_par(emergency_stretch_code) +@d pdf_page_width == dimen_par(pdf_page_width_code) +@d pdf_page_height == dimen_par(pdf_page_height_code) +@z + +@x +emergency_stretch_code:print_esc("emergencystretch"); +@y +emergency_stretch_code:print_esc("emergencystretch"); +pdf_page_width_code: print_esc("pdfpagewidth"); +pdf_page_height_code: print_esc("pdfpageheight"); +@z + +@x +primitive("emergencystretch",assign_dimen,dimen_base+emergency_stretch_code);@/ +@!@:emergency_stretch_}{\.{\\emergencystretch} primitive@> +@y +primitive("emergencystretch",assign_dimen,dimen_base+emergency_stretch_code);@/ +@!@:emergency_stretch_}{\.{\\emergencystretch} primitive@> + +primitive("pdfpagewidth",assign_dimen,dimen_base+pdf_page_width_code);@/ +@!@:pdf_page_width_}{\.{\\pdfpagewidth} primitive@> +primitive("pdfpageheight",assign_dimen,dimen_base+pdf_page_height_code);@/ +@!@:pdf_page_height_}{\.{\\pdfpageheight} primitive@> +@z + +@x +for q:=active_base to box_base+255 do +@y +for q:=active_base to box_base+biggest_reg do +@z + +@x +@* \[18] The hash table. +@y +@* \[18] The hash table. +@z + +@x +while pool_ptr>str_start[str_ptr] do +@y +while pool_ptr>str_start_macro(str_ptr) do +@z + +@x +The conversion from control sequence to byte sequence for enc\TeX is +implemented here. Of course, the simplest way is to implement an array +of string pointers with |hash_size| length, but we assume that only a +few control sequences will need to be converted. So |mubyte_cswrite|, +an array with only 128 items, is used. The items point to the token +lists. First token includes a csname number and the second points the +string to be output. The third token includes the number of another +csname and fourth token its pointer to the string etc. We need to do +the sequential searching in one of the 128 token lists. +@y +@z + +@x +else begin k:=str_start[s]; l:=str_start[s+1]-k; +@y +else begin k:=str_start_macro(s); l:=str_start_macro(s+1)-k; +@z + +@x +primitive("mathchar",math_char_num,0);@/ +@!@:math_char_}{\.{\\mathchar} primitive@> +@y +primitive("mathchar",math_char_num,0);@/ +primitive("XeTeXmathchar",math_char_num,1);@/ +primitive("XeTeXextmathchar",math_char_num,2);@/ +@!@:math_char_}{\.{\\mathchar} primitive@> +@z + +@x +primitive("relax",relax,256); {cf.\ |scan_file_name|} +@y +primitive("relax",relax,too_big_char); {cf.\ |scan_file_name|} +@z + +@x +end_cs_name: if chr_code = 10 then print_esc("endmubyte") + else print_esc("endcsname"); +@y +end_cs_name: print_esc("endcsname"); +@z + +@x +math_char_num: print_esc("mathchar"); +@y +math_char_num: if chr_code=2 then print_esc("XeTeXextmathchar") + else if chr_code=1 then print_esc("XeTeXmathchar") + else print_esc("mathchar"); +@z + +@x +@* \[19] Saving and restoring equivalents. +@y +@* \[19] Saving and restoring equivalents. +@z + +@x +@ The |eq_define| and |eq_word_define| routines take care of local definitions. +@y +@# +procedure eq_word_define1(@!p:pointer;@!w:integer); +label exit; +begin if eTeX_ex and(read_cint1(eqtb[p])=w) then + begin assign_trace(p,"reassigning")@;@/ + return; + end; +assign_trace(p,"changing")@;@/ +if xeq_level[p]<>cur_level then + begin eq_save(p,xeq_level[p]); xeq_level[p]:=cur_level; + end; +set_cint1(eqtb[p],w); +assign_trace(p,"into")@;@/ +exit:end; + +@ The |eq_define| and |eq_word_define| routines take care of local definitions. +@z + +@x +@ Subroutine |save_for_after| puts a token on the stack for save-keeping. +@y +@# +procedure geq_word_define1(@!p:pointer;@!w:integer); {global |eq_word_define1|} +begin assign_trace(p,"globally changing")@;@/ +begin set_cint1(eqtb[p],w); xeq_level[p]:=level_one; +end; +assign_trace(p,"into")@;@/ +end; + +@ Subroutine |save_for_after| puts a token on the stack for save-keeping. +@z + +@x +@* \[20] Token lists. +@y +@* \[20] Token lists. +@z + +@x +A \TeX\ token is either a character or a control sequence, and it is +@^token@> +represented internally in one of two ways: (1)~A character whose ASCII +code number is |c| and whose command code is |m| is represented as the +number $2^8m+c$; the command code is in the range |1<=m<=14|. (2)~A control +sequence whose |eqtb| address is |p| is represented as the number +|cs_token_flag+p|. Here |cs_token_flag=@t$2^{12}-1$@>| is larger than +$2^8m+c$, yet it is small enough that |cs_token_flag+p< max_halfword|; +thus, a token fits comfortably in a halfword. +@y +A \TeX\ token is either a character or a control sequence, and it is +@^token@> +represented internally in one of two ways: (1)~A character whose ASCII +code number is |c| and whose command code is |m| is represented as the +number $2^16m+c$; the command code is in the range |1<=m<=14|. (2)~A control +sequence whose |eqtb| address is |p| is represented as the number +|cs_token_flag+p|. Here |cs_token_flag=@t$2^{20}-1$@>| is larger than +$2^8m+c$, yet it is small enough that |cs_token_flag+p< max_halfword|; +thus, a token fits comfortably in a halfword. +@z + +@x +@d cs_token_flag==@'7777 {amount added to the |eqtb| location in a + token that stands for a control sequence; is a multiple of~256, less~1} +@d left_brace_token=@'0400 {$2^8\cdot|left_brace|$} +@d left_brace_limit=@'1000 {$2^8\cdot(|left_brace|+1)$} +@d right_brace_token=@'1000 {$2^8\cdot|right_brace|$} +@d right_brace_limit=@'1400 {$2^8\cdot(|right_brace|+1)$} +@d math_shift_token=@'1400 {$2^8\cdot|math_shift|$} +@d tab_token=@'2000 {$2^8\cdot|tab_mark|$} +@d out_param_token=@'2400 {$2^8\cdot|out_param|$} +@d space_token=@'5040 {$2^8\cdot|spacer|+|" "|$} +@d letter_token=@'5400 {$2^8\cdot|letter|$} +@d other_token=@'6000 {$2^8\cdot|other_char|$} +@d match_token=@'6400 {$2^8\cdot|match|$} +@d end_match_token=@'7000 {$2^8\cdot|end_match|$} +@d protected_token=@'7001 {$2^8\cdot|end_match|+1$} +@y +@d cs_token_flag=@"FFFFF {amount added to the |eqtb| location in a + token that stands for a control sequence; is a multiple of~65536, less~1} +@d max_char_val=@"10000 {to separate char and command code} +@d left_brace_token=@"10000 {$2^16\cdot|left_brace|$} +@d left_brace_limit=@"20000 {$2^16\cdot(|left_brace|+1)$} +@d right_brace_token=@"20000 {$2^16\cdot|right_brace|$} +@d right_brace_limit=@"30000 {$2^16\cdot(|right_brace|+1)$} +@d math_shift_token=@"30000 {$2^16\cdot|math_shift|$} +@d tab_token=@"40000 {$2^16\cdot|tab_mark|$} +@d out_param_token=@"50000 {$2^16\cdot|out_param|$} +@d space_token=@"A0020 {$2^16\cdot|spacer|+|" "|$} +@d letter_token=@"B0000 {$2^16\cdot|letter|$} +@d other_token=@"C0000 {$2^16\cdot|other_char|$} +@d match_token=@"D0000 {$2^16\cdot|match|$} +@d end_match_token=@"E0000 {$2^16\cdot|end_match|$} + +@d protected_token=end_match_token+1 {$2^8\cdot|end_match|+1$} +@z + +@x +else begin m:=info(p) div @'400; c:=info(p) mod @'400; +@y +else begin m:=info(p) div max_char_val; c:=info(p) mod max_char_val; +@z + +@x +@* \[21] Introduction to the syntactic routines. +@y +@* \[21] Introduction to the syntactic routines. +@z + +@x +procedure print_cmd_chr(@!cmd:quarterword;@!chr_code:halfword); +var n:integer; {temp variable} +@y +procedure print_cmd_chr(@!cmd:quarterword;@!chr_code:halfword); +var n:integer; {temp variable} +@!font_name_str:str_number; {local vars for \.{\\fontname} quoting extension} +@!quote_char:UTF16_code; +@z + +@x +@* \[22] Input stacks and states. +@y +@* \[22] Input stacks and states. +@z + +@x +@!input_file : ^alpha_file; +@y +@!input_file : ^unicode_file; +@z + +@x +for q:=p to first_count-1 do print_char(trick_buf[q mod error_line]); +print_ln; +for q:=1 to n do print_char(" "); {print |n| spaces to begin line~2} +if m+n<=error_line then p:=first_count+m else p:=first_count+(error_line-n-3); +for q:=first_count to p-1 do print_char(trick_buf[q mod error_line]); +@y +for q:=p to first_count-1 do print_visible_char(trick_buf[q mod error_line]); +print_ln; +for q:=1 to n do print_visible_char(" "); {print |n| spaces to begin line~2} +if m+n<=error_line then p:=first_count+m else p:=first_count+(error_line-n-3); +for q:=first_count to p-1 do print_visible_char(trick_buf[q mod error_line]); +@z + +@x +@* \[23] Maintaining the input stacks. +@y +@* \[23] Maintaining the input stacks. +@z + +@x +if name>17 then a_close(cur_file); {forget it} +@y +if name>17 then u_close(cur_file); {forget it} +@z + +@x +@* \[24] Getting the next token. +@y +@* \[24] Getting the next token. +@z + +@x +primitive("par",par_end,256); {cf. |scan_file_name|} +@y +primitive("par",par_end,too_big_char); {cf. |scan_file_name|} +@z + +@x +@!c,@!cc:ASCII_code; {constituents of a possible expanded code} +@!d:2..3; {number of excess characters in an expanded code} +@y +@!c,@!cc,@!ccc,@!cccc:ASCII_code; {constituents of a possible expanded code} +@!d:2..7; {number of excess characters in an expanded code} +@z + +@x +@d hex_to_cur_chr== + if c<="9" then cur_chr:=c-"0" @+else cur_chr:=c-"a"+10; + if cc<="9" then cur_chr:=16*cur_chr+cc-"0" + else cur_chr:=16*cur_chr+cc-"a"+10 +@y +@d hex_to_cur_chr== + if c<="9" then cur_chr:=c-"0" @+else cur_chr:=c-"a"+10; + if cc<="9" then cur_chr:=16*cur_chr+cc-"0" + else cur_chr:=16*cur_chr+cc-"a"+10 +@d long_hex_to_cur_chr== + if c<="9" then cur_chr:=c-"0" @+else cur_chr:=c-"a"+10; + if cc<="9" then cur_chr:=16*cur_chr+cc-"0" + else cur_chr:=16*cur_chr+cc-"a"+10; + if ccc<="9" then cur_chr:=16*cur_chr+ccc-"0" + else cur_chr:=16*cur_chr+ccc-"a"+10; + if cccc<="9" then cur_chr:=16*cur_chr+cccc-"0" + else cur_chr:=16*cur_chr+cccc-"a"+10 +@z + +@x + begin c:=buffer[loc+1]; @+if c<@'200 then {yes we have an expanded char} +@y + begin if (cur_chr=buffer[loc+1]) and (cur_chr=buffer[loc+2]) and + ((loc+6)<=limit) then + begin c:=buffer[loc+3]; cc:=buffer[loc+4]; + ccc:=buffer[loc+5]; cccc:=buffer[loc+6]; + if is_hex(c) and is_hex(cc) and is_hex(ccc) and is_hex(cccc) then + begin loc:=loc+7; long_hex_to_cur_chr; goto reswitch; + end; + end; + c:=buffer[loc+1]; @+if c<@'200 then {yes we have an expanded char} +@z + +@x +begin if buffer[k]=cur_chr then @+if cat=sup_mark then @+if k2 then + begin hex_to_cur_chr; buffer[k-1]:=cur_chr; + end + else if c<@'100 then buffer[k-1]:=c+@'100 + else buffer[k-1]:=c-@'100; + limit:=limit-d; first:=first-d; + while k<=limit do + begin buffer[k]:=buffer[k+d]; incr(k); + end; + goto start_cs; + end; + end; +end +@y +begin if buffer[k]=cur_chr then @+if cat=sup_mark then @+if k2 then + begin hex_to_cur_chr; buffer[k-1]:=cur_chr; + end + else if c<@'100 then buffer[k-1]:=c+@'100 + else buffer[k-1]:=c-@'100; + limit:=limit-d; first:=first-d; + while k<=limit do + begin buffer[k]:=buffer[k+d]; incr(k); + end; + goto start_cs; + end + end + end +end +@z + +@x + else begin cur_cmd:=t div @'400; cur_chr:=t mod @'400; +@y + else begin cur_cmd:=t div max_char_val; cur_chr:=t mod max_char_val; +@z + +@x +@d no_expand_flag=257 {this characterizes a special variant of |relax|} +@y +@d no_expand_flag=special_char {this characterizes a special variant of |relax|} +@z + +@x + k := start; + while k < limit do begin print_buffer(k) end; +@y + if startmatch_token+255)or(info(r)=end_match_token)or(info(r) + if (cur_cs=0)and@| + ((cur_chr=s)or(cur_chr=s-"a"+"A")) then + begin store_new_token(cur_tok); + flush_list(link(backup_head)); scan_keyword:=true; return; + end + else if (cur_cmd<>spacer)or(p<>backup_head) then + begin back_input; + if p<>backup_head then back_list(link(backup_head)); + scan_keyword:=false; return; + end; + end; + end; +k:=str_start_macro(s); +while k; +@y +def_code: @; +XeTeX_def_code: + begin + scan_char_num; + if m=math_code_base then begin + cur_val1:=ho(math_code(cur_val)); + scanned_result(cur_val1)(int_val) + end + else if m=math_code_base+1 then begin + print_err("Can't use \XeTeXextmathcode as a number"); + help2("\XeTeXextmathcode is for setting a mathcode from separate values;")@/ + ("use \XeTeXmathcode to access them as single values."); error; + scanned_result(0)(int_val) + end + else begin + scanned_result(-1)(int_val); { FIXME - XeTeXdelcode } + end; + end; +@z + +@x +if m=xord_code_base then scanned_result(xord[cur_val])(int_val) +else if m=xchr_code_base then scanned_result(xchr[cur_val])(int_val) +else if m=xprn_code_base then scanned_result(xprn[cur_val])(int_val) +else if m=math_code_base then scanned_result(ho(math_code(cur_val)))(int_val) +@y +if m=math_code_base then begin + cur_val1:=ho(math_code(cur_val)); + if (math_class_field(cur_val1)>8) or + (math_fam_field(cur_val1)>15) or + (math_char_field(cur_val1)>255) then + begin print_err("Extended mathchar used as mathchar"); +@.Bad mathchar@> + help2("A mathchar number must be between 0 and ""7FFF.")@/ + ("I changed this one to zero."); int_error(cur_val1); cur_val1:=0; + end; + cur_val1:=(math_class_field(cur_val1)*@"1000) + + (math_fam_field(cur_val1)*@"100) + + math_char_field(cur_val1); + scanned_result(cur_val1)(int_val) + end +else if m=del_code_base then begin + cur_val1:=del_code(cur_val); + if (math_class_field(cur_val1) > 8) or + (math_fam_field(cur_val1) > 15) or + (math_char_field(cur_val1) > 255) then begin + print_err("Extended delcode used as delcode"); +@.Bad delcode@> + help2("A delimiter code must be between 0 and ""7FFFFFF.")@/ + ("I changed this one to zero."); error; + scanned_result(0)(int_val); + end else begin + cur_val1:=del_code1(cur_val); + if (math_class_field(cur_val1) > 0) or + (math_fam_field(cur_val1) > 15) or + (math_char_field(cur_val1) > 255) then begin + print_err("Extended delcode used as delcode"); + help2("A delimiter code must be between 0 and ""7FFFFFF.")@/ + ("I changed this one to zero."); error; + scanned_result(0)(int_val); + end else begin + scanned_result(((math_class_field(del_code(cur_val))*@"1000) + + (math_fam_field(del_code(cur_val))*@"100) + + math_char_field(del_code(cur_val)))*@"1000 + + (math_fam_field(cur_val1)*@"100) + + math_char_field(cur_val1))(int_val); + end + end +end +@z + +@x +@d eTeX_dim=eTeX_int+8 {first of \eTeX\ codes for dimensions} +@y +@# +@d XeTeX_int=eTeX_int+8 {first of \XeTeX\ codes for integers} +@# +@d eTeX_dim=XeTeX_int+27 {first of \eTeX\ codes for dimensions} + {changed for \XeTeX\ to make room for \XeTeX\ integers} +@z + +@x +if (cur_val<0)or(cur_val>255) then +@y +if (cur_val<0)or(cur_val>biggest_reg) then +@z + +@x + help2("A register number must be between 0 and 255.")@/ +@y + help2("A register number must be between 0 and 65535.")@/ +@z + +@x +procedure scan_char_num; +begin scan_int; +if (cur_val<0)or(cur_val>255) then +@y +procedure scan_usv_num; +begin scan_int; +if (cur_val<0)or(cur_val>@"10FFFF) then + begin print_err("Bad USV code"); +@.Bad character code@> + help2("A Unicode Scalar Value must be between 0 and ""10FFFF.")@/ + ("I changed this one to zero."); int_error(cur_val); cur_val:=0; + end; +end; + +procedure scan_char_num; +begin scan_int; +if (cur_val<0)or(cur_val>biggest_char) then +@z + +@x + help2("A character number must be between 0 and 255.")@/ +@y + help2("A character number must be between 0 and 65535.")@/ +@z + +@x +procedure scan_four_bit_int; +@y +procedure scan_xetex_math_char_int; +begin scan_int; + if is_active_math_char(cur_val) then begin + if cur_val <> active_math_char then begin + print_err("Bad active XeTeX math code"); + help2("Since I ignore class and family for active math chars,")@/ + ("I changed this one to ""1FFFFF."); int_error(cur_val); + cur_val := active_math_char; + end + end else if math_char_field(cur_val) > @"10FFFF then begin + print_err("Bad XeTeX math character code"); + help2("Since I expected a character number between 0 and ""10FFFF,")@/ + ("I changed this one to zero."); int_error(cur_val); cur_val:=0; + end; +end; + +procedure scan_math_class_int; +begin scan_int; +if (cur_val<0)or(cur_val>7) then + begin print_err("Bad math class"); +@.Bad number@> + help2("Since I expected to read a number between 0 and 7,")@/ + ("I changed this one to zero."); int_error(cur_val); cur_val:=0; + end; +end; + +procedure scan_math_fam_int; +begin scan_int; +if (cur_val<0)or(cur_val>number_math_families-1) then + begin print_err("Bad math family"); +@.Bad number@> + help2("Since I expected to read a number between 0 and 255,")@/ + ("I changed this one to zero."); int_error(cur_val); cur_val:=0; + end; +end; + +procedure scan_four_bit_int; +@z + + x +procedure scan_fifteen_bit_int; +begin scan_int; +if (cur_val<0)or(cur_val>@'77777) then + begin print_err("Bad mathchar"); +@.Bad mathchar@> + help2("A mathchar number must be between 0 and 32767.")@/ + ("I changed this one to zero."); int_error(cur_val); cur_val:=0; + end; +end; + y +procedure scan_real_fifteen_bit_int; +begin scan_int; +if (cur_val<0)or(cur_val>@'77777) then + begin print_err("Bad mathchar"); +@.Bad mathchar@> + help2("A mathchar number must be between 0 and 32767.")@/ + ("I changed this one to zero."); int_error(cur_val); cur_val:=0; + end; +end; + +procedure scan_fifteen_bit_int; { scans a \mathchar value and expands it to 32-bit form } +begin scan_int; +if (cur_val<0)or(cur_val>@'77777) then + begin print_err("Bad mathchar"); +@.Bad mathchar@> + help2("A mathchar number must be between 0 and 32767.")@/ + ("I changed this one to zero."); int_error(cur_val); cur_val:=0; + end; +cur_val := set_class_field(cur_val div @"1000) + + set_family_field((cur_val mod @"1000) div @"100) + + (cur_val mod @"100); +end; + z + +@x +procedure scan_twenty_seven_bit_int; +begin scan_int; +if (cur_val<0)or(cur_val>@'777777777) then + begin print_err("Bad delimiter code"); +@.Bad delimiter code@> + help2("A numeric delimiter code must be between 0 and 2^{27}-1.")@/ + ("I changed this one to zero."); int_error(cur_val); cur_val:=0; + end; +end; +@y +procedure scan_delimiter_int; +begin scan_int; +if (cur_val<0)or(cur_val>@'777777777) then + begin print_err("Bad delimiter code"); +@.Bad delimiter code@> + help2("A numeric delimiter code must be between 0 and 2^{27}-1.")@/ + ("I changed this one to zero."); int_error(cur_val); cur_val:=0; + end; +cur_val1 := set_family_field((cur_val mod @"1000) div @"100) + + (cur_val mod @"100); +cur_val := cur_val div @"1000; +cur_val := set_family_field((cur_val mod @"1000) div @"100) + + set_class_field(cur_val div @"1000) + + (cur_val mod @"100); +end; +@z + +procedure scan_twenty_seven_bit_int; +begin scan_int; +if (cur_val<0)or(cur_val>@'777777777) then + begin print_err("Bad delimiter code"); +@.Bad delimiter code@> + help2("A numeric delimiter code must be between 0 and 2^{27}-1.")@/ + ("I changed this one to zero."); int_error(cur_val); cur_val:=0; + end; +cur_val1 := (((cur_val mod @"1000) div @"100) * @"10000) + + (cur_val mod @"100); +cur_val := cur_val div @"1000; +cur_val := ((cur_val div @"1000) * @"1000000) + + (((cur_val mod @"1000) div @"100) * @"10000) + + (cur_val mod @"100); +end; + z + +@x +if cur_val>255 then +@y +if cur_val>biggest_char then +@z + +@x +@p procedure scan_dimen(@!mu,@!inf,@!shortcut:boolean); +@y +@p procedure xetex_scan_dimen(@!mu,@!inf,@!shortcut,@!requires_units:boolean); +@z + +@x +@; +@; +@y +if requires_units then begin +@; +@; +end else begin + if cur_val>=@'40000 then arith_error:=true + else cur_val:=cur_val*unity+f; +end; +@z + +@x +@ @= +@y +procedure scan_dimen(@!mu,@!inf,@!shortcut:boolean); +begin + xetex_scan_dimen(mu,inf,shortcut,true); +end; + +@ For XeTeX, we have an additional version |scan_decimal|, like |scan_dimen| +but without any scanning of units. + +@p procedure scan_decimal; + {sets |cur_val| to a quantity expressed as a decimal fraction} +begin + xetex_scan_dimen(false, false, false, false); +end; + +@ @= +@z + +@x +@d etex_convert_base=5 {base for \eTeX's command codes} +@d eTeX_revision_code=etex_convert_base {command code for \.{\\eTeXrevision}} +@d etex_convert_codes=etex_convert_base+1 {end of \eTeX's command codes} +@y +@d etex_convert_base=5 {base for \eTeX's command codes} +@d eTeX_revision_code=etex_convert_base {command code for \.{\\eTeXrevision}} + +@d XeTeX_revision_code=6 +@d XeTeX_variation_name_code=7 { must match codes in xetexmac.c } +@d XeTeX_feature_name_code=8 +@d XeTeX_selector_name_code=9 + +@d etex_convert_codes=XeTeX_selector_name_code+1 {end of \eTeX's command codes} +@z + +@x + eTeX_revision_code: print_esc("eTeXrevision"); +@y + @/@@/ +@z + +@x +@!c:number_code..job_name_code; {desired type of conversion} +@y +@!c:small_number; {desired type of conversion} +@z + +@x +@!b:pool_pointer; {base of temporary string} +@y +@!b:pool_pointer; {base of temporary string} +@!fnt,@!arg1,@!arg2:integer; {args for \XeTeX\ extensions} +@!font_name_str:str_number; {local vars for \.{\\fontname} quoting extension} +@!i:small_number; +@!quote_char:UTF16_code; +@z + +@x +eTeX_revision_code: do_nothing; +@y +@/@@/ +@z + +@x +font_name_code: begin print(font_name[cur_val]); +@y +font_name_code: begin + font_name_str:=font_name[cur_val]; + if is_native_font(cur_val) then begin + quote_char:=""""; + for i:=0 to length(font_name_str) - 1 do + if str_pool[str_start_macro(font_name_str) + i] = """" then quote_char:="'"; + print_char(quote_char); + print(font_name_str); + print_char(quote_char); + end else + print(font_name_str); +@z + +@x +eTeX_revision_code: print(eTeX_revision); +@y +@/@@/ +@z + +@x +@!read_file:array[0..15] of alpha_file; {used for \.{\\read}} +@y +@!read_file:array[0..15] of unicode_file; {used for \.{\\read}} +@z + +@x +else begin a_close(read_file[m]); read_open[m]:=closed; +@y +else begin u_close(read_file[m]); read_open[m]:=closed; +@z + +@x + begin a_close(read_file[m]); read_open[m]:=closed; +@y + begin u_close(read_file[m]); read_open[m]:=closed; +@z + +@x +if (cur_cmd>active_char)or(cur_chr>255) then {not a character} + begin m:=relax; n:=256; +@y +if (cur_cmd>active_char)or(cur_chr>biggest_char) then {not a character} + begin m:=relax; n:=too_big_char; +@z + +@x +if (cur_cmd>active_char)or(cur_chr>255) then + begin cur_cmd:=relax; cur_chr:=256; +@y +if (cur_cmd>active_char)or(cur_chr>biggest_char) then + begin cur_cmd:=relax; cur_chr:=too_big_char; +@z + +@x +@* \[29] File names. +@y +@* \[29] File names. +@z + +@x +The following procedures don't allow spaces to be part of +file names; but some users seem to like names that are spaced-out. +System-dependent changes to allow such things should probably +be made with reluctance, and only when an entire file name that +includes spaces is ``quoted'' somehow. + +@y +@z + +@x +@!ext_delimiter:pool_pointer; {the most recent `\..', if any} +@y +@!ext_delimiter:pool_pointer; {the most recent `\..', if any} +@!file_name_quote_char:UTF16_code; +@z + +@x +begin area_delimiter:=0; ext_delimiter:=0; quoted_filename:=false; +@y +begin area_delimiter:=0; ext_delimiter:=0; +file_name_quote_char:=0; +@z + +@x +@p function more_name(@!c:ASCII_code):boolean; +begin if (c=" ") and stop_at_space and (not quoted_filename) then + more_name:=false +else if c="""" then begin + quoted_filename:=not quoted_filename; + more_name:=true; + end +else begin str_room(1); append_char(c); {contribute |c| to the current string} + if IS_DIR_SEP(c) then + begin area_delimiter:=cur_length; ext_delimiter:=0; + end + else if c="." then ext_delimiter:=cur_length; + more_name:=true; + end; +end; +@y +@p function more_name(@!c:ASCII_code):boolean; +begin if stop_at_space and (c=" ") then more_name:=false +else begin + if (cur_length=0) and stop_at_space + and ((c="'") or (c="""") or (c="(")) then begin + if c="(" then file_name_quote_char:=")" else file_name_quote_char:=c; + stop_at_space:=false; more_name:=true; + end + else if (file_name_quote_char<>0) and (c=file_name_quote_char) then begin + stop_at_space:=true; more_name:=false; + end + else begin + str_room(1); append_char(c); {contribute |c| to the current string} + if IS_DIR_SEP(c) then + begin area_delimiter:=cur_length; ext_delimiter:=0; + end + else if c="." then ext_delimiter:=cur_length; + more_name:=true; + end; +end; +end; +@z + +@x +@p procedure end_name; +var temp_str: str_number; {result of file name cache lookups} +@!j,@!s,@!t: pool_pointer; {running indices} +@!must_quote:boolean; {whether we need to quote a string} +begin if str_ptr+3>max_strings then + overflow("number of strings",max_strings-init_str_ptr); +@:TeX capacity exceeded number of strings}{\quad number of strings@> +str_room(6); {Room for quotes, if needed.} +{add quotes if needed} +if area_delimiter<>0 then begin + {maybe quote |cur_area|} + must_quote:=false; + s:=str_start[str_ptr]; + t:=str_start[str_ptr]+area_delimiter; + j:=s; + while (not must_quote) and (j<>t) do begin + must_quote:=str_pool[j]=" "; incr(j); + end; + if must_quote then begin + for j:=pool_ptr-1 downto t do str_pool[j+2]:=str_pool[j]; + str_pool[t+1]:=""""; + for j:=t-1 downto s do str_pool[j+1]:=str_pool[j]; + str_pool[s]:=""""; + if ext_delimiter<>0 then ext_delimiter:=ext_delimiter+2; + area_delimiter:=area_delimiter+2; + pool_ptr:=pool_ptr+2; + end; + end; +{maybe quote |cur_name|} +s:=str_start[str_ptr]+area_delimiter; +if ext_delimiter=0 then t:=pool_ptr else t:=str_start[str_ptr]+ext_delimiter-1; +must_quote:=false; +j:=s; +while (not must_quote) and (j<>t) do begin + must_quote:=str_pool[j]=" "; incr(j); + end; +if must_quote then begin + for j:=pool_ptr-1 downto t do str_pool[j+2]:=str_pool[j]; + str_pool[t+1]:=""""; + for j:=t-1 downto s do str_pool[j+1]:=str_pool[j]; + str_pool[s]:=""""; + if ext_delimiter<>0 then ext_delimiter:=ext_delimiter+2; + pool_ptr:=pool_ptr+2; + end; +if ext_delimiter<>0 then begin + {maybe quote |cur_ext|} + s:=str_start[str_ptr]+ext_delimiter-1; + t:=pool_ptr; + must_quote:=false; + j:=s; + while (not must_quote) and (j<>t) do begin + must_quote:=str_pool[j]=" "; incr(j); + end; + if must_quote then begin + str_pool[t+1]:=""""; + for j:=t-1 downto s do str_pool[j+1]:=str_pool[j]; + str_pool[s]:=""""; + pool_ptr:=pool_ptr+2; + end; + end; +@y +@p procedure end_name; +var temp_str: str_number; {result of file name cache lookups} +@!j: pool_pointer; {running index} +begin if str_ptr+3>max_strings then + overflow("number of strings",max_strings-init_str_ptr); +@:TeX capacity exceeded number of strings}{\quad number of strings@> +@z + +@x + str_start[str_ptr+1]:=str_start[str_ptr]+area_delimiter; incr(str_ptr); +@y + str_start_macro(str_ptr+1):=str_start_macro(str_ptr)+area_delimiter; incr(str_ptr); +@z + +@x + for j:=str_start[str_ptr+1] to pool_ptr-1 do +@y + for j:=str_start_macro(str_ptr+1) to pool_ptr-1 do +@z + +@x + str_start[str_ptr+1]:=str_start[str_ptr]+ext_delimiter-area_delimiter-1; +@y + str_start_macro(str_ptr+1):=str_start_macro(str_ptr)+ext_delimiter-area_delimiter-1; +@z + +@x + for j:=str_start[str_ptr+1] to pool_ptr-1 do +@y + for j:=str_start_macro(str_ptr+1) to pool_ptr-1 do +@z + +@x +procedure print_file_name(@!n,@!a,@!e:integer); +var must_quote: boolean; {whether to quote the filename} +@!j:pool_pointer; {index into |str_pool|} +begin +must_quote:=false; +if a<>0 then begin + j:=str_start[a]; + while (not must_quote) and (j<>str_start[a+1]) do begin + must_quote:=str_pool[j]=" "; incr(j); + end; +end; +if n<>0 then begin + j:=str_start[n]; + while (not must_quote) and (j<>str_start[n+1]) do begin + must_quote:=str_pool[j]=" "; incr(j); + end; +end; +if e<>0 then begin + j:=str_start[e]; + while (not must_quote) and (j<>str_start[e+1]) do begin + must_quote:=str_pool[j]=" "; incr(j); + end; +end; +{FIXME: Alternative is to assume that any filename that has to be quoted has + at least one quoted component...if we pick this, a number of insertions + of |print_file_name| should go away. +|must_quote|:=((|a|<>0)and(|str_pool|[|str_start|[|a|]]=""""))or + ((|n|<>0)and(|str_pool|[|str_start|[|n|]]=""""))or + ((|e|<>0)and(|str_pool|[|str_start|[|e|]]=""""));} +if must_quote then print_char(""""); +if a<>0 then + for j:=str_start[a] to str_start[a+1]-1 do + if so(str_pool[j])<>"""" then + print(so(str_pool[j])); +if n<>0 then + for j:=str_start[n] to str_start[n+1]-1 do + if so(str_pool[j])<>"""" then + print(so(str_pool[j])); +if e<>0 then + for j:=str_start[e] to str_start[e+1]-1 do + if so(str_pool[j])<>"""" then + print(so(str_pool[j])); +if must_quote then print_char(""""); +end; +@y +procedure print_file_name(@!n,@!a,@!e:integer); +begin slow_print(a); slow_print(n); slow_print(e); +end; +@z + +@x +@d append_to_name(#)==begin c:=#; if not (c="""") then begin incr(k); + if k<=file_name_size then name_of_file[k]:=xchr[c]; + end end +@y +@d append_to_name(#)==begin c:=#; incr(k); + if k<=file_name_size then begin + if (c < 128) then name_of_file[k]:=c + else if (c < @"800) then begin + name_of_file[k]:=@"C0 + c div @"40; incr(k); + name_of_file[k]:=@"80 + c mod @"40; + end else begin + name_of_file[k]:=@"E0 + c div @"1000; incr(k); + name_of_file[k]:=@"80 + (c mod @"1000) div @"40; incr(k); + name_of_file[k]:=@"80 + (c mod @"1000) mod @"40; + end + end + end +@z + +@x +name_of_file:= xmalloc_array (ASCII_code, length(a)+length(n)+length(e)+1); +for j:=str_start[a] to str_start[a+1]-1 do append_to_name(so(str_pool[j])); +for j:=str_start[n] to str_start[n+1]-1 do append_to_name(so(str_pool[j])); +for j:=str_start[e] to str_start[e+1]-1 do append_to_name(so(str_pool[j])); +@y +name_of_file:= xmalloc_array (UTF8_code, (length(a)+length(n)+length(e))*3+1); +for j:=str_start_macro(a) to str_start_macro(a+1)-1 do append_to_name(so(str_pool[j])); +for j:=str_start_macro(n) to str_start_macro(n+1)-1 do append_to_name(so(str_pool[j])); +for j:=str_start_macro(e) to str_start_macro(e+1)-1 do append_to_name(so(str_pool[j])); +@z + +@x +name_of_file := xmalloc_array (ASCII_code, n+(b-a+1)+format_ext_length+1); +for j:=1 to n do append_to_name(xord[TEX_format_default[j]]); +@y +name_of_file := xmalloc_array (UTF8_code, n+(b-a+1)+format_ext_length+1); +for j:=1 to n do append_to_name(TEX_format_default[j]); +@z + +@x + append_to_name(xord[TEX_format_default[j]]); +@y + append_to_name(TEX_format_default[j]); +@z + +@x +@p function make_name_string:str_number; +var k:1..file_name_size; {index into |name_of_file|} +begin if (pool_ptr+name_length>pool_size)or(str_ptr=max_strings)or + (cur_length>0) then + make_name_string:="?" +else begin for k:=1 to name_length do append_char(xord[name_of_file[k]]); + make_name_string:=make_string; + end; + {At this point we also set |cur_name|, |cur_ext|, and |cur_area| to + match the contents of |name_of_file|.} + k:=1; + name_in_progress:=true; + begin_name; + stop_at_space:=false; + while (k<=name_length)and(more_name(name_of_file[k])) do + incr(k); + stop_at_space:=true; + end_name; + name_in_progress:=false; +end; +@y +@p function make_name_string:str_number; +var k:1..file_name_size; {index into |name_of_file|} +begin if (pool_ptr+name_length>pool_size)or(str_ptr=max_strings)or + (cur_length>0) then + make_name_string:="?" +else begin + make_utf16_name; + for k:=0 to name_length16-1 do append_char(name_of_file16[k]); + make_name_string:=make_string; + end; +end; +function u_make_name_string(var f:unicode_file):str_number; +begin u_make_name_string:=make_name_string; +end; +@z + +@x +loop@+begin if (cur_cmd>other_char)or(cur_chr>255) then {not a character} +@y +loop@+begin if (cur_cmd>other_char)or(cur_chr>biggest_char) then + {not a character} +@z + +@x + {If |cur_chr| is a space and we're not scanning a token list, check + whether we're at the end of the buffer. Otherwise we end up adding + spurious spaces to file names in some cases.} + if (cur_chr=" ") and (state<>token_list) and (loc>limit) then goto done; +@y +@z + +@x + pack_job_name(".dvi"); + while not b_open_out(dvi_file) do + prompt_file_name("file name for output",".dvi"); +@y + pack_job_name(output_file_extension); + while not dvi_open_out(dvi_file) do + prompt_file_name("file name for output",output_file_extension); +@z + +@x +@!dvi_file: byte_file; {the device-independent output goes here} +@y +@!output_file_extension: str_number; +@!no_pdf_output: boolean; +@!dvi_file: byte_file; {the device-independent output goes here} +@z + +@x +@ @=output_file_name:=0; +@y +@ @= + output_file_name:=0; + if no_pdf_output then output_file_extension:=".xdv" + else output_file_extension:=".pdf"; +@z + +@x + if open_in_name_ok(stringcast(name_of_file+1)) + and a_open_in(cur_file, kpse_tex_format) then + goto done; +@y + if open_in_name_ok(stringcast(name_of_file+1)) + and u_open_in(cur_file, kpse_tex_format, XeTeX_default_input_mode, XeTeX_default_input_encoding) then + {At this point |name_of_file| contains the actual name found, as a UTF8 string. + We convert to UTF16, then extract the |cur_area|, |cur_name|, and |cur_ext| from it.} + begin + make_utf16_name; + name_in_progress:=true; + begin_name; + stop_at_space:=false; + k:=0; + while (k0 then begin + { quoted name, so try for a native font } + g:=load_native_font(u,nom,aire,s); + if g=null_font then goto bad_tfm else goto done; +end; +{ it was an unquoted name, so try for a TFM file } +@; +@y +if g<>null_font then goto done; +if file_name_quote_char=0 then begin + { we failed to find a TFM file, so try for a native font } + g:=load_native_font(u,nom,aire,s); + if g<>null_font then goto done +end; +bad_tfm: +if (not file_opened) and (file_name_quote_char<>0) then begin + @; +end; +@; +@z + +@x +@d start_font_error_message==print_err("Font "); sprint_cs(u); + print_char("="); print_file_name(nom,aire,""); +@y +@d start_font_error_message==print_err("Font "); sprint_cs(u); + print_char("="); + if file_name_quote_char=")" then print_char("(") + else if file_name_quote_char<>0 then print_char(file_name_quote_char); + print_file_name(nom,aire,cur_ext); + if file_name_quote_char<>0 then print_char(file_name_quote_char); +@z + +@x +else print(" not loadable: Metric (TFM) file not found"); +@y +else print(" not loadable: Metric (TFM) file or installed font not found"); +@z + +@x +@ @= +@; +@y +@ @= +start_font_error_message; +@.Font x=xx not loadable...@> +print(" not loadable: installed font not found"); +help4("I wasn't able to find this font in the Mac OS,")@/ +("so I will ignore the font specification.")@/ +("You might try inserting a different font spec;")@/ +("e.g., type `I\font='."); +error; +goto done + +@ @= +@; +@z + +@x +@ +@y +@; +end +@z + +@x +@ @= +file_opened:=false; +@y +@ @= +@z + +@x +if not b_open_in(tfm_file) then abort; +file_opened:=true +@y +if b_open_in(tfm_file) then begin + file_opened:=true +@z + +@x we have to move this before new_native_character +@ When \TeX\ wants to typeset a character that doesn't exist, the +character node is not created; thus the output routine can assume +that characters exist when it sees them. The following procedure +prints a warning message unless the user has suppressed it. + +@p procedure char_warning(@!f:internal_font_number;@!c:eight_bits); +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; + begin begin_diagnostic; + print_nl("Missing character: There is no "); +@.Missing character@> + print_ASCII(c); print(" in font "); + slow_print(font_name[f]); print_char("!"); end_diagnostic(false); + end; + tracing_online:=old_setting; + end; +end; +@y +@ Procedure |char_warning| has been moved in the source. +@z + +@x +@p function new_character(@!f:internal_font_number;@!c:eight_bits):pointer; +@y +@p function new_character(@!f:internal_font_number;@!c:ASCII_code):pointer; +@z + +@x +begin ec:=effective_char(false,f,qi(c)); +@y +begin +if is_native_font(f) then + begin new_character:=new_native_character(f,c); return; + end; +ec:=effective_char(false,f,qi(c)); +@z + +@x +@* \[31] Device-independent file format. +@y +@* \[31] Device-independent file format. +@z + +@x +\yskip\noindent Commands 250--255 are undefined at the present time. +@y +\yskip\hang|set_glyph_string| 254 w[4] k[2] x[4k] g[2k]. + +\yskip\hang|set_glyph_array| 253 w[4] k[2] xy[8k] g[2k] + +\yskip\hang|define_native_font| 252 k[4] s[4] flags[2] + lenps[1] lenfam[1] lensty[1] ps[lenps] fam[lenfam] sty[lensty] + if (flags & COLORED): + rgba[4] + if (flags & VARIATIONS): + numvars[2] + axes[4nv] + values[4nv] + if (flags & MATRIX): + ta[4] tb[4] tc[4] td[4] tx[4] ty[4] + +\yskip\hang|pic_file| 251 flags[1] t[4][6] p[2] len[2] path[l] + flags = 0 for raster image, 1 for PDF + t is transform matrix + p is page # from the graphic file (0-based) + len is length of pathname + path is pathname of graphic file + +\yskip\noindent Commands 250 and 255 are undefined at the present time (but 255 is used by pTeX). +@z + +@x +@d post_post=249 {postamble ending} +@y +@d post_post=249 {postamble ending} + +@d set_glyph_string=254 {sequence of glyphs, all at the current y-position} +@d set_glyph_array=253 {sequence of glyphs with individual x-y coordinates} +@d define_native_font=252 {define native font} +@d pic_file=251 {embed picture or PDF} +@z + +@x +@d id_byte=2 {identifies the kind of \.{DVI} files described here} +@y +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} +@z + +@x +@* \[32] Shipping pages out. +@y +@* \[32] Shipping pages out. +@z + +@x +@ A mild optimization of the output is performed by the |dvi_pop| +@y +procedure dvi_two(s: UTF16_code); +begin + dvi_out(s div @'400); + dvi_out(s mod @'400); +end; + +@ A mild optimization of the output is performed by the |dvi_pop| +@z + +@x +@p procedure dvi_font_def(@!f:internal_font_number); +@y +@p procedure dvi_native_font_def(@!f:internal_font_number); +var + 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]); +end; + +procedure dvi_font_def(@!f:internal_font_number); +@z + +@x +begin if f<=256+font_base then +@y +begin if is_native_font(f) then dvi_native_font_def(f) else +begin if f<=256+font_base then +@z + +@x +@; +@y +@; +end; +@z + +@x +@ @= +for k:=str_start[font_area[f]] to str_start[font_area[f]+1]-1 do + dvi_out(so(str_pool[k])); +for k:=str_start[font_name[f]] to str_start[font_name[f]+1]-1 do + dvi_out(so(str_pool[k])) +@y +@ @= +for k:=str_start_macro(font_area[f]) to str_start_macro(font_area[f]+1)-1 do + dvi_out(so(str_pool[k])); +for k:=str_start_macro(font_name[f]) to str_start_macro(font_name[f]+1)-1 do + dvi_out(so(str_pool[k])) +@z + +@x +@ @= +dvi_h:=0; dvi_v:=0; cur_h:=h_offset; dvi_f:=null_font; +@y +@ @= +dvi_h:=0; dvi_v:=0; cur_h:=h_offset; dvi_f:=null_font; +@; +@z + +@x + print(" TeX output "); print_int(year); print_char("."); +@y + print(" XeTeX output "); print_int(year); print_char("."); +@z + +@x + for s:=str_start[str_ptr] to pool_ptr-1 do dvi_out(so(str_pool[s])); + pool_ptr:=str_start[str_ptr]; {flush the current string} +@y + for s:=str_start_macro(str_ptr) to pool_ptr-1 do dvi_out(so(str_pool[s])); + pool_ptr:=str_start_macro(str_ptr); {flush the current string} +@z + +@x +@d next_p=15 {go to this label when finished with node |p|} +@y +@d next_p=15 {go to this label when finished with node |p|} + +@d check_next=1236 +@d end_node_run=1237 +@z + +@x +label reswitch, move_past, fin_rule, next_p, continue, found; +@y +label reswitch, move_past, fin_rule, next_p, continue, found, check_next, end_node_run; +@z + +@x +@!prev_p:pointer; {one step behind |p|} +@y +@!prev_p:pointer; {one step behind |p|} +@!len: integer; { length of scratch string for native word output } +@!q,@!r: pointer; +@!k,@!j: integer; +@z + +@x +g_sign:=glue_sign(this_box); p:=list_ptr(this_box); +@y +g_sign:=glue_sign(this_box); +@; +p:=list_ptr(this_box); +@z + +@x +@ We ought to give special care to the efficiency of one part of |hlist_out|, +@y +@ Extra stuff for justifiable AAT text; need to merge runs of words and normal spaces. + +@d is_native_word_node(#) == (not is_char_node(#)) and (type(#) = whatsit_node) and (subtype(#) = native_word_node) + +@= +p := list_ptr(this_box); +prev_p := this_box+list_offset; +while p<>null do begin + if link(p) <> null then begin {not worth looking ahead at the end} + if is_native_word_node(p) and (font_area[native_font(p)] = aat_font_flag) + and (font_letter_space[native_font(p)] = 0) then begin + {got a word in an AAT font, might be the start of a run} + r := p; {|r| is start of possible run} + k := native_length(r); + q := link(p); +check_next: + @; + if (q <> null) and not is_char_node(q) then begin + if (type(q) = glue_node) and (subtype(q) = normal) and (glue_ptr(q) = font_glue[native_font(r)]) then begin + {found a normal space; if the next node is another word in the same font, we'll merge} + q := link(q); + @; + if (q <> null) and is_native_word_node(q) and (native_font(q) = native_font(r)) then begin + p := q; {record new tail of run in |p|} + k := k + 1 + native_length(q); + q := link(q); + goto check_next; + end; + goto end_node_run; + end; + {@;} + if (q <> null) and is_native_word_node(q) and (native_font(q) = native_font(r)) then begin + p := q; {record new tail of run in |p|} + q := link(q); + goto check_next; + end + end; +end_node_run: {now |r| points to first |native_word_node| of the run, and |p| to the last} + if p <> r then begin {merge nodes from |r| to |p| inclusive; total text length is |k|} + str_room(k); + k := 0; {now we'll use this as accumulator for total width} + q := r; + loop begin + if type(q) = whatsit_node then begin + if subtype(q) = native_word_node then begin + for j := 0 to native_length(q)-1 do + append_char(get_native_char(q, j)); + k := k + width(q); + end + end else if type(q) = glue_node then begin + append_char(" "); + g := glue_ptr(q); + k := k + width(g); + if g_sign <> normal then begin + if g_sign = stretching then begin + if stretch_order(g) = g_order then begin + k := k + round(float(glue_set(this_box)) * stretch(g)) + end + end else begin + if shrink_order(g) = g_order then begin + k := k - round(float(glue_set(this_box)) * shrink(g)) + end + end + end + end; + {discretionary and deleted nodes can be discarded here} + if q = p then break + else q := link(q); + end; +done: + q := new_native_word_node(native_font(r), cur_length); + link(prev_p) := q; + for j := 0 to cur_length - 1 do + set_native_char(q, j, str_pool[str_start_macro(str_ptr) + j]); + link(q) := link(p); + link(p) := null; + flush_node_list(r); + width(q) := k; + set_justified_native_glyphs(q); + p := q; + pool_ptr := str_start_macro(str_ptr); {flush the temporary string data} + end + end; + prev_p := p; + end; + p := link(p); +end + +@ @= +while (q <> null) and (not is_char_node(q)) + and ( (type(q) = disc_node) or ((type(q) = whatsit_node) and (subtype(q) = deleted_native_node)) ) do + q := link(q) + +@ We ought to give special care to the efficiency of one part of |hlist_out|, +@z + +@x +dvi_four(last_bop); last_bop:=page_loc; +@y +dvi_four(last_bop); last_bop:=page_loc; +if (pdf_page_width > 0) and (pdf_page_height > 0) then begin + { generate a papersize \special at start of page } + old_setting:=selector; selector:=new_string; + print("papersize "); + if mag=1000 then print_scaled(pdf_page_width) + else print_scaled(xn_over_d(pdf_page_width,mag,1000)); + print("pt"); print(","); + if mag=1000 then print_scaled(pdf_page_height) + else print_scaled(xn_over_d(pdf_page_height,mag,1000)); + print("pt"); + selector:=old_setting; + dvi_out(xxx1); dvi_out(cur_length); + for s:=str_start_macro(str_ptr) to pool_ptr-1 do dvi_out(so(str_pool[s])); + pool_ptr:=str_start_macro(str_ptr); {erase the string} +end; +@z + +@x +dvi_out(eop); incr(total_pages); cur_s:=-1; +@y +dvi_out(eop); incr(total_pages); cur_s:=-1; +if not no_pdf_output then fflush(dvi_file); +@z + +@x + print_nl("Output written on "); print_file_name(0, output_file_name, 0); +@y + print_nl("Output written on "); print_file_name(output_file_name, "", ""); +@z + +@x + print(", "); print_int(dvi_offset+dvi_ptr); print(" bytes)."); + b_close(dvi_file); +@y + if no_pdf_output then begin + print(", "); print_int(dvi_offset+dvi_ptr); print(" bytes)."); + end else print(")."); + dvi_close(dvi_file); +@z + +@x +@* \[33] Packaging. +@y +@* \[33] Packaging. +@z + +@x +@p function hpack(@!p:pointer;@!w:scaled;@!m:small_number):pointer; +label reswitch, common_ending, exit; +@y +@p function hpack(@!p:pointer;@!w:scaled;@!m:small_number):pointer; +label reswitch, common_ending, exit, restart; +@z + +@x +@!hd:eight_bits; {height and depth indices for a character} +@y +@!hd:eight_bits; {height and depth indices for a character} +@!pp,@!ppp: pointer; +@!total_chars, @!k: integer; +@z + +@x +@* \[34] Data structures for math mode. +@y +@* \[34] Data structures for math mode. +@z + +@x +@d fam==font {a |quarterword| in |mem|} +@y +@d plane_and_fam_field==font {a |quarterword| in |mem|} +@d fam(#) == (plane_and_fam_field(#) mod @"100) +@z + +@x +@d small_fam(#)==mem[#].qqqq.b0 {|fam| for ``small'' delimiter} +@d small_char(#)==mem[#].qqqq.b1 {|character| for ``small'' delimiter} +@d large_fam(#)==mem[#].qqqq.b2 {|fam| for ``large'' delimiter} +@d large_char(#)==mem[#].qqqq.b3 {|character| for ``large'' delimiter} +@y +@d small_fam(#)==(mem[#].qqqq.b0 mod @"100) {|fam| for ``small'' delimiter} +@d small_char(#)==(mem[#].qqqq.b1 + (mem[#].qqqq.b0 div @"100) * @"10000) {|character| for ``small'' delimiter} +@d large_fam(#)==(mem[#].qqqq.b2 mod @"100) {|fam| for ``large'' delimiter} +@d large_char(#)==(mem[#].qqqq.b3 + (mem[#].qqqq.b2 div @"100) * @"10000) {|character| for ``large'' delimiter} +@d small_plane_and_fam_field(#)==mem[#].qqqq.b0 +@d small_char_field(#)==mem[#].qqqq.b1 +@d large_plane_and_fam_field(#)==mem[#].qqqq.b2 +@d large_char_field(#)==mem[#].qqqq.b3 +@z + +@x +procedure print_fam_and_char(@!p:pointer); {prints family and character} +begin print_esc("fam"); print_int(fam(p)); print_char(" "); +print_ASCII(qo(character(p))); +@y +procedure print_fam_and_char(@!p:pointer); {prints family and character} +begin print_esc("fam"); print_int(fam(p) mod @"100); print_char(" "); +print_ASCII(qo(character(p)) + (fam(p) div @"100) * @"10000); +@z + +@x +@* \[35] Subroutines for math mode. +@y +@* \[35] Subroutines for math mode. +@z + +@x +@d text_size=0 {size code for the largest size in a family} +@d script_size=16 {size code for the medium size in a family} +@d script_script_size=32 {size code for the smallest size in a family} +@y +@z + +@x +else cur_size:=16*((cur_style-text_style) div 2); +@y +else cur_size:=script_size*((cur_style-text_style) div 2); +@z + +@x +function var_delimiter(@!d:pointer;@!s:small_number;@!v:scaled):pointer; +@y +function var_delimiter(@!d:pointer;@!s:integer;@!v:scaled):pointer; +@z + +@x +@!z: small_number; {runs through font family members} +@y +@!z: integer; {runs through font family members} +@z + +@x + begin z:=z+s+16; + repeat z:=z-16; g:=fam_fnt(z); +@y + begin z:=z+s+script_size; + repeat z:=z-script_size; g:=fam_fnt(z); +@z + +@x + until z<16; +@y + until z +else begin if (qo(cur_c)>=font_bc[cur_f])and(qo(cur_c)<=font_ec[cur_f]) then + cur_i:=orig_char_info(cur_f)(cur_c) +@y +@p procedure fetch(@!a:pointer); {unpack the |math_char| field |a|} +begin cur_c:=cast_to_ushort(character(a)); cur_f:=fam_fnt(fam(a)+cur_size); +cur_c:=cur_c + (plane_and_fam_field(a) div @"100) * @"10000; +if cur_f=null_font then + @ +else if is_native_font(cur_f) then begin + cur_i:=null_character; +end else begin if (qo(cur_c)>=font_bc[cur_f])and(qo(cur_c)<=font_ec[cur_f]) then + cur_i:=orig_char_info(cur_f)(cur_c) +@z + +@x +@!cur_c:quarterword; {the |character| field of a |math_char|} +@y +@!cur_c:integer; {the |character| field of a |math_char|} +@z + +@x + character(nucleus(r)):=rem_byte(cur_i); + fam(nucleus(r)):=fam(nucleus(q));@/ +@y + character(nucleus(r)):=rem_byte(cur_i); + plane_and_fam_field(nucleus(r)):=fam(nucleus(q));@/ +@z + +@x +@ @= +begin fetch(nucleus(q)); +if char_exists(cur_i) then +@y +@ @= +begin fetch(nucleus(q)); +if is_native_font(cur_f) then begin + delta:=0; p:=new_native_character(cur_f, qo(cur_c)); +end else if char_exists(cur_i) then +@z + +@x +procedure make_scripts(@!q:pointer;@!delta:scaled); +var p,@!x,@!y,@!z:pointer; {temporary registers for box construction} +@!shift_up,@!shift_down,@!clr:scaled; {dimensions in the calculation} +@!t:small_number; {subsidiary size code} +@y +procedure make_scripts(@!q:pointer;@!delta:scaled); +var p,@!x,@!y,@!z:pointer; {temporary registers for box construction} +@!shift_up,@!shift_down,@!clr:scaled; {dimensions in the calculation} +@!t:integer; {subsidiary size code} +@z + +@x +magic_offset:=str_start[math_spacing]-9*ord_noad +@y +magic_offset:=str_start_macro(math_spacing)-9*ord_noad +@z + +@x +@* \[37] Alignment. +@y +@* \[37] Alignment. +@z + +@x +@d span_code=256 {distinct from any character} +@d cr_code=257 {distinct from |span_code| and from any character} +@y +@d span_code=special_char {distinct from any character} +@d cr_code=span_code+1 {distinct from |span_code| and from any character} +@z + +@x +if n>max_quarterword then confusion("256 spans"); {this can happen, but won't} +@^system dependencies@> +@:this can't happen 256 spans}{\quad 256 spans@> +@y +if n>max_quarterword then confusion("too many spans"); + {this can happen, but won't} +@^system dependencies@> +@:this can't happen too many spans}{\quad too many spans@> +@z + +@x +@* \[38] Breaking paragraphs into lines. +@y +@* \[38] Breaking paragraphs into lines. +@z + +@x +label done,done1,done2,done3,done4,done5,continue; +@y +label done,done1,done2,done3,done4,done5,done6,continue, restart; +@z + +@x + othercases confusion("disc1") +@y + whatsit_node: + if (subtype(v)=native_word_node) + or (subtype(v)=glyph_node) + or (subtype(v)=pic_node) + or (subtype(v)=pdf_node) + then break_width[1]:=break_width[1]-width(v) + else if subtype(v)=deleted_native_node then do_nothing + else confusion("disc1a"); + othercases confusion("disc1") +@z + +@x + othercases confusion("disc2") +@y + whatsit_node: + if (subtype(s)=native_word_node) + or (subtype(s)=glyph_node) + or (subtype(s)=pic_node) + or (subtype(s)=pdf_node) + then break_width[1]:=break_width[1]+width(s) + else if subtype(s)=deleted_native_node then do_nothing + else confusion("disc2a"); + othercases confusion("disc2") +@z + +@x +@* \[39] Breaking paragraphs into lines, continued. +@y +@* \[39] Breaking paragraphs into lines, continued. +@z + +@x + othercases confusion("disc3") +@y + whatsit_node: + if (subtype(s)=native_word_node) + or (subtype(s)=glyph_node) + or (subtype(s)=pic_node) + or (subtype(s)=pdf_node) + then disc_width:=disc_width+width(s) + else if subtype(s)=deleted_native_node then do_nothing + else confusion("disc3a"); + othercases confusion("disc3") +@z + +@x + othercases confusion("disc4") +@y + whatsit_node: + if (subtype(s)=native_word_node) + or (subtype(s)=glyph_node) + or (subtype(s)=pic_node) + or (subtype(s)=pdf_node) + then act_width:=act_width+width(s) + else if subtype(s)=deleted_native_node then do_nothing + else confusion("disc4a"); + othercases confusion("disc4") +@z + +@x +@* \[40] Pre-hyphenation. +@y +@* \[40] Pre-hyphenation. +@z + +@x +@!hc:array[0..65] of 0..256; {word to be hyphenated} +@y +@!hc:array[0..65] of 0..too_big_char; {word to be hyphenated} +@z + +@x +@!hu:array[0..63] of 0..256; {like |hc|, before conversion to lowercase} +@y +@!hu:array[0..63] of 0..too_big_char; + {like |hc|, before conversion to lowercase} +@z + +@x +@!cur_lang,@!init_cur_lang:ASCII_code; {current hyphenation table of interest} +@y +@!cur_lang,@!init_cur_lang:0..biggest_lang; + {current hyphenation table of interest} +@z + +@x +@!hyf_bchar:halfword; {boundary character after $c_n$} +@y +@!hyf_bchar:halfword; {boundary character after $c_n$} +@!max_hyph_char:integer; + +@ @= +max_hyph_char:=too_big_lang; +@z + +@x +@!c:0..255; {character being considered for hyphenation} +@y +@!c:ASCII_code; {character being considered for hyphenation} +@z + +@x + @; +@y +if (not is_char_node(ha)) and (type(ha) = whatsit_node) and (subtype(ha) = native_word_node) then begin + @; + @; +end else begin + @; +end; +@z + +@x +@ The first thing we need to do is find the node |ha| just before the +first letter. +@y +@ @= +s := link(ha); +loop@+ begin if not(is_char_node(s)) then + case type(s) of + ligature_node: do_nothing; + kern_node: if subtype(s)<>normal then goto done6; + whatsit_node,glue_node,penalty_node,ins_node,adjust_node,mark_node: + goto done6; + othercases goto done1 + endcases; + s:=link(s); + end; +done6: + +@ @= +{ note that if there are chars with |lccode = 0|, we split them out into separate |native_word| nodes } +hn := 0; +restart: +for l := 0 to native_length(ha)-1 do begin + c := get_native_char(ha, l); + set_lc_code(c); + if (hc[0] = 0) {or (hc[0] > max_hyph_char) -- no, there can be letters > max_hyph_char in the word} + 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 } + @; + goto done3; + end + end else if (hn = 0) and (l > 0) then begin + { we've found the first letter after some non-letters, so break off the head of the |native_word| and restart } + @; + ha := link(ha); + goto restart; + end else if (hn = 63) then + { reached max hyphenatable length } + goto done3 + else begin + { found a letter that is part of a potentially hyphenatable sequence } + incr(hn); hu[hn] := c; hc[hn] := hc[0]; hyf_bchar := non_char; + end +end; + +@ @= + q := new_native_word_node(hf, native_length(ha) - l); + for i := l to native_length(ha) - 1 do + set_native_char(q, i - l, get_native_char(ha, i)); + set_native_metrics(q, XeTeX_use_glyph_metrics); + link(q) := link(ha); + link(ha) := q; + { truncate text in node |ha| } + native_length(ha) := l; + set_native_metrics(ha, XeTeX_use_glyph_metrics); + +@ @= +l: integer; +i: integer; + +@ The first thing we need to do is find the node |ha| just before the +first letter. +@z + +@x + begin @; + goto continue; +@y + begin + if subtype(s) = native_word_node then begin + c := get_native_char(s, 0); + hf := native_font(s); + prev_s := s; + goto done2; + end else begin + @; + goto continue; + end +@z + +@x +if hyf_char>255 then goto done1; +@y +if hyf_char>biggest_char then goto done1; +@z + +@x + if hc[0]=0 then goto done3; +@y + if hc[0]=0 then goto done3; + if hc[0]>max_hyph_char then goto done3; +@z + +@x + if hc[0]=0 then goto done3; +@y + if hc[0]=0 then goto done3; + if hc[0]>max_hyph_char then goto done3; +@z + +@x +@* \[41] Post-hyphenation. +@y +@* \[41] Post-hyphenation. +@z + +@x +@= +@y +@= +if (not is_char_node(ha)) and (type(ha) = whatsit_node) and (subtype(ha) = native_word_node) then begin + @; +end else begin +@z + +@x + begin hu[0]:=256; init_lig:=false; +@y + begin hu[0]:=max_hyph_char; init_lig:=false; +@z + +@x +found2: s:=ha; j:=0; hu[0]:=256; init_lig:=false; init_list:=null; +@y +found2: s:=ha; j:=0; hu[0]:=max_hyph_char; init_lig:=false; init_list:=null; +@z + +@x +flush_list(init_list) +@y +flush_list(init_list); +end + +@ @= +{ find the node immediately before the word to be hyphenated } +s := cur_p; {we have |cur_p<>ha| because |type(cur_p)=glue_node|} +while link(s) <> ha do s := link(s); + +{ for each hyphen position, + create a |native_word_node| fragment for the text before this point, + and a |disc_node| for the break, with the |hyf_char| in the |pre_break| text +} + +hyphen_passed := 0; { location of last hyphen we saw } + +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 the |disc_node| for the hyphenation point } + q := new_disc; + pre_break(q) := new_native_character(hf, hyf_char); + link(s) := q; + s := q; + + hyphen_passed := j; + end +end; + +{ make a |native_word_node| for the last fragment of the word } +hn := native_length(ha); { ensure trailing punctuation is not lost! } +q := new_native_word_node(hf, hn - hyphen_passed); +for i := 0 to hn - 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; + +q := link(ha); +link(s) := q; +link(ha) := null; +flush_node_list(ha); +@z + +@x + begin decr(l); c:=hu[l]; c_loc:=l; hu[l]:=256; +@y + begin decr(l); c:=hu[l]; c_loc:=l; hu[l]:=max_hyph_char; +@z + +@x +@* \[42] Hyphenation. +@y +@* \[42] Hyphenation. +@z + +@x +@!op_start:array[ASCII_code] of 0..trie_op_size; {offset for current language} +@y +@!op_start:array[0..biggest_lang] of 0..trie_op_size; {offset for current language} +@z + +@x +hc[0]:=0; hc[hn+1]:=0; hc[hn+2]:=256; {insert delimiters} +@y +hc[0]:=0; hc[hn+1]:=0; hc[hn+2]:=max_hyph_char; {insert delimiters} +@z + +@x + begin j:=1; u:=str_start[k]; +@y + begin j:=1; u:=str_start_macro(k); +@z + +@x + else if language>255 then cur_lang:=0 +@y + else if language>biggest_lang then cur_lang:=0 +@z + +@x +u:=str_start[k]; v:=str_start[s]; +@y +u:=str_start_macro(k); v:=str_start_macro(s); +@z + +@x +until u=str_start[k+1]; +@y +until u=str_start_macro(k+1); +@z + +@x +@* \[43] Initializing the hyphenation tables. +@y +@* \[43] Initializing the hyphenation tables. +@z + +@x +@!trie_used:array[ASCII_code] of trie_opcode; +@y +@!trie_used:array[0..biggest_lang] of trie_opcode; +@z + +@x +@!trie_op_lang:array[1..trie_op_size] of ASCII_code; +@y +@!trie_op_lang:array[1..trie_op_size] of 0..biggest_lang; +@z + +@x +for j:=1 to 255 do op_start[j]:=op_start[j-1]+qo(trie_used[j-1]); +@y +for j:=1 to biggest_lang do op_start[j]:=op_start[j-1]+qo(trie_used[j-1]); +@z + +@x +for k:=0 to 255 do trie_used[k]:=min_trie_op; +@y +for k:=0 to biggest_lang do trie_used[k]:=min_trie_op; +@z + +@x +for p:=0 to 255 do trie_min[p]:=p+1; +@y +for p:=0 to biggest_char do trie_min[p]:=p+1; +@z + +@x +@!ll:1..256; {upper limit of |trie_min| updating} +@y +@!ll:1..too_big_char; {upper limit of |trie_min| updating} +@z + +@x + @=h+256|@>; +@y + @=h+max_hyph_char|@>; +@z + +@x +@ By making sure that |trie_max| is at least |h+256|, we can be sure that +@y +@ By making sure that |trie_max| is at least |h+max_hyph_char|, +we can be sure that +@z + +@x +@=h+256|@>= +if trie_max=h+max_hyph_char|@>= +if trie_maxmax_hyph_char then max_hyph_char:=cur_chr; + if k<63 then +@z + +@x +begin @; +@y +begin +incr(max_hyph_char); +@; +@z + +@x +@* \[44] Breaking vertical lists into pages. +@y +@* \[44] Breaking vertical lists into pages. +@z + +@x +@* \[45] The page builder. +@y +@* \[45] The page builder. +@z + +@x +@!n:min_quarterword..255; {insertion box number} +@y +@!n:min_quarterword..biggest_reg; {insertion box number} +@z + +@x +@!n:min_quarterword..255; {insertion box number} +@y +@!n:min_quarterword..biggest_reg; {insertion box number} +@z + +@x +@* \[46] The chief executive. +@y +@* \[46] The chief executive. +@z + +@x +@d main_loop=70 {go here to typeset a string of consecutive characters} +@y +@d main_loop=70 {go here to typeset a string of consecutive characters} +@d collect_native=71 {go here to collect characters in a "native" font string} +@z + +@x +hmode+char_num: begin scan_char_num; cur_chr:=cur_val; goto main_loop;@+end; +@y +hmode+char_num: begin scan_usv_num; cur_chr:=cur_val; goto main_loop;@+end; +@z + +@x +@!main_p:pointer; {temporary register for list manipulation} +@y +@!main_p:pointer; {temporary register for list manipulation} +@!main_pp:pointer; {another temporary register for list manipulation} +@!main_h:pointer; {temp for hyphen offset in native-font text} +@!is_hyph:boolean; {whether the last char seen is the font's hyphenchar} +@z + +@x +adjust_space_factor;@/ +@y + +{ added code for native font support } +if is_native_font(cur_font) then begin + if mode>0 then if language<>clang then fix_language; + + main_h := 0; + main_f := cur_font; + +collect_native: + adjust_space_factor; + if (cur_chr > @"FFFF) then begin + str_room(2); + append_char((cur_chr - @"10000) div 1024 + @"D800); + append_char((cur_chr - @"10000) mod 1024 + @"DC00); + end else begin + str_room(1); + append_char(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 := cur_length; + + {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; + + if (font_mapping[main_f] <> 0) then begin + main_k := apply_mapping(font_mapping[main_f], address_of(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 } + str_room(main_k); + main_h := 0; + for main_p := 0 to main_k - 1 do begin + append_char(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 := cur_length; + end + end; + + if tracing_lost_chars > 0 then begin + temp_ptr := str_start_macro(str_ptr); + main_p := temp_ptr + cur_length; + while (temp_ptr < main_p) do begin + main_k := str_pool[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 + str_pool[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 := cur_length; + main_pp := tail; + + if mode=hmode then begin + + temp_ptr := str_start_macro(str_ptr); + repeat + if main_h = 0 then main_h := main_k; + + if (not is_char_node(main_pp)) and (type(main_pp)=whatsit_node) and (subtype(main_pp)=native_word_node) and (native_font(main_pp)=main_f) 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); + str_room(main_k); + + temp_ptr := pool_ptr; + for main_p := 0 to native_length(main_pp) - 1 do + append_char(get_native_char(main_pp, main_p)); + for main_p := str_start_macro(str_ptr) to temp_ptr - 1 do + append_char(str_pool[main_p]); + + do_locale_linebreaks(temp_ptr, main_k); + + pool_ptr := temp_ptr; { discard the temp string } + main_k := cur_length - main_h; { and set main_k to remaining length of new word } + temp_ptr := str_start_macro(str_ptr) + main_h; { pointer to remaining fragment } + + main_h := 0; + while (main_h < main_k) and (str_pool[temp_ptr + main_h] <> hyphen_char[main_f]) + and ( (not XeTeX_dash_break_en) + or ((str_pool[temp_ptr + main_h] <> @"2014) and (str_pool[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); + + { flag the previous node as no longer valid } + free_native_glyph_info(main_pp); + subtype(main_pp) := deleted_native_node; + + 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 (str_pool[temp_ptr + main_h] <> hyphen_char[main_f]) + and ( (not XeTeX_dash_break_en) + or ((str_pool[temp_ptr + main_h] <> @"2014) and (str_pool[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 } + end; + until main_k = 0; + + end else begin + { must be restricted hmode, so no need for line-breaking or discretionaries } + if (not is_char_node(main_pp)) and (type(main_pp)=whatsit_node) and (subtype(main_pp)=native_word_node) and (native_font(main_pp)=main_f) 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), str_pool[str_start_macro(str_ptr) + main_p]); + set_native_metrics(tail, XeTeX_use_glyph_metrics); + + { flag the previous node as no longer valid } + free_native_glyph_info(main_pp); + subtype(main_pp) := deleted_native_node; + 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, str_pool[str_start_macro(str_ptr) + main_p]); + set_native_metrics(tail, XeTeX_use_glyph_metrics); + end + end; + + pool_ptr := str_start_macro(str_ptr); + goto reswitch; +end; +{ End of added code for native fonts } + +adjust_space_factor;@/ +@z + +@x +non_math(math_given), non_math(math_comp), non_math(delim_num), +@y +non_math(math_given), non_math(XeTeX_math_given), non_math(math_comp), non_math(delim_num), +@z + +@x +procedure append_italic_correction; +label exit; +var p:pointer; {|char_node| at the tail of the current list} +@!f:internal_font_number; {the font in the |char_node|} +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 return; +@y +procedure append_italic_correction; +label exit; +var p:pointer; {|char_node| at the tail of the current list} +@!f:internal_font_number; {the font in the |char_node|} +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 + tail_append(new_kern(get_native_italic_correction(tail))); subtype(tail):=explicit; + end + else if (subtype(tail)=glyph_node) then begin + tail_append(new_kern(get_native_glyph_italic_correction(tail))); subtype(tail):=explicit; + end; + return; + end + else return; +@z + +@x + if c>=0 then if c<256 then pre_break(tail):=new_character(cur_font,c); +@y + if c>=0 then if c<=biggest_char then pre_break(tail):=new_character(cur_font,c); +@z + +@x + if type(p)<>kern_node then if type(p)<>ligature_node then + begin print_err("Improper discretionary list"); +@y + 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)<>deleted_native_node) + and (subtype(p)<>glyph_node)) then + begin print_err("Improper discretionary list"); +@z + +@x +@!a,@!h,@!x,@!w,@!delta:scaled; {heights and widths, as explained above} +@y +@!a,@!h,@!x,@!w,@!delta,@!lsb,@!rsb:scaled; {heights and widths, as explained above} +@z + +@x + a:=char_width(f)(char_info(f)(character(p)));@/ +@y + if is_native_font(f) then + begin a:=width(p); + if a=0 then get_native_char_sidebearings(f, cur_val, address_of(lsb), address_of(rsb)) + end + else a:=char_width(f)(char_info(f)(character(p)));@/ +@z + +@x +if (cur_cmd=letter)or(cur_cmd=other_char)or(cur_cmd=char_given) then + q:=new_character(f,cur_chr) +@y +if (cur_cmd=letter)or(cur_cmd=other_char)or(cur_cmd=char_given) then + begin q:=new_character(f,cur_chr); cur_val:=cur_chr + end +@z + +@x +i:=char_info(f)(character(q)); +w:=char_width(f)(i); h:=char_height(f)(height_depth(i)); +@y +if is_native_font(f) then begin + w:=width(q); + get_native_char_height_depth(f, cur_val, address_of(h), address_of(delta)) + {using delta as scratch space for the unneeded depth value} +end else begin + i:=char_info(f)(character(q)); + w:=char_width(f)(i); h:=char_height(f)(height_depth(i)) +end; +@z + +@x +delta:=round((w-a)/float_constant(2)+h*t-x*s); +@y +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); +@z + +@x +whatsit_node: @; +@y +whatsit_node: @; +@z + +@x +letter,other_char,char_given: begin c:=ho(math_code(cur_chr)); + if c=@'100000 then +@y +letter,other_char,char_given: begin c:=ho(math_code(cur_chr)); + if is_active_math_char(c) then +@z + +@x +math_char_num: begin scan_fifteen_bit_int; c:=cur_val; + end; +@y +math_char_num: + if cur_chr = 2 then begin { \XeTeXextmathchar } + scan_math_class_int; c := set_class_field(cur_val); + scan_math_fam_int; c := c + set_family_field(cur_val); + scan_usv_num; c := c + cur_val; + end else if cur_chr = 1 then begin { \XeTeXmathchar } + scan_xetex_math_char_int; c := cur_val; + end else begin scan_fifteen_bit_int; + c := set_class_field(cur_val div @"1000) + + set_family_field((cur_val mod @"1000) div @"100) + + (cur_val mod @"100); + end; +@z + +@x +math_given: c:=cur_chr; +delim_num: begin scan_twenty_seven_bit_int; c:=cur_val div @'10000; +@y +math_given: begin + c := set_class_field(cur_chr div @"1000) + + set_family_field((cur_chr mod @"1000) div @"100) + + (cur_chr mod @"100); + end; +XeTeX_math_given: c:=cur_chr; +delim_num: begin + scan_delimiter_int; + c := cur_val; {cur_val is the 'small' delimiter mathchar value} +@z + +@x +math_type(p):=math_char; character(p):=qi(c mod 256); +if (c>=var_code)and fam_in_range then fam(p):=cur_fam +else fam(p):=(c div 256) mod 16; +@y +math_type(p):=math_char; character(p):=qi(c mod @"10000); +if (is_var_family(c)) and fam_in_range then plane_and_fam_field(p):=cur_fam +else plane_and_fam_field(p):=(math_fam_field(c)); +plane_and_fam_field(p) := plane_and_fam_field(p) + (math_char_field(c) div @"10000) * @"100; +@z + +@x +mmode+math_char_num: begin scan_fifteen_bit_int; set_math_char(cur_val); + end; +@y +mmode+math_char_num: if cur_chr = 2 then begin { \XeTeXextmathchar } + scan_math_class_int; t := set_class_field(cur_val); + scan_math_fam_int; t := t + set_family_field(cur_val); + scan_usv_num; t := t + cur_val; + set_math_char(t); + end else if cur_chr = 1 then begin { \XeTeXmathchar } + scan_xetex_math_char_int; set_math_char(cur_val); + end else begin scan_fifteen_bit_int; + set_math_char(set_class_field(cur_val div @"1000) + + set_family_field((cur_val mod @"1000) div @"100) + + (cur_val mod @"100)); + end; +@z + +@x +mmode+math_given: set_math_char(cur_chr); +mmode+delim_num: begin scan_twenty_seven_bit_int; + set_math_char(cur_val div @'10000); +@y +mmode+math_given: begin + set_math_char(set_class_field(cur_chr div @"1000) + + set_family_field((cur_chr mod @"1000) div @"100) + + (cur_chr mod @"100)); + end; +mmode+XeTeX_math_given: set_math_char(cur_chr); +mmode+delim_num: begin + scan_delimiter_int; + set_math_char(cur_val); +@z + +@x +procedure set_math_char(@!c:integer); +var p:pointer; {the new noad} +begin if c>=@'100000 then + @ +else begin p:=new_noad; math_type(nucleus(p)):=math_char; + character(nucleus(p)):=qi(c mod 256); + fam(nucleus(p)):=(c div 256) mod 16; + if c>=var_code then + begin if fam_in_range then fam(nucleus(p)):=cur_fam; + type(p):=ord_noad; + end + else type(p):=ord_noad+(c div @'10000); +@y +procedure set_math_char(@!c:integer); +var p,q,r:pointer; {the new noad} + ch: UnicodeScalar; +begin if is_active_math_char(c) then + @ +else begin p:=new_noad; math_type(nucleus(p)):=math_char; + ch:=math_char_field(c); + character(nucleus(p)):=qi(ch mod @"10000); + plane_and_fam_field(nucleus(p)):=math_fam_field(c); + if is_var_family(c) then + begin if fam_in_range then plane_and_fam_field(nucleus(p)):=cur_fam; + type(p):=ord_noad; + end + else type(p):=ord_noad+math_class_field(c); + plane_and_fam_field(nucleus(p)) := plane_and_fam_field(nucleus(p)) + (ch div @"10000) * @"100; +@z + +@x +procedure scan_delimiter(@!p:pointer;@!r:boolean); +begin if r then scan_twenty_seven_bit_int +@y +procedure scan_delimiter(@!p:pointer;@!r:boolean); +begin if r then scan_delimiter_int +@z + +@x + letter,other_char: cur_val:=del_code(cur_chr); + delim_num: scan_twenty_seven_bit_int; + othercases cur_val:=-1 +@y + letter,other_char: begin + cur_val:=del_code(cur_chr); cur_val1:=del_code1(cur_chr); + end; + delim_num: scan_delimiter_int; + othercases begin cur_val:=-1; cur_val1:=-1; end; +@z + +@x +if cur_val<0 then @; +small_fam(p):=(cur_val div @'4000000) mod 16; +small_char(p):=qi((cur_val div @'10000) mod 256); +large_fam(p):=(cur_val div 256) mod 16; +large_char(p):=qi(cur_val mod 256); +@y +if cur_val<0 then begin @; + cur_val1:=0; + end; +small_plane_and_fam_field(p) := (math_char_field(cur_val) div @"10000) * @"100 + math_fam_field(cur_val); +small_char_field(p) := cur_val mod @"10000; +large_plane_and_fam_field(p) := (math_char_field(cur_val1) div @"10000) * @"100 + math_fam_field(cur_val1); +large_char_field(p) := cur_val1 mod @"10000; +@z + +@x +character(accent_chr(tail)):=qi(cur_val mod 256); +if (cur_val>=var_code)and fam_in_range then fam(accent_chr(tail)):=cur_fam +else fam(accent_chr(tail)):=(cur_val div 256) mod 16; +@y +character(accent_chr(tail)):=qi(cur_val mod @"10000); +if (is_var_family(cur_val))and fam_in_range then plane_and_fam_field(accent_chr(tail)):=cur_fam +else plane_and_fam_field(accent_chr(tail)):=math_fam_field(cur_val); +plane_and_fam_field(accent_chr(tail)) + := plane_and_fam_field(accent_chr(tail)) + (math_char_field(cur_val) div @"10000) * @"100; +@z + +@x +@* \[49] Mode-independent processing. +@y +@* \[49] Mode-independent processing. +@z + +@x +any_mode(def_code), +@y +any_mode(def_code), +any_mode(XeTeX_def_code), +@z + +@x +@d word_define(#)==if global then geq_word_define(#)@+else eq_word_define(#) +@y +@d word_define(#)==if global then geq_word_define(#)@+else eq_word_define(#) +@d word_define1(#)==if global then geq_word_define1(#)@+else eq_word_define1(#) +@z + +@x +@d char_def_code=0 {|shorthand_def| for \.{\\chardef}} +@d math_char_def_code=1 {|shorthand_def| for \.{\\mathchardef}} +@d count_def_code=2 {|shorthand_def| for \.{\\countdef}} +@d dimen_def_code=3 {|shorthand_def| for \.{\\dimendef}} +@d skip_def_code=4 {|shorthand_def| for \.{\\skipdef}} +@d mu_skip_def_code=5 {|shorthand_def| for \.{\\muskipdef}} +@d toks_def_code=6 {|shorthand_def| for \.{\\toksdef}} +@d char_sub_def_code=7 {|shorthand_def| for \.{\\charsubdef}} +@y +@d char_def_code=0 {|shorthand_def| for \.{\\chardef}} +@d math_char_def_code=1 {|shorthand_def| for \.{\\mathchardef}} +@d count_def_code=2 {|shorthand_def| for \.{\\countdef}} +@d dimen_def_code=3 {|shorthand_def| for \.{\\dimendef}} +@d skip_def_code=4 {|shorthand_def| for \.{\\skipdef}} +@d mu_skip_def_code=5 {|shorthand_def| for \.{\\muskipdef}} +@d toks_def_code=6 {|shorthand_def| for \.{\\toksdef}} +@d char_sub_def_code=7 {|shorthand_def| for \.{\\charsubdef}} +@d XeTeX_math_char_def_code=8 +@d XeTeX_ext_math_char_def_code=9 +@z + +@x +primitive("mathchardef",shorthand_def,math_char_def_code);@/ +@!@:math_char_def_}{\.{\\mathchardef} primitive@> +@y +primitive("mathchardef",shorthand_def,math_char_def_code);@/ +primitive("XeTeXmathchardef",shorthand_def,XeTeX_math_char_def_code);@/ +primitive("XeTeXextmathchardef",shorthand_def,XeTeX_ext_math_char_def_code);@/ +@!@:math_char_def_}{\.{\\mathchardef} primitive@> +@z + +@x + math_char_def_code: print_esc("mathchardef"); +@y + math_char_def_code: print_esc("mathchardef"); + XeTeX_math_char_def_code: print_esc("XeTeXmathchardef"); + XeTeX_ext_math_char_def_code: print_esc("XeTeXextmathchardef"); +@z + +@x +math_given: begin print_esc("mathchar"); print_hex(chr_code); + end; +@y +math_given: begin print_esc("mathchar"); print_hex(chr_code); + end; +XeTeX_math_given: begin print_esc("XeTeXmathchar"); print_hex(chr_code); + end; +@z + +@x +else begin n:=cur_chr; get_r_token; p:=cur_cs; define(p,relax,256); +@y +else begin n:=cur_chr; get_r_token; p:=cur_cs; define(p,relax,too_big_char); +@z + +@x + char_def_code: begin scan_char_num; define(p,char_given,cur_val); +@y + char_def_code: begin scan_usv_num; define(p,char_given,cur_val); +@z + +@x + math_char_def_code: begin scan_fifteen_bit_int; define(p,math_given,cur_val); + end; +@y + math_char_def_code: begin scan_fifteen_bit_int; define(p,math_given,cur_val); + end; + XeTeX_math_char_def_code: begin scan_xetex_math_char_int; + define(p, XeTeX_math_given, cur_val); + end; + XeTeX_ext_math_char_def_code: begin + scan_math_class_int; n := set_class_field(cur_val); + scan_math_fam_int; n := n + set_family_field(cur_val); + scan_usv_num; n := n + cur_val; + define(p, XeTeX_math_given, n); + end; +@z + +@x +primitive("mathcode",def_code,math_code_base); +@y +primitive("mathcode",def_code,math_code_base); +primitive("XeTeXmathcode",XeTeX_def_code,math_code_base); +primitive("XeTeXextmathcode",XeTeX_def_code,math_code_base+1); +@z + +@x +def_family: print_size(chr_code-math_font_base); +@y +XeTeX_def_code: if chr_code=math_code_base then print_esc("XeTeXmathcode") + else if chr_code=math_code_base+1 then print_esc("XeTeXextmathcode") + else print_esc("XeTeXdelcode"); +def_family: print_size(chr_code-math_font_base); +@z + +@x +def_code: begin @; +@y +XeTeX_def_code: begin + if cur_chr = math_code_base then begin + p:=cur_chr; scan_char_num; + p:=p+cur_val; + scan_optional_equals; + scan_xetex_math_char_int; + define(p,data,hi(cur_val)); + end + else if cur_chr = math_code_base+1 then begin + p:=cur_chr-1; scan_char_num; + p:=p+cur_val; + scan_optional_equals; + scan_math_class_int; n := set_class_field(cur_val); + scan_math_fam_int; n := n + set_family_field(cur_val); + scan_usv_num; n := n + cur_val; + define(p,data,hi(n)); + end + else do_nothing; {FIXME - XeTeXdelcode} + end; +def_code: begin @; +@z + +@x + if p<256 then xord[p]:=cur_val + else if p<512 then xchr[p-256]:=cur_val + else if p<768 then xprn[p-512]:=cur_val + else if pmin_quarterword then +@y +for k:=biggest_lang downto 0 do if trie_used[k]>min_quarterword then +@z + +@x +undump_size(0)(trie_op_size)('trie op size')(j); @+init trie_op_ptr:=j;@+tini +@y +undump_int(max_hyph_char); +undump_size(0)(trie_op_size)('trie op size')(j); @+init trie_op_ptr:=j;@+tini +@z + +@x +init for k:=0 to 255 do trie_used[k]:=min_quarterword;@+tini@;@/ +k:=256; +@y +init for k:=0 to biggest_lang do trie_used[k]:=min_quarterword;@+tini@;@/ +k:=biggest_lang+1; +@z + +@x + setup_bound_var (15000)('max_strings')(max_strings); +@y + setup_bound_var (15000)('max_strings')(max_strings); + max_strings:=max_strings+too_big_char; {the max_strings value doesn't include the 64K synthetic strings} +@z + +@x + input_file:=xmalloc_array (alpha_file, max_in_open); +@y + input_file:=xmalloc_array (unicode_file, max_in_open); +@z + +@x + print_file_name(0, log_name, 0); print_char("."); +@y + print_file_name(log_name, "", ""); print_char("."); +@z + +@x + {Allocate and initialize font arrays} +@y + {Allocate and initialize font arrays} + font_mapping:=xmalloc_array(void_pointer, font_max); + font_layout_engine:=xmalloc_array(void_pointer, font_max); + font_flags:=xmalloc_array(char, font_max); + font_letter_space:=xmalloc_array(scaled, font_max); +@z + +@x + font_bc:=xmalloc_array(eight_bits, font_max); + font_ec:=xmalloc_array(eight_bits, font_max); +@y + font_bc:=xmalloc_array(UTF16_code, font_max); + font_ec:=xmalloc_array(UTF16_code, font_max); +@z + +@x +@* \[53] Extensions. +@y +@* \[53] Extensions. +@z + +@x +@d write_stream(#) == type(#+1) {stream number (0 to 17)} +@d mubyte_zero == 64 +@d write_mubyte(#) == subtype(#+1) {mubyte value + |mubyte_zero|} +@y +@d write_stream(#) == info(#+1) {stream number (0 to 17)} +@z + +@x +@d set_language_code=5 {command modifier for \.{\\setlanguage}} +@y +@d set_language_code=5 {command modifier for \.{\\setlanguage}} + +@d pdftex_first_extension_code = 6 +@d pdf_save_pos_node == pdftex_first_extension_code + 0 + +@d pic_file_code=41 { command modifier for \.{\\XeTeXpicfile}, skipping codes pdfTeX might use } +@d pdf_file_code=42 { command modifier for \.{\\XeTeXpdffile} } +@d glyph_code=43 { command modifier for \.{\\XeTeXglyph} } + +@d XeTeX_input_encoding_extension_code=44 +@d XeTeX_default_encoding_extension_code=45 +@d XeTeX_linebreak_locale_extension_code=46 +@z + +@x +@!@:set_language_}{\.{\\setlanguage} primitive@> +@y +@!@:set_language_}{\.{\\setlanguage} primitive@> + +@ The \.{\\XeTeXpicfile} and \.{\\XeTeXpdffile} primitives are only defined in extended mode. + +@= +primitive("XeTeXpicfile",extension,pic_file_code);@/ +primitive("XeTeXpdffile",extension,pdf_file_code);@/ +primitive("XeTeXglyph",extension,glyph_code);@/ +primitive("XeTeXlinebreaklocale", extension, XeTeX_linebreak_locale_extension_code);@/ + +primitive("pdfsavepos",extension,pdf_save_pos_node);@/ +@z + +@x + set_language_code:print_esc("setlanguage"); +@y + set_language_code:print_esc("setlanguage"); + pic_file_code:print_esc("XeTeXpicfile"); + pdf_file_code:print_esc("XeTeXpdffile"); + glyph_code:print_esc("XeTeXglyph"); + XeTeX_linebreak_locale_extension_code:print_esc("XeTeXlinebreaklocale"); + + pdf_save_pos_node: print_esc("pdfsavepos"); +@z + +@x +set_language_code:@; +@y +set_language_code:@; +pic_file_code:@; +pdf_file_code:@; +glyph_code:@; +XeTeX_input_encoding_extension_code:@; +XeTeX_default_encoding_extension_code:@; +XeTeX_linebreak_locale_extension_code:@; + +pdf_save_pos_node: @; +@z + +@x +@ @= +@y +procedure print_native_word(@!p:pointer); +var i:integer; +begin + for i:=0 to native_length(p) - 1 do print_char(get_native_char(p,i)); +end; + +@ @= +@z + +@x +if write_stream(p) <> mubyte_zero then +begin + print_char ("<"); print_int (write_stream(p)-mubyte_zero); + if (write_stream(p)-mubyte_zero = 2) or + (write_stream(p)-mubyte_zero = 3) then + begin + print_char (":"); print_int (write_mubyte(p)-mubyte_zero); + end; + print_char (">"); +end; +@y +@z + +@x +othercases print("whatsit?") +@y +native_word_node:begin + print_esc(font_id_text(native_font(p))); + print_char(" "); + print_native_word(p); + end; +deleted_native_node: + print("[DELETED]"); +glyph_node:begin + print_esc(font_id_text(native_font(p))); + print(" glyph#"); + 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(""""); + end; +pdf_save_pos_node: print_esc("pdfsavepos"); +othercases print("whatsit?") +@z + +@x +@ @= +@y +@ Picture nodes are tricky in that they are variable size. +@d total_pic_node_size(#) == (pic_node_size + (pic_path_length(#) + sizeof(memory_word) - 1) div sizeof(memory_word)) + +@= +@z + +@x +othercases confusion("ext2") +@y +native_word_node: begin words:=native_size(p); + r:=get_node(words); + while words > 0 do + begin decr(words); mem[r+words]:=mem[p+words]; end; + native_glyph_info_ptr(r):=0; native_glyph_count(r):=0; + copy_native_glyph_info(p, r); + end; +deleted_native_node: begin words:=native_size(p); + r:=get_node(words); + end; +glyph_node: begin r:=get_node(glyph_node_size); + words:=glyph_node_size; + end; +pic_node,pdf_node: begin words:=total_pic_node_size(p); + r:=get_node(words); + end; +pdf_save_pos_node: + r := get_node(small_node_size); +othercases confusion("ext2") +@z + +@x +othercases confusion("ext3") +@y +native_word_node: begin free_native_glyph_info(p); free_node(p,native_size(p)); end; +deleted_native_node: free_node(p,native_size(p)); +glyph_node: free_node(p,glyph_node_size); +pic_node,pdf_node: free_node(p,total_pic_node_size(p)); +pdf_save_pos_node: + free_node(p, small_node_size); +othercases confusion("ext3") +@z + +@x +@ @=do_nothing +@y +@ @= +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; +end +@z + +@x +@ @=do_nothing +@y +@ @= +begin + case subtype(p) of + + native_word_node: + begin + { merge with any following word fragments, discarding discretionary breaks } + while (link(q) <> p) do q := link(q); { bring q up in preparation for deletion of nodes starting at p } + pp := link(p); + restart: + if (pp <> null) and (not is_char_node(pp)) and (type(pp) = disc_node) then begin + ppp := link(pp); + if (ppp <> null) and (not is_char_node(ppp)) and (type(ppp) = whatsit_node) and (subtype(ppp) = native_word_node) and (native_font(ppp) = native_font(p)) then begin + pp := link(ppp); + goto restart; + end + end; + { now pp points to the non-native_word node that ended the chain, or null } + + if (pp <> link(p)) then begin + { found a chain of at least two pieces starting at p } + total_chars := 0; + p := q; + while (p <> pp) do begin + p := link(p); { point to fragment } + total_chars := total_chars + native_length(p); { accumulate char count } + ppp := p; { remember last fragment seen } + p := link(p); { point to discretionary or other terminator } + end; + + p := link(q); { the first fragment } + 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 + 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); + if (ppp <> null) then ppp := link(ppp); { pass a disc_node } + 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 +@z + +@x +@ @=d:=0 +@y +@ @= +if (subtype(p)=native_word_node) +or (subtype(p)=glyph_node) +or (subtype(p)=pic_node) +or (subtype(p)=pdf_node) +then begin + d:=width(p); + goto found; +end else + d := 0 +@z + +@x +@ @d adv_past(#)==@+if subtype(#)=language_node then + begin cur_lang:=what_lang(#); l_hyf:=what_lhm(#); r_hyf:=what_rhm(#);@+end +@y +@ @d adv_past(#)==@+if subtype(#)=language_node then + begin cur_lang:=what_lang(#); l_hyf:=what_lhm(#); r_hyf:=what_rhm(#);@+end + else if (subtype(#)=native_word_node) + or (subtype(#)=glyph_node) + or (subtype(#)=pic_node) + or (subtype(#)=pdf_node) + then + begin act_width:=act_width+width(#); end +@z + +@x +@ @= +goto contribute +@y +@ @= +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; +end +@z + +@x +@ @= +goto not_found +@y +@ @= +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; +end +@z + +@x +@ @= +out_what(p) +@y +@ @= +begin + case subtype(p) of + 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: + @; + + othercases + out_what(p) + + endcases +end +@z + +@x +@ @= +out_what(p) +@y +@ @= +begin + pdf_last_x_pos := cur_h + cur_h_offset; + pdf_last_y_pos := cur_page_height - cur_v - cur_v_offset +end + +@ @= +cur_h_offset := h_offset + (unity * 7227) / 100; +cur_v_offset := v_offset + (unity * 7227) / 100; +if pdf_page_width <> 0 then + cur_page_width := pdf_page_width +else + cur_page_width := width(p) + 2*cur_h_offset; +if pdf_page_height <> 0 then + cur_page_height := pdf_page_height +else + cur_page_height := height(p) + depth(p) + 2*cur_v_offset + +@ @= +@!cur_page_width: scaled; {width of page being shipped} +@!cur_page_height: scaled; {height of page being shipped} +@!cur_h_offset: scaled; {horizontal offset of page being shipped} +@!cur_v_offset: scaled; {vertical offset of page being shipped} + +@ @= +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 @; + + 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) <> 0 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: + @; + + othercases + out_what(p) + + endcases +end +@z + +@x +procedure special_out(@!p:pointer); +var old_setting:0..max_selector; {holds print |selector|} +@!k:pool_pointer; {index into |str_pool|} +begin synch_h; synch_v;@/ +@y +procedure special_out(@!p:pointer); +var old_setting:0..max_selector; {holds print |selector|} +@!k:pool_pointer; {index into |str_pool|} +begin synch_h; synch_v;@/ +doing_special := true; +@z + +@x +for k:=str_start[str_ptr] to pool_ptr-1 do dvi_out(so(str_pool[k])); +spec_out := spec_sout; mubyte_out := mubyte_sout; mubyte_log := mubyte_slog; +special_printing := false; cs_converting := false; +active_noconvert := false; +pool_ptr:=str_start[str_ptr]; {erase the string} +@y +for k:=str_start_macro(str_ptr) to pool_ptr-1 do dvi_out(so(str_pool[k])); +pool_ptr:=str_start_macro(str_ptr); {erase the string} +doing_special := false; +@z + +@x +@!j:small_number; {write stream number} +@y +@!j:small_number; {write stream number} +@!k:integer; +@z + +@x + print(so(str_pool[str_start[str_ptr]+d])); {N.B.: not |print_char|} +@y + print(so(str_pool[str_start_macro(str_ptr)+d])); {N.B.: not |print_char|} +@z + +@x + begin str_pool[str_start[str_ptr]+d]:=xchr[str_pool[str_start[str_ptr]+d]]; + if (str_pool[str_start[str_ptr]+d]=null_code) +@y + begin + if (str_pool[str_start_macro(str_ptr)+d]=null_code) +@z + +@x + system(stringcast(address_of(str_pool[str_start[str_ptr]]))); +@y + if name_of_file then libc_free(name_of_file); + name_of_file := xmalloc(cur_length * 3 + 2); + k := 0; + for d:=0 to cur_length-1 do append_to_name(str_pool[str_start_macro(str_ptr)+d]); + name_of_file[k+1] := 0; + system(name_of_file + 1); +@z + +@x + pool_ptr:=str_start[str_ptr]; {erase the string} +@y + pool_ptr:=str_start_macro(str_ptr); {erase the string} +@z + +@x +@= +@y +@= +procedure pic_out(@!p:pointer; @!is_pdf:boolean); +var + i:integer; +begin +synch_h; synch_v; +dvi_out(pic_file); +if is_pdf then + dvi_out(pic_box_type(p)) +else + dvi_out(0); +dvi_four(pic_transform1(p)); +dvi_four(pic_transform2(p)); +dvi_four(pic_transform3(p)); +dvi_four(pic_transform4(p)); +dvi_four(pic_transform5(p)); +dvi_four(pic_transform6(p)); +dvi_two(pic_page(p)); +dvi_two(pic_path_length(p)); +for i:=0 to pic_path_length(p)-1 do + dvi_out(pic_path_byte(p, i)); +end; + +@z + +@x +language_node:do_nothing; +@y +language_node,deleted_native_node:do_nothing; +@z + +@x +@ @= +for k:=0 to 15 do if write_open[k] then a_close(write_file[k]) +@y +@ @= +terminate_font_manager; +for k:=0 to 15 do if write_open[k] then a_close(write_file[k]) + +@ @= +if abs(mode)=mmode then report_illegal_case +else load_picture(false) + +@ @= +if abs(mode)=mmode then report_illegal_case +else load_picture(true) + +@ @= +begin + if abs(mode)=vmode then begin + back_input; + new_graf(true); + end else if abs(mode)=mmode then report_illegal_case + else begin + if is_native_font(cur_font) then begin + new_whatsit(glyph_node,glyph_node_size); + scan_int; + if (cur_val<0)or(cur_val>65535) then + begin print_err("Bad glyph number"); + help2("A glyph number must be between 0 and 65535.")@/ + ("I changed this one to zero."); int_error(cur_val); cur_val:=0; + end; + native_font(tail):=cur_font; + native_glyph(tail):=cur_val; + set_native_glyph_metrics(tail, XeTeX_use_glyph_metrics); + end else begin + print_err("Invalid use of \XeTeXglyph"); + help2("The \XeTeXglyph command can only be used with AAT or OT fonts,") + ("not TFM-based fonts. So I'm ignoring this."); + error; + end + end +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 + +@d update_corners== + for i := 0 to 3 do + transform_point(address_of(corners[i]), address_of(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(address_of(t2), y_size_req / (ymax - ymin), y_size_req / (ymax - ymin)); + end else if y_size_req = 0.0 then begin + make_scale(address_of(t2), x_size_req / (xmax - xmin), x_size_req / (xmax - xmin)); + end else begin + make_scale(address_of(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(address_of(t), address_of(t2)); +end + +@= +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; + x_size, y_size: real; + 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; + + 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(address_of(pic_path), address_of(bounds), pdf_box_type, page); + + setPoint(corners[0], 0.0, 0.0); + setPoint(corners[1], 0.0, htField(bounds) * 72.27 / 72.0); + setPoint(corners[2], wdField(bounds) * 72.27 / 72.0, htField(bounds) * 72.27 / 72.0); + setPoint(corners[3], wdField(bounds) * 72.27 / 72.0, 0.0); + + x_size_req := 0.0; + y_size_req := 0.0; + + { look for any scaling requests for this picture } + make_identity(address_of(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(address_of(t2), float(cur_val) / 1000.0, float(cur_val) / 1000.0); + update_corners; + transform_concat(address_of(t), address_of(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(address_of(t2), float(cur_val) / 1000.0, 1.0); + update_corners; + transform_concat(address_of(t), address_of(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(address_of(t2), 1.0, float(cur_val) / 1000.0); + update_corners; + transform_concat(address_of(t), address_of(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 := Fix2X(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 := Fix2X(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(address_of(t2), Fix2X(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(address_of(t), address_of(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(address_of(t2), -xmin, -ymin); + transform_concat(address_of(t), address_of(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) := X2Fix(xmax - xmin); + height(tail) := X2Fix(ymax - ymin); + depth(tail) := 0; + + pic_transform1(tail) := X2Fix(aField(t)); + pic_transform2(tail) := X2Fix(bField(t)); + pic_transform3(tail) := X2Fix(cField(t)); + pic_transform4(tail) := X2Fix(dField(t)); + pic_transform5(tail) := X2Fix(xField(t)); + pic_transform6(tail) := X2Fix(yField(t)); + + memcpy(address_of(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; + +@ @= +begin + { scan a filename-like arg for the input encoding } + scan_and_pack_name; + + { convert it to "mode" and "encoding" values, and apply to the current input file } + i := get_encoding_mode_and_info(address_of(j)); + 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); +end + +@ @= +begin + { scan a filename-like arg for the input encoding } + scan_and_pack_name; + + { convert it to "mode" and "encoding" values, and store them as defaults for new input files } + XeTeX_default_input_mode := get_encoding_mode_and_info(address_of(j)); + XeTeX_default_input_encoding := j; +end + +@ @= +begin + { scan a filename-like arg for the locale name } + scan_file_name; + if length(cur_name) = 0 then XeTeX_linebreak_locale := 0 + else XeTeX_linebreak_locale := cur_name; { we ignore the area and extension! } +end + +@ @= +@!pdf_last_x_pos: integer; +@!pdf_last_y_pos: integer; + +@ @= +begin + new_whatsit(pdf_save_pos_node, small_node_size); +end + +@z + +@x +@d eTeX_version_code=eTeX_int {code for \.{\\eTeXversion}} +@y +@d eTeX_version_code=eTeX_int {code for \.{\\eTeXversion}} + +@d XeTeX_version_code=XeTeX_int {code for \.{\\XeTeXversion}} + +{ these are also in xetexmac.c and must correspond! } +@d XeTeX_count_glyphs_code=XeTeX_int+1 + +@d XeTeX_count_variations_code=XeTeX_int+2 +@d XeTeX_variation_code=XeTeX_int+3 +@d XeTeX_find_variation_by_name_code=XeTeX_int+4 +@d XeTeX_variation_min_code=XeTeX_int+5 +@d XeTeX_variation_max_code=XeTeX_int+6 +@d XeTeX_variation_default_code=XeTeX_int+7 + +@d XeTeX_count_features_code=XeTeX_int+8 +@d XeTeX_feature_code_code=XeTeX_int+9 +@d XeTeX_find_feature_by_name_code=XeTeX_int+10 +@d XeTeX_is_exclusive_feature_code=XeTeX_int+11 +@d XeTeX_count_selectors_code=XeTeX_int+12 +@d XeTeX_selector_code_code=XeTeX_int+13 +@d XeTeX_find_selector_by_name_code=XeTeX_int+14 +@d XeTeX_is_default_selector_code=XeTeX_int+15 + +@d XeTeX_OT_count_scripts_code=XeTeX_int+16 +@d XeTeX_OT_count_languages_code=XeTeX_int+17 +@d XeTeX_OT_count_features_code=XeTeX_int+18 +@d XeTeX_OT_script_code=XeTeX_int+19 +@d XeTeX_OT_language_code=XeTeX_int+20 +@d XeTeX_OT_feature_code=XeTeX_int+21 + +@d XeTeX_map_char_to_glyph_code=XeTeX_int+22 +@d XeTeX_glyph_index_code=XeTeX_int+23 +@d XeTeX_font_type_code=XeTeX_int+24 + +@d pdf_last_x_pos_code = XeTeX_int+25 +@d pdf_last_y_pos_code = XeTeX_int+26 +{ remember to update eTeX_dim when new items are added here } +@z + +@x +@!@:eTeX_revision_}{\.{\\eTeXrevision} primitive@> +@y +@!@:eTeX_revision_}{\.{\\eTeXrevision} primitive@> + +primitive("XeTeXversion",last_item,XeTeX_version_code); +@!@:XeTeX_version_}{\.{\\XeTeXversion} primitive@> +primitive("XeTeXrevision",convert,XeTeX_revision_code);@/ +@!@:XeTeXrevision_}{\.{\\XeTeXrevision} primitive@> + +primitive("XeTeXcountglyphs",last_item,XeTeX_count_glyphs_code); + +primitive("XeTeXcountvariations",last_item,XeTeX_count_variations_code); +primitive("XeTeXvariation",last_item,XeTeX_variation_code); +primitive("XeTeXfindvariationbyname",last_item,XeTeX_find_variation_by_name_code); +primitive("XeTeXvariationmin",last_item,XeTeX_variation_min_code); +primitive("XeTeXvariationmax",last_item,XeTeX_variation_max_code); +primitive("XeTeXvariationdefault",last_item,XeTeX_variation_default_code); + +primitive("XeTeXcountfeatures",last_item,XeTeX_count_features_code); +primitive("XeTeXfeaturecode",last_item,XeTeX_feature_code_code); +primitive("XeTeXfindfeaturebyname",last_item,XeTeX_find_feature_by_name_code); +primitive("XeTeXisexclusivefeature",last_item,XeTeX_is_exclusive_feature_code); +primitive("XeTeXcountselectors",last_item,XeTeX_count_selectors_code); +primitive("XeTeXselectorcode",last_item,XeTeX_selector_code_code); +primitive("XeTeXfindselectorbyname",last_item,XeTeX_find_selector_by_name_code); +primitive("XeTeXisdefaultselector",last_item,XeTeX_is_default_selector_code); + +primitive("XeTeXvariationname",convert,XeTeX_variation_name_code); +primitive("XeTeXfeaturename",convert,XeTeX_feature_name_code); +primitive("XeTeXselectorname",convert,XeTeX_selector_name_code); + +primitive("XeTeXOTcountscripts",last_item,XeTeX_OT_count_scripts_code); +primitive("XeTeXOTcountlanguages",last_item,XeTeX_OT_count_languages_code); +primitive("XeTeXOTcountfeatures",last_item,XeTeX_OT_count_features_code); +primitive("XeTeXOTscripttag",last_item,XeTeX_OT_script_code); +primitive("XeTeXOTlanguagetag",last_item,XeTeX_OT_language_code); +primitive("XeTeXOTfeaturetag",last_item,XeTeX_OT_feature_code); + +primitive("XeTeXcharglyph", last_item, XeTeX_map_char_to_glyph_code); +primitive("XeTeXglyphindex", last_item, XeTeX_glyph_index_code); + +primitive("XeTeXfonttype", last_item, XeTeX_font_type_code); + +primitive("pdflastxpos",last_item,pdf_last_x_pos_code); +primitive("pdflastypos",last_item,pdf_last_y_pos_code); +@z + +@x +eTeX_version_code: print_esc("eTeXversion"); +@y +eTeX_version_code: print_esc("eTeXversion"); +XeTeX_version_code: print_esc("XeTeXversion"); + +XeTeX_count_glyphs_code: print_esc("XeTeXcountglyphs"); + +XeTeX_count_variations_code: print_esc("XeTeXcountvariations"); +XeTeX_variation_code: print_esc("XeTeXvariation"); +XeTeX_find_variation_by_name_code: print_esc("XeTeXfindvariationbyname"); +XeTeX_variation_min_code: print_esc("XeTeXvariationmin"); +XeTeX_variation_max_code: print_esc("XeTeXvariationmax"); +XeTeX_variation_default_code: print_esc("XeTeXvariationdefault"); + +XeTeX_count_features_code: print_esc("XeTeXcountfeatures"); +XeTeX_feature_code_code: print_esc("XeTeXfeaturecode"); +XeTeX_find_feature_by_name_code: print_esc("XeTeXfindfeaturebyname"); +XeTeX_is_exclusive_feature_code: print_esc("XeTeXisexclusivefeature"); +XeTeX_count_selectors_code: print_esc("XeTeXcountselectors"); +XeTeX_selector_code_code: print_esc("XeTeXselectorcode"); +XeTeX_find_selector_by_name_code: print_esc("XeTeXfindselectorbyname"); +XeTeX_is_default_selector_code: print_esc("XeTeXisdefaultselector"); + +XeTeX_OT_count_scripts_code: print_esc("XeTeXOTcountscripts"); +XeTeX_OT_count_languages_code: print_esc("XeTeXOTcountlanguages"); +XeTeX_OT_count_features_code: print_esc("XeTeXOTcountfeatures"); +XeTeX_OT_script_code: print_esc("XeTeXOTscripttag"); +XeTeX_OT_language_code: print_esc("XeTeXOTlanguagetag"); +XeTeX_OT_feature_code: print_esc("XeTeXOTfeaturetag"); + +XeTeX_map_char_to_glyph_code: print_esc("XeTeXcharglyph"); +XeTeX_glyph_index_code: print_esc("XeTeXglyphindex"); + +XeTeX_font_type_code: print_esc("XeTeXfonttype"); + + pdf_last_x_pos_code: print_esc("pdflastxpos"); + pdf_last_y_pos_code: print_esc("pdflastypos"); +@z + +@x +eTeX_version_code: cur_val:=eTeX_version; +@y +eTeX_version_code: cur_val:=eTeX_version; +XeTeX_version_code: cur_val:=XeTeX_version; + +XeTeX_count_glyphs_code: + begin + scan_font_ident; n:=cur_val; + if is_atsu_font(n) then + cur_val:=atsu_font_get(m - XeTeX_int, font_layout_engine[n]) + else if is_ot_font(n) then + cur_val:=ot_font_get(m - XeTeX_int, font_layout_engine[n]) + else + cur_val:=0; + end; + +XeTeX_count_variations_code, +XeTeX_count_features_code: + begin + scan_font_ident; n:=cur_val; + if is_atsu_font(n) then + cur_val:=atsu_font_get(m - XeTeX_int, font_layout_engine[n]) + else begin + cur_val:=0; + end; + end; + +XeTeX_variation_code, +XeTeX_variation_min_code, +XeTeX_variation_max_code, +XeTeX_variation_default_code, +XeTeX_feature_code_code, +XeTeX_is_exclusive_feature_code, +XeTeX_count_selectors_code: + begin + scan_font_ident; n:=cur_val; + if is_atsu_font(n) then begin + scan_int; k:=cur_val; + cur_val:=atsu_font_get_1(m - XeTeX_int, font_layout_engine[n], k); + end else begin + not_atsu_font_error(last_item, m, n); cur_val:=-1; + end; + end; + +XeTeX_selector_code_code, +XeTeX_is_default_selector_code: + begin + scan_font_ident; n:=cur_val; + if is_atsu_font(n) then begin + scan_int; k:=cur_val; scan_int; + cur_val:=atsu_font_get_2(m - XeTeX_int, font_layout_engine[n], k, cur_val); + end else begin + not_atsu_font_error(last_item, m, n); cur_val:=-1; + end; + end; + +XeTeX_find_variation_by_name_code, +XeTeX_find_feature_by_name_code: + begin + scan_font_ident; n:=cur_val; + if is_atsu_font(n) then begin + scan_and_pack_name; + cur_val:=atsu_font_get_named(m - XeTeX_int, font_layout_engine[n]); + end else begin + not_atsu_font_error(last_item, m, n); cur_val:=-1; + end; + end; + +XeTeX_find_selector_by_name_code: + begin + scan_font_ident; n:=cur_val; + if is_atsu_font(n) then begin + scan_int; k:=cur_val; scan_and_pack_name; + cur_val:=atsu_font_get_named_1(m - XeTeX_int, font_layout_engine[n], k); + end else begin + not_atsu_font_error(last_item, m, n); cur_val:=-1; + end; + end; + +XeTeX_OT_count_scripts_code: + begin + scan_font_ident; n:=cur_val; + if is_ot_font(n) then + cur_val:=ot_font_get(m - XeTeX_int, font_layout_engine[n]) + else begin +{ + not_ot_font_error(last_item, m, n); cur_val:=-1; +} + cur_val:=0; + end; + end; + +XeTeX_OT_count_languages_code, +XeTeX_OT_script_code: + begin + scan_font_ident; n:=cur_val; + if is_ot_font(n) then begin + scan_int; k:=cur_val; + cur_val:=ot_font_get_1(m - XeTeX_int, font_layout_engine[n], k); + end else begin + not_ot_font_error(last_item, m, n); cur_val:=-1; + end; + end; + +XeTeX_OT_count_features_code, +XeTeX_OT_language_code: + begin + scan_font_ident; n:=cur_val; + if is_ot_font(n) then begin + scan_int; k:=cur_val; scan_int; + cur_val:=ot_font_get_2(m - XeTeX_int, font_layout_engine[n], k, cur_val); + end else begin + not_ot_font_error(last_item, m, n); cur_val:=-1; + end; + end; + +XeTeX_OT_feature_code: + begin + scan_font_ident; n:=cur_val; + if is_ot_font(n) then begin + scan_int; k:=cur_val; scan_int; kk:=cur_val; scan_int; + cur_val:=ot_font_get_3(m - XeTeX_int, font_layout_engine[n], k, kk, cur_val); + end else begin + not_ot_font_error(last_item, m, n); cur_val:=-1; + end; + end; + +XeTeX_map_char_to_glyph_code: + begin + if is_native_font(cur_font) then begin + scan_int; n:=cur_val; cur_val:=map_char_to_glyph(cur_font, n) + end else begin + not_native_font_error(last_item, m, cur_font); cur_val:=0 + end + end; + +XeTeX_glyph_index_code: + begin + if is_native_font(cur_font) then begin + scan_and_pack_name; + cur_val:=map_glyph_to_index(cur_font) + end else begin + not_native_font_error(last_item, m, cur_font); cur_val:=0 + end + end; + +XeTeX_font_type_code: + begin + scan_font_ident; n:=cur_val; + if is_atsu_font(n) then cur_val:=1 + else begin + if is_ot_font(n) then cur_val:=2 + else cur_val:=0 + end + end; + + pdf_last_x_pos_code: cur_val := pdf_last_x_pos; + pdf_last_y_pos_code: cur_val := pdf_last_y_pos; + +@ Slip in an extra procedure here and there.... + +@= +procedure scan_and_pack_name; forward; + +@ @= +procedure scan_and_pack_name; +begin + scan_file_name; pack_cur_name; +end; + +@ @= +procedure not_atsu_font_error(cmd, c: integer; f: integer); +begin + print_err("Cannot use "); print_cmd_chr(cmd, c); + print(" with "); print(font_name[f]); + print("; not an AAT font"); + error; +end; + +procedure not_ot_font_error(cmd, c: integer; f: integer); +begin + print_err("Cannot use "); print_cmd_chr(cmd, c); + print(" with "); print(font_name[f]); + print("; not an OpenType Layout font"); + error; +end; + +procedure not_native_font_error(cmd, c: integer; f: integer); +begin + print_err("Cannot use "); print_cmd_chr(cmd, c); + print(" with "); print(font_name[f]); + print("; not a native platform font"); + error; +end; + +@ @= +eTeX_revision_code: print_esc("eTeXrevision"); +XeTeX_revision_code: print_esc("XeTeXrevision"); + +XeTeX_variation_name_code: print_esc("XeTeXvariationname"); +XeTeX_feature_name_code: print_esc("XeTeXfeaturename"); +XeTeX_selector_name_code: print_esc("XeTeXselectorname"); + +@ @= +eTeX_revision_code: do_nothing; +XeTeX_revision_code: do_nothing; + +XeTeX_variation_name_code, +XeTeX_feature_name_code: + begin + scan_font_ident; fnt:=cur_val; + if is_atsu_font(fnt) then begin + scan_int; arg1:=cur_val; arg2:=0; + end else + not_atsu_font_error(convert, c, f); + end; + +XeTeX_selector_name_code: + begin + scan_font_ident; fnt:=cur_val; + if is_atsu_font(fnt) then begin + scan_int; arg1:=cur_val; scan_int; arg2:=cur_val; + end else + not_atsu_font_error(convert, c, f); + end; + +@ @= +eTeX_revision_code: print(eTeX_revision); +XeTeX_revision_code: print(XeTeX_revision); + +XeTeX_variation_name_code, +XeTeX_feature_name_code, +XeTeX_selector_name_code: + if is_atsu_font(fnt) then + atsu_print_font_name(c, font_layout_engine[fnt], arg1, arg2); +@z + +@x +font_char_wd_code, +font_char_ht_code, +font_char_dp_code, +font_char_ic_code: begin scan_font_ident; q:=cur_val; scan_char_num; + if (font_bc[q]<=cur_val)and(font_ec[q]>=cur_val) then + begin i:=char_info(q)(qi(cur_val)); + case m of + font_char_wd_code: cur_val:=char_width(q)(i); + font_char_ht_code: cur_val:=char_height(q)(height_depth(i)); + font_char_dp_code: cur_val:=char_depth(q)(height_depth(i)); + font_char_ic_code: cur_val:=char_italic(q)(i); + end; {there are no other cases} + end + else cur_val:=0; + end; +@y +font_char_wd_code, +font_char_ht_code, +font_char_dp_code, +font_char_ic_code: begin scan_font_ident; q:=cur_val; scan_usv_num; + if is_native_font(q) then begin + case m of + font_char_wd_code: cur_val := getnativecharwd(q, cur_val); + font_char_ht_code: cur_val := getnativecharht(q, cur_val); + font_char_dp_code: cur_val := getnativechardp(q, cur_val); + font_char_ic_code: cur_val := getnativecharic(q, cur_val); + end; {there are no other cases} + end else begin + if (font_bc[q]<=cur_val)and(font_ec[q]>=cur_val) then + begin i:=char_info(q)(qi(cur_val)); + case m of + font_char_wd_code: cur_val:=char_width(q)(i); + font_char_ht_code: cur_val:=char_height(q)(height_depth(i)); + font_char_dp_code: cur_val:=char_depth(q)(height_depth(i)); + font_char_ic_code: cur_val:=char_italic(q)(i); + end; {there are no other cases} + end + else cur_val:=0; + end + end; +@z + +@x +@d TeXXeT_en==(TeXXeT_state>0) {is \TeXXeT\ enabled?} +@y +@d TeXXeT_en==(TeXXeT_state>0) {is \TeXXeT\ enabled?} + +@d XeTeX_dash_break_state == eTeX_state(XeTeX_dash_break_code) +@d XeTeX_dash_break_en == (XeTeX_dash_break_state>0) + +@d XeTeX_default_input_mode == eTeX_state(XeTeX_default_input_mode_code) +@d XeTeX_default_input_encoding == eTeX_state(XeTeX_default_input_encoding_code) +@z + +@x +eTeX_state_code+TeXXeT_code:print_esc("TeXXeTstate"); +@y +eTeX_state_code+TeXXeT_code:print_esc("TeXXeTstate"); +eTeX_state_code+XeTeX_dash_break_code:print_esc("XeTeXdashbreakstate"); +@z + +@x +primitive("TeXXeTstate",assign_int,eTeX_state_base+TeXXeT_code); +@!@:TeXXeT_state_}{\.{\\TeXXeT_state} primitive@> +@y +primitive("TeXXeTstate",assign_int,eTeX_state_base+TeXXeT_code); +@!@:TeXXeT_state_}{\.{\\TeXXeT_state} primitive@> + +primitive("XeTeXdashbreakstate",assign_int,eTeX_state_base+XeTeX_dash_break_code); +@!@:XeTeX_dash_break_state_}{\.{\\XeTeX_dash_break_state} primitive@> + +primitive("XeTeXinputencoding",extension,XeTeX_input_encoding_extension_code); +primitive("XeTeXdefaultencoding",extension,XeTeX_default_encoding_extension_code); +@z + +@x +@ Here we compute the effective width of a glue node as in |hlist_out|. + +@= +glue_node: begin round_glue; + @; + end; +@y +@ Need to measure native_word and picture nodes when reversing! +@= +whatsit_node: + if (subtype(p)=native_word_node) + or (subtype(p)=glyph_node) + or (subtype(p)=pic_node) + or (subtype(p)=pdf_node) + then + rule_wd:=width(p) + else + goto next_p; + +@ Here we compute the effective width of a glue node as in |hlist_out|. +@z + +@x +str_pool[pool_ptr]:=si(" "); l:=str_start[s]; +@y +str_pool[pool_ptr]:=si(" "); l:=str_start_macro(s); +@z + +@x +if_font_char_code:begin scan_font_ident; n:=cur_val; scan_char_num; + if (font_bc[n]<=cur_val)and(font_ec[n]>=cur_val) then + b:=char_exists(char_info(n)(qi(cur_val))) + else b:=false; + end; +@y +if_font_char_code:begin scan_font_ident; n:=cur_val; scan_usv_num; + if is_native_font(n) then + b := (map_char_to_glyph(n, cur_val) > 0) + else begin + if (font_bc[n]<=cur_val)and(font_ec[n]>=cur_val) then + b:=char_exists(char_info(n)(qi(cur_val))) + else b:=false; + end; + end; +@z + +@x + for c := str_start[text(h)] to str_start[text(h) + 1] - 1 +@y + for c := str_start_macro(text(h)) to str_start_macro(text(h) + 1) - 1 +@z + +@x + while s>255 do {first 256 strings depend on implementation!!} +@y + while s>65535 do {first 64K strings don't really exist in the pool!} +@z + +@x +@!mltex_enabled_p:boolean; {enable character substitution} +@y +@!mltex_enabled_p:boolean; {enable character substitution} +@!native_font_type_flag:integer; {used by XeTeX font loading code to record which font technology was used} +@z + +@x +effective_char_info:=null_character; +exit:end; +@y +effective_char_info:=null_character; +exit:end; + +{ the following procedure has been moved so that new_native_character can call it } + +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; + begin begin_diagnostic; + print_nl("Missing character: There is no "); +@.Missing character@> + if c < @"10000 then print_ASCII(c) + else begin { non-Plane 0 Unicodes can't be sent through print_ASCII } + print("character number "); + print_hex(c); + end; + print(" in font "); + slow_print(font_name[f]); print_char("!"); end_diagnostic(false); + end; + tracing_online:=old_setting; + end; +end; + +{ additional functions for native font support } + +function new_native_word_node(@!f:internal_font_number;@!n:integer):pointer; + { note that this function creates the node, but does not actually set its metrics; + call set_native_metrics(node) if that is required! } +var + l: integer; + q: pointer; +begin + 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; + + native_size(q) := l; + native_font(q) := f; + native_length(q) := n; + + native_glyph_count(q) := 0; + native_glyph_info_ptr(q) := 0; + + new_native_word_node := q; +end; + +function new_native_character(@!f:internal_font_number;@!c:UnicodeScalar):pointer; +var + 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], address_of(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) := 0; + 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); +var + 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); +end; + +procedure font_mapping_warning(mappingNameP:void_pointer; mappingNameLen:integer); +var + i: integer; +begin + begin_diagnostic; + 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; + print("' not found."); + end_diagnostic(false); +end; + +function load_native_font(u: pointer; nom, aire:str_number; s: scaled): internal_font_number; +label + done; +var + k: integer; + font_engine: void_pointer; {really an ATSUStyle 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; + + if (s < 0) then actual_size := -s * unity div 100 else actual_size := s; + font_engine := find_native_font(name_of_file + 1, actual_size); + if font_engine = 0 then goto done; + + { 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; + end; + + if (font_ptr = font_max) or (fmem_ptr + 8 > font_mem_size) then begin + @; + 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] := 10 * unity; + font_size[font_ptr] := actual_size; + + if (native_font_type_flag = aat_font_flag) then begin + atsu_get_font_metrics(font_engine, address_of(ascent), address_of(descent), + address_of(x_ht), address_of(cap_ht), address_of(font_slant)) + end else begin + ot_get_font_metrics(font_engine, address_of(ascent), address_of(descent), + address_of(x_ht), address_of(cap_ht), address_of(font_slant)); + end; + + height_base[font_ptr] := ascent; + depth_base[font_ptr] := -descent; + + font_params[font_ptr] := 8; { we add an extra \fontdimen: #8 -> cap_height } + 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; + + {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); + + 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: pointer; len: integer); +var + offs, prevOffs, i: integer; + use_penalty, use_skip: boolean; +begin + if XeTeX_linebreak_locale = 0 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, str_pool[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(XeTeX_linebreak_locale, address_of(str_pool[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, str_pool[s + i]); + set_native_metrics(tail, XeTeX_use_glyph_metrics); + end; + until offs < 0; + end +end; + +@z diff --git a/Build/source/texk/web2c/xetexdir/xetex-noenc.ch b/Build/source/texk/web2c/xetexdir/xetex-noenc.ch new file mode 100644 index 00000000000..71591ca8350 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/xetex-noenc.ch @@ -0,0 +1,1144 @@ +% /****************************************************************************\ +% Part of the XeTeX typesetting system +% copyright (c) 1994-2006 by SIL International +% written by Jonathan Kew +% +% Permission is hereby granted, free of charge, to any person obtaining +% a copy of this software and associated documentation files (the +% "Software"), to deal in the Software without restriction, including +% without limitation the rights to use, copy, modify, merge, publish, +% distribute, sublicense, and/or sell copies of the Software, and to +% permit persons to whom the Software is furnished to do so, subject to +% the following conditions: +% +% The above copyright notice and this permission notice shall be +% included in all copies or substantial portions of the Software. +% +% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +% EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +% MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +% NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +% ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +% CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +% WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +% +% Except as contained in this notice, the name of SIL International +% shall not be used in advertising or otherwise to promote the sale, +% use or other dealings in this Software without prior written +% authorization from SIL International. +% \****************************************************************************/ + +% Extra changes to remove the encTeX features from XeTeX +% (and print a warning if --translate-file is used) +% ====================================================== + + +@x +@!xord: array [text_char] of ASCII_code; + {specifies conversion of input characters} +xchr: array [ASCII_code] of text_char; + { specifies conversion of output characters } +xprn: array [ASCII_code] of ASCII_code; + { non zero iff character is printable } +mubyte_read: array [ASCII_code] of pointer; + { non zero iff character begins the multi byte code } +mubyte_write: array [ASCII_code] of str_number; + { non zero iff character expands to multi bytes in log and write files } +mubyte_cswrite: array [0..127] of pointer; + { non null iff cs mod 128 expands to multi bytes in log and write files } +mubyte_skip: integer; { the number of bytes to skip in |buffer| } +mubyte_keep: integer; { the number of chars we need to keep unchanged } +mubyte_skeep: integer; { saved |mubyte_keep| } +mubyte_prefix: integer; { the type of mubyte prefix } +mubyte_tablein: boolean; { the input side of table will be updated } +mubyte_tableout: boolean; { the output side of table will be updated } +mubyte_relax: boolean; { the relax prefix is used } +mubyte_start: boolean; { we are making the token at the start of the line } +mubyte_sstart: boolean; { saved |mubyte_start| } +mubyte_token: pointer; { the token returned by |read_buffer| } +mubyte_stoken: pointer; { saved first token in mubyte primitive } +mubyte_sout: integer; { saved value of |mubyte_out| } +mubyte_slog: integer; { saved value of |mubyte_log| } +spec_sout: integer; { saved value of |spec_out| } +no_convert: boolean; { conversion supressed by noconvert primitive } +active_noconvert: boolean; { true if noconvert primitive is active } +write_noexpanding: boolean; { true only if we need not write expansion } +cs_converting: boolean; { true only if we need csname converting } +special_printing: boolean; { true only if we need converting in special } +message_printing: boolean; { true if message or errmessage prints to string } +@y +@!xchr: ^text_char; + {dummy variable so tangle doesn't complain; not actually used} +@z + +@x +xchr[@'40]:=' '; +xchr[@'41]:='!'; +xchr[@'42]:='"'; +xchr[@'43]:='#'; +xchr[@'44]:='$'; +xchr[@'45]:='%'; +xchr[@'46]:='&'; +xchr[@'47]:='''';@/ +xchr[@'50]:='('; +xchr[@'51]:=')'; +xchr[@'52]:='*'; +xchr[@'53]:='+'; +xchr[@'54]:=','; +xchr[@'55]:='-'; +xchr[@'56]:='.'; +xchr[@'57]:='/';@/ +xchr[@'60]:='0'; +xchr[@'61]:='1'; +xchr[@'62]:='2'; +xchr[@'63]:='3'; +xchr[@'64]:='4'; +xchr[@'65]:='5'; +xchr[@'66]:='6'; +xchr[@'67]:='7';@/ +xchr[@'70]:='8'; +xchr[@'71]:='9'; +xchr[@'72]:=':'; +xchr[@'73]:=';'; +xchr[@'74]:='<'; +xchr[@'75]:='='; +xchr[@'76]:='>'; +xchr[@'77]:='?';@/ +xchr[@'100]:='@@'; +xchr[@'101]:='A'; +xchr[@'102]:='B'; +xchr[@'103]:='C'; +xchr[@'104]:='D'; +xchr[@'105]:='E'; +xchr[@'106]:='F'; +xchr[@'107]:='G';@/ +xchr[@'110]:='H'; +xchr[@'111]:='I'; +xchr[@'112]:='J'; +xchr[@'113]:='K'; +xchr[@'114]:='L'; +xchr[@'115]:='M'; +xchr[@'116]:='N'; +xchr[@'117]:='O';@/ +xchr[@'120]:='P'; +xchr[@'121]:='Q'; +xchr[@'122]:='R'; +xchr[@'123]:='S'; +xchr[@'124]:='T'; +xchr[@'125]:='U'; +xchr[@'126]:='V'; +xchr[@'127]:='W';@/ +xchr[@'130]:='X'; +xchr[@'131]:='Y'; +xchr[@'132]:='Z'; +xchr[@'133]:='['; +xchr[@'134]:='\'; +xchr[@'135]:=']'; +xchr[@'136]:='^'; +xchr[@'137]:='_';@/ +xchr[@'140]:='`'; +xchr[@'141]:='a'; +xchr[@'142]:='b'; +xchr[@'143]:='c'; +xchr[@'144]:='d'; +xchr[@'145]:='e'; +xchr[@'146]:='f'; +xchr[@'147]:='g';@/ +xchr[@'150]:='h'; +xchr[@'151]:='i'; +xchr[@'152]:='j'; +xchr[@'153]:='k'; +xchr[@'154]:='l'; +xchr[@'155]:='m'; +xchr[@'156]:='n'; +xchr[@'157]:='o';@/ +xchr[@'160]:='p'; +xchr[@'161]:='q'; +xchr[@'162]:='r'; +xchr[@'163]:='s'; +xchr[@'164]:='t'; +xchr[@'165]:='u'; +xchr[@'166]:='v'; +xchr[@'167]:='w';@/ +xchr[@'170]:='x'; +xchr[@'171]:='y'; +xchr[@'172]:='z'; +xchr[@'173]:='{'; +xchr[@'174]:='|'; +xchr[@'175]:='}'; +xchr[@'176]:='~';@/ +@y +{ don't need to set up xchr here } +@z + +@x +{Initialize |xchr| to the identity mapping.} +for i:=0 to @'37 do xchr[i]:=i; +for i:=@'177 to @'377 do xchr[i]:=i; +{Initialize enc\TeX\ data.} +for i:=0 to 255 do mubyte_read[i]:=null; +for i:=0 to 255 do mubyte_write[i]:=0; +for i:=0 to 128 do mubyte_cswrite[i]:=null; +mubyte_keep := 0; mubyte_start := false; +write_noexpanding := false; cs_converting := false; +special_printing := false; message_printing := false; +no_convert := false; active_noconvert := false; +@y +@z + +@x +for i:=first_text_char to last_text_char do xord[chr(i)]:=invalid_code; +for i:=@'200 to @'377 do xord[xchr[i]]:=i; +for i:=0 to @'176 do xord[xchr[i]]:=i; +{Set |xprn| for printable ASCII, unless |eight_bit_p| is set.} +for i:=0 to 255 do xprn[i]:=(eight_bit_p or ((i>=" ")and(i<="~"))); + +{The idea for this dynamic translation comes from the patch by + Libor Skarvada \.{} + and Petr Sojka \.{}. I didn't use any of the + actual code, though, preferring a more general approach.} + +{This updates the |xchr|, |xord|, and |xprn| arrays from the provided + |translate_filename|. See the function definition in \.{texmfmp.c} for + more comments.} +if translate_filename then read_tcx_file; +@y +@z + +@x +if translate_filename then begin + wterm(' ('); + fputs(translate_filename, stdout); + wterm_ln(')'); +end; +@y +if translate_filename then begin + wterm(' (WARNING: translate-file "'); + fputs(translate_filename, stdout); + wterm_ln('" ignored)'); +end; +@z + +@x +@d xord_code_base=cur_font_loc+1 +@d xchr_code_base=xord_code_base+1 +@d xprn_code_base=xchr_code_base+1 +@d math_font_base=xprn_code_base+1 +@y +@d math_font_base=cur_font_loc+1 +@z + +@x +@d mubyte_in_code=web2c_int_base+3 {if positive then reading mubytes is active} +@d mubyte_out_code=web2c_int_base+4 {if positive then printing mubytes is active} +@d mubyte_log_code=web2c_int_base+5 {if positive then print mubytes to log and terminal} +@d spec_out_code=web2c_int_base+6 {if positive then print specials by mubytes} +@d web2c_int_pars=web2c_int_base+7 {total number of web2c's integer parameters} +@y +@d web2c_int_pars=web2c_int_base+3 {total number of web2c's integer parameters} +@z + +@x +@d mubyte_in==int_par(mubyte_in_code) +@d mubyte_out==int_par(mubyte_out_code) +@d mubyte_log==int_par(mubyte_log_code) +@d spec_out==int_par(spec_out_code) +@y +@z + +@x +mubyte_in_code:print_esc("mubytein"); +mubyte_out_code:print_esc("mubyteout"); +mubyte_log_code:print_esc("mubytelog"); +spec_out_code:print_esc("specialout"); +@y +@z + +@x +if enctex_p then + begin enctex_enabled_p:=true; + primitive("mubytein",assign_int,int_base+mubyte_in_code);@/ +@!@:mubyte_in_}{\.{\\mubytein} primitive@> + primitive("mubyteout",assign_int,int_base+mubyte_out_code);@/ +@!@:mubyte_out_}{\.{\\mubyteout} primitive@> + primitive("mubytelog",assign_int,int_base+mubyte_log_code);@/ +@!@:mubyte_log_}{\.{\\mubytelog} primitive@> + primitive("specialout",assign_int,int_base+spec_out_code);@/ +@!@:spec_out_}{\.{\\specialout} primitive@> +end; +@y +@z + +@x +procedure print_cs(@!p:integer); {prints a purported control sequence} +var q: pointer; + s: str_number; +begin + if active_noconvert and (not no_convert) and + (eq_type(p) = let) and (equiv(p) = normal+11) then { noconvert } + begin + no_convert := true; + return; + end; + s := 0; + if cs_converting and (not no_convert) then + begin + q := mubyte_cswrite [p mod 128] ; + while q <> null do + if info (q) = p then + begin + s := info (link(q)); q := null; + end else q := link (link (q)); + end; + no_convert := false; + if s > 0 then print (s) + else if p +end; +@y +@z + +@x +i := start; mubyte_skeep := mubyte_keep; +mubyte_sstart := mubyte_start; mubyte_start := false; +if j>0 then while i < j do +begin + if i=loc then set_trick_count; + print_buffer(i); +end; +mubyte_keep := mubyte_skeep; mubyte_start := mubyte_sstart +@y +if j>0 then for i:=start to j-1 do + begin if i=loc then set_trick_count; + print(buffer[i]); + end +@z + +@x +Some additional routines used by the enc\TeX extension have to be +declared at this point. + +@p @t\4@>@@/ + +@y +@z + +@x +@!i,@!j: 0..buf_size; {more indexes for encTeX} +@!mubyte_incs: boolean; {control sequence is converted by mubyte} +@!p:pointer; {for encTeX test if noexpanding} +@y +@z + +@x + begin + { Use |k| instead of |loc| for type correctness. } + k := loc; + cur_chr := read_buffer (k); + loc := k; incr (loc); + if (mubyte_token > 0) then + begin + state := mid_line; + cur_cs := mubyte_token - cs_token_flag; + goto found; + end; +@y + begin cur_chr:=buffer[loc]; incr(loc); +@z + +@x +else begin start_cs: + mubyte_incs := false; k := loc; mubyte_skeep := mubyte_keep; + cur_chr := read_buffer (k); cat := cat_code (cur_chr); + if (mubyte_in>0) and (not mubyte_incs) and + ((mubyte_skip>0) or (cur_chr<>buffer[k])) then mubyte_incs := true; + incr (k); + if mubyte_token > 0 then + begin + state := mid_line; + cur_cs := mubyte_token - cs_token_flag; + goto found; + end; +@y +else begin start_cs: k:=loc; cur_chr:=buffer[k]; cat:=cat_code(cur_chr); + incr(k); +@z + +@x + mubyte_keep := mubyte_skeep; + cur_cs:=single_base + read_buffer(loc); incr(loc); +@y + cur_cs:=single_base+buffer[loc]; incr(loc); +@z + +@x +if write_noexpanding then +begin + p := mubyte_cswrite [cur_cs mod 128]; + while p <> null do + if info (p) = cur_cs then + begin + cur_cmd := relax; cur_chr := 256; p := null; + end else p := link (link (p)); +end; +@y +@z + +@x +@ @= +begin + repeat cur_chr := read_buffer (k); cat := cat_code (cur_chr); + if mubyte_token>0 then cat := escape; + if (mubyte_in>0) and (not mubyte_incs) and (cat=letter) and + ((mubyte_skip>0) or (cur_chr<>buffer[k])) then mubyte_incs := true; + incr (k); + until (cat <> letter) or (k > limit); + @; + if cat <> letter then + begin + decr (k); k := k - mubyte_skip; + end; + if k > loc + 1 then { multiletter control sequence has been scanned } + begin + if mubyte_incs then { multibyte in csname occurrs } + begin + i := loc; j := first; mubyte_keep := mubyte_skeep; + if j - loc + k > max_buf_stack then + begin + max_buf_stack := j - loc + k; + if max_buf_stack >= buf_size then + begin + max_buf_stack := buf_size; + overflow ("buffer size", buf_size); + end; + end; + while i < k do + begin + buffer [j] := read_buffer (i); + incr (i); incr (j); + end; + if j = first+1 then + cur_cs := single_base + buffer [first] + else + cur_cs := id_lookup (first, j-first); + end else cur_cs := id_lookup (loc, k-loc) ; + loc := k; + goto found; + end; +end +@y +@ @= +begin repeat cur_chr:=buffer[k]; cat:=cat_code(cur_chr); incr(k); +until (cat<>letter)or(k>limit); +@; +if cat<>letter then decr(k); + {now |k| points to first nonletter} +if k>loc+1 then {multiletter control sequence has been scanned} + begin cur_cs:=id_lookup(loc,k-loc); loc:=k; goto found; + end; +end +@z + +@x + if write_noexpanding then + begin + p := mubyte_cswrite [cur_cs mod 128]; + while p <> null do + if info (p) = cur_cs then + begin + cur_cmd := relax; cur_chr := 256; p := null; + end else p := link (link (p)); + end; +@y +@z + +@x +if enctex_enabled_p then + begin wlog_cr; wlog(encTeX_banner); wlog(', reencoding enabled'); + if translate_filename then + begin wlog_cr; + wlog(' (\xordcode, \xchrcode, \xprncode overridden by TCX)'); + end; + end; +@y +@z + +@x +if translate_filename then begin + wlog_cr; + wlog(' ('); + fputs(translate_filename, log_file); + wlog(')'); + end; +@y +if translate_filename then begin + wlog_cr; + wlog(' (WARNING: translate-file "'); + fputs(translate_filename, log_file); + wlog('" ignored)'); + end; +@z + +@x +procedure cs_error; +begin +if cur_chr = 10 then +begin + print_err("Extra "); print_esc("endmubyte"); +@.Extra \\endmubyte@> + help1("I'm ignoring this, since I wasn't doing a \mubyte."); +end else begin + print_err("Extra "); print_esc("endcsname"); +@.Extra \\endcsname@> + help1("I'm ignoring this, since I wasn't doing a \csname."); +end; +error; +end; +@y +procedure cs_error; +begin print_err("Extra "); print_esc("endcsname"); +@.Extra \\endcsname@> +help1("I'm ignoring this, since I wasn't doing a \csname."); +error; +end; +@z + +@x +if enctex_p then +begin + primitive("mubyte",let,normal+10);@/ +@!@:mubyte_}{\.{\\mubyte} primitive@> + primitive("noconvert",let,normal+11);@/ +@!@:noconvert_}{\.{\\noconvert} primitive@> +end; +@y +@z + +@x +let: if chr_code<>normal then + if chr_code = normal+10 then print_esc("mubyte") + else if chr_code = normal+11 then print_esc("noconvert") + else print_esc("futurelet") + else print_esc("let"); +@y +let: if chr_code<>normal then print_esc("futurelet")@+else print_esc("let"); +@z + +@x +let: if cur_chr = normal+11 then do_nothing { noconvert primitive } + else if cur_chr = normal+10 then { mubyte primitive } + begin + selector:=term_and_log; + get_token; + mubyte_stoken := cur_tok; + if cur_tok <= cs_token_flag then mubyte_stoken := cur_tok mod 256; + mubyte_prefix := 60; mubyte_relax := false; + mubyte_tablein := true; mubyte_tableout := true; + get_x_token; + if cur_cmd = spacer then get_x_token; + if cur_cmd = sub_mark then + begin + mubyte_tableout := false; get_x_token; + if cur_cmd = sub_mark then + begin + mubyte_tableout := true; mubyte_tablein := false; + get_x_token; + end; + end else if (mubyte_stoken > cs_token_flag) and + (cur_cmd = mac_param) then + begin + mubyte_tableout := false; + scan_int; mubyte_prefix := cur_val; get_x_token; + if mubyte_prefix > 50 then mubyte_prefix := 52; + if mubyte_prefix <= 0 then mubyte_prefix := 51; + end + else if (mubyte_stoken > cs_token_flag) and (cur_cmd = relax) then + begin + mubyte_tableout := true; mubyte_tablein := false; + mubyte_relax := true; get_x_token; + end; + r := get_avail; p := r; + while cur_cs = 0 do begin store_new_token (cur_tok); get_x_token; end; + if (cur_cmd <> end_cs_name) or (cur_chr <> 10) then + begin + print_err("Missing "); print_esc("endmubyte"); print(" inserted"); + help2("The control sequence marked should")@/ +("not appear in between \mubyte and \endmubyte."); + back_error; + end; + p := link(r); + if (p = null) and mubyte_tablein then + begin + print_err("The empty , "); + print_esc("mubyte"); print(" ignored"); + help2("The in")@/ +("\mubyte \endmubyte should not be empty."); + error; + end else begin + while p <> null do + begin + append_char (info(p) mod 256); + p := link (p); + end; + flush_list (r); + if (str_start [str_ptr] + 1 = pool_ptr) and + (str_pool [pool_ptr-1] = mubyte_stoken) then + begin + if mubyte_read [mubyte_stoken] <> null + and mubyte_tablein then { clearing data } + dispose_munode (mubyte_read [mubyte_stoken]); + if mubyte_tablein then mubyte_read [mubyte_stoken] := null; + if mubyte_tableout then mubyte_write [mubyte_stoken] := 0; + pool_ptr := str_start [str_ptr]; + end else begin + if mubyte_tablein then mubyte_update; { updating input side } + if mubyte_tableout then { updating output side } + begin + if mubyte_stoken > cs_token_flag then { control sequence } + begin + dispose_mutableout (mubyte_stoken-cs_token_flag); + if (str_start [str_ptr] < pool_ptr) or mubyte_relax then + begin { store data } + r := mubyte_cswrite[(mubyte_stoken-cs_token_flag) mod 128]; + p := get_avail; + mubyte_cswrite[(mubyte_stoken-cs_token_flag) mod 128] := p; + info (p) := mubyte_stoken-cs_token_flag; + link (p) := get_avail; + p := link (p); + if mubyte_relax then begin + info (p) := 0; pool_ptr := str_start [str_ptr]; + end else info (p) := slow_make_string; + link (p) := r; + end; + end else begin { single character } + if str_start [str_ptr] = pool_ptr then + mubyte_write [mubyte_stoken] := 0 + else + mubyte_write [mubyte_stoken] := slow_make_string; + end; + end else pool_ptr := str_start [str_ptr]; + end; + end; + end else begin { let primitive } + n:=cur_chr; +@y +let: begin n:=cur_chr; +@z + +@x +if enctex_p then +begin + primitive("xordcode",def_code,xord_code_base); +@!@:xord_code_}{\.{\\xordcode} primitive@> + primitive("xchrcode",def_code,xchr_code_base); +@!@:xchr_code_}{\.{\\xchrcode} primitive@> + primitive("xprncode",def_code,xprn_code_base); +@!@:xprn_code_}{\.{\\xprncode} primitive@> +end; +@y +@z + +@x +def_code: if chr_code=xord_code_base then print_esc("xordcode") + else if chr_code=xchr_code_base then print_esc("xchrcode") + else if chr_code=xprn_code_base then print_esc("xprncode") + else if chr_code=cat_code_base then print_esc("catcode") +@y +def_code: if chr_code=cat_code_base then print_esc("catcode") +@z + +@x + if p=xord_code_base then p:=cur_val + else if p=xchr_code_base then p:=cur_val+256 + else if p=xprn_code_base then p:=cur_val+512 + else p:=p+cur_val; +@y + p:=p+cur_val; +@z + +@x +message_printing := true; active_noconvert := true; +token_show(def_ref); +message_printing := false; active_noconvert := false; +@y +token_show(def_ref); +@z + +@x +@; +@y +@z + +@x +@!dummy_xord: ASCII_code; +@!dummy_xchr: text_char; +@!dummy_xprn: ASCII_code; +@y +@z + +@x +@; +@y +@z + +@x +@; +@y +@z + +@x +@; +@y +@z + +@x +if enctex_enabled_p then + begin wterm(encTeX_banner); wterm_ln(', reencoding enabled.'); + if translate_filename then begin + wterm_ln(' (\xordcode, \xchrcode, \xprncode overridden by TCX)'); + end; + end; +@y +@z + +@x +if mubyte_out + mubyte_zero < 0 then write_mubyte(tail) := 0 +else if mubyte_out + mubyte_zero >= 2*mubyte_zero then + write_mubyte(tail) := 2*mubyte_zero - 1 + else write_mubyte(tail) := mubyte_out + mubyte_zero; +@y +@z + +@x +@= +begin new_whatsit(special_node,write_node_size); +if spec_out + mubyte_zero < 0 then write_stream(tail) := 0 +else if spec_out + mubyte_zero >= 2*mubyte_zero then + write_stream(tail) := 2*mubyte_zero - 1 + else write_stream(tail) := spec_out + mubyte_zero; +if mubyte_out + mubyte_zero < 0 then write_mubyte(tail) := 0 +else if mubyte_out + mubyte_zero >= 2*mubyte_zero then + write_mubyte(tail) := 2*mubyte_zero - 1 + else write_mubyte(tail) := mubyte_out + mubyte_zero; +if (spec_out = 2) or (spec_out = 3) then + if (mubyte_out > 2) or (mubyte_out = -1) or (mubyte_out = -2) then + write_noexpanding := true; +p:=scan_toks(false,true); write_tokens(tail):=def_ref; +write_noexpanding := false; +end +@y +@= +begin new_whatsit(special_node,write_node_size); write_stream(tail):=0; +p:=scan_toks(false,true); write_tokens(tail):=def_ref; +end +@z + +@x +if (s = "write") and (write_mubyte (p) <> mubyte_zero) then +begin + print_char ("<"); print_int (write_mubyte(p)-mubyte_zero); print_char (">"); +end; +@y +@z + +@x +spec_sout := spec_out; spec_out := write_stream(p) - mubyte_zero; +mubyte_sout := mubyte_out; mubyte_out := write_mubyte(p) - mubyte_zero; +active_noconvert := true; +mubyte_slog := mubyte_log; +mubyte_log := 0; +if (mubyte_out > 0) or (mubyte_out = -1) then mubyte_log := 1; +if (spec_out = 2) or (spec_out = 3) then +begin + if (mubyte_out > 0) or (mubyte_out = -1) then + begin + special_printing := true; mubyte_log := 1; + end; + if mubyte_out > 1 then cs_converting := true; +end; +@y +@z + +@x +if (spec_out = 1) or (spec_out = 3) then + for k:=str_start[str_ptr] to pool_ptr-1 do + str_pool[k] := si(xchr[so(str_pool[k])]); +@y +@z + +@x +begin +mubyte_sout := mubyte_out; mubyte_out := write_mubyte(p) - mubyte_zero; +if (mubyte_out > 2) or (mubyte_out = -1) or (mubyte_out = -2) then + write_noexpanding := true; +@ 1 then cs_converting := true; +mubyte_slog := mubyte_log; +if (mubyte_out > 0) or (mubyte_out = -1) then mubyte_log := 1 +else mubyte_log := 0; +token_show(def_ref); print_ln; +cs_converting := false; write_noexpanding := false; +active_noconvert := false; +mubyte_out := mubyte_sout; mubyte_log := mubyte_slog; +@y +token_show(def_ref); print_ln; +@z + +@x +@ Dumping the |xord|, |xchr|, and |xprn| arrays. We dump these always +in the format, so a TCX file loaded during format creation can set a +default for users of the format. + +@= +dump_things(xord[0], 256); +dump_things(xchr[0], 256); +dump_things(xprn[0], 256); + +@ Undumping the |xord|, |xchr|, and |xprn| arrays. This code is more +complicated, because we want to ensure that a TCX file specified on +the command line will override whatever is in the format. Since the +tcx file has already been loaded, that implies throwing away the data +in the format. Also, if no |translate_filename| is given, but +|eight_bit_p| is set we have to make all characters printable. + +@= +if translate_filename then begin + for k:=0 to 255 do undump_things(dummy_xord, 1); + for k:=0 to 255 do undump_things(dummy_xchr, 1); + for k:=0 to 255 do undump_things(dummy_xprn, 1); + end +else begin + undump_things(xord[0], 256); + undump_things(xchr[0], 256); + undump_things(xprn[0], 256); + if eight_bit_p then + for k:=0 to 255 do + xprn[k]:=1; +end; + + +@y +@z + +@x +@* \[54/enc\TeX] System-dependent changes for enc\TeX. + +@d encTeX_banner == ' encTeX v. Jun. 2004' + +@ The boolean variable |enctex_p| is set by web2c according to the given +command line option (or an entry in the configuration file) before any +\TeX{} function is called. + +@ = +@!enctex_p: boolean; + + +@ The boolean variable |enctex_enabled_p| is used to enable enc\TeX's +primitives. It is initialised to |false|. When loading a \.{FMT} it +is set to the value of the boolean |enctex_p| saved in the \.{FMT} file. +Additionally it is set to the value of |enctex_p| in Ini\TeX. + +@= +@!enctex_enabled_p:boolean; {enable encTeX} + + +@ @= +enctex_enabled_p:=false; + + +@ Auxiliary functions/procedures for enc\TeX{} (by Petr Olsak) follow. +These functions implement the \.{\\mubyte} code to convert +the multibytes in |buffer| to one byte or to one control +sequence. These functions manipulate a mubyte tree: each node of +this tree is token list with n+1 tokens (first token consist the byte +from the byte sequence itself and the other tokens point to the +branches). If you travel from root of the tree to a leaf then you +find exactly one byte sequence which we have to convert to one byte or +control sequence. There are two variants of the leaf: the ``definitive +end'' or the ``middle leaf'' if a longer byte sequence exists and the mubyte +tree continues under this leaf. First variant is implemented as one +memory word where the link part includes the token to +which we have to convert and type part includes the number 60 (normal +conversion) or 1..52 (insert the control sequence). +The second variant of ``middle leaf'' is implemented as two memory words: +first one has a type advanced by 64 and link points to the second +word where info part includes the token to which we have to convert +and link points to the next token list with the branches of +the subtree. + +The inverse: one byte to multi byte (for log printing and \.{\\write} +printing) is implemented via a pool. Each multibyte sequence is stored +in a pool as a string and |mubyte_write|[{\it printed char\/}] points +to this string. + +@d new_mubyte_node == + link (p) := get_avail; p := link (p); info (p) := get_avail; p := info (p) +@d subinfo (#) == subtype (#) + +@= +{ read |buffer|[|i|] and convert multibyte. |i| should have been + of type 0..|buf_size|, but web2c doesn't like that construct in + argument lists. } +function read_buffer(var i:integer):ASCII_code; +var p: pointer; + last_found: integer; + last_type: integer; +begin + mubyte_skip := 0; mubyte_token := 0; + read_buffer := buffer[i]; + if mubyte_in = 0 then + begin + if mubyte_keep > 0 then mubyte_keep := 0; + return ; + end; + last_found := -2; + if (i = start) and (not mubyte_start) then + begin + mubyte_keep := 0; + if (end_line_char >= 0) and (end_line_char < 256) then + if mubyte_read [end_line_char] <> null then + begin + mubyte_start := true; mubyte_skip := -1; + p := mubyte_read [end_line_char]; + goto continue; + end; + end; +restart: + mubyte_start := false; + if (mubyte_read [buffer[i]] = null) or (mubyte_keep > 0) then + begin + if mubyte_keep > 0 then decr (mubyte_keep); + return ; + end; + p := mubyte_read [buffer[i]]; +continue: + if type (p) >= 64 then + begin + last_type := type (p) - 64; + p := link (p); + mubyte_token := info (p); last_found := mubyte_skip; + end else if type (p) > 0 then + begin + last_type := type (p); + mubyte_token := link (p); + goto found; + end; + incr (mubyte_skip); + if i + mubyte_skip > limit then + begin + mubyte_skip := 0; + if mubyte_start then goto restart; + return; + end; + repeat + p := link (p); + if subinfo (info(p)) = buffer [i+mubyte_skip] then + begin + p := info (p); goto continue; + end; + until link (p) = null; + mubyte_skip := 0; + if mubyte_start then goto restart; + if last_found = -2 then return; { no found } + mubyte_skip := last_found; +found: + if mubyte_token < 256 then { multibyte to one byte } + begin + read_buffer := mubyte_token; mubyte_token := 0; + i := i + mubyte_skip; + if mubyte_start and (i >= start) then mubyte_start := false; + return; + end else begin { multibyte to control sequence } + read_buffer := 0; + if last_type = 60 then { normal conversion } + i := i + mubyte_skip + else begin { insert control sequence } + decr (i); mubyte_keep := last_type; + if i < start then mubyte_start := true; + if last_type = 52 then mubyte_keep := 10000; + if last_type = 51 then mubyte_keep := mubyte_skip + 1; + mubyte_skip := -1; + end; + if mubyte_start and (i >= start) then mubyte_start := false; + return; + end; +exit: end; + +@ @= +procedure mubyte_update; { saves new string to mubyte tree } +var j: pool_pointer; + p: pointer; + q: pointer; + in_mutree: integer; +begin + j := str_start [str_ptr]; + if mubyte_read [so(str_pool[j])] = null then + begin + in_mutree := 0; + p := get_avail; + mubyte_read [so(str_pool[j])] := p; + subinfo (p) := so(str_pool[j]); type (p) := 0; + end else begin + in_mutree := 1; + p := mubyte_read [so(str_pool[j])]; + end; + incr (j); + while j < pool_ptr do + begin + if in_mutree = 0 then + begin + new_mubyte_node; subinfo (p) := so(str_pool[j]); type (p) := 0; + end else { |in_mutree| = 1 } + if (type (p) > 0) and (type (p) < 64) then + begin + type (p) := type (p) + 64; + q := link (p); link (p) := get_avail; p := link (p); + info (p) := q; + new_mubyte_node; subinfo (p) := so(str_pool[j]); type (p) := 0; + in_mutree := 0; + end else begin + if type (p) >= 64 then p := link (p); + repeat + p := link (p); + if subinfo (info(p)) = so(str_pool[j]) then + begin + p := info (p); + goto continue; + end; + until link (p) = null; + new_mubyte_node; subinfo (p) := so(str_pool[j]); type (p) := 0; + in_mutree := 0; + end; +continue: + incr (j); + end; + if in_mutree = 1 then + begin + if type (p) = 0 then + begin + type (p) := mubyte_prefix + 64; + q := link (p); link (p) := get_avail; p := link (p); + link (p) := q; info (p) := mubyte_stoken; + return; + end; + if type (p) >= 64 then + begin + type (p) := mubyte_prefix + 64; + p := link (p); info (p) := mubyte_stoken; + return; + end; + end; + type (p) := mubyte_prefix; + link (p) := mubyte_stoken; +exit: end; +@# +procedure dispose_munode (p: pointer); { frees a mu subtree recursivelly } +var q: pointer; +begin + if (type (p) > 0) and (type (p) < 64) then free_avail (p) + else begin + if type (p) >= 64 then + begin + q := link (p); free_avail (p); p := q; + end; + q := link (p); free_avail (p); p := q; + while p <> null do + begin + dispose_munode (info (p)); + q := link (p); + free_avail (p); + p := q; + end; + end; +end; +@# +procedure dispose_mutableout (cs: pointer); { frees record from out table } +var p, q, r: pointer; +begin + p := mubyte_cswrite [cs mod 128]; + r := null; + while p <> null do + if info (p) = cs then + begin + if r <> null then link (r) := link (link (p)) + else mubyte_cswrite[cs mod 128] := link (link (p)); + q := link (link(p)); + free_avail (link(p)); free_avail (p); + p := q; + end else begin + r := link (p); p := link (r); + end; +end; + +@ The |print_buffer| procedure prints one character from |buffer|[|i|]. +It also increases |i| to the next character in the buffer. + +@= +{ print one char from |buffer|[|i|]. |i| should have been of type + 0..|buf_size|, but web2c doesn't like that construct in argument lists. } +procedure print_buffer(var i:integer); +var c: ASCII_code; +begin + if mubyte_in = 0 then print (buffer[i]) { normal TeX } + else if mubyte_log > 0 then print_char (buffer[i]) + else begin + c := read_buffer (i); + if mubyte_token > 0 then print_cs (mubyte_token-cs_token_flag) + else print (c); + end; + incr (i); +end; + +@ Additional material to dump for enc\TeX. This includes whether +enc\TeX is enabled, and if it is we also have to dump the \.{\\mubyte} +arrays. + +@= +dump_int(@"45435458); {enc\TeX's magic constant: "ECTX"} +if not enctex_p then dump_int(0) +else begin + dump_int(1); + dump_things(mubyte_read[0], 256); + dump_things(mubyte_write[0], 256); + dump_things(mubyte_cswrite[0], 128); +end; + +@ Undumping the additional material we dumped for enc\TeX. This includes +conditionally undumping the \.{\\mubyte} arrays. + +@= +undump_int(x); {check magic constant of enc\TeX} +if x<>@"45435458 then goto bad_fmt; +undump_int(x); {undump |enctex_p| flag into |enctex_enabled_p|} +if x=0 then enctex_enabled_p:=false +else if x<>1 then goto bad_fmt +else begin + enctex_enabled_p:=true; + undump_things(mubyte_read[0], 256); + undump_things(mubyte_write[0], 256); + undump_things(mubyte_cswrite[0], 128); +end; + +@y +@z diff --git a/Build/source/texk/web2c/xetexdir/xetex-upwards.ch b/Build/source/texk/web2c/xetexdir/xetex-upwards.ch new file mode 100644 index 00000000000..64a423f1bb8 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/xetex-upwards.ch @@ -0,0 +1,244 @@ +% /****************************************************************************\ +% Part of the XeTeX typesetting system +% copyright (c) 1994-2006 by SIL International +% written by Jonathan Kew +% +% Permission is hereby granted, free of charge, to any person obtaining +% a copy of this software and associated documentation files (the +% "Software"), to deal in the Software without restriction, including +% without limitation the rights to use, copy, modify, merge, publish, +% distribute, sublicense, and/or sell copies of the Software, and to +% permit persons to whom the Software is furnished to do so, subject to +% the following conditions: +% +% The above copyright notice and this permission notice shall be +% included in all copies or substantial portions of the Software. +% +% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +% EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +% MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +% NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +% ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +% CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +% WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +% +% Except as contained in this notice, the name of SIL International +% shall not be used in advertising or otherwise to promote the sale, +% use or other dealings in this Software without prior written +% authorization from SIL International. +% \****************************************************************************/ + +{ This file implements the experimental feature \XeTeXupwardsmode. + It also adds the state variable \XeTeXuseglyphmetrics, for use + from xetex-new.ch } + +@x +@d XeTeX_default_input_mode_code = 2 {input mode for newly opened files} +@y +@d XeTeX_upwards_code = 2 {non-zero if the main vertical list is being built upwards} +@d XeTeX_use_glyph_metrics_code = 3 {non-zero to use exact glyph height/depth} +@# +@d XeTeX_default_input_mode_code = 4 {input mode for newly opened files} +@z + +@x +@d XeTeX_default_input_encoding_code = 3 {str_number of encoding name if mode = ICU} +@# +@d eTeX_states=4 {number of \eTeX\ state variables in |eqtb|} +@y +@d XeTeX_default_input_encoding_code = 5 {str_number of encoding name if mode = ICU} +@# +@d eTeX_states=6 {number of \eTeX\ state variables in |eqtb|} +@z + +@x { to ensure following change doesn't get applied to hlist_out() } +@p procedure vlist_out; {output a |vlist_node| box} +@y +@p procedure vlist_out; {output a |vlist_node| box} +@z + +@x +@!cur_g:scaled; {rounded equivalent of |cur_glue| times the glue ratio} +begin cur_g:=0; cur_glue:=float_constant(0); +this_box:=temp_ptr; g_order:=glue_order(this_box); +g_sign:=glue_sign(this_box); p:=list_ptr(this_box); +incr(cur_s); +if cur_s>0 then dvi_out(push); +if cur_s>max_push then max_push:=cur_s; +save_loc:=dvi_offset+dvi_ptr; left_edge:=cur_h; cur_v:=cur_v-height(this_box); +@y +@!cur_g:scaled; {rounded equivalent of |cur_glue| times the glue ratio} +@!upwards:boolean; {whether we're stacking upwards} +begin cur_g:=0; cur_glue:=float_constant(0); +this_box:=temp_ptr; g_order:=glue_order(this_box); +g_sign:=glue_sign(this_box); p:=list_ptr(this_box); +upwards:=(subtype(this_box)=min_quarterword+1); +incr(cur_s); +if cur_s>0 then dvi_out(push); +if cur_s>max_push then max_push:=cur_s; +save_loc:=dvi_offset+dvi_ptr; left_edge:=cur_h; +if upwards then cur_v:=cur_v+depth(this_box) else cur_v:=cur_v-height(this_box); +@z + +@x +kern_node:cur_v:=cur_v+width(p); +@y +kern_node:if upwards then cur_v:=cur_v-width(p) else cur_v:=cur_v+width(p); +@z + +@x +move_past: cur_v:=cur_v+rule_ht; +@y +move_past: if upwards then cur_v:=cur_v-rule_ht else cur_v:=cur_v+rule_ht; +@z + +@x +@= +if list_ptr(p)=null then cur_v:=cur_v+height(p)+depth(p) +else begin cur_v:=cur_v+height(p); synch_v; + save_h:=dvi_h; save_v:=dvi_v; + if cur_dir=right_to_left then cur_h:=left_edge-shift_amount(p) + else cur_h:=left_edge+shift_amount(p); {shift the box right} + temp_ptr:=p; + if type(p)=vlist_node then vlist_out@+else hlist_out; + dvi_h:=save_h; dvi_v:=save_v; + cur_v:=save_v+depth(p); cur_h:=left_edge; + end +@y +@= +if list_ptr(p)=null then + if upwards then cur_v:=cur_v-height(p)-depth(p) + else cur_v:=cur_v+height(p)+depth(p) +else begin if upwards then cur_v:=cur_v-depth(p) else cur_v:=cur_v+height(p); synch_v; + save_h:=dvi_h; save_v:=dvi_v; + if cur_dir=right_to_left then cur_h:=left_edge-shift_amount(p) + else cur_h:=left_edge+shift_amount(p); {shift the box right} + temp_ptr:=p; + if type(p)=vlist_node then vlist_out@+else hlist_out; + dvi_h:=save_h; dvi_v:=save_v; + if upwards then cur_v:=save_v-height(p) else cur_v:=save_v+depth(p); cur_h:=left_edge; + end +@z + +@x +cur_v:=cur_v+rule_ht; +@y +if upwards then cur_v:=cur_v-rule_ht else cur_v:=cur_v+rule_ht; +@z + +@x +cur_v:=height(p)+v_offset; temp_ptr:=p; +@y +cur_v:=height(p)+v_offset; { does this need changing for upwards mode ???? } +temp_ptr:=p; +@z + +@x { to ensure following change doesn't get applied to hpack() } +@d vpack(#)==vpackage(#,max_dimen) {special case of unconstrained depth} +@y +@d vpack(#)==vpackage(#,max_dimen) {special case of unconstrained depth} +@z + +@x +subtype(r):=min_quarterword; shift_amount(r):=0; +@y +if XeTeX_upwards then subtype(r):=min_quarterword+1 else subtype(r):=min_quarterword; +shift_amount(r):=0; +@z + +@x +@p procedure append_to_vlist(@!b:pointer); +var d:scaled; {deficiency of space between baselines} +@!p:pointer; {a new glue specification} +begin if prev_depth>ignore_depth then + begin d:=width(baseline_skip)-prev_depth-height(b); + if dignore_depth then + begin if upwards then d:=width(baseline_skip)-prev_depth-depth(b) + else d:=width(baseline_skip)-prev_depth-height(b); + if d; + end; +pop_nest; box_end(saved(0)); +@y +@!u,v:integer; {saved values for upwards mode flag} +begin d:=box_max_depth; u:=XeTeX_upwards_state; unsave; save_ptr:=save_ptr-3; +v:=XeTeX_upwards_state; XeTeX_upwards_state:=u; +if mode=-hmode then cur_box:=hpack(link(head),saved(2),saved(1)) +else begin cur_box:=vpackage(link(head),saved(2),saved(1),d); + if c=vtop_code then @; + end; +XeTeX_upwards_state:=v; +pop_nest; box_end(saved(0)); +@z + +@x +@ @= +dump_int(eTeX_mode); +for j:=0 to eTeX_states-1 do eTeX_state(j):=0; {disable all enhancements} +@y +@ @= +dump_int(eTeX_mode); +{ in a deliberate change from e-TeX, we allow non-zero state variables to be dumped } +@z + +@x +@d TeXXeT_en==(TeXXeT_state>0) {is \TeXXeT\ enabled?} +@y +@d TeXXeT_en==(TeXXeT_state>0) {is \TeXXeT\ enabled?} + +@d XeTeX_upwards_state==eTeX_state(XeTeX_upwards_code) +@d XeTeX_upwards==(XeTeX_upwards_state>0) + +@d XeTeX_use_glyph_metrics_state==eTeX_state(XeTeX_use_glyph_metrics_code) +@d XeTeX_use_glyph_metrics==(XeTeX_use_glyph_metrics_state>0) +@z + +@x +eTeX_state_code+TeXXeT_code:print_esc("TeXXeTstate"); +@y +eTeX_state_code+TeXXeT_code:print_esc("TeXXeTstate"); +eTeX_state_code+XeTeX_upwards_code:print_esc("XeTeXupwardsmode"); +eTeX_state_code+XeTeX_use_glyph_metrics_code:print_esc("XeTeXuseglyphmetrics"); +@z + +@x +primitive("TeXXeTstate",assign_int,eTeX_state_base+TeXXeT_code); +@!@:TeXXeT_state_}{\.{\\TeXXeT_state} primitive@> +@y +primitive("TeXXeTstate",assign_int,eTeX_state_base+TeXXeT_code); +@!@:TeXXeT_state_}{\.{\\TeXXeT_state} primitive@> +primitive("XeTeXupwardsmode",assign_int,eTeX_state_base+XeTeX_upwards_code); +@!@:XeTeX_upwards_mode_}{\.{\\XeTeX_upwards_mode} primitive@> +primitive("XeTeXuseglyphmetrics",assign_int,eTeX_state_base+XeTeX_use_glyph_metrics_code); +@!@:XeTeX_use_glyph_metrics_}{\.{\\XeTeX_use_glyph_metrics} primitive@> +@z + diff --git a/Build/source/texk/web2c/xetexdir/xetex.defines b/Build/source/texk/web2c/xetexdir/xetex.defines new file mode 100644 index 00000000000..d29e0fe281d --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/xetex.defines @@ -0,0 +1,136 @@ +{ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ +} + +{ xetex.defines: additions for xetex } + +@define type voidpointer; +@define function getnativechar(); +@define procedure setnativechar(); +@define procedure setnativemetrics(); +@define procedure setjustifiednativeglyphs(); +@define procedure setnativeglyphmetrics(); +@define function findnativefont(); +@define procedure releasefontengine(); +@define function sizeof(); +@define function makefontdef(); +@define function makexdvglypharraydata(); +@define function xdvbufferbyte(); +@define procedure fprintf(); +@define type unicodefile; +@define function uopenin(); +@define function uopenout(); +@define procedure uclose(); +@define function dviopenout(); +@define procedure dviclose(); +@define function delcode1(); +@define procedure setdelcode1(); +@define function readcint1(); +@define procedure setcint1(); +@define procedure printutf8str(); +@define procedure setinputfileencoding(); +@define procedure terminatefontmanager; + +@define procedure memcpy(); +@define function casttoptr(); +@define function casttointeger(); +@define function glyphinfobyte(); +@define function casttoushort(); + +@define function atsufontget(); +@define function atsufontget1(); +@define function atsufontget2(); +@define function atsufontgetnamed(); +@define function atsufontgetnamed1(); +@define procedure atsuprintfontname(); +@define function otfontget(); +@define function otfontget1(); +@define function otfontget2(); +@define function otfontget3(); +@define function mapchartoglyph(); +@define function mapglyphtoindex(); +@define procedure getnativecharheightdepth(); +@define procedure getnativecharsidebearings(); +@define function getnativeitaliccorrection(); +@define function getnativeglyphitaliccorrection(); + +@define function getnativecharwd(); +@define function getnativecharht(); +@define function getnativechardp(); +@define function getnativecharic(); + +@define function setfamilyfield(); +@define function setclassfield(); +@define function mathfamfield(); +@define function mathclassfield(); +@define function mathcharfield(); + +@define procedure atsugetfontmetrics(); +@define procedure otgetfontmetrics(); + +@define function getencodingmodeandinfo(); + +@define procedure linebreakstart(); +@define function linebreaknext; + +{ extra stuff used in picfile code } +@define type realpoint; +@define type realrect; +@define type transform; + +@define function deref(); + +@define function X2Fix(); +@define function Fix2X(); + +@define function findpicfile(); +@define function picpathbyte(); + +@define procedure makeidentity(); +@define procedure makescale(); +@define procedure maketranslation(); +@define procedure makerotation(); +@define procedure transformpoint(); +@define procedure transformconcat(); + +@define procedure setPoint(); + +@define function xCoord(); +@define function yCoord(); +@define function aField(); +@define function bField(); +@define function cField(); +@define function dField(); +@define function xField(); +@define function yField(); +@define function wdField(); +@define function htField(); +@define function applymapping(); diff --git a/Build/source/texk/web2c/xetexdir/xetex.h b/Build/source/texk/web2c/xetexdir/xetex.h new file mode 100644 index 00000000000..2078449f499 --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/xetex.h @@ -0,0 +1,100 @@ +/****************************************************************************\ + Part of the XeTeX typesetting system + copyright (c) 1994-2006 by SIL International + written by Jonathan Kew + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL SIL INTERNATIONAL BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of SIL International +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in this Software without prior written +authorization from SIL International. +\****************************************************************************/ + +/* 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 getnativechar(p,i) native_node_text(p)[i] +#define setnativechar(p,i,v) native_node_text(p)[i] = v + +/* p is native_word node; g is XeTeX_use_glyph_metrics flag */ +#define setnativemetrics(p,g) measure_native_node(&(mem[p]), g) + +#define setnativeglyphmetrics(p,g) measure_native_glyph(&(mem[p]), g) + +#define setjustifiednativeglyphs(p) store_justified_native_glyphs(&(mem[p])) + +#define getnativeitaliccorrection(p) get_native_ital_corr(&(mem[p])) +#define getnativeglyphitaliccorrection(p) get_native_glyph_ital_corr(&(mem[p])) + +#define makexdvglypharraydata(p) makeXDVGlyphArrayData(&(mem[p])) +#define xdvbufferbyte(i) xdvbuffer[i] + +#define pic_node_size 8 + +#define deref(p) (*(p)) + +#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 dviopenout(f) open_dvi_output(&(f)) + +#define readcint1(x) (x).cint1 +#define setcint1(x,y) (x).cint1 = (y) + +#define delcode1(x) readcint1(eqtb[xetexdelcodebase+(x)]) +#define setdelcode1(x,y) setcint1(eqtb[xetexdelcodebase+(x)],(y)) + +#define casttoptr(x) (void*)(x) +#define casttointeger(x) (long)(x) +#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) +/* calculate pieces to assign to a math code */ +#define setfamilyfield(x) (((unsigned)(x) & 0xFF) << 24) +#define setclassfield(x) (((unsigned)(x) & 0x07) << 21) + +/* 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 + +/* we don't use xchr, so change the cpascal.h definition of this... */ +#undef Xchr +#define Xchr(x) (x) + +#ifdef XETEX_MAC +#include /* for Mac OS X, it's handy to have the Carbon APIs available */ +#endif + +#include "trans.h" /* functions for affine transform operations */ +#include "TECkit_Common.h" /* include this before XeTeX_ext.h */ +#include "XeTeX_ext.h" /* other extension functions */ diff --git a/Build/source/texk/web2c/xetexdir/xetex.mk b/Build/source/texk/web2c/xetexdir/xetex.mk new file mode 100644 index 00000000000..321ea17686f --- /dev/null +++ b/Build/source/texk/web2c/xetexdir/xetex.mk @@ -0,0 +1,303 @@ +# Makefile fragment for XeTeX and web2c. -- Jonathan Kew -- Public domain. +# This fragment contains the parts of the makefile that are most likely to +# differ between releases of XeTeX. + +Makefile: $(srcdir)/xetexdir/xetex.mk + +# We build xetex unless configure decides to skip it +xetex = @XETEX@ xetex + +### Platform-specific defines and files to be built + +# On Mac OS X: +@XETEX_MACOSX@ xetex_platform_o = XeTeX_mac.o XeTeXFontMgr_Mac.o +@XETEX_MACOSX@ xetex_platform_layout_o = XeTeXFontInst_Mac.o +@XETEX_MACOSX@ xetex_platform_layout_cxx = XeTeXFontInst_Mac.cpp +@XETEX_MACOSX@ xetex_images_o = + +@XETEX_MACOSX@ XETEX_DEFINES = -DXETEX_MAC + +@XETEX_MACOSX@ EXTRALIBS = -framework Carbon -framework Cocoa -framework QuickTime + +@XETEX_MACOSX@ EXTRADEPS = + +# On non-Mac platforms: +@XETEX_GENERIC@ xetex_platform_o = XeTeXFontMgr_Linux.o +@XETEX_GENERIC@ xetex_platform_layout_o = XeTeXFontInst_FC.o +@XETEX_GENERIC@ xetex_platform_layout_cxx = XeTeXFontInst_FC.cpp +@XETEX_GENERIC@ xetex_images_o = mfileio.o numbers.o pdfimage.o bmpimage.o jpegimage.o pngimage.o XeTeX_pic.o + +@XETEX_GENERIC@ XETEX_DEFINES = -DXETEX_OTHER + +@XETEX_GENERIC@ # FIXME: FontConfig not yet handled by configure +@XETEX_GENERIC@ EXTRALIBS = @LDFREETYPE2@ @LDLIBXPDF@ @LDLIBPNG@ -lfontconfig + +@XETEX_GENERIC@ EXTRADEPS = @FREETYPE2DEP@ @LIBXPDFDEP@ @LIBPNGDEP@ + +### end of platform-specific setup + +LDLIBXPDF=@LDLIBXPDF@ +LIBXPDFCPPFLAGS=@LIBXPDFCPPFLAGS@ +LIBXPDFDEP=@LIBXPDFDEP@ + +LIBXPDFDIR=../../libs/xpdf +LIBXPDFSRCDIR=$(srcdir)/$(LIBXPDFDIR) + +LDLIBPNG=@LDLIBPNG@ +LIBPNGCPPFLAGS=@LIBPNGCPPFLAGS@ +LIBPNGDEP=@LIBPNGDEP@ + +LIBPNGDIR=../../libs/libpng +LIBPNGSRCDIR=$(srcdir)/$(LIBPNGDIR) + +FTFLAGS = @FREETYPE2CPPFLAGS@ + +FREETYPE2DIR = ../../libs/freetype2 +FREETYPE2SRCDIR = $(srcdir)/$(FREETYPE2DIR) + +TECKITFLAGS = @TECKITCPPFLAGS@ +LDTECKIT = @LDTECKIT@ +TECKITDEP = @TECKITDEP@ + +TECKITDIR=../../libs/teckit +TECKITSRCDIR=$(srcdir)/$(TECKITDIR) + +ICUFLAGS = @ICUCPPFLAGS@ +LDICU = @LDICU@ +ICUDEP = @ICUDEP@ + +ICUDIR=../../libs/icu-xetex +ICUSRCDIR=$(srcdir)/$(ICUDIR) + +ICUCFLAGS = @ICUCPPFLAGS@ -DLE_USE_CMEMORY + + +# Font-related headers +XeTeXFontHdrs = \ + $(srcdir)/xetexdir/FontTableCache.h \ + $(srcdir)/xetexdir/XeTeXFontInst.h \ + $(srcdir)/xetexdir/XeTeXFontInst_FC.h \ + $(srcdir)/xetexdir/XeTeXFontInst_Mac.h \ + $(srcdir)/xetexdir/XeTeXFontMgr.h \ + $(srcdir)/xetexdir/XeTeXFontMgr_Linux.h \ + $(srcdir)/xetexdir/XeTeXFontMgr_Mac.h \ + $(srcdir)/xetexdir/XeTeXLayoutInterface.h \ + $(srcdir)/xetexdir/XeTeXOTLayoutEngine.h + +# Image-related headers +XeTeXImageHdrs = \ + $(srcdir)/xetexdir/bmpimage.h \ + $(srcdir)/xetexdir/jpegimage.h \ + $(srcdir)/xetexdir/pdfimage.h \ + $(srcdir)/xetexdir/pngimage.h + +# Extract xetex version +xetexdir/xetex.version: $(srcdir)/xetexdir/xetex-new.ch + test -d xetexdir || mkdir xetexdir + grep '^@d XeTeX_version_string==' $(srcdir)/xetexdir/xetex-new.ch \ + | sed "s/^.*'-//;s/'.*$$//" >xetexdir/xetex.version + +# The C sources. +xetex_c = xetexini.c xetex0.c xetex1.c xetex2.c +xetex_o = xetexini.o xetex0.o xetex1.o xetex2.o xetexextra.o +xetex_add_o = trans.o XeTeX_ext.o $(xetex_platform_o) + +# these compilations require the path to TECkit headers; +# just setting it in XCFLAGS doesn't seem to work when we're called +# recursively from "make world" etc +xetexini.o: xetexini.c $(srcdir)/xetexdir/XeTeX_ext.h + $(compile) $(TECKITFLAGS) $(ALL_CFLAGS) $(XETEX_DEFINES) -c $< -o $@ +xetex0.o: xetex0.c $(srcdir)/xetexdir/XeTeX_ext.h + $(compile) $(TECKITFLAGS) $(ALL_CFLAGS) $(XETEX_DEFINES) -c $< -o $@ +xetex1.o: xetex1.c $(srcdir)/xetexdir/XeTeX_ext.h + $(compile) $(TECKITFLAGS) $(ALL_CFLAGS) $(XETEX_DEFINES) -c $< -o $@ +xetex2.o: xetex2.c $(srcdir)/xetexdir/XeTeX_ext.h + $(compile) $(TECKITFLAGS) $(ALL_CFLAGS) $(XETEX_DEFINES) -c $< -o $@ +xetexextra.o: xetexextra.c $(srcdir)/xetexdir/XeTeX_ext.h + $(compile) $(TECKITFLAGS) $(ALL_CFLAGS) $(XETEX_DEFINES) -c $< -o $@ + +# image support +mfileio.o: $(srcdir)/xetexdir/mfileio.c $(srcdir)/xetexdir/mfileio.h + $(compile) $(ALL_CFLAGS) -c $< -o $@ + +numbers.o: $(srcdir)/xetexdir/numbers.c $(srcdir)/xetexdir/numbers.h + $(compile) $(ALL_CFLAGS) -c $< -o $@ + +bmpimage.o: $(srcdir)/xetexdir/bmpimage.c $(srcdir)/xetexdir/bmpimage.h + $(compile) $(ALL_CFLAGS) -c $< -o $@ + +jpegimage.o: $(srcdir)/xetexdir/jpegimage.c $(srcdir)/xetexdir/jpegimage.h + $(compile) $(ALL_CFLAGS) -c $< -o $@ + +pngimage.o: $(srcdir)/xetexdir/pngimage.c $(srcdir)/xetexdir/pngimage.h + $(compile) $(ALL_CFLAGS) $(LIBPNGCPPFLAGS) -c $< -o $@ + +pdfimage.o: $(srcdir)/xetexdir/pdfimage.cpp $(srcdir)/xetexdir/pdfimage.h + $(compile) $(ALL_CFLAGS) $(LIBXPDFCPPFLAGS) -c $< -o $@ + +XeTeX_pic.o: $(srcdir)/xetexdir/XeTeX_pic.c $(srcdir)/xetexdir/XeTeX_ext.h $(XeTeXImageHdrs) + $(compile) $(TECKITFLAGS) $(ALL_CFLAGS) $(XETEX_DEFINES) -c $< -o $@ + +# Layout library +xetex_ot_layout_o = \ + XeTeXFontMgr.o \ + XeTeXLayoutInterface.o XeTeXOTLayoutEngine.o \ + XeTeXFontInst.o cmaps.o FontTableCache.o \ + $(xetex_platform_layout_o) + +XeTeXLayoutInterface.o: $(srcdir)/xetexdir/XeTeXLayoutInterface.cpp $(XeTeXFontHdrs) + $(CXX) $(ICUCFLAGS) $(FTFLAGS) $(ALL_CXXFLAGS) $(XETEX_DEFINES) -c $< -o $@ +XeTeXOTLayoutEngine.o: $(srcdir)/xetexdir/XeTeXOTLayoutEngine.cpp $(XeTeXFontHdrs) + $(CXX) $(ICUCFLAGS) $(FTFLAGS) $(ALL_CXXFLAGS) $(XETEX_DEFINES) -c $< -o $@ + +XeTeXFontMgr.o: $(srcdir)/xetexdir/XeTeXFontMgr.cpp $(XeTeXFontHdrs) + $(CXX) $(ICUCFLAGS) $(FTFLAGS) $(ALL_CXXFLAGS) $(XETEX_DEFINES) -c $< -o $@ +XeTeXFontMgr_Linux.o: $(srcdir)/xetexdir/XeTeXFontMgr_Linux.cpp $(XeTeXFontHdrs) + $(CXX) $(ICUCFLAGS) $(FTFLAGS) $(ALL_CXXFLAGS) $(XETEX_DEFINES) -c $< -o $@ + +XeTeXFontMgr_Mac.o: $(srcdir)/xetexdir/XeTeXFontMgr_Mac.mm $(XeTeXFontHdrs) + gcc -ObjC++ $(ICUCFLAGS) $(FTFLAGS) $(ALL_CXXFLAGS) $(XETEX_DEFINES) -c $< -o $@ + +cmaps.o: $(srcdir)/xetexdir/cmaps.cpp + $(CXX) $(ICUCFLAGS) $(ALL_CXXFLAGS) $(XETEX_DEFINES) -c $< -o $@ +FontTableCache.o: $(srcdir)/xetexdir/FontTableCache.cpp + $(CXX) $(ICUCFLAGS) $(ALL_CXXFLAGS) $(XETEX_DEFINES) -c $< -o $@ + +XeTeXFontInst.o: $(srcdir)/xetexdir/XeTeXFontInst.cpp $(XeTeXFontHdrs) + $(CXX) $(ICUCFLAGS) $(FTFLAGS) $(ALL_CXXFLAGS) $(XETEX_DEFINES) -c $< -o $@ +XeTeXFontInst_Mac.o: $(srcdir)/xetexdir/XeTeXFontInst_Mac.cpp $(XeTeXFontHdrs) + $(CXX) $(ICUCFLAGS) $(ALL_CXXFLAGS) $(XETEX_DEFINES) -c $< -o $@ +XeTeXFontInst_FC.o: $(srcdir)/xetexdir/XeTeXFontInst_FC.cpp $(XeTeXFontHdrs) + $(CXX) $(ICUCFLAGS) $(FTFLAGS) $(ALL_CXXFLAGS) $(XETEX_DEFINES) -c $< -o $@ + + +xetexlibs = $(LDICU) $(LDTECKIT) + +# special rules for files that need the TECkit headers as well +XeTeX_ext.o: $(srcdir)/xetexdir/XeTeX_ext.c xetexd.h + $(compile) $(ICUCFLAGS) $(FTFLAGS) $(TECKITFLAGS) $(ALL_CFLAGS) $(XETEX_DEFINES) -c $< -o $@ +XeTeX_mac.o: $(srcdir)/xetexdir/XeTeX_mac.c xetexd.h + $(compile) $(ICUCFLAGS) $(TECKITFLAGS) $(ALL_CFLAGS) $(XETEX_DEFINES) -c $< -o $@ + +trans.o: $(srcdir)/xetexdir/trans.c + $(compile) $(ALL_CFLAGS) $(XETEX_DEFINES) -c $< -o $@ + +# Making xetex. +xetex: $(xetex_o) $(xetex_add_o) $(xetex_images_o) $(xetex_ot_layout_o) $(xetexlibs) $(EXTRADEPS) + $(kpathsea_cxx_link) $(xetex_o) $(xetex_add_o) $(xetex_images_o) $(xetex_ot_layout_o) \ + $(socketlibs) $(LOADLIBES) \ + $(xetexlibs) $(EXTRALIBS) -lz + +# C file dependencies +$(xetex_c) xetexcoerce.h xetexd.h: xetex.p $(web2c_texmf) + $(web2c) xetex +xetexextra.c: lib/texmfmp.c xetexdir/xetexextra.h + sed s/TEX-OR-MF-OR-MP/xetex/ $(srcdir)/lib/texmfmp.c >$@ +xetexdir/xetexextra.h: xetexdir/xetexextra.in xetexdir/xetex.version + test -d xetexdir || mkdir xetexdir + sed s/XETEX-VERSION/`cat xetexdir/xetex.version`/ \ + $(srcdir)/xetexdir/xetexextra.in >$@ + +# Tangling +xetex.p xetex.pool: ./otangle xetex.web # xetex.ch + ./otangle xetex.web # xetex.ch + +# Generation of the web [and ch] file. +# Sources for xetex.web: +xetex_web_srcs = $(srcdir)/tex.web \ + $(srcdir)/etexdir/etex.ch \ + $(srcdir)/etexdir/tex.ch0 \ + $(srcdir)/tex.ch \ + $(srcdir)/etexdir/tex.ch1 \ + $(srcdir)/etexdir/tex.ech \ + $(srcdir)/xetexdir/xetex-new.ch \ + $(srcdir)/xetexdir/xetex-noenc.ch \ + $(srcdir)/xetexdir/xetex-upwards.ch +xetex.web: tie xetexdir/xetex.mk $(xetex_web_srcs) + $(TIE) -m xetex.web $(xetex_web_srcs) + +################## FIXME: the rest of this isn't properly updated for xetex yet... +################## e.g., we don't have real xetex tests to run! + +# Tests... +#check: @XETEX@ xetex-check +#xetex-check: etrip xetex.fmt +# Test truncation (but don't bother showing the warning msg). +# ./xetex --progname=xetex --output-comment="`cat $(srcdir)/PROJECTS`" \ +# $(srcdir)/tests/hello 2>/dev/null \ +# && ./dvitype hello.dvi | grep olaf@infovore.xs4all.nl >/dev/null +# \openout should show up in \write's. +# ./xetex --progname=xetex $(srcdir)/tests/openout && grep xfoo openout.log +# one.two.tex -> one.two.log +# ./xetex --progname=xetex $(srcdir)/tests/one.two && ls -l one.two.log +# uno.dos -> uno.log +# ./xetex --progname=xetex $(srcdir)/tests/uno.dos && ls -l uno.log +# ./xetex --progname=xetex $(srcdir)/tests/just.texi && ls -l just.log +# -./xetex --progname=xetex $(srcdir)/tests/batch.tex +# ./xetex --progname=xetex --shell $(srcdir)/tests/write18 | grep echo +# ./xetex --mltex --progname=xeinitex $(srcdir)/tests/mltextst +# -./xetex --progname=xetex