[ooo-build-commit] Branch 'ooo/master' - graphite/download graphite/graphite-2.3.1.patch graphite/makefile.mk graphite/prj
Jan Holesovsky
kendy at kemper.freedesktop.org
Mon Aug 17 18:15:13 PDT 2009
graphite/download/Readme.txt | 15
graphite/download/silgraphite-2.3.1.tar.gz |binary
graphite/graphite-2.3.1.patch | 1979 +++++++++++++++++++++++++++++
graphite/makefile.mk | 178 ++
graphite/prj/build.lst | 3
graphite/prj/d.lst | 15
6 files changed, 2190 insertions(+)
New commits:
commit 8d84736d2320003d64330bfb3edfb27e03f6edd5
Author: Ivo Hinkelmann <ihi at openoffice.org>
Date: Mon Aug 17 14:12:14 2009 +0000
CWS-TOOLING: integrate CWS graphite01
2009-08-06 11:09:01 +0200 hdu r274708 : #i10000# fix build breaker for SYSTEM_GRAPHITE=NO
2009-07-21 12:01:52 +0200 hdu r274174 : #i93645# fix include files for EXT_USE_STLPORT
2009-07-21 11:51:07 +0200 hdu r274173 : #i93645# convert line-endings of files to be patched
2009-07-21 10:49:01 +0200 hdu r274170 : #i93645# adjust makefile.vc8 for HH-RelEng env (thanks ause)
2009-07-20 05:21:32 +0200 kstribley r274105 : attempt to fix Windows build error caused by NULL variable in nmake file
2009-07-16 10:22:36 +0200 hdu r274032 : #i69129# also use solar minor version to find graphite lib
2009-07-16 05:36:06 +0200 kstribley r274029 : allow windows build to have Graphite disabled with SAL_DISABLE_GRAPHITE
2009-07-15 13:59:22 +0200 hdu r274011 : #i69129# default to ENABLE_GRAPHITE=TRUE
2009-07-15 13:19:54 +0200 hdu r274008 : #i93645# ignore compile warnings for graphite
2009-07-15 13:18:25 +0200 hdu r274006 : #i93645# stlport needs libmath, use solar minor version to find matching libs
2009-07-15 09:21:13 +0200 hdu r273989 : #i100000# avoid compile warning
2009-07-14 12:19:08 +0200 hdu r273963 : CWS-TOOLING: rebase CWS graphite01 to trunk at 273858 (milestone: DEV300:m52)
2009-07-13 06:54:56 +0200 kstribley r273912 : change to use standard file headers
2009-07-13 05:39:14 +0200 kstribley r273911 : Remove unnecessary change to configure.in as reported by Rene
2009-07-10 16:58:44 +0200 hdu r273902 : #i100000# fix compile for precompiled-header support
2009-07-02 13:48:26 +0200 kstribley r273647 : #69129# fix a graphite bug which could crash with fonts containing obscure GDL positioning rules
2009-07-02 01:44:02 +0200 rene r273616 : #i10000# we need to link with -licuuc
2009-07-01 04:02:20 +0200 kstribley r273540 : restore missing sdf files from base
2009-07-01 04:01:40 +0200 kstribley r273539 : restore missing sdf files from base
2009-07-01 04:01:12 +0200 kstribley r273538 : restore missing sdf files from base
2009-07-01 03:59:41 +0200 kstribley r273537 : restore missing sdf files from base
2009-06-29 10:16:51 +0200 kstribley r273456 : #i69129# fixes a bug which caused occasional incorrect linebreaking when graphite is asked to render a part of a cluster not containing a base
2009-06-27 10:43:58 +0200 kstribley r273445 : #i69129# added kashida support for justified RTL text
2009-06-01 12:57:06 +0200 kstribley r272476 : CWS-TOOLING: rebase CWS graphite01 to trunk at 272291 (milestone: DEV300:m49)
2009-05-26 10:50:06 +0200 kstribley r272286 : #i69129# fixes a build error when NDEBUG is not defined
2009-05-25 13:14:06 +0200 kstribley r272237 : #i69129# enable debugging by fixing compile warnings
2009-05-25 13:07:47 +0200 kstribley r272234 : #i69129# added env variable to disable GRAPHITE at run time on linux and fixed a bug with a rare attachment sequence
2009-04-20 17:39:25 +0200 kstribley r271001 : CWS-TOOLING: rebase CWS graphite01 to trunk at 270723 (milestone: DEV300:m46)
2009-04-18 07:11:33 +0200 kstribley r270957 : #i101178# attempt to fix buildbot builds by reordering configure.in
2009-04-14 17:37:07 +0200 kstribley r270801 : #i93645# tweak configure to enable graphite by default on windows and linux to assist testing with tinderbox build
2009-04-14 16:33:17 +0200 kstribley r270796 : #i96925# another fix for rtl fallback and add optional debug info in MultiSalLayout
2009-04-08 13:27:55 +0200 kstribley r270641 : #i69129# fix features after a bad merge
2009-04-08 13:26:34 +0200 kstribley r270640 : #i69129# add a patch for WinFont
2009-03-24 12:37:54 +0100 kstribley r269937 : #i69129# fix build error due to locale being included in method for features
2009-03-24 12:36:10 +0100 kstribley r269936 : #i93645# change patch variable and fix configure
2009-03-20 04:18:56 +0100 kstribley r269776 : CWS-TOOLING: rebase CWS graphite01 to trunk at 269297 (milestone: DEV300:m43)
2009-03-01 13:10:59 +0100 kstribley r268622 : added a patch to improve handling of a font with bad graphite language feature tables #i93645#
2009-02-12 04:50:51 +0100 kstribley r267631 : #i93645# fix windows build for graphite 2.3.1 and remove unnecessary patch
2009-02-10 04:48:50 +0100 kstribley r267535 : #i93645# fix a build error with stlport on Ubuntu 8.10 x86
2009-02-10 03:51:10 +0100 kstribley r267534 : #i69129# remove legacy config_office
2009-02-07 19:12:54 +0100 kstribley r267482 : #i93645# upgrade to using silgraphite-2.3.1
2009-02-02 18:17:57 +0100 kstribley r267290 : #i69129# backout unwanted checkin
2009-02-02 17:44:03 +0100 kstribley r267281 : #i69129# backout erroneous update to aclocal.m4
2009-02-01 10:05:03 +0100 kstribley r267236 : #i69129# fix build error due to locale being added to set font attributes
2009-02-01 06:02:52 +0100 kstribley r267235 : #i69129# fix erroneous merge
2009-01-31 16:24:56 +0100 kstribley r267234 : #i69129# update configure.in solenv.in in their new locations with enable graphite
2009-01-31 10:53:18 +0100 kstribley r267232 : CWS-TOOLING: rebase CWS graphite01 to trunk at 267171 (milestone: DEV300:m41)
2008-12-17 04:17:33 +0100 kstribley r265577 : #i93645# remove superfluous autoreconf check and autoconf patch
2008-12-16 10:07:20 +0100 rene r265529 : fix aclocal.m4 breakage
2008-12-16 05:13:29 +0100 kstribley r265520 : #i93645# change to autoconf && configure
2008-12-16 04:39:48 +0100 kstribley r265519 : #i93645# modified LD_FLAGS so that system graphite isn't pulled in by accident and fixed autoconf problem
2008-12-15 14:16:25 +0100 rene r265497 : check for working STL
2008-12-15 12:53:39 +0100 rene r265473 : revert broken check
2008-12-15 11:59:21 +0100 kstribley r265472 : #i93645# added check for system STL, since this is a requirement for system graphite to work correctly and moved the position of the check further down
2008-12-15 11:55:34 +0100 kstribley r265471 : #i93645# remove references to gr3ooo to allow system graphite to be used
2008-12-12 18:48:18 +0100 rene r265437 : fix link for system-graphite
2008-12-12 18:46:45 +0100 rene r265436 : the tarball is in graphite, remove obsolete check
2008-12-12 18:22:22 +0100 rene r265433 : typo; re-autoconf
2008-12-12 17:35:26 +0100 rene r265432 : actually implement SYSTEM_GRAPHIT checks (as already checked for in makefile.mks) but remove the checks in graphit itself and move to BUILD_TYPE
2008-12-12 08:08:33 +0100 kstribley r265387 : #i69129# 2 of the patched files need windows line endings so patch works on linux as well as windows
2008-12-12 08:04:41 +0100 kstribley r265386 : #i69129# rtl fallback fix which prevents caching of segments with fallback
2008-12-08 04:28:12 +0100 kstribley r264969 : results of running autoconf with graphite config changes #i69129#
2008-12-05 08:12:47 +0100 kstribley r264886 : backout unintential change at r264884
2008-12-05 06:26:33 +0100 kstribley r264884 : #i96925# fixes for uniscribe fallback
2008-12-05 06:11:37 +0100 kstribley r264883 : #i69129# improvements to windows graphite code, including caching of sila table lookup
2008-12-02 13:28:51 +0100 kstribley r264694 : #i93645# add graphite library and append to patch
2008-11-27 06:47:10 +0100 kstribley r264445 : #69129# fix rtl loop bug and rtl caching problem
2008-11-27 06:42:20 +0100 kstribley r264444 : add caching for GraphiteFontAdaptor
2008-11-14 15:57:03 +0100 kstribley r263681 : #69129# add graphite addtional files from cvs
2008-11-14 15:54:47 +0100 kstribley r263680 : #69129# fix for modified resolution api
2008-11-13 16:24:09 +0100 kstribley r263652 : #69129# add skeleton to build graphite module library
2008-11-13 16:22:19 +0100 kstribley r263651 : #69129# add skeleton to build graphite module library
2008-11-13 16:16:10 +0100 kstribley r263650 : #69129# migrate from cvs
2008-11-13 15:26:54 +0100 kstribley r263646 : #69129# add a module for the graphite library
diff --git a/graphite/download/Readme.txt b/graphite/download/Readme.txt
new file mode 100644
index 0000000..fc008de
--- /dev/null
+++ b/graphite/download/Readme.txt
@@ -0,0 +1,15 @@
+The Graphite library is free software; you can redistribute it and/or modify
+ it under the terms of either:
+
+ a) the Common Public License as published by the "Agreement
+ Steward" for that license (currently IBM); either version 0.5
+ of the License, or (at your option) any later version,
+
+ or
+
+ b) the GNU Lesser General Public License as published by the
+ Free Software Foundation; either version 2.1 of License, or
+ (at your option) any later version.
+
+Download source tarball of silgraphite-version.tar.gz from http://sf.net/projects/silgraphite
+Place the downloaded tar ball in this directory.
diff --git a/graphite/download/silgraphite-2.3.1.tar.gz b/graphite/download/silgraphite-2.3.1.tar.gz
new file mode 100644
index 0000000..0c6ed5c
Binary files /dev/null and b/graphite/download/silgraphite-2.3.1.tar.gz differ
diff --git a/graphite/graphite-2.3.1.patch b/graphite/graphite-2.3.1.patch
new file mode 100644
index 0000000..2601db0
--- /dev/null
+++ b/graphite/graphite-2.3.1.patch
@@ -0,0 +1,1979 @@
+--- misc/silgraphite-2.3.1/engine/include/graphite/GrCommon.h 2009-01-21 23:36:40.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/include/graphite/GrCommon.h 2009-07-21 10:41:45.828204700 +0200
+@@ -18,6 +18,8 @@
+ #ifndef GRCOMMON_INCLUDED
+ #define GRCOMMON_INCLUDED
+
++#define _SECURE_SCL 0 // to allow GlyphSetIterator to work, which points off the end of a vector
++#define _HAS_ITERATOR_DEBUGGING 0
+
+ // Standard Headers.
+
+@@ -33,6 +35,7 @@
+ #include <vector>
+ #include <algorithm>
+ #include <string>
++///#include <stdexcept> -- possibly needed for std::string Xran and Xlen functions??
+
+ // Uncomment this to allow multiple versions of gr to coexist
+ // in the same program e.g. pangographite with gtk uses namespace gr
+@@ -41,7 +44,7 @@
+ // Provided the client includes GrClient.h first this #define is
+ // picked up by all files.
+
+-//#define gr gr2
++#define gr gr3ooo
+
+ // Project headers
+ #include "GrPlatform.h"
+--- misc/silgraphite-2.3.1/engine/include/graphite/GrMstypes.h 2009-01-21 23:36:40.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/include/graphite/GrMstypes.h 2009-07-21 10:41:45.957240900 +0200
+@@ -24,11 +24,11 @@
+
+ typedef signed long HRESULT;
+
+-inline const long InterlockedIncrement(long *const intr_lck) {
++inline long InterlockedIncrement(long *const intr_lck) {
+ return ++*intr_lck;
+ }
+
+-inline const long InterlockedDecrement(long *const intr_lck) {
++inline long InterlockedDecrement(long *const intr_lck) {
+ return --*intr_lck;
+ }
+
+--- misc/silgraphite-2.3.1/engine/makefile.vc7 2008-08-21 16:24:32.000000000 +0200
++++ misc/build/silgraphite-2.3.1/engine/makefile.vc7 2009-07-21 10:41:46.072542800 +0200
+@@ -48,11 +48,7 @@
+ CPP_DEBUG=/D "TRACING" $(CPP_DEBUG)
+ !ENDIF
+
+-!IF "$(OS)" == "Windows_NT"
+ NULL=
+-!ELSE
+-NULL=nul
+-!ENDIF
+
+ clean :
+ @- rd /s/q .\release_temp
+--- misc/silgraphite-2.3.1/engine/makefile.vc8 2008-08-21 16:24:32.000000000 +0200
++++ misc/build/silgraphite-2.3.1/engine/makefile.vc8 2009-07-21 10:41:46.221522700 +0200
+@@ -6,7 +6,7 @@
+ # /Wp62
+
+ LINK=link.exe
+-LINK_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /dll /pdb:"$(OUTDIR)\\graphite.pdb" /machine:I386 /out:"$(OUTDIR)\\$(TARGET).dll" /implib:"$(OUTDIR)\\$(TARGET).lib"
++LINK_FLAGS=$(ADDLIBS) kernel32.lib user32.lib gdi32.lib winspool.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /dll /pdb:"$(OUTDIR)\\graphite.pdb" /machine:I386 /out:"$(OUTDIR)\\$(TARGET).dll" /implib:"$(OUTDIR)\\$(TARGET).lib"
+
+ BSC32=bscmake.exe
+ BSC32_FLAGS=/nologo /o"$(OUTDIR)\\$(TARGET).bsc"
+@@ -48,11 +48,7 @@
+ CPP_DEBUG=/D "TRACING" $(CPP_DEBUG)
+ !ENDIF
+
+-!IF "$(OS)" == "Windows_NT"
+ NULL=
+-!ELSE
+-NULL=nul
+-!ENDIF
+
+ clean :
+ @- rd /s/q .\release_temp
+--- misc/silgraphite-2.3.1/engine/src/font/FileFont.cpp 2009-01-21 23:36:42.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/font/FileFont.cpp 2009-07-21 10:41:46.344237000 +0200
+@@ -233,7 +233,7 @@
+ FileFont::readTable(int /*TableId*/ tid, size_t & size)
+ {
+ const TableId tableId = TableId(tid);
+- bool isValid = true;
++ bool isTableValid = true;
+ size_t lOffset = 0, lSize = 0;
+ if (!m_pTableCache)
+ {
+@@ -245,9 +245,9 @@
+ size = m_pTableCache->getTableSize(tableId);
+ // check whether it is already in the cache
+ if (pTable) return pTable;
+- isValid &= TtfUtil::GetTableInfo(tableId, m_pHeader, m_pTableDir,
++ isTableValid &= TtfUtil::GetTableInfo(tableId, m_pHeader, m_pTableDir,
+ lOffset, lSize);
+- if (!isValid)
++ if (!isTableValid)
+ return NULL;
+ fseek(m_pfile, lOffset, SEEK_SET);
+ // only allocate if needed
+@@ -255,16 +255,16 @@
+
+ if (!pTable)
+ {
+- isValid = false;
++ isTableValid = false;
+ return NULL;
+ }
+ size_t bytesRead = fread(pTable, 1, lSize, m_pfile);
+- isValid = bytesRead == lSize;
+- if (isValid)
++ isTableValid = bytesRead == lSize;
++ if (isTableValid)
+ {
+- isValid &= TtfUtil::CheckTable(tableId, pTable, lSize);
++ isTableValid &= TtfUtil::CheckTable(tableId, pTable, lSize);
+ }
+- if (!isValid)
++ if (!isTableValid)
+ {
+ return 0;
+ }
+--- misc/silgraphite-2.3.1/engine/src/font/Font.cpp 2008-05-20 08:04:16.000000000 +0200
++++ misc/build/silgraphite-2.3.1/engine/src/font/Font.cpp 2009-07-21 10:41:46.476133500 +0200
+@@ -626,7 +626,7 @@
+ Assert(false);
+ m_ifeat = m_cfeat;
+ }
+- else if (m_ifeat + n < 0)
++ else if (static_cast<int>(m_ifeat) + n < 0)
+ {
+ // Can't decrement.
+ Assert(false);
+@@ -727,7 +727,7 @@
+ Assert(false);
+ m_ifset = m_cfset;
+ }
+- if (m_ifset + n < 0)
++ if (static_cast<int>(m_ifset) + n < 0)
+ {
+ // Can't decrement.
+ Assert(false);
+@@ -820,7 +820,7 @@
+ Assert(false);
+ m_ilang = m_clang;
+ }
+- else if (m_ilang + n < 0)
++ else if (static_cast<int>(m_ilang) + n < 0)
+ {
+ // Can't decrement.
+ Assert(false);
+@@ -906,7 +906,7 @@
+ Assert(false);
+ m_ilang = m_clang;
+ }
+- else if (m_ilang + n < 0)
++ else if (static_cast<int>(m_ilang) + n < 0)
+ {
+ // Can't decrement.
+ Assert(false);
+--- misc/silgraphite-2.3.1/engine/src/font/TtfUtil.cpp 2009-01-29 09:33:19.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/font/TtfUtil.cpp 2009-07-21 10:41:46.620489600 +0200
+@@ -492,7 +492,7 @@
+ const Sfnt::FontHeader * pTable =
+ reinterpret_cast<const Sfnt::FontHeader *>(pHead);
+
+- return read(((pTable->mac_style) & 0x00000002) != 0);
++ return ((read(pTable->mac_style) & 0x00000002) != 0);
+ }
+
+ /*----------------------------------------------------------------------------------------------
+@@ -1108,8 +1108,8 @@
+ { // loca entries are two bytes and have been divided by two
+ if (nGlyphId <= (lLocaSize >> 1) - 1) // allow sentinel value to be accessed
+ {
+- const uint16 * pTable = reinterpret_cast<const uint16 *>(pLoca);
+- return (read(pTable[nGlyphId]) << 1);
++ const uint16 * pTableLoca = reinterpret_cast<const uint16 *>(pLoca);
++ return (read(pTableLoca[nGlyphId]) << 1);
+ }
+ }
+
+@@ -1117,8 +1117,8 @@
+ { // loca entries are four bytes
+ if (nGlyphId <= (lLocaSize >> 2) - 1)
+ {
+- const uint32 * pTable = reinterpret_cast<const uint32 *>(pLoca);
+- return read(pTable[nGlyphId]);
++ const uint32 * pTableLoca = reinterpret_cast<const uint32 *>(pLoca);
++ return read(pTableLoca[nGlyphId]);
+ }
+ }
+
+@@ -1586,7 +1586,7 @@
+
+ for (size_t i = 0; i < cCompId; i++)
+ {
+- void * pSimpleGlyf = GlyfLookup(static_cast<gr::gid16>(rgnCompId[i]),
++ pSimpleGlyf = GlyfLookup(static_cast<gr::gid16>(rgnCompId[i]),
+ pGlyf, pLoca, lLocaSize, pHead);
+ if (pSimpleGlyf == NULL) {return false;}
+
+@@ -1748,7 +1748,7 @@
+ ----------------------------------------------------------------------------------------------*/
+ bool GlyfPoints(gr::gid16 nGlyphId, const void * pGlyf,
+ const void * pLoca, size_t lLocaSize, const void * pHead,
+- const int * prgnContourEndPoint, size_t cnEndPoints,
++ const int * /*prgnContourEndPoint*/, size_t /*cnEndPoints*/,
+ int * prgnX, int * prgnY, bool * prgfOnCurve, size_t cnPoints)
+ {
+ std::fill_n(prgnX, cnPoints, INT_MAX);
+--- misc/silgraphite-2.3.1/engine/src/painter/SegmentPainter.cpp 2009-01-28 03:01:29.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/painter/SegmentPainter.cpp 2009-07-21 10:41:46.768243300 +0200
+@@ -353,7 +353,7 @@
+ @param bOn - true if we are turning on (ignored in this implementation)
+ ----------------------------------------------------------------------------------------------*/
+ bool SegmentPainter::drawSelectionRange(int ichwAnchor, int ichwEnd,
+- float ydLineTop, float ydLineBottom, bool bOn)
++ float ydLineTop, float ydLineBottom, bool /*bOn*/)
+ {
+ if (g_fDrawing)
+ return true;
+@@ -993,7 +993,7 @@
+ an I-beam (std selection)
+ ----------------------------------------------------------------------------------------------*/
+ void SegmentPainter::CalcOrDrawInsertionPoint(
+- int ichwIP, bool fAssocPrev, bool bOn, bool fForceSplit,
++ int ichwIP, bool fAssocPrev, bool /*bOn*/, bool fForceSplit,
+ Rect * prdPrimary, Rect * prdSecondary)
+ {
+ GrResult res = kresOk;
+@@ -1277,7 +1277,7 @@
+ if NULL, do the drawing
+ ----------------------------------------------------------------------------------------------*/
+ void SegmentPainter::InvertIBeam(float xs, float ysTop, float ysBottom,
+- bool fAssocPrev, Rect * prdRet)
++ bool /*fAssocPrev*/, Rect * prdRet)
+ {
+ float xd = ScaleXToDest(xs);
+ float ydTop = ScaleYToDest(ysTop);
+@@ -1675,7 +1675,7 @@
+ }
+
+ bool SegmentPainter::AtEdgeOfCluster(GrSlotOutput * psloutBase, int isloutBase,
+- GrSlotOutput * pslout, int islout, bool fBefore)
++ GrSlotOutput * /*pslout*/, int islout, bool fBefore)
+ {
+ // Compare pslout to all the members of the cluster. If it is the minimum or maximum, it
+ // is at an edge.
+@@ -1778,12 +1778,12 @@
+ }
+ for (icomp = 0; icomp < pslout->NumberOfComponents(); icomp++)
+ {
+- for (int ichw = pslout->FirstUnderlyingComponent(icomp) ;
+- ichw <= pslout->LastUnderlyingComponent(icomp) ;
+- ichw++)
++ for (int ichwTemp = pslout->FirstUnderlyingComponent(icomp) ;
++ ichwTemp <= pslout->LastUnderlyingComponent(icomp) ;
++ ichwTemp++)
+ {
+- if (m_pseg->m_prgiComponent[ichw - m_pseg->m_ichwAssocsMin] == icomp)
+- prgfAllSelected[ichw] = fAll;
++ if (m_pseg->m_prgiComponent[ichwTemp - m_pseg->m_ichwAssocsMin] == icomp)
++ prgfAllSelected[ichwTemp] = fAll;
+ }
+ }
+ }
+@@ -2304,7 +2304,11 @@
+ Assert that there are no overlaps among all the rectangles in the array, which should
+ be the case if AdjustRectsToNotOverlap is working properly.
+ ----------------------------------------------------------------------------------------------*/
++#ifdef _DEBUG
+ void SegmentPainter::AssertNoOverlaps(std::vector<Rect> & vrect)
++#else
++void SegmentPainter::AssertNoOverlaps(std::vector<Rect> & /*vrect*/)
++#endif
+ {
+ #ifdef _DEBUG
+ for (int irect1 = 0; irect1 < signed(vrect.size() - 1); irect1++)
+@@ -2452,7 +2456,11 @@
+ Assert that there are no overlaps among all the rectangles in the array, which should
+ be the case if AdjustRectsToNotOverlap is working properly.
+ ----------------------------------------------------------------------------------------------*/
++#ifdef _DEBUG
+ void SegmentPainter::AssertNoOverlaps(std::vector<LineSeg> & vls)
++#else
++void SegmentPainter::AssertNoOverlaps(std::vector<LineSeg> & /*vls*/)
++#endif
+ {
+ #ifdef _DEBUG
+ for (int ils1 = 0; ils1 < (int)vls.size() - 1; ils1++)
+@@ -2884,7 +2892,7 @@
+ {
+ if (icompNext != icompCurr)
+ {
+- float xsHorizNext = (fIPOnRight) ? vxsRights[icompNext] : vxsLefts[icompNext];
++ xsHorizNext = (fIPOnRight) ? vxsRights[icompNext] : vxsLefts[icompNext];
+ if (fMovingRight && xsHorizNext > xsHorizCurr)
+ break;
+ else if (!fMovingRight && xsHorizNext < xsHorizCurr)
+@@ -2996,7 +3004,7 @@
+ /*----------------------------------------------------------------------------------------------
+ Make sure the font is set to use the character properties required by this segment.
+ ----------------------------------------------------------------------------------------------*/
+-void SegmentPainter::SetFontProps(unsigned long clrFore, unsigned long clrBack)
++void SegmentPainter::SetFontProps(unsigned long /*clrFore*/, unsigned long /*clrBack*/)
+ {
+ return;
+ }
+--- misc/silgraphite-2.3.1/engine/src/segment/FileInput.cpp 2009-01-21 23:36:42.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/FileInput.cpp 2009-07-21 10:41:46.902538700 +0200
+@@ -80,7 +80,7 @@
+ #ifdef GR_FW
+ bool GrBufferIStream::Open(std::wstring stuFileName, int kMode)
+ #else
+-bool GrBufferIStream::Open(const char * pcFileName, std::ios::openmode kMode)
++bool GrBufferIStream::Open(const char * /*pcFileName*/, std::ios::openmode /*kMode*/)
+ #endif
+ {
+ Assert(false); // use OpenBuffer
+--- misc/silgraphite-2.3.1/engine/src/segment/GrCharStream.cpp 2009-01-21 23:36:42.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/GrCharStream.cpp 2009-07-21 10:41:47.039468200 +0200
+@@ -417,8 +417,11 @@
+ return true;
+ */
+ }
+-
++#ifdef NDEBUG
++bool GrCharStream::AtUnicodeCharBoundary(utf8 * prgchs, int cchs, int ichs, UtfType /*utf*/)
++#else
+ bool GrCharStream::AtUnicodeCharBoundary(utf8 * prgchs, int cchs, int ichs, UtfType utf)
++#endif
+ {
+ Assert(ichs >= 0);
+ Assert(ichs <= cchs);
+--- misc/silgraphite-2.3.1/engine/src/segment/GrClassTable.h 2009-01-21 23:36:42.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/GrClassTable.h 2009-07-21 10:41:47.171157400 +0200
+@@ -54,7 +54,11 @@
+ /*------------------------------------------------------------------------------------------
+ Copy the raw memory into the instance.
+ ------------------------------------------------------------------------------------------*/
++#ifdef NDEBUG
++ void CopyFrom(data16 * pchwStart, int /*cchw*/)
++#else
+ void CopyFrom(data16 * pchwStart, int cchw)
++#endif
+ {
+ m_cgixBIG = pchwStart[0];
+ m_digixBIGInit = pchwStart[1];
+--- misc/silgraphite-2.3.1/engine/src/segment/GrEngine.cpp 2009-01-28 03:01:29.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/GrEngine.cpp 2009-07-21 10:41:47.323131300 +0200
+@@ -159,12 +159,12 @@
+ GrEngine::~GrEngine()
+ {
+ DestroyEverything();
+- #ifdef _MSC_VER
+- if (!_CrtCheckMemory())
+- {
+- OutputDebugString(L"bad memory");
+- }
+- #endif
++// #ifdef _MSC_VER
++// if (!_CrtCheckMemory())
++// {
++// OutputDebugString(L"bad memory");
++// }
++// #endif
+ }
+
+ /*----------------------------------------------------------------------------------------------
+@@ -173,12 +173,12 @@
+ void GrEngine::DestroyEverything()
+ {
+ DestroyContents();
+- #ifdef _MSC_VER
+- if (!_CrtCheckMemory())
+- {
+- OutputDebugString(L"bad memory");
+- }
+- #endif
++// #ifdef _MSC_VER
++// if (!_CrtCheckMemory())
++// {
++// OutputDebugString(L"bad memory");
++// }
++// #endif
+
+ m_strCtrlFileReg.erase();
+ m_strCtrlFileBold.erase();
+@@ -417,7 +417,11 @@
+ @return The supported script direction(s). If more than one, the application is
+ responsible for choosing the most appropriate.
+ ----------------------------------------------------------------------------------------------*/
++#ifdef NDEBUG
++GrResult GrEngine::get_ScriptDirection(unsigned int * pgrfsdc, OLECHAR * /*prgchwErrMsg*/, int /*cchMaxErrMsg*/)
++#else
+ GrResult GrEngine::get_ScriptDirection(unsigned int * pgrfsdc, OLECHAR * prgchwErrMsg, int cchMaxErrMsg)
++#endif
+ {
+ ChkGrOutPtr(pgrfsdc);
+ ChkGrArrayArg(prgchwErrMsg, cchMaxErrMsg);
+@@ -789,7 +793,7 @@
+ Record a system error indicating a bad error in rendering using a supposedly valid font.
+ OBSOLETE
+ ----------------------------------------------------------------------------------------------*/
+-void GrEngine::RecordFontRunError(OLECHAR * prgchwErrMsg, int cchMax, GrResult res)
++void GrEngine::RecordFontRunError(OLECHAR * prgchwErrMsg, int cchMax, GrResult /*res*/)
+ {
+ if (prgchwErrMsg == NULL || cchMax == 0)
+ return;
+@@ -970,7 +974,7 @@
+ /*----------------------------------------------------------------------------------------------
+ Return whether the text is asking for bold and/or italic text.
+ ----------------------------------------------------------------------------------------------*/
+-void GrEngine::GetStyles(Font * pfont, int ichwMin, bool * pfBold, bool * pfItalic)
++void GrEngine::GetStyles(Font * pfont, int /*ichwMin*/, bool * pfBold, bool * pfItalic)
+ {
+ *pfBold = pfont->bold();
+ *pfItalic = pfont->italic();
+@@ -981,7 +985,11 @@
+ Should only be called when we know we are using a base font, or when we are reading
+ the base font to see if it is valid.
+ ----------------------------------------------------------------------------------------------*/
++#ifdef NDEBUG
++void GrEngine::SwitchGraphicsFont(bool /*fBase*/)
++#else
+ void GrEngine::SwitchGraphicsFont(bool fBase)
++#endif
+ {
+ Assert(!fBase || m_stuBaseFaceName.size() > 0);
+
+@@ -1135,7 +1143,7 @@
+ m_chwJShrink0 = 0xffff;
+ m_chwJStep0 = 0xffff;
+ m_chwJWeight0 = 0xffff;
+- for (int i = 0; i < m_cJLevels; i++)
++ for (i = 0; i < m_cJLevels; i++)
+ {
+ // justification glyph attribute IDs
+ bTmp = grstrm.ReadByteFromFont();
+@@ -1210,10 +1218,12 @@
+
+ // rendering behaviors--ignore for now
+ byte cBehaviors = grstrm.ReadByteFromFont();
+- unsigned int nBehaviors[kMaxRenderingBehavior];
++ int nTmp;
++ //unsigned int nBehaviors[kMaxRenderingBehavior]; -- this big buffer causes a stack overflow in Multiscribe; rework eventually
+ for (i = 0; i < cBehaviors; i++)
+ {
+- nBehaviors[i] = unsigned(grstrm.ReadIntFromFont());
++ //nBehaviors[i] = unsigned(grstrm.ReadIntFromFont());
++ nTmp = unsigned(grstrm.ReadIntFromFont());
+ }
+
+ // linebreak glyph ID
+--- misc/silgraphite-2.3.1/engine/src/segment/GrFSM.cpp 2009-01-21 23:36:42.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/GrFSM.cpp 2009-07-21 10:41:47.462405200 +0200
+@@ -46,7 +46,7 @@
+ Fill in the FSM by reading from the font stream.
+ Assumes the stream is in the correct position.
+ ----------------------------------------------------------------------------------------------*/
+-bool GrFSM::ReadFromFont(GrIStream & grstrm, int fxdVersion)
++bool GrFSM::ReadFromFont(GrIStream & grstrm, int /*fxdVersion*/)
+ {
+ short snTmp;
+
+@@ -138,7 +138,7 @@
+ Fill in the FSM's state table by reading from the font stream.
+ Assumes the stream is in the correct position.
+ ----------------------------------------------------------------------------------------------*/
+-bool GrFSM::ReadStateTableFromFont(GrIStream & grstrm, int fxdVersion)
++bool GrFSM::ReadStateTableFromFont(GrIStream & grstrm, int /*fxdVersion*/)
+ {
+ int cCells = ((m_crow - m_crowFinal) * m_ccol);
+ m_prgrowTransitions = new short[cCells];
+--- misc/silgraphite-2.3.1/engine/src/segment/GrFeature.cpp 2009-01-21 23:36:42.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/GrFeature.cpp 2009-07-21 10:41:47.602102200 +0200
+@@ -186,7 +186,7 @@
+ /*----------------------------------------------------------------------------------------------
+ Read the languages from the font.
+ ----------------------------------------------------------------------------------------------*/
+-bool GrLangTable::ReadFromFont(GrIStream * pgrstrm, int fxdVersion)
++bool GrLangTable::ReadFromFont(GrIStream * pgrstrm, int /*fxdVersion*/)
+ {
+ GrIStream & grstrm = *pgrstrm;
+
+@@ -206,13 +206,22 @@
+
+ m_cbOffset0 = (lsbf)(m_prglang[0].cbOffsetBIG);
+
+- Assert((lsbf)(m_prglang[m_clang].cFeaturesBIG) == 0); // bogus entry has no settings
++ if ((lsbf)(m_prglang[m_clang].cFeaturesBIG) == 0) // bogus entry has no settings
++ {
+ cb = (lsbf)(m_prglang[m_clang].cbOffsetBIG) - m_cbOffset0;
+- Assert(cb % sizeof(FeatSet) == 0); // # of bytes fits nicely into FeatSet class
++ if (cb % sizeof(FeatSet) == 0) // # of bytes fits nicely into FeatSet class
++ {
+ int cfset = cb / sizeof(FeatSet);
+ m_prgfset = new FeatSet[cfset];
+ m_cfset = cfset;
+ grstrm.ReadBlockFromFont(m_prgfset, cb);
++ }
++ else return false;
++ }
++ else
++ {
++ return false;
++ }
+
+ return true;
+ }
+--- misc/silgraphite-2.3.1/engine/src/segment/GrPass.cpp 2009-01-28 03:01:29.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/GrPass.cpp 2009-07-21 10:41:47.751390400 +0200
+@@ -279,9 +279,10 @@
+ @param twsh - how we are handling trailing white-space
+ @param pnRet - return value
+ @param pcslotGot - return the number of slots gotten
+- @param pislotFinalBreak - return the index of the final slot, when we are removing
+- the trailing white-space and so the end of the segment
+- will be before the any actual line-break slot
++ @param pislotFinalBreak - index of the final slot (LB or actual glyph), or -1;
++ adjusted when we are removing the trailing white-space and
++ so the end of the segment will be before the any actual
++ line-break slot
+
+ @return kNextPass if we were able to generated the number requested, or processing is
+ complete; otherwise return the number of slots needed from the previous pass.
+@@ -465,7 +466,7 @@
+ void GrBidiPass::ExtendOutput(GrTableManager * ptman,
+ GrSlotStream* psstrmIn, GrSlotStream* psstrmOut,
+ int cslotNeededByNext, TrWsHandling twsh,
+- int * pnRet, int * pcslotGot, int * pislotFinalBreak)
++ int * pnRet, int * pcslotGot, int * /*pislotFinalBreak*/)
+ {
+ Assert(psstrmIn->SlotsToReprocess() == 0);
+
+@@ -776,7 +777,7 @@
+ int GrPass::ExtendFinalOutput(GrTableManager * ptman,
+ GrSlotStream * psstrmInput, GrSlotStream * psstrmOutput,
+ float xsSpaceAllotted, bool fWidthIsCharCount, bool fInfiniteWidth,
+- bool fHaveLineBreak, bool fMustBacktrack, LineBrk lbMax, TrWsHandling twsh,
++ bool fHaveLineBreak, bool fMustBacktrack, LineBrk /*lbMax*/, TrWsHandling twsh,
+ int * pislotLB, float * pxsWidth)
+ {
+ EngineState * pengst = ptman->State();
+@@ -897,7 +898,11 @@
+ Remove undesirable trailing white-space.
+ ----------------------------------------------------------------------------------------------*/
+ int GrPass::RemoveTrailingWhiteSpace(GrTableManager * ptman, GrSlotStream * psstrmOut,
++#ifdef NDEBUG
++ TrWsHandling /*twsh*/, int * pislotFinalBreak)
++#else
+ TrWsHandling twsh, int * pislotFinalBreak)
++#endif
+ {
+ EngineState * pengst = ptman->State();
+
+@@ -944,7 +949,7 @@
+ should never be necessary if they've set up their tables right.
+ ----------------------------------------------------------------------------------------------*/
+ void GrPass::CheckInputProgress(GrSlotStream * psstrmInput, GrSlotStream * psstrmOutput,
+- int islotOrigInput)
++ int /*islotOrigInput*/)
+ {
+ int islotInput = psstrmInput->ReadPosForNextGet();
+ // Assert(islotInput >= islotOrigInput); -- no longer true now that we can back up
+@@ -1752,7 +1757,7 @@
+ ----------------------------------------------------------------------------------------------*/
+ int GrPass::Unwind(GrTableManager * ptman,
+ int islotChanged, GrSlotStream * psstrmIn, GrSlotStream * psstrmOut,
+- bool fFirst)
++ bool /*fFirst*/)
+ {
+ // Back up the number of slots required for the longest rule context,
+ // but if we land in the middle of a chunk, go forward to its boundary.
+@@ -1824,7 +1829,7 @@
+ ----------------------------------------------------------------------------------------------*/
+ int GrBidiPass::Unwind(GrTableManager * ptman,
+ int islotChanged, GrSlotStream * psstrmIn, GrSlotStream * psstrmOut,
+- bool fFirst)
++ bool /*fFirst*/)
+ {
+ int islotIn;
+ int islotOut;
+@@ -1901,8 +1906,8 @@
+ OBSOLETE
+ ----------------------------------------------------------------------------------------------*/
+ //:Ignore
+-void GrPosPass::Unattach(GrSlotStream * psstrmIn, int islotIn,
+- GrSlotStream * psstrmOut, int islotOut, int islotLB)
++void GrPosPass::Unattach(GrSlotStream * /*psstrmIn*/, int /*islotIn*/,
++ GrSlotStream * /*psstrmOut*/, int /*islotOut*/, int /*islotLB*/)
+ {
+ // Because this is a positioning pass, there is a one-to-one correspondence between
+ // the slots in the input and the slots in the output. Thus we can make simplifying
+--- misc/silgraphite-2.3.1/engine/src/segment/GrPass.h 2008-08-21 16:24:32.000000000 +0200
++++ misc/build/silgraphite-2.3.1/engine/src/segment/GrPass.h 2009-07-21 10:41:47.894201400 +0200
+@@ -197,7 +197,7 @@
+ bool ReadFromFont(GrIStream & grstrm, int fxdSilfVersion, int fxdRuleVersion, int nOffset);
+ void InitializeWithNoRules();
+
+- virtual void SetTopDirLevel(int n)
++ virtual void SetTopDirLevel(int /*n*/)
+ { // only GrBidiPass does anything interesting
+ }
+
+@@ -253,13 +253,13 @@
+ m_pzpst->SetResyncSkip(n);
+ }
+
+- virtual void DoCleanUpSegMin(GrTableManager * ptman,
+- GrSlotStream * psstrmIn, int islotInitReadPos, GrSlotStream * psstrmOut)
++ virtual void DoCleanUpSegMin(GrTableManager * /*ptman*/,
++ GrSlotStream * /*psstrmIn*/, int /*islotInitReadPos*/, GrSlotStream * /*psstrmOut*/)
+ {
+ }
+
+- virtual void DoCleanUpSegLim(GrTableManager * ptman, GrSlotStream * psstrmOut,
+- TrWsHandling twsh)
++ virtual void DoCleanUpSegLim(GrTableManager * /*ptman*/, GrSlotStream * /*psstrmOut*/,
++ TrWsHandling /*twsh*/)
+ {
+ }
+
+@@ -383,8 +383,8 @@
+ void MapChunks(GrSlotStream * psstrmIn, GrSlotStream * psstrmOut,
+ int islotChunkI, int islotChunkO, int cslotReprocessed);
+
+- virtual void Unattach(GrSlotStream * psstrmIn, int islotIn, // GrPosPass overrides
+- GrSlotStream * psstrmOut, int islotOut, int islotLB)
++ virtual void Unattach(GrSlotStream * /*psstrmIn*/, int /*islotIn*/, // GrPosPass overrides
++ GrSlotStream * /*psstrmOut*/, int /*islotOut*/, int /*islotLB*/)
+ {
+ }
+
+@@ -500,8 +500,8 @@
+
+ protected:
+ // Irrelevant when generating glyphs.
+- virtual void RunRule(GrTableManager *, int ruln,
+- GrSlotStream * psstrmInput, GrSlotStream * psstrmOutput)
++ virtual void RunRule(GrTableManager *, int /*ruln*/,
++ GrSlotStream * /*psstrmInput*/, GrSlotStream * /*psstrmOutput*/)
+ {
+ Assert(false);
+ }
+--- misc/silgraphite-2.3.1/engine/src/segment/GrPassActionCode.cpp 2009-01-28 03:01:29.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/GrPassActionCode.cpp 2009-07-21 10:41:48.046193000 +0200
+@@ -632,8 +632,13 @@
+ /*----------------------------------------------------------------------------------------------
+ We are finished processing a slot; go on to the next slot, or possibly go backwards.
+ ----------------------------------------------------------------------------------------------*/
+-void GrPass::DoNext(GrTableManager * ptman,
+- int cslot, GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
++#ifdef NDEBUG
++void GrPass::DoNext(GrTableManager * /*ptman*/,
++ int /*cslot*/, GrSlotStream * /*psstrmIn*/, GrSlotStream * /*psstrmOut*/)
++#else
++void GrPass::DoNext(GrTableManager * /*ptman*/,
++ int cslot, GrSlotStream * /*psstrmIn*/, GrSlotStream * /*psstrmOut*/)
++#endif
+ {
+ gAssert(cslot == 1); // for now anyway
+ }
+@@ -690,6 +695,7 @@
+ psstrmOut->SetSegMinToWritePos(false);
+ if (fSetSegLim)
+ psstrmOut->SetSegLimToWritePos(false);
++ //gid16 chw; chw = pslotNew->GlyphID();
+ psstrmOut->NextPut(pslotNew);
+ }
+
+@@ -729,6 +735,7 @@
+ psstrmOut->SetSegMinToWritePos(false);
+ if (fSetSegLim)
+ psstrmOut->SetSegLimToWritePos(false);
++ //gid16 chw; chw = pslotNew->GlyphID();
+ psstrmOut->NextPut(pslotNew);
+ }
+
+@@ -825,7 +832,7 @@
+ @param psstrmIn / Out - input/output streams
+ ----------------------------------------------------------------------------------------------*/
+ void GrPass::DoPutSubs3(GrTableManager * ptman, bool fInserting,
+- int cslotSel1, int nSelClass1, int cslotSel2, int nSelClass2, int cslotSel3, int nSelClass3,
++ int cslotSel1, int nSelClass1, int cslotSel2, int nSelClass2, int /*cslotSel3*/, int nSelClass3,
+ int nReplacementClass,
+ GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
+ {
+@@ -888,7 +895,7 @@
+ Common part of all the DoPutSubs... methods.
+ ----------------------------------------------------------------------------------------------*/
+ void GrPass::DoPutSubsAux(GrTableManager * ptman, bool fInserting, gid16 nGlyphReplacement,
+- GrSlotStream * psstrmIn, GrSlotStream * psstrmOut, GrSlotState * pslotNextInput,
++ GrSlotStream * /*psstrmIn*/, GrSlotStream * psstrmOut, GrSlotState * pslotNextInput,
+ bool fAtSegMin, bool fAtSegLim)
+ {
+ EngineState * pengst = ptman->State();
+@@ -915,6 +922,7 @@
+ psstrmOut->SetSegMinToWritePos(false);
+ if (fSetSegLim)
+ psstrmOut->SetSegLimToWritePos(false);
++ //gid16 chw; chw = pslotNew->GlyphID();
+ psstrmOut->NextPut(pslotNew);
+ }
+
+@@ -924,7 +932,7 @@
+ and its after-assoc to the slot before it. This makes it basically unselectable.
+ OBSOLETE - handled by slot initialization code
+ ----------------------------------------------------------------------------------------------*/
+-void GrPass::SetNeutralAssocs(GrSlotState * pslotNew, GrSlotStream * psstrmIn)
++void GrPass::SetNeutralAssocs(GrSlotState * pslotNew, GrSlotStream * /*psstrmIn*/)
+ {
+ pslotNew->ClearAssocs();
+ }
+@@ -943,6 +951,7 @@
+ psstrmOut->SetSegLimToWritePos();
+
+ GrSlotState * pslot = psstrmIn->NextGet();
++ //gid16 chw; chw = pslotNew->GlyphID();
+ pslot->MarkDeleted();
+
+ if (ptman->LoggingTransduction())
+@@ -957,7 +966,7 @@
+ @param fInserting - whether current slot was inserted
+ @param psstrmIn / Out - input/output streams
+ ----------------------------------------------------------------------------------------------*/
+-void GrPass::DoAssoc(int cnAssocs, std::vector<int> & vnAssocs, bool fInserting,
++void GrPass::DoAssoc(int cnAssocs, std::vector<int> & vnAssocs, bool /*fInserting*/,
+ GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
+ {
+ gAssert((unsigned)cnAssocs == vnAssocs.size());
+@@ -997,7 +1006,11 @@
+ @param vnStack - stack to read value from
+ @param psstrmIn / Out - input/output streams
+ ----------------------------------------------------------------------------------------------*/
++#ifdef NDEBUG
++void GrPass::DoSetAttr(GrTableManager * ptman, ActionCommand op, bool /*fInserting*/,
++#else
+ void GrPass::DoSetAttr(GrTableManager * ptman, ActionCommand op, bool fInserting,
++#endif
+ SlotAttrName slat, int slati, std::vector<int> & vnStack,
+ GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
+ {
+@@ -1192,7 +1205,7 @@
+ @param psstrmIn - input stream
+ ----------------------------------------------------------------------------------------------*/
+ void GrPass::DoPushSlotAttr(GrTableManager * ptman,
+- int nSlotRef, bool fInserting,
++ int nSlotRef, bool /*fInserting*/,
+ SlotAttrName slat, int slati, std::vector<int> & vnStack,
+ GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
+ {
+@@ -1236,16 +1249,16 @@
+
+ case kslatAttTo: nVal = pslot->AttachTo(); break;
+ case kslatAttLevel: nVal = pslot->AttachLevel(); break;
+- case kslatAttAtX: nVal = pslot->AttachAtX(ptman, psstrmIn); break;
+ case kslatAttAtY: nVal = pslot->AttachAtY(); break;
+ case kslatAttAtGpt: nVal = pslot->AttachAtGpoint(); break;
+ case kslatAttAtXoff: nVal = pslot->AttachAtXOffset(); break;
+ case kslatAttAtYoff: nVal = pslot->AttachAtYOffset(); break;
+- case kslatAttWithX: nVal = pslot->AttachWithX(ptman, psstrmIn); break;
+ case kslatAttWithY: nVal = pslot->AttachWithY(); break;
+ case kslatAttWithGpt: nVal = pslot->AttachWithGpoint(); break;
+ case kslatAttWithXoff: nVal = pslot->AttachWithXOffset(); break;
+ case kslatAttWithYoff: nVal = pslot->AttachWithYOffset(); break;
++ case kslatAttAtX: nVal = pslot->AttachAtX(ptman, psstrmIn); break;
++ case kslatAttWithX: nVal = pslot->AttachWithX(ptman, psstrmIn); break;
+
+ case kslatMeasureSol: nVal = pslot->MeasureSol(); break;
+ case kslatMeasureEol: nVal = pslot->MeasureEol(); break;
+@@ -1282,7 +1295,7 @@
+ @param vnStack - stack to push onto
+ @param psstrmIn - input stream
+ ----------------------------------------------------------------------------------------------*/
+-void GrPass::DoPushGlyphAttr(GrTableManager * ptman, int nSlotRef, bool fInserting,
++void GrPass::DoPushGlyphAttr(GrTableManager * ptman, int nSlotRef, bool /*fInserting*/,
+ int nGlyphAttr,
+ std::vector<int> & vnStack, GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
+ {
+@@ -1307,7 +1320,7 @@
+ @param vnStack - stack to push onto
+ @param psstrmIn - input stream
+ ----------------------------------------------------------------------------------------------*/
+-void GrPass::DoPushAttToGlyphAttr(GrTableManager * ptman, int nSlotRef, bool fInserting,
++void GrPass::DoPushAttToGlyphAttr(GrTableManager * ptman, int nSlotRef, bool /*fInserting*/,
+ int nGlyphAttr, std::vector<int> & vnStack,
+ GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
+ {
+@@ -1337,7 +1350,7 @@
+ @param vnStack - stack to push onto
+ @param psstrmIn - input stream
+ ----------------------------------------------------------------------------------------------*/
+-void GrPass::DoPushGlyphMetric(GrTableManager * ptman, int nSlotRef, bool fInserting,
++void GrPass::DoPushGlyphMetric(GrTableManager * ptman, int nSlotRef, bool /*fInserting*/,
+ int nGlyphAttr, int nAttLevel,
+ std::vector<int> & vnStack, GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
+ {
+@@ -1364,7 +1377,7 @@
+ @param psstrmIn - input stream
+ @param psstrmOut - output stream
+ ----------------------------------------------------------------------------------------------*/
+-void GrPass::DoPushAttToGlyphMetric(GrTableManager * ptman, int nSlotRef, bool fInserting,
++void GrPass::DoPushAttToGlyphMetric(GrTableManager * ptman, int nSlotRef, bool /*fInserting*/,
+ int nGlyphAttr, int nAttLevel,
+ std::vector<int> & vnStack,
+ GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
+@@ -1399,7 +1412,7 @@
+ }
+ else
+ {
+- pslot->CalcCompositeMetrics(ptman, psstrmIn, nAttLevel, true);
++ pslot->CalcCompositeMetrics(ptman, psstrmIn, NULL, nAttLevel, true);
+
+ float xy;
+ switch (gmet)
+@@ -1435,7 +1448,11 @@
+ @param psstrmIn - input stream
+ @param psstrmOut - output stream
+ ----------------------------------------------------------------------------------------------*/
+-void GrPass::DoPushFeatValue(GrTableManager * ptman, int nSlotRef, bool fInserting,
++#ifdef NDEBUG
++void GrPass::DoPushFeatValue(GrTableManager * /*ptman*/, int nSlotRef, bool /*fInserting*/,
++#else
++void GrPass::DoPushFeatValue(GrTableManager * /*ptman*/, int nSlotRef, bool fInserting,
++#endif
+ int nFeat, std::vector<int> & vnStack, GrSlotStream * psstrmIn, GrSlotStream * psstrmOut)
+ {
+ gAssert(!fInserting);
+--- misc/silgraphite-2.3.1/engine/src/segment/GrSlotState.cpp 2009-01-28 03:01:29.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/GrSlotState.cpp 2009-07-21 10:41:48.198035300 +0200
+@@ -261,7 +261,7 @@
+ root or attached leaf slots.
+ OBSOLETE
+ ----------------------------------------------------------------------------------------------*/
+-void GrSlotState::FixAttachmentTree(GrSlotState * pslotOld)
++void GrSlotState::FixAttachmentTree(GrSlotState * /*pslotOld*/)
+ {
+ #if 0
+ pslotOld->m_vpslotAttLeaves.CopyTo(m_vpslotAttLeaves);
+@@ -524,13 +524,13 @@
+ GrSlotState * pslot;
+ if (HasComponents())
+ {
+- for (int iComponent = 0; iComponent < m_cnCompPerLig; iComponent++)
++ for (int iLigComponent = 0; iLigComponent < m_cnCompPerLig; iLigComponent++)
+ {
+- pslot = CompRefSlot(iComponent);
++ pslot = CompRefSlot(iLigComponent);
+ if (pslot)
+ {
+ Assert(PassModified() >= pslot->PassModified());
+- pslot->AllComponentRefs(vichw, vicomp, iComponent);
++ pslot->AllComponentRefs(vichw, vicomp, iLigComponent);
+ }
+ }
+ }
+@@ -1024,7 +1024,7 @@
+ NOTE: the caller is responsible to zap the cached positions of following glyphs
+ in the stream.
+ ----------------------------------------------------------------------------------------------*/
+-void GrSlotState::AttachToRoot(GrTableManager * ptman, GrSlotStream * psstrm,
++void GrSlotState::AttachToRoot(GrTableManager * /*ptman*/, GrSlotStream * psstrm,
+ GrSlotState * pslotNewRoot)
+ {
+ GrSlotState * pslotOldRoot = (m_dislotRootFixed == 0) ?
+@@ -1063,7 +1063,7 @@
+
+ float xsWidth, xsVisWidth;
+ if (m_xsPositionX == kNegInfFloat || m_ysPositionY == kNegInfFloat)
+- ptman->CalcPositionsUpTo(psstrmOut->m_ipass, this, &xsWidth, &xsVisWidth);
++ ptman->CalcPositionsUpTo(psstrmOut->m_ipass, this, true, &xsWidth, &xsVisWidth);
+
+ *pmXPos = ptman->LogToEmUnits(m_xsPositionX);
+ *pmYPos = ptman->LogToEmUnits(m_ysPositionY);
+@@ -1077,7 +1077,7 @@
+ {
+ Assert(m_dislotRootFixed == m_srAttachTo);
+ GrSlotState * pslotRoot = AttachRoot(psstrm);
+- CalcRootMetrics(ptman, psstrm, kPosInfinity);
++ CalcRootMetrics(ptman, psstrm, NULL, kPosInfinity);
+ if (pslotRoot)
+ pslotRoot->AdjustRootMetrics(ptman, psstrm);
+ }
+@@ -1086,13 +1086,15 @@
+ Calculate the composite metrics for this slot.
+
+ @param psstrm - stream for which we are calculating it
++ @param psstrmNext - because when processing in the middle of a pass, we may need to
++ get the slot from the following (output) stream
+ @param nLevel - attachment level we are asking for; kPosInifinity means all levels
+ @param fThorough - true: do a thorough recalculation; false: don't recalculate
+ metrics for leaves (are they assumed to be accurate???)
+ --currently not used
+ ----------------------------------------------------------------------------------------------*/
+ void GrSlotState::CalcCompositeMetrics(GrTableManager * ptman, GrSlotStream * psstrm,
+- int nLevel, bool fThorough)
++ GrSlotStream * psstrmNext, int nLevel, bool fThorough)
+ {
+ if (m_nCompositeLevel == nLevel)
+ return;
+@@ -1101,19 +1103,38 @@
+ {
+ Assert(m_dislotRootFixed == m_srAttachTo);
+ GrSlotState * pslotRoot = AttachRoot(psstrm);
++ // Kludge to handle the fact that we might have gotten the root from the wrong stream.
++ // Calling MidPassSlotAt finds the right one.
++ if (psstrmNext && pslotRoot)
++ {
++ int islotRoot = pslotRoot->PosPassIndex();
++ pslotRoot = psstrm->MidPassSlotAt(islotRoot, psstrmNext);
++ }
+
+ InitMetrics(ptman, pslotRoot);
+
+ for (size_t islot = 0; islot < m_vdislotAttLeaves.size(); islot++)
+ {
+- GrSlotState * pslotLeaf = SlotAtOffset(psstrm, m_vdislotAttLeaves[islot]);
++ GrSlotState * pslotLeaf;
++ if (psstrmNext)
++ {
++ // Calculating a position in the middle of processing a pass.
++ pslotLeaf = psstrm->MidPassSlotAt(PosPassIndex() + m_vdislotAttLeaves[islot],
++ psstrmNext);
++ }
++ else
++ {
++ // Calculating the final position.
++ pslotLeaf = SlotAtOffset(psstrm, m_vdislotAttLeaves[islot]);
++ }
++
+ if (pslotLeaf->AttachLevel() <= nLevel)
+- pslotLeaf->CalcCompositeMetrics(ptman, psstrm, nLevel, fThorough);
++ pslotLeaf->CalcCompositeMetrics(ptman, psstrm, psstrmNext, nLevel, fThorough);
+ else
+ // this slot will be ignored in the composite metrics
+ pslotLeaf->ZapRootMetrics();
+ }
+- CalcRootMetrics(ptman, psstrm, nLevel);
++ CalcRootMetrics(ptman, psstrm, psstrmNext, nLevel);
+
+ m_nCompositeLevel = nLevel;
+ }
+@@ -1129,25 +1150,33 @@
+ /*----------------------------------------------------------------------------------------------
+ Calculate the metrics for this node and all its leaf nodes.
+ ----------------------------------------------------------------------------------------------*/
+-void GrSlotState::CalcRootMetrics(GrTableManager * ptman, GrSlotStream * psstrm, int nLevel)
++void GrSlotState::CalcRootMetrics(GrTableManager * /*ptman*/, GrSlotStream * psstrm,
++ GrSlotStream * psstrmNext, int nLevel)
+ {
+ for (size_t idislot = 0; idislot < m_vdislotAttLeaves.size(); idislot++)
+ {
+- GrSlotState * pslot = SlotAtOffset(psstrm, m_vdislotAttLeaves[idislot]);
+- if (pslot->AttachLevel() > nLevel)
++ GrSlotState * pslotLeaf = SlotAtOffset(psstrm, m_vdislotAttLeaves[idislot]);
++ // Kludge to handle the fact that we might have gotten the leaf from the wrong stream.
++ // Calling MidPassSlotAt finds the right one.
++ if (psstrmNext)
++ {
++ int islot = pslotLeaf->PosPassIndex();
++ pslotLeaf = psstrm->MidPassSlotAt(islot, psstrmNext);
++ }
++ if (pslotLeaf->AttachLevel() > nLevel)
+ continue;
+
+- m_xsClusterXOffset = min(m_xsClusterXOffset, pslot->m_xsClusterXOffset);
+- if (!pslot->m_fIgnoreAdvance)
++ m_xsClusterXOffset = min(m_xsClusterXOffset, pslotLeaf->m_xsClusterXOffset);
++ if (!pslotLeaf->m_fIgnoreAdvance)
+ {
+ m_xsClusterAdv = max(
+ m_xsClusterAdv,
+- pslot->m_xsClusterAdv + m_xsRootShiftX);
++ pslotLeaf->m_xsClusterAdv + m_xsRootShiftX);
+ }
+- m_xsClusterBbLeft = min(m_xsClusterBbLeft, pslot->m_xsClusterBbLeft);
+- m_xsClusterBbRight = max(m_xsClusterBbRight, pslot->m_xsClusterBbRight);
+- m_ysClusterBbTop = max(m_ysClusterBbTop, pslot->m_ysClusterBbTop);
+- m_ysClusterBbBottom = min(m_ysClusterBbBottom, pslot->m_ysClusterBbBottom);
++ m_xsClusterBbLeft = min(m_xsClusterBbLeft, pslotLeaf->m_xsClusterBbLeft);
++ m_xsClusterBbRight = max(m_xsClusterBbRight, pslotLeaf->m_xsClusterBbRight);
++ m_ysClusterBbTop = max(m_ysClusterBbTop, pslotLeaf->m_ysClusterBbTop);
++ m_ysClusterBbBottom = min(m_ysClusterBbBottom, pslotLeaf->m_ysClusterBbBottom);
+ }
+ }
+
+@@ -1263,7 +1292,7 @@
+ /*----------------------------------------------------------------------------------------------
+ Y-offsets of a single glyph relative to the previous advance position.
+ ----------------------------------------------------------------------------------------------*/
+-float GrSlotState::GlyphYOffset(GrSlotStream * psstrm)
++float GrSlotState::GlyphYOffset(GrSlotStream * /*psstrm*/)
+ {
+ return m_ysOffsetY;
+ }
+--- misc/silgraphite-2.3.1/engine/src/segment/GrSlotState.h 2009-01-28 03:01:29.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/GrSlotState.h 2009-07-21 10:41:48.351654100 +0200
+@@ -308,7 +308,11 @@
+ {
+ return m_islotPosPass;
+ }
++#ifdef NDEBUG
++ void SetPosPassIndex(int islot, bool /*fInputToPosPass1*/)
++#else
+ void SetPosPassIndex(int islot, bool fInputToPosPass1)
++#endif
+ {
+ // If we're resetting it, it should be to the same value as before:
+ Assert(fInputToPosPass1 || m_islotPosPass == kNotYetSet || m_islotPosPass == islot);
+@@ -386,12 +390,12 @@
+ return (IsInitialLineBreak(chwLB) || IsFinalLineBreak(chwLB));
+ //return (m_chwGlyphID == chwLB); // TODO: remove
+ }
+- bool IsInitialLineBreak(gid16 chwLB)
++ bool IsInitialLineBreak(gid16 /*chwLB*/)
+ {
+ return (m_spsl == kspslLbInitial);
+ //return (IsLineBreak(chwLB) && m_fInitialLB == true); // TODO: remove
+ }
+- bool IsFinalLineBreak(gid16 chwLB)
++ bool IsFinalLineBreak(gid16 /*chwLB*/)
+ {
+ return (m_spsl == kspslLbFinal);
+ //return (IsLineBreak(chwLB) && m_fInitialLB == false); // TODO: remove
+@@ -475,7 +479,7 @@
+ return m_mAttachAtX;
+ }
+
+- int AttachWithX(GrTableManager * ptman, GrSlotStream * psstrm)
++ int AttachWithX(GrTableManager * /*ptman*/, GrSlotStream * /*psstrm*/)
+ {
+ if (m_mAttachAtX == kNotYetSet)
+ {
+@@ -615,7 +619,7 @@
+ GrSlotStream * psstrmIn, GrSlotStream * psstrmOut, int islotThis);
+
+ void CalcCompositeMetrics(GrTableManager * ptman, GrSlotStream * psstrm,
+- int nLevel, bool fThorough = false);
++ GrSlotStream * psstrmNext, int nLevel, bool fThorough = false);
+
+ void Position(GrTableManager * ptman,
+ GrSlotStream * psstrmOut, int * pmXPos, int * pmYPos);
+@@ -646,7 +650,7 @@
+ {
+ return ClusterBbLeft(psstrm) + xs;
+ }
+- float ClusterRsb(GrSlotStream * psstrm, float xs)
++ float ClusterRsb(GrSlotStream * /*psstrm*/, float xs)
+ {
+ return ClusterAdvWidthFrom(xs) - ClusterBbRightFrom(xs);
+ }
+@@ -668,19 +672,19 @@
+ {
+ return ClusterBbRightFrom(Base(psstrm)->ClusterRootOffset());
+ }
+- float ClusterBbTop(GrSlotStream * psstrm)
++ float ClusterBbTop(GrSlotStream * /*psstrm*/)
+ {
+ return m_ysClusterBbTop;
+ }
+- float ClusterBbBottom(GrSlotStream * psstrm)
++ float ClusterBbBottom(GrSlotStream * /*psstrm*/)
+ {
+ return m_ysClusterBbBottom;
+ }
+- float ClusterBbWidth(GrSlotStream * psstrm)
++ float ClusterBbWidth(GrSlotStream * /*psstrm*/)
+ {
+ return m_xsClusterBbRight - m_xsClusterBbLeft + 1;
+ }
+- float ClusterBbHeight(GrSlotStream * psstrm)
++ float ClusterBbHeight(GrSlotStream * /*psstrm*/)
+ {
+ return m_ysClusterBbTop - m_ysClusterBbBottom + 1;
+ }
+@@ -990,7 +994,8 @@
+ void InitMetrics(GrTableManager * ptman, GrSlotState * pslotRoot);
+ void InitLeafMetrics(GrTableManager * ptman, GrSlotState * pslotRoot);
+ void InitRootMetrics(GrTableManager * ptman);
+- void CalcRootMetrics(GrTableManager * ptman, GrSlotStream *, int nLevel);
++ void CalcRootMetrics(GrTableManager * ptman, GrSlotStream * psstrm,
++ GrSlotStream * psstrmNext, int nLevel);
+ void AttachToRoot(GrTableManager * ptman, GrSlotStream *, GrSlotState * pslotNewRoot);
+ void AttachLogUnits(GrTableManager * ptman,
+ GrSlotState * pslotRoot,
+--- misc/silgraphite-2.3.1/engine/src/segment/GrSlotStream.cpp 2009-02-04 06:53:26.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/GrSlotStream.cpp 2009-07-21 10:41:48.503535500 +0200
+@@ -189,12 +189,16 @@
+ stream position when the rule is being run.
+
+ @param dislot - how far back to peek before the write position
+- when the rule started; a negative number
++ WHEN THE RULE STARTED; a negative number
+ (NOTE: the current write position is irrelevant)
+ @param fNullOkay - true if it's okay to return NULL in the situation where we're asking
+ for something before the beginning of the stream
+ ----------------------------------------------------------------------------------------------*/
++#ifdef NDEBUG
++GrSlotState * GrSlotStream::PeekBack(int dislot, bool /*fNullOkay*/)
++#else
+ GrSlotState * GrSlotStream::PeekBack(int dislot, bool fNullOkay)
++#endif
+ {
+ Assert(dislot < 0);
+ if (dislot < m_islotRuleStartWrite * -1)
+@@ -1104,6 +1108,7 @@
+ case kdircRLO:
+ case kdircRLE:
+ case kdircPdfR:
++ case kdircRlb:
+ return true;
+
+ case kdircNeutral:
+@@ -1212,7 +1217,7 @@
+ return true;
+
+ float xsWidth, xsVisWidth;
+- ptman->CalcPositionsUpTo(m_ipass, NULL, &xsWidth, &xsVisWidth);
++ ptman->CalcPositionsUpTo(m_ipass, NULL, false, &xsWidth, &xsVisWidth);
+
+ *pxsWidth = (fIgnoreTrailingWS || twsh == ktwshOnlyWs) ? xsVisWidth : xsWidth;
+ return (*pxsWidth < xsSpaceAllotted);
+@@ -1322,7 +1327,7 @@
+ @param islotMin - first slot that is officially part of the segment (after initial LB)
+ ----------------------------------------------------------------------------------------------*/
+ int GrSlotStream::MakeSegmentBreak(GrTableManager * ptman,
+- int islotPrevBreak, bool fInsertedLB, int islotStartTry,
++ int /*islotPrevBreak*/, bool /*fInsertedLB*/, int islotStartTry,
+ LineBrk lb, TrWsHandling twsh, int islotMin,
+ LineBrk * plbNextToTry)
+ {
+@@ -1576,7 +1581,11 @@
+ Return the break weight of the given slot, which should be a line-break.
+ OBSOLETE??
+ ----------------------------------------------------------------------------------------------*/
++#ifdef NDEBUG
++LineBrk GrSlotStream::BreakWeightAt(gid16 /*chwLB*/, int islot)
++#else
+ LineBrk GrSlotStream::BreakWeightAt(gid16 chwLB, int islot)
++#endif
+ {
+ GrSlotState * pslot = GetSlotAt(islot);
+ Assert(pslot->IsLineBreak(chwLB));
+@@ -1769,7 +1778,7 @@
+ @param fBackingUp - this chunk results in the stream position moving backwards,
+ so clear anything we're backing over
+ ----------------------------------------------------------------------------------------------*/
+-void GrSlotStream::MapInputChunk(int islotInputMin, int islotOutputMin, int islotInputLim,
++void GrSlotStream::MapInputChunk(int islotInputMin, int islotOutputMin, int /*islotInputLim*/,
+ bool fSkipChunkStart, bool fBackingUp)
+ {
+ Assert(AssertValid());
+@@ -1828,7 +1837,7 @@
+ @param fBackingUp - this chunk results in the stream position moving backwards,
+ so clear anything we're backing over
+ ----------------------------------------------------------------------------------------------*/
+-void GrSlotStream::MapOutputChunk(int islotOutputMin, int islotInputMin, int islotOutputLim,
++void GrSlotStream::MapOutputChunk(int islotOutputMin, int islotInputMin, int /*islotOutputLim*/,
+ bool fSkipChunkStart, int cslotReprocess, bool fBackingUp)
+ {
+ Assert(AssertValid());
+@@ -1863,7 +1872,7 @@
+ Ensure that the chunk maps for a pair of streams match properly. The recipient is
+ the input stream.
+ ----------------------------------------------------------------------------------------------*/
+-void GrSlotStream::AssertChunkMapsValid(GrSlotStream * psstrmOut)
++void GrSlotStream::AssertChunkMapsValid(GrSlotStream * /*psstrmOut*/)
+ {
+ #ifdef _DEBUG
+ GrSlotStream * psstrmIn = this;
+@@ -1915,7 +1924,7 @@
+ Ensure that corresponding items in the streams of a positioning pass have matching
+ stream indices. The recipient is the output stream.
+ ----------------------------------------------------------------------------------------------*/
+-void GrSlotStream::AssertStreamIndicesValid(GrSlotStream * psstrmIn)
++void GrSlotStream::AssertStreamIndicesValid(GrSlotStream * /*psstrmIn*/)
+ {
+ #ifdef _DEBUG
+ if (!GotIndexOffset())
+@@ -1939,7 +1948,7 @@
+ in the output stream. (Currently the compiler ensures this by making it an error
+ to write rules that don't do this.)
+ ----------------------------------------------------------------------------------------------*/
+-void GrSlotStream::AssertAttachmentsInOutput(int islotMin, int islotLim)
++void GrSlotStream::AssertAttachmentsInOutput(int /*islotMin*/, int /*islotLim*/)
+ {
+ #ifdef _DEBUG
+ for (int islot = islotMin; islot < islotLim; islot++)
+@@ -2007,7 +2016,7 @@
+ Record the number of slots in the stream that are previous to the official start of the
+ segment.
+ ----------------------------------------------------------------------------------------------*/
+-void GrSlotStream::CalcIndexOffset(GrTableManager * ptman)
++void GrSlotStream::CalcIndexOffset(GrTableManager * /*ptman*/)
+ {
+ if (GotIndexOffset())
+ return; // already figured it
+@@ -2203,6 +2212,21 @@
+ }
+
+ /*----------------------------------------------------------------------------------------------
++ In the middle of running a pass, return the given slot to use in processing.
++ Read it from the reprocess buffer if appropriate, or for slots previous to the current
++ position, read from the output stream (psstrmNext).
++
++ psstrmNext may be NULL when processing is complete, therefore we only have one stream to
++ deal with.
++----------------------------------------------------------------------------------------------*/
++GrSlotState * GrSlotStream::MidPassSlotAt(int islot, GrSlotStream * psstrmNext)
++{
++ int islotInput = islot - ReadPosForNextGet() + 1; // +1 because RuleInputSlot takes 0 to mean the previously read slot
++ GrSlotState * pslot = RuleInputSlot(islotInput, psstrmNext);
++ return pslot;
++}
++
++/*----------------------------------------------------------------------------------------------
+ Return the "current" input item from the rule's perspective, ie, the last slot read.
+ So dislotOffset = 0 means not the slot at the read position but one slot earlier.
+
+@@ -2214,7 +2238,6 @@
+ @param fNullOkay - true if it's okay to return NULL in the situation where we're asking
+ for something before the beginning of the stream
+ ----------------------------------------------------------------------------------------------*/
+-
+ GrSlotState * GrSlotStream::RuleInputSlot(int dislotOffset, GrSlotStream * psstrmOutput,
+ bool fNullOkay)
+ {
+@@ -2244,8 +2267,10 @@
+
+ if (cslotOffsetBack >= cslotPostReproc + cslotValidReproc)
+ {
+- // Read from the output stream.
+- int dislotTmp = dislotOffset - 1 + cslotPostReproc + cslotValidReproc;
++ // Read from the output stream. (Remember that PeekBack works relative to
++ // the rule-start write position, not the current write position.)
++ int dislotTmp = dislotOffset - 1 + cslotPostReproc
++ + cslotValidReproc - SlotsToReprocess();
+ Assert(dislotTmp < 0);
+ return psstrmOutput->PeekBack(dislotTmp);
+ }
+@@ -2253,7 +2278,7 @@
+ {
+ if (m_islotReprocPos > -1)
+ {
+- // Current read pos is inside reprocess buffer.
++ // Current read pos could be inside reprocess buffer.
+ Assert(cslotPostReproc == 0);
+ int islotStartReadReprocBuf = m_vpslotReproc.size() - cslotValidReproc;
+ Assert(islotStartReadReprocBuf >= 0);
+@@ -2342,9 +2367,10 @@
+ else if (pslotAfter)
+ pslot->Associate(pslotAfter);
+ else
++ {
+ // Weird, but can happen with an empty segment.
+ Warn("No assocations");
+-
++ }
+ // Assert(pslot->m_vpslotAssoc.Size() > 0);
+ pslot->m_fNeutralAssocs = true;
+ }
+--- misc/silgraphite-2.3.1/engine/src/segment/GrSlotStream.h 2009-01-21 23:36:42.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/GrSlotStream.h 2009-07-21 10:41:48.661390600 +0200
+@@ -107,7 +107,7 @@
+ ReleaseSlots(0, m_vpslot.size());
+ }
+
+- void ReleaseSlots(int islotMin, int islotLim)
++ void ReleaseSlots(int /*islotMin*/, int /*islotLim*/)
+ {
+ // A slot stream is responsible for deleting the slot states that it created,
+ // that is, the ones whose modified tag equals this stream's pass index.
+@@ -182,6 +182,7 @@
+ return Peek(islot - ReadPosForNextGet());
+ }
+
++ // Return the functional read position, taking into account the reprocess buffer.
+ int ReadPosForNextGet()
+ {
+ return ReadPos() - SlotsToReprocess();
+@@ -260,12 +261,16 @@
+
+ void MarkFullyWritten();
+
++#ifdef NDEBUG
++ void SetSegMin(int islot, bool /*fAdjusting*/ = false)
++#else
+ void SetSegMin(int islot, bool fAdjusting = false)
++#endif
+ {
+ Assert(fAdjusting || m_islotSegMin == -1 || m_islotSegMin == islot);
+ m_islotSegMin = islot;
+ }
+- void SetSegMinToWritePos(bool fMod = true)
++ void SetSegMinToWritePos(bool /*fMod*/ = true)
+ {
+ if (m_islotSegMin == -1)
+ m_islotSegMin = m_islotWritePos;
+@@ -456,6 +461,7 @@
+ }
+ }
+
++ GrSlotState * MidPassSlotAt(int islot, GrSlotStream * psstrmNext = NULL);
+ GrSlotState * RuleInputSlot(int dislot = 0, GrSlotStream * psstrmOut = NULL,
+ bool fNullOkay = false);
+ GrSlotState * RuleOutputSlot(int dislot = 0);
+--- misc/silgraphite-2.3.1/engine/src/segment/GrTableManager.cpp 2009-01-28 03:01:29.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/GrTableManager.cpp 2009-07-21 10:41:48.823423600 +0200
+@@ -25,8 +25,8 @@
+ DEFINE_THIS_FILE
+ #ifndef _WIN32
+ #include <stdlib.h>
+-#include <math.h>
+ #endif
++#include <math.h>
+
+ //:>********************************************************************************************
+ //:> Forward declarations
+@@ -572,7 +572,7 @@
+ else
+ {
+ Assert(!m_engst.m_fInsertedLB);
+- Assert(islotUnderBreak == -1 || m_engst.m_fFinalLB);
++ //Assert(islotUnderBreak == -1 || m_engst.m_fFinalLB); -- no, ExtendGlyphIDOutput clearly sets islotUnderBreak regardless
+ }
+ int islotTmp = OutputStream(m_cpass - 1)->WritePos();
+ GrSlotState * pslotTmp;
+@@ -931,7 +931,7 @@
+ @param plbFound - kind of line-break created
+ ----------------------------------------------------------------------------------------------*/
+ bool GrTableManager::Backtrack(int * pislotPrevBreak,
+- LineBrk * plbMin, LineBrk lbMax, TrWsHandling twsh, bool fMoreText,
++ LineBrk * plbMin, LineBrk lbMax, TrWsHandling twsh, bool /*fMoreText*/,
+ int ichwCallerBtLim, bool fEndLine,
+ LineBrk * plbFound)
+ {
+@@ -1343,7 +1343,7 @@
+ Calculate the associations, and record the output slots in the segment.
+ ----------------------------------------------------------------------------------------------*/
+ void GrTableManager::RecordAssocsAndOutput(Font * pfont,
+- Segment * pseg, bool fWidthIsCharCount,
++ Segment * pseg, bool /*fWidthIsCharCount*/,
+ TrWsHandling twsh, bool fParaRtl, int nDirDepth)
+ {
+ int cchwUnderlying = pseg->stopCharacter() - pseg->startCharacter();
+@@ -1362,7 +1362,7 @@
+ #endif // OLD_TEST_STUFF
+
+ // Make sure the final positions are set for every glyph.
+- CalcPositionsUpTo(m_cpass-1, reinterpret_cast<GrSlotState *>(NULL),
++ CalcPositionsUpTo(m_cpass-1, reinterpret_cast<GrSlotState *>(NULL), false,
+ &xsTotalWidth, &xsVisWidth);
+ pseg->SetWidths(xsVisWidth, xsTotalWidth);
+
+@@ -1377,7 +1377,7 @@
+ Calculate the underlying-to-surface associations and ligature mappings.
+ Assumes the arrays have been properly initialized.
+ ----------------------------------------------------------------------------------------------*/
+-void GrTableManager::CalculateAssociations(Segment * pseg, int csloutSurface)
++void GrTableManager::CalculateAssociations(Segment * pseg, int /*csloutSurface*/)
+ {
+ GrSlotStream * psstrmFinal = OutputStream(m_cpass-1);
+
+@@ -2350,18 +2350,20 @@
+ final pass, but it could be another if positions are
+ requested by the rules themselves
+ @param pslotLast - last slot that needs to be positioned, or NULL
++ @param fMidPass - calculating the position of some slot in the middle of the pass
+ @param pxsWidth - return the total width used so far
+ @param psxVisibleWidth - return the visible width so far
+
+ MOVE to EngineState
+ ----------------------------------------------------------------------------------------------*/
+-void GrTableManager::CalcPositionsUpTo(int ipass, GrSlotState * pslotLast,
++void GrTableManager::CalcPositionsUpTo(int ipass, GrSlotState * pslotLast, bool fMidPass,
+ float * pxsWidth, float * pxsVisibleWidth)
+ {
+ Assert(ipass >= m_ipassPos1 - 1);
+
+ int isstrm = ipass;
+ GrSlotStream * psstrm = OutputStream(isstrm);
++ GrSlotStream * psstrmNext = (isstrm >= m_cpass - 1) ? NULL : OutputStream(isstrm + 1);
+ Assert(psstrm->GotIndexOffset());
+ if (psstrm->WritePos() <= psstrm->IndexOffset())
+ {
+@@ -2399,7 +2401,9 @@
+ // to be later in the stream than the last actual slot passed in.
+ if (!psstrm->HasSlotAtPosPassIndex(pslotLast->AttachRootPosPassIndex()))
+ return;
+- GrSlotState * pslotLastBase = pslotLast->Base(psstrm);
++ GrSlotState * pslotLastBase = (fMidPass && pslotLast->PosPassIndex() < psstrm->WritePos())
++ ? pslotLast->Base(psstrmNext)
++ : pslotLast->Base(psstrm);
+
+ if (ipass == m_cpass - 1 && m_engst.m_islotPosNext > -1)
+ {
+@@ -2428,6 +2432,7 @@
+ }
+
+ std::vector<GrSlotState *> vpslotAttached;
++ std::vector<GrSlotStream *> vpsstrmAttached;
+
+ bool fRtl = RightToLeft();
+
+@@ -2435,13 +2440,24 @@
+ {
+ Assert(islot < psstrm->SlotsPresent());
+
+- pslot = (isstrm == ipass) ? psstrm->SlotAt(islot) : psstrm->OutputSlotAt(islot);
++ GrSlotStream * psstrmThis = psstrm;
++ if (fMidPass && islot < psstrm->WritePos())
++ {
++ pslot = psstrm->MidPassSlotAt(islot, psstrmNext);
++ psstrmThis = psstrmNext;
++ }
++ else
++ {
++ //pslot = (isstrm == ipass) ? psstrm->SlotAt(islot) : psstrm->OutputSlotAt(islot);
++ pslot = psstrm->SlotAt(islot);
++ }
+
+ if (!pslot->IsBase())
+ {
+ // This slot is attached to another; it will be positioned strictly
+ // relative to that one. This happens in the loop below.
+ vpslotAttached.push_back(pslot);
++ vpsstrmAttached.push_back(psstrmThis);
+ }
+ else
+ {
+@@ -2455,7 +2471,7 @@
+ }
+
+ // Make sure the metrics are the complete ones.
+- pslot->CalcCompositeMetrics(this, psstrm, kPosInfinity, true);
++ pslot->CalcCompositeMetrics(this, psstrm, psstrmNext, kPosInfinity, true);
+
+ float xsInc = pslot->GlyphXOffset(psstrm, fakeItalicRatio);
+ float ysInc = pslot->GlyphYOffset(psstrm);
+@@ -2514,8 +2530,9 @@
+
+ for (size_t ipslot = 0; ipslot < vpslotAttached.size(); ipslot++)
+ {
+- GrSlotState * pslot = vpslotAttached[ipslot];
+- GrSlotState * pslotBase = pslot->Base(psstrm);
++ GrSlotState * pslotAtt = vpslotAttached[ipslot];
++ GrSlotStream * psstrmAtt = vpsstrmAttached[ipslot];
++ GrSlotState * pslotBase = pslotAtt->Base(psstrmAtt);
+ if (pslotBase->XPosition() == kNegInfinity || pslotBase->YPosition() == kNegInfinity)
+ {
+ Assert(false);
+@@ -2523,10 +2540,10 @@
+ }
+ float xsCluster = pslotBase->XPosition() - pslotBase->GlyphXOffset(psstrm, fakeItalicRatio);
+ float ysCluster = pslotBase->YPosition() - pslotBase->GlyphYOffset(psstrm);
+- float xsInc = pslot->GlyphXOffset(psstrm, fakeItalicRatio);
+- float ysInc = pslot->GlyphYOffset(psstrm);
+- pslot->SetXPos(xsCluster + xsInc);
+- pslot->SetYPos(ysCluster + ysInc);
++ float xsInc = pslotAtt->GlyphXOffset(psstrm, fakeItalicRatio);
++ float ysInc = pslotAtt->GlyphYOffset(psstrm);
++ pslotAtt->SetXPos(xsCluster + xsInc);
++ pslotAtt->SetYPos(ysCluster + ysInc);
+
+ // My theory is that we don't need to adjust *pxsWidth here, because the width of
+ // any non-base slots should be factored into the advance width of their cluster
+--- misc/silgraphite-2.3.1/engine/src/segment/GrTableManager.h 2009-01-28 03:01:29.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/GrTableManager.h 2009-07-21 10:41:48.943947800 +0200
+@@ -442,7 +442,7 @@
+ int LogToEmUnits(float xys);
+ bool GPointToXY(gid16 chwGlyphID, int nGPoint, float * xs, float * ys);
+
+- void CalcPositionsUpTo(int ipass, GrSlotState * pslotLast,
++ void CalcPositionsUpTo(int ipass, GrSlotState * pslotLast, bool fMidPass,
+ float * pxsWidth, float * pxsVisibleWidth);
+
+ void InitPosCache()
+--- misc/silgraphite-2.3.1/engine/src/segment/Platform.cpp 2009-01-21 23:36:42.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/Platform.cpp 2009-07-21 10:41:49.080902200 +0200
+@@ -103,7 +103,7 @@
+ {
+ // assumes NULL terminated strings
+ const utf16 *start = s;
+- for (; *s; ++s);
++ for (; *s; ++s) {};
+
+ return s - start;
+ }
+--- misc/silgraphite-2.3.1/engine/src/segment/Segment.cpp 2008-08-21 16:24:32.000000000 +0200
++++ misc/build/silgraphite-2.3.1/engine/src/segment/Segment.cpp 2009-07-21 10:41:49.243648400 +0200
+@@ -1178,7 +1178,7 @@
+ part of the segment.
+ ----------------------------------------------------------------------------------------------*/
+ float Segment::getRangeWidth(int ichMin, int ichLim,
+- bool fStartLine, bool fEndLine, bool fSkipSpace)
++ bool /*fStartLine*/, bool /*fEndLine*/, bool fSkipSpace)
+ {
+ if (m_dxsWidth < 0)
+ {
+@@ -1549,7 +1549,11 @@
+ void Segment::SetUpOutputArrays(Font * pfont, GrTableManager * ptman,
+ GrSlotStream * psstrmFinal,
+ int cchwInThisSeg, int csloutSurface, gid16 chwLB,
++#ifdef NDEBUG
++ TrWsHandling twsh, bool fParaRtl, int nDirDepth, bool /*fEmpty*/)
++#else
+ TrWsHandling twsh, bool fParaRtl, int nDirDepth, bool fEmpty)
++#endif
+ {
+ m_mFontEmUnits = EngineImpl()->GetFontEmUnits();
+
+@@ -1725,7 +1729,7 @@
+ Set up the data structures that represent the actual rendered glyphs for the new segment.
+ ----------------------------------------------------------------------------------------------*/
+ void Segment::SetUpGlyphInfo(GrTableManager * ptman, GrSlotStream * psstrmFinal,
+- gid16 chwLB, int nDirDepth, int islotMin, int cslot)
++ gid16 chwLB, int /*nDirDepth*/, int islotMin, int cslot)
+ {
+ //int paraDirLevel = (ptman->State()->ParaRightToLeft()) ? 1 : 0;
+
+@@ -1751,7 +1755,7 @@
+
+ m_isloutGinf0 = -1;
+ int iginf = 0;
+- for (int islot = islotMin; islot < cslot; islot++)
++ for (islot = islotMin; islot < cslot; islot++)
+ {
+ GrSlotState * pslot = psstrmFinal->SlotAt(islot);
+
+@@ -2160,7 +2164,7 @@
+ @param ichwUnder - character index relative to the official beginning of the segment
+ @param islot - processed glyph it maps to
+ ----------------------------------------------------------------------------------------------*/
+-void Segment::MarkSlotInPrevSeg(int ichwUnder, int islot)
++void Segment::MarkSlotInPrevSeg(int ichwUnder, int /*islot*/)
+ {
+ if (ichwUnder >= m_ichwAssocsMin)
+ m_prgisloutBefore[ichwUnder - m_ichwAssocsMin] = kNegInfinity;
+@@ -2174,7 +2178,7 @@
+ @param ichwUnder - character index relative to the official beginning of the segment
+ @param islot - processed glyph it maps to
+ ----------------------------------------------------------------------------------------------*/
+-void Segment::MarkSlotInNextSeg(int ichwUnder, int islot)
++void Segment::MarkSlotInNextSeg(int ichwUnder, int /*islot*/)
+ {
+ if (ichwUnder < m_ichwAssocsLim)
+ m_prgisloutAfter[ichwUnder - m_ichwAssocsMin] = kPosInfinity;
+@@ -2351,7 +2355,7 @@
+ @param pfAfter - return true if they clicked on trailing side; possibly NULL
+ ----------------------------------------------------------------------------------------------*/
+ int Segment::LogicalSurfaceToUnderlying(int islout, float xsOffset, float ysClick,
+- float dxsGlyphWidth, float dysGlyphHeight, bool * pfAfter)
++ float dxsGlyphWidth, float /*dysGlyphHeight*/, bool * pfAfter)
+ {
+ Assert(islout >= 0);
+ Assert(islout < m_cslout);
+@@ -2529,31 +2533,31 @@
+ else if (fBefore)
+ {
+ int isloutRet;
+- int ichw = ichwSegOffset;
++ int ichwTemp = ichwSegOffset;
+ // If no association has been made, loop forward to the next slot
+ // we are before. As a last resort, answer kPosInfinity, meaning we
+ // aren't before anything.
+ do
+ {
+- isloutRet = m_prgisloutBefore[ichw - m_ichwAssocsMin];
+- do { ++ichw; }
+- while (!GrCharStream::AtUnicodeCharBoundary(m_pgts, ichw));
+- } while (isloutRet == kPosInfinity && ichw < m_ichwAssocsLim);
++ isloutRet = m_prgisloutBefore[ichwTemp - m_ichwAssocsMin];
++ do { ++ichwTemp; }
++ while (!GrCharStream::AtUnicodeCharBoundary(m_pgts, ichwTemp));
++ } while (isloutRet == kPosInfinity && ichwTemp < m_ichwAssocsLim);
+ return isloutRet;
+ }
+ else
+ {
+ int isloutRet;
+- int ichw = ichwSegOffset;
++ int ichwTemp = ichwSegOffset;
+ // If no association has been made, loop backward to the previous slot
+ // we are after. As a last resort, answer kNegInfinity, meaning we
+ // aren't after anything.
+ do
+ {
+- isloutRet = m_prgisloutAfter[ichw - m_ichwAssocsMin];
+- do { --ichw; }
+- while (!GrCharStream::AtUnicodeCharBoundary(m_pgts, ichw));
+- } while (isloutRet == kNegInfinity && ichw >= 0);
++ isloutRet = m_prgisloutAfter[ichwTemp - m_ichwAssocsMin];
++ do { --ichwTemp; }
++ while (!GrCharStream::AtUnicodeCharBoundary(m_pgts, ichwTemp));
++ } while (isloutRet == kNegInfinity && ichwTemp >= 0);
+ return isloutRet;
+ }
+ Assert(false); // should never reach here
+@@ -2748,7 +2752,11 @@
+ that root glyph as one of its roots.
+ OBSOLETE
+ ----------------------------------------------------------------------------------------------*/
++#ifdef _DEBUG
+ void Segment::AssertValidClusters(GrSlotStream * psstrm)
++#else
++void Segment::AssertValidClusters(GrSlotStream * /*psstrm*/)
++#endif
+ {
+ #ifdef _DEBUG
+ for (int islot = 0; islot < psstrm->WritePos(); islot++)
+--- misc/silgraphite-2.3.1/engine/src/segment/TransductionLog.cpp 2009-01-28 03:01:29.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/src/segment/TransductionLog.cpp 2009-07-21 10:41:49.393543400 +0200
+@@ -175,7 +175,7 @@
+ Output a file showing a log of the transduction process and the resulting segment.
+ ----------------------------------------------------------------------------------------------*/
+ void GrTableManager::WriteXductnLog(std::ostream & strmOut,
+- GrCharStream * pchstrm, Segment * psegRet,
++ GrCharStream * pchstrm, Segment * /*psegRet*/,
+ int cbPrevSegDat, byte * pbPrevSegDat)
+ {
+ if (cbPrevSegDat == 0)
+@@ -416,8 +416,8 @@
+ the raw (UTF-16 or UTF-8) chars for display. To do this we get the raw characters
+ directly from the text source.
+ ----------------------------------------------------------------------------------------------*/
+-void GrCharStream::GetLogDataRaw(GrTableManager * ptman, int cchl, int cchrBackup,
+- int cchrMaxRaw, int * prgchl,
++void GrCharStream::GetLogDataRaw(GrTableManager * /*ptman*/, int cchl, int cchrBackup,
++ int /*cchrMaxRaw*/, int * prgchl,
+ utf16 * prgchw2, utf16 * prgchw3, utf16 * prgchw4, utf16 * prgchw5, utf16 * prgchw6,
+ int * prgcchr)
+ {
+@@ -441,7 +441,7 @@
+ case kutf8:
+ prgchsRunText8 = new utf8[cchrRange];
+ m_pgts->fetch(ichrMin, cchrRange, prgchsRunText8);
+- for (int ichr = 0; ichr < cchrRange; ichr++)
++ for (ichr = 0; ichr < cchrRange; ichr++)
+ prgchwRunText[ichr] = (utf16)prgchsRunText8[ichr]; // zero-extend into UTF-16 buffer
+ break;
+ case kutf16:
+@@ -634,7 +634,7 @@
+ m_pzpst->LogRulesFiredAndFailed(strmOut, psstrmIn);
+ }
+
+-void PassState::LogRulesFiredAndFailed(std::ostream & strmOut, GrSlotStream * psstrmIn)
++void PassState::LogRulesFiredAndFailed(std::ostream & strmOut, GrSlotStream * /*psstrmIn*/)
+ {
+
+ strmOut << "PASS " << m_ipass << "\n\n" << "Rules matched: ";
+@@ -1193,7 +1193,7 @@
+ if (fAnyPseudos)
+ {
+ strmOut << "Actual glyphs: ";
+- for (int islout = 0; islout < m_cslout; islout++)
++ for (islout = 0; islout < m_cslout; islout++)
+ {
+ GrSlotOutput * psloutTmp = m_prgslout + islout;
+ if (psloutTmp->GlyphID() != psloutTmp->ActualGlyphForOutput(ptman))
+@@ -1319,7 +1319,7 @@
+ Write out the header lines for the slot contents.
+ ----------------------------------------------------------------------------------------------*/
+ void GrTableManager::LogSlotHeader(std::ostream & strmOut, int islotLim,
+- int cspPerSlot, int cspLeading, int islotMin)
++ int /*cspPerSlot*/, int cspLeading, int islotMin)
+ {
+ islotLim = min(islotLim, MAX_SLOTS);
+
+@@ -1721,7 +1721,7 @@
+
+ case kslatAttAtX: // always do these in pairs
+ case kslatAttAtY:
+- if (m_mAttachAtX != (pslotPrev ? pslotPrev->m_mAttachAtX : kNotYetSet) ||
++ if (m_mAttachAtX != (pslotPrev ? pslotPrev->m_mAttachAtX : static_cast<short>(kNotYetSet)) ||
+ m_mAttachAtY != (pslotPrev ? pslotPrev->m_mAttachAtY : 0))
+ {
+ ptman->LogInTable(strmOut,
+@@ -1730,7 +1730,7 @@
+ }
+ break;
+ case kslatAttAtGpt:
+- if (m_nAttachAtGpoint != (pslotPrev ? pslotPrev->m_nAttachAtGpoint : kNotYetSet))
++ if (m_nAttachAtGpoint != (pslotPrev ? pslotPrev->m_nAttachAtGpoint : static_cast<short>(kNotYetSet)))
+ {
+ ptman->LogInTable(strmOut,
+ ((m_nAttachAtGpoint == kGpointZero) ? 0 : m_nAttachAtGpoint));
+@@ -1750,7 +1750,7 @@
+
+ case kslatAttWithX: // always do these in pairs
+ case kslatAttWithY:
+- if (m_mAttachWithX != (pslotPrev ? pslotPrev->m_mAttachWithX : kNotYetSet) ||
++ if (m_mAttachWithX != (pslotPrev ? pslotPrev->m_mAttachWithX : static_cast<short>(kNotYetSet)) ||
+ m_mAttachWithY != (pslotPrev ? pslotPrev->m_mAttachWithY : 0))
+ {
+ ptman->LogInTable(strmOut,
+@@ -1759,7 +1759,7 @@
+ }
+ break;
+ case kslatAttWithGpt:
+- if (m_nAttachWithGpoint != (pslotPrev ? pslotPrev->m_nAttachWithGpoint : kNotYetSet))
++ if (m_nAttachWithGpoint != (pslotPrev ? pslotPrev->m_nAttachWithGpoint : static_cast<short>(kNotYetSet)))
+ {
+ ptman->LogInTable(strmOut,
+ ((m_nAttachWithGpoint == kGpointZero) ? 0 : m_nAttachWithGpoint));
+@@ -1786,14 +1786,14 @@
+ break;
+
+ case kslatBreak:
+- if (m_lb != (pslotPrev ? pslotPrev->m_lb : kNotYetSet8))
++ if (m_lb != (pslotPrev ? pslotPrev->m_lb : static_cast<sdata8>(kNotYetSet8)))
+ {
+ ptman->LogBreakWeightInTable(strmOut, m_lb);
+ return;
+ }
+ break;
+ case kslatDir:
+- if (m_dirc != (pslotPrev ? pslotPrev->m_dirc : kNotYetSet8))
++ if (m_dirc != (pslotPrev ? pslotPrev->m_dirc : static_cast<sdata8>(kNotYetSet8)))
+ {
+ ptman->LogDirCodeInTable(strmOut, m_dirc);
+ return;
+--- misc/silgraphite-2.3.1/engine/test/ProfileHarness/GrUtfTextSrc.cpp 2009-01-21 23:36:42.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/test/ProfileHarness/GrUtfTextSrc.cpp 2009-07-21 10:41:49.530874700 +0200
+@@ -210,12 +210,12 @@
+ }
+
+
+-bool GrUtfTextSrc::getRightToLeft(gr::toffset ich)
++bool GrUtfTextSrc::getRightToLeft(gr::toffset /*ich*/)
+ {
+ return mRtl; // assumes src only contains one direction
+ }
+
+-unsigned int GrUtfTextSrc::getDirectionDepth(gr::toffset ich)
++unsigned int GrUtfTextSrc::getDirectionDepth(gr::toffset /*ich*/)
+ {
+ return (mRtl) ? 1 : 0; // TBD
+ }
+@@ -254,7 +254,7 @@
+ return range;
+ }
+
+-size_t GrUtfTextSrc::getFontFeatures(gr::toffset ich, gr::FeatureSetting * prgfset)
++size_t GrUtfTextSrc::getFontFeatures(gr::toffset /*ich*/, gr::FeatureSetting * /*prgfset*/)
+ {
+ return 0;
+ }
+@@ -277,14 +277,14 @@
+
+ // these should be called I hope
+ float
+-GrUtfTextSrc::getFontSize(gr::toffset ich)
++GrUtfTextSrc::getFontSize(gr::toffset /*ich*/)
+ {
+ assert(mFont);
+ return mPointSize;
+ }
+
+ bool
+-GrUtfTextSrc::getBold(gr::toffset ich)
++GrUtfTextSrc::getBold(gr::toffset /*ich*/)
+ {
+ assert(mFont);
+ // NS_ASSERTION(false, "unexpected call to getBold");
+@@ -293,7 +293,7 @@
+ }
+
+ bool
+-GrUtfTextSrc::getItalic(gr::toffset ich)
++GrUtfTextSrc::getItalic(gr::toffset /*ich*/)
+ {
+ assert(mFont);
+ //NS_ASSERTION(false, "unexpected call to getItalic");
+@@ -301,7 +301,7 @@
+ return mFont->italic();
+ }
+
+-gr::isocode GrUtfTextSrc::getLanguage(gr::toffset ich)
++gr::isocode GrUtfTextSrc::getLanguage(gr::toffset /*ich*/)
+ {
+ gr::isocode unknown;
+ std::fill_n(unknown.rgch, 4, '\0');
+--- misc/silgraphite-2.3.1/engine/test/ProfileHarness/GrUtfTextSrc.h 2009-01-21 23:36:42.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/test/ProfileHarness/GrUtfTextSrc.h 2009-07-21 10:41:49.655662500 +0200
+@@ -79,7 +79,7 @@
+ virtual size_t fetch(gr::toffset ichMin, size_t cch, gr::utf32 * prgchBuffer);
+ virtual size_t fetch(gr::toffset ichMin, size_t cch, gr::utf16 * prgchwBuffer);
+ virtual size_t fetch(gr::toffset ichMin, size_t cch, gr::utf8 * prgchsBuffer);
+- virtual gr::GrResult getFaceName(int ich, unsigned int cchMax,
++ virtual gr::GrResult getFaceName(int /*ich*/, unsigned int /*cchMax*/,
+ gr::utf16 * prgchFaceName, unsigned int * pcchLen)
+ {
+ prgchFaceName[0] = 0;
+@@ -92,12 +92,12 @@
+ virtual bool getItalic(gr::toffset ich);
+ virtual bool getRightToLeft(gr::toffset ich);
+ virtual unsigned int getDirectionDepth(gr::toffset ich);
+- virtual float getVerticalOffset(gr::toffset ich) { return 0;};
++ virtual float getVerticalOffset(gr::toffset /*ich*/) { return 0;};
+ virtual gr::isocode getLanguage(gr::toffset ich);
+
+ virtual std::pair<gr::toffset, gr::toffset> propertyRange(gr::toffset ich);
+ virtual size_t getFontFeatures(gr::toffset ich, gr::FeatureSetting * prgfset);
+- virtual bool sameSegment(gr::toffset ich1, gr::toffset ich2) { return true; };
++ virtual bool sameSegment(gr::toffset /*ich1*/, gr::toffset /*ich2*/) { return true; };
+
+ protected:
+ bool checkBuffer8();
+@@ -129,11 +129,11 @@
+ virtual void getColors(gr::toffset ich, int * pclrFore, int * pclrBack);
+
+ // Shouldn't be here!
+- virtual gr::GrResult Fetch(int ichMin, int ichLim, gr::utf16 * prgchBuf) { return gr::kresNotImpl; };
+- virtual gr::GrResult get_Length(int * pcch) { return gr::kresNotImpl; };
+- virtual gr::GrResult GetFontVariations(int ich,
+- wchar_t * prgchFontVar, int ichMax, int * pich,
+- int * pichMin, int * pichLim) { return gr::kresNotImpl; };
++ virtual gr::GrResult Fetch(int /*ichMin*/, int /*ichLim*/, gr::utf16 * /*prgchBuf*/) { return gr::kresNotImpl; };
++ virtual gr::GrResult get_Length(int * /*pcch*/) { return gr::kresNotImpl; };
++ virtual gr::GrResult GetFontVariations(int /*ich*/,
++ wchar_t * /*prgchFontVar*/, int /*ichMax*/, int * /*pich*/,
++ int * /*pichMin*/, int * /*pichLim*/) { return gr::kresNotImpl; };
+
+ };
+
+--- misc/silgraphite-2.3.1/engine/test/ProfileHarness/ProfileHarness.cpp 2009-01-21 23:36:42.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/test/ProfileHarness/ProfileHarness.cpp 2009-07-21 10:41:49.778359100 +0200
+@@ -39,14 +39,14 @@
+ typedef std::pair< gr::GlyphIterator, gr::GlyphIterator > GlyphRange;
+
+ #ifndef HAVE_STRTOF
+-float strtof(char * text, char ** ignore)
++float strtof(char * text, char ** /*ignore*/)
+ {
+ return static_cast<float>(atof(text));
+ }
+ #endif
+
+ #ifndef HAVE_STRTOL
+-long strtol(char * text, char ** ignore)
++long strtol(char * text, char ** /*ignore*/)
+ {
+ return atol(text);
+ }
+--- misc/silgraphite-2.3.1/engine/test/RegressionTest/GrJustifier.cpp 2009-01-21 23:36:42.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/test/RegressionTest/GrJustifier.cpp 2009-07-21 10:41:49.903885000 +0200
+@@ -327,7 +327,7 @@
+ &dxStretchAchieved);
+ for (int iiiGlyph = 0; iiiGlyph < cStretchable; iiiGlyph++)
+ {
+- int iiGlyph = viiGlyphsRem[iiiGlyph];
++ iiGlyph = viiGlyphsRem[iiiGlyph];
+ vdxStretchLeft[iiGlyph] = vdxStretchRem[iiiGlyph];
+ vdxWidth[iiGlyph] = vdxWidthRem[iiiGlyph];
+ }
+--- misc/silgraphite-2.3.1/engine/test/RegressionTest/RegressionTest.cpp 2009-01-21 23:36:42.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/test/RegressionTest/RegressionTest.cpp 2009-07-21 10:41:50.034192400 +0200
+@@ -675,7 +675,7 @@
+ OutputErrorAux(ptcase, strErr, i, true, valueFound, valueExpected);
+ }
+
+-void OutputErrorAux(TestCase * ptcase, std::string strErr, int i,
++void OutputErrorAux(TestCase * /*ptcase*/, std::string strErr, int i,
+ bool showValues, int valueFound, int valueExpected)
+ {
+ // if (g_debugMode)
+--- misc/silgraphite-2.3.1/engine/test/RegressionTest/SimpleTextSrc.cpp 2009-01-21 23:36:42.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/test/RegressionTest/SimpleTextSrc.cpp 2009-07-21 10:41:50.160430000 +0200
+@@ -70,7 +70,7 @@
+ /*----------------------------------------------------------------------------------------------
+ Return true if the text uses a right-to-left writing system.
+ ----------------------------------------------------------------------------------------------*/
+-bool SimpleTextSrc::getRightToLeft(toffset ich)
++bool SimpleTextSrc::getRightToLeft(toffset /*ich*/)
+ {
+ return false;
+ }
+@@ -78,7 +78,7 @@
+ /*----------------------------------------------------------------------------------------------
+ Return the depth of embedding of the writing system.
+ ----------------------------------------------------------------------------------------------*/
+-unsigned int SimpleTextSrc::getDirectionDepth(toffset ich)
++unsigned int SimpleTextSrc::getDirectionDepth(toffset /*ich*/)
+ {
+ return 0;
+ }
+@@ -87,7 +87,7 @@
+ Return the vertical offset of the text. This simple implementation provides no
+ vertical offset.
+ ----------------------------------------------------------------------------------------------*/
+-float SimpleTextSrc::getVerticalOffset(toffset ich)
++float SimpleTextSrc::getVerticalOffset(toffset /*ich*/)
+ {
+ return 0;
+ }
+--- misc/silgraphite-2.3.1/engine/test/RegressionTest/SimpleTextSrc.h 2009-01-21 23:36:42.000000000 +0100
++++ misc/build/silgraphite-2.3.1/engine/test/RegressionTest/SimpleTextSrc.h 2009-07-21 10:41:50.284794200 +0200
+@@ -59,12 +59,12 @@
+ {
+ return m_cchLength;
+ }
+- virtual size_t fetch(toffset ichMin, size_t cch, utf32 * prgchBuffer)
++ virtual size_t fetch(toffset /*ichMin*/, size_t /*cch*/, utf32 * /*prgchBuffer*/)
+ {
+ throw;
+ }
+ virtual size_t fetch(toffset ichMin, size_t cch, gr::utf16 * prgchwBuffer);
+- virtual size_t fetch(toffset ichMin, size_t cch, utf8 * prgchsBuffer)
++ virtual size_t fetch(toffset /*ichMin*/, size_t /*cch*/, utf8 * /*prgchsBuffer*/)
+ {
+ throw;
+ };
+@@ -73,14 +73,14 @@
+ virtual unsigned int getDirectionDepth(toffset ich);
+ virtual float getVerticalOffset(toffset ich);
+
+- virtual isocode getLanguage(toffset ich)
++ virtual isocode getLanguage(toffset /*ich*/)
+ {
+ isocode ret;
+ ret.rgch[0] = 'e'; ret.rgch[1] = 'n'; ret.rgch[2] = 0; ret.rgch[3] = 0;
+ return ret;
+ }
+
+- virtual std::pair<toffset, toffset> propertyRange(toffset ich)
++ virtual std::pair<toffset, toffset> propertyRange(toffset /*ich*/)
+ {
+ std::pair<toffset, toffset> pairRet;
+ pairRet.first = 0;
+@@ -88,16 +88,16 @@
+ return pairRet;
+ }
+
+- virtual size_t getFontFeatures(toffset ich, FeatureSetting * prgfset)
++ virtual size_t getFontFeatures(toffset /*ich*/, FeatureSetting * /*prgfset*/)
+ {
+ return 0; // no features in this simple implementation
+ }
+- virtual bool sameSegment(toffset ich1, toffset ich2)
++ virtual bool sameSegment(toffset /*ich1*/, toffset /*ich2*/)
+ {
+ return true;
+ }
+
+- virtual void getColors(toffset ich, int * pclrFore, int * pclrBack)
++ virtual void getColors(toffset /*ich*/, int * pclrFore, int * pclrBack)
+ {
+ *pclrFore = kclrBlack;
+ *pclrBack = kclrTransparent;
+--- misc/silgraphite-2.3.1/wrappers/win32/WinFont.cpp 2009-01-29 09:33:19.000000000 +0100
++++ misc/build/silgraphite-2.3.1/wrappers/win32/WinFont.cpp 2009-07-21 10:41:50.425877300 +0200
+@@ -767,7 +767,7 @@
+ ----------------------------------------------------------------------------------------------*/
+ void WinFont::FontHandleCache::DeleteFont(HFONT hfont)
+ {
+- if (!hfont || !m_bValid)
++ if (!hfont || !m_bValid || m_hmlffcv.size() == 0)
+ return;
+
+ // find the font in the hash map
+--- misc/silgraphite-2.3.1/wrappers/win32/WinFont.h 2009-01-29 09:33:19.000000000 +0100
++++ misc/build/silgraphite-2.3.1/wrappers/win32/WinFont.h 2009-07-21 10:41:50.547556200 +0200
+@@ -27,6 +27,10 @@
+ #include "GrClient.h"
+ #include "Font.h"
+
++#ifdef _STLPORT_VERSION
++namespace stdext = _STLP_STD;
++#endif
++
+ namespace gr
+ {
+
diff --git a/graphite/makefile.mk b/graphite/makefile.mk
new file mode 100644
index 0000000..2346a34
--- /dev/null
+++ b/graphite/makefile.mk
@@ -0,0 +1,178 @@
+#*************************************************************************
+#
+# $RCSfile: graphite-makefile-mk.diff,v $
+#
+# last change: $Author: rodo $ $Date: 2006/01/03 17:58:01 $
+#
+# The Contents of this file are made available subject to the terms of
+# either of the following licenses
+#
+# - GNU Lesser General Public License Version 2.1
+# - Sun Industry Standards Source License Version 1.1
+#
+# Sun Microsystems Inc., October, 2000
+#
+# GNU Lesser General Public License Version 2.1
+# =============================================
+# Copyright 2000 by Sun Microsystems, Inc.
+# 901 San Antonio Road, Palo Alto, CA 94303, USA
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1, as published by the Free Software Foundation.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+# MA 02111-1307 USA
+#
+#
+# Sun Industry Standards Source License Version 1.1
+# =================================================
+# The contents of this file are subject to the Sun Industry Standards
+# Source License Version 1.1 (the "License"); You may not use this file
+# except in compliance with the License. You may obtain a copy of the
+# License at http://www.openoffice.org/license.html.
+#
+# Software provided under this License is provided on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+# WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+# MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+# See the License for the specific provisions governing your rights and
+# obligations concerning the Software.
+#
+# The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+#
+# Copyright: 2000 by Sun Microsystems, Inc.
+#
+# All Rights Reserved.
+#
+# Contributor(s): _______________________________________
+#
+#
+#
+#*************************************************************************
+
+# TODO: enable warnings again when external module compiles without warnings on all platforms
+EXTERNAL_WARNINGS_NOT_ERRORS := TRUE
+
+PRJ=.
+
+PRJNAME=graphite
+TARGET=so_graphite
+
+# --- Settings -----------------------------------------------------
+
+.INCLUDE : settings.mk
+
+# --- Files --------------------------------------------------------
+
+TARFILE_NAME=silgraphite-2.3.1
+PATCH_FILES=graphite-2.3.1.patch
+
+# convert line-endings to avoid problems when patching
+CONVERTFILES=\
+ engine/makefile.vc8
+
+#.IF "$(OS)"=="WNT" && "$(COM)"!="GCC"
+#CONFIGURE_DIR=win32
+#.ELSE
+#CONFIGURE_DIR=engine
+#.ENDIF
+
+CONFIGURE_DIR=engine
+
+.IF "$(COM)"=="MSC"
+.IF "$(COMEX)"=="10"
+VCNUM=7
+.ELSE
+VCNUM=8
+.ENDIF
+# make use of stlport headerfiles
+EXT_USE_STLPORT=TRUE
+BUILD_ACTION=nmake
+.IF "$(debug)"=="true"
+BUILD_FLAGS= "CFG=DEBUG" "MLIB=MD" /F makefile.vc$(VCNUM) dll
+.ELSE
+BUILD_FLAGS="MLIB=MD" /F makefile.vc$(VCNUM) dll
+.ENDIF
+.ENDIF
+
+.IF "$(COM)"=="GCC"
+
+# Does linux want --disable-shared?
+.IF "$(debug)"=="true"
+GR_CONFIGURE_FLAGS= --enable-debug=yes --disable-final --enable-static --disable-shared
+.ELSE
+GR_CONFIGURE_FLAGS= --enable-final=yes --enable-static --disable-shared
+.ENDIF
+EXTRA_GR_CXX_FLAGS=-fPIC
+
+.IF "$(USE_SYSTEM_STL)"!="YES"
+EXTRA_GR_LD_FLAGS=$(LIBSTLPORT) -lm
+GR_LIB_PATH=LD_LIBRARY_PATH=$(SOLARVERSION)/$(INPATH)/lib$(UPDMINOREXT)
+.ELSE
+GR_LIB_PATH=
+.ENDIF
+
+# don't use SOLARLIB for LDFLAGS because it pulls in system graphite so build will fail
+#
+CONFIGURE_ACTION=bash -c 'CXXFLAGS="$(INCLUDE) $(CFLAGSCXX) $(CFLAGSCOBJ) $(CDEFS) $(CDEFSOBJ) $(SOLARINC) $(LFS_CFLAGS) $(EXTRA_GR_CXX_FLAGS)" $(GR_LIB_PATH) LDFLAGS="-L$(SOLARVERSION)/$(INPATH)/lib$(UPDMINOREXT) $(EXTRA_GR_LD_FLAGS)" ./configure $(GR_CONFIGURE_FLAGS)'
+.ENDIF
+
+BUILD_DIR=$(CONFIGURE_DIR)
+
+.IF "$(OS)"=="WNT" && "$(COM)"!="GCC"
+#OUT2LIB=win32$/bin.msvc$/*.lib
+.IF "$(debug)"=="true"
+OUT2LIB=engine$/debug$/*.lib
+.ELSE
+OUT2LIB=engine$/release$/*.lib
+.ENDIF
+.ELSE
+OUT2LIB=engine$/src$/.libs$/libgraphite*.a
+.ENDIF
+
+.IF "$(COM)"=="GCC"
+BUILD_ACTION=$(GNUMAKE) -j$(EXTMAXPROCESS)
+.ENDIF
+
+.IF "$(OS)"=="MACOSX"
+OUT2LIB+=src$/.libs$/libgraphite.*.dylib
+.ELSE
+.IF "$(OS)"=="WNT"
+#OUT2LIB+=engine$/src$/.libs$/libgraphite*.dll
+.IF "$(debug)"=="true"
+OUT2BIN= \
+ engine$/debug$/*.dll \
+ engine$/debug$/*.pdb
+.ELSE
+OUT2BIN= \
+ engine$/release$/*.dll
+# engine$/release$/*.pdb
+.ENDIF
+.ELSE
+#OUT2LIB+=engine$/src$/.libs$/libgraphite.so.*.*.*
+.ENDIF
+.ENDIF
+
+
+OUTDIR2INC= \
+ engine$/include$/graphite
+
+.IF "$(OS)"=="WNT"
+OUT2INC=wrappers$/win32$/WinFont.h
+.ENDIF
+
+# --- Targets ------------------------------------------------------
+
+
+.INCLUDE : set_ext.mk
+.INCLUDE : target.mk
+.INCLUDE : tg_ext.mk
+
diff --git a/graphite/prj/build.lst b/graphite/prj/build.lst
new file mode 100644
index 0000000..b409ff4
--- /dev/null
+++ b/graphite/prj/build.lst
@@ -0,0 +1,3 @@
+gr graphite : stlport solenv NULL
+gr graphite usr1 - all gr_mkout NULL
+gr graphite nmake - all gr_graphite NULL
diff --git a/graphite/prj/d.lst b/graphite/prj/d.lst
new file mode 100644
index 0000000..574849d
--- /dev/null
+++ b/graphite/prj/d.lst
@@ -0,0 +1,15 @@
+mkdir: %_DEST%\inc%_EXT%\graphite
+..\%__SRC%\inc\graphite\*.h %_DEST%\inc%_EXT%\graphite\*.h
+..\%__SRC%\inc\WinFont.h %_DEST%\inc%_EXT%\graphite\WinFont.h
+
+..\%__SRC%\lib\*.so.* %_DEST%\lib%_EXT%\*.so.*
+..\%__SRC%\lib\*.dylib %_DEST%\lib%_EXT%\*.dylib
+..\%__SRC%\lib\*.a %_DEST%\lib%_EXT%\*.a
+..\%__SRC%\lib\*.lib %_DEST%\lib%_EXT%\*.lib
+..\%__SRC%\bin\*.dll %_DEST%\bin%_EXT%\*.dll
+..\%__SRC%\bin\*.pdb %_DEST%\bin%_EXT%\*.pdb
+..\%__SRC%\lib\graphite.lib %_DEST%\lib%_EXT%\graphite.lib
+
+linklib: libgraphite.so.*.*.*
+linklib: libgraphite.dylib.*.*.*
+#linklib: graphite.*
More information about the ooo-build-commit
mailing list