[Vm-dev] [commit] r2171 - add freetype plugin

commits at squeakvm.org commits at squeakvm.org
Fri Apr 2 15:05:22 UTC 2010


Author: piumarta
Date: 2010-04-02 08:05:22 -0700 (Fri, 02 Apr 2010)
New Revision: 2171

Added:
   trunk/platforms/unix/plugins/FT2Plugin/
   trunk/platforms/unix/plugins/FT2Plugin/FT2PluginHeaderFix-ikp.1.cs
   trunk/platforms/unix/plugins/FT2Plugin/config.cmake
   trunk/platforms/unix/src/plugins/FT2Plugin/
   trunk/platforms/unix/src/plugins/FT2Plugin/FT2Plugin.c
Log:
add freetype plugin

Added: trunk/platforms/unix/plugins/FT2Plugin/FT2PluginHeaderFix-ikp.1.cs
===================================================================
--- trunk/platforms/unix/plugins/FT2Plugin/FT2PluginHeaderFix-ikp.1.cs	                        (rev 0)
+++ trunk/platforms/unix/plugins/FT2Plugin/FT2PluginHeaderFix-ikp.1.cs	2010-04-02 15:05:22 UTC (rev 2171)
@@ -0,0 +1,19 @@
+'From Squeak3.10.2 of ''5 June 2008'' [latest update: #7179] on 2 April 2010 at 7:58:47 am'!
+"Change Set:		FT2PluginHeaderFix-ikp
+Date:			2 April 2010
+Author:			Ian Piumarta
+
+freetype-config -cflags adds /usr/include/freetype2 to include paths under which exists freetype/tttables.h so we need to use the two-level relative path when including that file."!
+
+
+!FT2Plugin class methodsFor: 'translation' stamp: 'ikp 4/2/2010 07:55'!
+declareCVarsIn: cg
+
+
+	cg addHeaderFile: '<ft2build.h>'.
+	cg addHeaderFile: '<freetype/tttables.h>'.
+	cg addHeaderFile: 'FT_FREETYPE_H'.
+	cg addHeaderFile: 'FT_OUTLINE_H'.
+	cg var: 'library' declareC: 'FT_Library library'.
+	cg var: 'errorCode' type: 'int'.! !
+
Added: trunk/platforms/unix/plugins/FT2Plugin/config.cmake
===================================================================
--- trunk/platforms/unix/plugins/FT2Plugin/config.cmake	                        (rev 0)
+++ trunk/platforms/unix/plugins/FT2Plugin/config.cmake	2010-04-02 15:05:22 UTC (rev 2171)
@@ -0,0 +1,11 @@
+PLUGIN_FIND_PACKAGE (FREETYPE freetype2)
+IF (NOT FREETYPE_FOUND)
+  CHECK_INCLUDE_FILE (freetype.h HAVE_FREETYPE_H)
+  CHECK_INCLUDE_FILE (freetype2/freetype.h HAVE_FREETYPE2_FREETYPE_H)
+  IF (NOT HAVE_FREETYPE_H AND NOT HAVE_FREETYPE2_FREETYPE_H)
+    PLUGIN_DISABLE ()
+  ELSE ()
+    PLUGIN_REQUIRE_LIBRARY (FREETYPE freetype)
+    PLUGIN_REQUIRE_LIBRARY (Z z)
+  ENDIF ()
+ENDIF ()

Added: trunk/platforms/unix/src/plugins/FT2Plugin/FT2Plugin.c
===================================================================
--- trunk/platforms/unix/src/plugins/FT2Plugin/FT2Plugin.c	                        (rev 0)
+++ trunk/platforms/unix/src/plugins/FT2Plugin/FT2Plugin.c	2010-04-02 15:05:22 UTC (rev 2171)
@@ -0,0 +1,1873 @@
+/* Automatically generated from Squeak on 2 April 2010 7:59:10 am 
+   by VMMaker 4.0.2
+ */
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+/* Default EXPORT macro that does nothing (see comment in sq.h): */
+#define EXPORT(returnType) returnType
+
+/* Do not include the entire sq.h file but just those parts needed. */
+/*  The virtual machine proxy definition */
+#include "sqVirtualMachine.h"
+/* Configuration options */
+#include "sqConfig.h"
+/* Platform specific definitions */
+#include "sqPlatformSpecific.h"
+
+#define true 1
+#define false 0
+#define null 0  /* using 'null' because nil is predefined in Think C */
+#ifdef SQUEAK_BUILTIN_PLUGIN
+#undef EXPORT
+// was #undef EXPORT(returnType) but screws NorCroft cc
+#define EXPORT(returnType) static returnType
+#endif
+#include <ft2build.h>
+#include <freetype/tttables.h>
+#include FT_FREETYPE_H
+#include FT_OUTLINE_H
+
+#include "sqMemoryAccess.h"
+
+
+/*** Constants ***/
+#define FT2GlyphSlotFaceIndex 0
+#define FT2GlyphSlotInstSize 17
+#define FT2OutlineContoursIndex 4
+#define FT2OutlineContoursSizeIndex 0
+#define FT2OutlineFlagsIndex 5
+#define FT2OutlineInstSize 6
+#define FT2OutlinePointsIndex 2
+#define FT2OutlinePointsSizeIndex 1
+#define FT2OutlineTagsIndex 3
+#define FormBitsIndex 0
+#define FormDepthIndex 3
+#define FormHeightIndex 2
+#define FormInstSize 5
+#define FormWidthIndex 1
+
+/*** Function Prototypes ***/
+static char * fetchByteArrayofObjectassureSize(sqInt fieldIndex, sqInt objectPointer, sqInt aSize);
+static short* fetchShortArrayofObjectassureSize(sqInt fieldIndex, sqInt objectPointer, sqInt aSize);
+static long * fetchWordArrayofObjectassureSize(sqInt fieldIndex, sqInt objectPointer, sqInt aSize);
+static sqInt ftAllocateHandleInReceiverForPointer(void *aPointer);
+static sqInt ftAllocateStringForPointer(const char *aPointer);
+static FT_Encoding ftEncodingValueFromString(sqInt string);
+static void * ftHandleValueFromReceiver(sqInt rcvrOop);
+static int ftInitBitmapfromForm(FT_Bitmap* bitmap, sqInt formOop);
+static int ftInitBitmapfromFormrenderMode(FT_Bitmap* bitmap, sqInt formOop, sqInt mode);
+static int ftParameterError(void);
+static sqInt ftStringFromEncodingValue(FT_Encoding encoding);
+static VirtualMachine * getInterpreter(void);
+#pragma export on
+EXPORT(const char*) getModuleName(void);
+#pragma export off
+static sqInt halt(void);
+#pragma export on
+EXPORT(sqInt) initialiseModule(void);
+#pragma export off
+static sqInt msg(char * s);
+#pragma export on
+EXPORT(sqInt) primitiveCopyToExternalMemory(void);
+EXPORT(sqInt) primitiveDoneFace(void);
+EXPORT(sqInt) primitiveDoneFacePreserveFields(void);
+EXPORT(sqInt) primitiveEmboldenFaceGlyphSlotOutline(void);
+EXPORT(sqInt) primitiveErrorCode(void);
+EXPORT(sqInt) primitiveErrorString(void);
+EXPORT(sqInt) primitiveFreeExternalMemory(void);
+EXPORT(sqInt) primitiveGetFaceCharIndex(void);
+EXPORT(sqInt) primitiveGetFaceCharMap(void);
+EXPORT(sqInt) primitiveGetFaceCharMapsIntoArray(void);
+EXPORT(sqInt) primitiveGetFaceGlyphName(void);
+EXPORT(sqInt) primitiveGetKerningLeftRight(void);
+EXPORT(sqInt) primitiveGetPostscriptName(void);
+EXPORT(sqInt) primitiveGetSfntTableOS2(void);
+#pragma export off
+static sqInt primitiveGetTrackKerningPointSizedegree(sqInt pointSize, sqInt degree);
+#pragma export on
+EXPORT(sqInt) primitiveHasKerning(void);
+EXPORT(sqInt) primitiveLibraryHandle(void);
+EXPORT(sqInt) primitiveLoadCharacter(void);
+EXPORT(sqInt) primitiveLoadFaceBbox(void);
+EXPORT(sqInt) primitiveLoadFaceFields(void);
+EXPORT(sqInt) primitiveLoadGlyph(void);
+EXPORT(sqInt) primitiveLoadGlyphSlotFromFace(void);
+EXPORT(sqInt) primitiveLoadOutlineArraysFromFace(void);
+EXPORT(sqInt) primitiveLoadOutlineSizesFromFace(void);
+EXPORT(sqInt) primitiveModuleErrorCode(void);
+EXPORT(sqInt) primitiveNewFaceFromFileAndIndex(void);
+EXPORT(sqInt) primitiveNewMemoryFaceFromExternalMemoryAndIndex(void);
+EXPORT(sqInt) primitiveNumberOfOutlineCountours(void);
+EXPORT(sqInt) primitiveRenderGlyphIntoForm(void);
+EXPORT(sqInt) primitiveRenderGlyphIntoFormWithRenderMode(void);
+EXPORT(sqInt) primitiveResetErrorCode(void);
+EXPORT(sqInt) primitiveSetFaceCharMap(void);
+EXPORT(sqInt) primitiveSetPixelSizes(void);
+EXPORT(sqInt) primitiveSetTransform(void);
+EXPORT(sqInt) primitiveTransformFaceGlyphSlotOutline(void);
+EXPORT(sqInt) primitiveTranslateFaceGlyphSlotOutline(void);
+EXPORT(sqInt) primitiveVersion(void);
+EXPORT(sqInt) setInterpreter(struct VirtualMachine* anInterpreter);
+EXPORT(sqInt) shutdownModule(void);
+#pragma export off
+static sqInt sqAssert(sqInt aBool);
+/*** Variables ***/
+static int errorCode;
+
+#ifdef SQUEAK_BUILTIN_PLUGIN
+extern
+#endif
+struct VirtualMachine* interpreterProxy;
+static FT_Library library;
+static const char *moduleName =
+#ifdef SQUEAK_BUILTIN_PLUGIN
+	"FT2Plugin 2 April 2010 (i)"
+#else
+	"FT2Plugin 2 April 2010 (e)"
+#endif
+;
+
+
+static char * fetchByteArrayofObjectassureSize(sqInt fieldIndex, sqInt objectPointer, sqInt aSize) {
+	sqInt array;
+
+	array = interpreterProxy->fetchPointerofObject(fieldIndex, objectPointer);
+	if ((interpreterProxy->isBytes(array)) && ((interpreterProxy->slotSizeOf(array)) == aSize)) {
+		return interpreterProxy->arrayValueOf(array);
+	}
+	return null;
+}
+
+static short* fetchShortArrayofObjectassureSize(sqInt fieldIndex, sqInt objectPointer, sqInt aSize) {
+	sqInt array;
+
+	array = interpreterProxy->fetchPointerofObject(fieldIndex, objectPointer);
+	if ((interpreterProxy->isWords(array)) && ((interpreterProxy->slotSizeOf(array)) == (((sqInt) (aSize + 1) >> 1)))) {
+		return interpreterProxy->arrayValueOf(array);
+	}
+	return null;
+}
+
+static long * fetchWordArrayofObjectassureSize(sqInt fieldIndex, sqInt objectPointer, sqInt aSize) {
+	sqInt array;
+
+	array = interpreterProxy->fetchPointerofObject(fieldIndex, objectPointer);
+	if ((interpreterProxy->isWords(array)) && ((interpreterProxy->slotSizeOf(array)) == aSize)) {
+		return interpreterProxy->arrayValueOf(array);
+	}
+	return null;
+}
+
+
+/*	given aPointer (returned from a library call),
+	set the receiver's (bottom of stack) first instance variable
+	to a ByteArray containing the pointer's bytes */
+
+static sqInt ftAllocateHandleInReceiverForPointer(void *aPointer) {
+	void **extraByteArrayPtr;
+	sqInt returnedHandle;
+
+	if (aPointer) {
+
+		/* Copy from the C bytecode buffer to the Smalltalk ByteArray */
+
+		returnedHandle = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classByteArray(), sizeof(void **));
+		extraByteArrayPtr = interpreterProxy->arrayValueOf(returnedHandle);
+		*extraByteArrayPtr = (void *)(aPointer);
+	} else {
+		returnedHandle = interpreterProxy->nilObject();
+	}
+	interpreterProxy->storePointerofObjectwithValue(0, interpreterProxy->stackObjectValue(interpreterProxy->methodArgumentCount()), returnedHandle);
+	;
+	return returnedHandle;
+}
+
+
+/*	given NUL-terminated char* aPointer (returned from a library call), 
+	return the oop for a String containing the pointer's bytes */
+
+static sqInt ftAllocateStringForPointer(const char *aPointer) {
+	char *extraByteArrayPtr;
+	sqInt returnedHandle;
+
+	if (aPointer) {
+
+		/* Copy from the C bytecode buffer to the Smalltalk ByteArray */
+
+		returnedHandle = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classString(), strlen(aPointer));
+		extraByteArrayPtr = interpreterProxy->arrayValueOf(returnedHandle);
+		;
+		strncpy(extraByteArrayPtr, aPointer, strlen(aPointer));
+	} else {
+		returnedHandle = interpreterProxy->nilObject();
+	}
+	return returnedHandle;
+}
+
+
+/*	Return a 32-bit word from the bytes held by string. */
+
+static FT_Encoding ftEncodingValueFromString(sqInt string) {
+	unsigned char* ptr;
+	unsigned long retval;
+
+	interpreterProxy->success((!((string & 1))) && ((interpreterProxy->isBytes(string)) && ((interpreterProxy->slotSizeOf(string)) == (sizeof(FT_Encoding)))));
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	retval = 0;
+
+	/* 	ptr := self cCode: '(unsigned char *) (string + 4)'. */
+
+	ptr = interpreterProxy->arrayValueOf(string);
+	;
+	retval = ((unsigned long)ptr[0]) << 24;
+	retval += ((unsigned long)ptr[1]) << 16;
+	retval += ((unsigned long)ptr[2]) << 8;
+	retval += (unsigned long)ptr[3];
+	;
+	return (FT_Encoding)retval;
+}
+
+
+/*	this is the opposite of #ftAllocateHandleIn:forPointer: .
+	It takes rcvr's first instance variable,
+	which should be a ByteArray the size of a void*,
+	and returns its value as a C pointer. */
+
+static void * ftHandleValueFromReceiver(sqInt rcvrOop) {
+	sqInt oop;
+	sqInt btw;
+
+	oop = interpreterProxy->fetchPointerofObject(0, rcvrOop);
+	interpreterProxy->success((interpreterProxy->isBytes(oop)) && ((interpreterProxy->slotSizeOf(oop)) == (sizeof(void *))));
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	btw =  4;
+	return *(void**)(pointerForOop(oop + btw));
+}
+
+
+/*	Initialize the values in an FT_Bitmap from the given Form */
+
+static int ftInitBitmapfromForm(FT_Bitmap* bitmap, sqInt formOop) {
+	sqInt width;
+	sqInt numGrays;
+	sqInt wordsPerRow;
+	sqInt pitch;
+	sqInt pixelMode;
+	unsigned char* buffer;
+	sqInt height;
+	sqInt depth;
+
+	interpreterProxy->success(interpreterProxy->isPointers(formOop));
+	interpreterProxy->success((interpreterProxy->slotSizeOf(formOop)) >= FormInstSize);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	width = interpreterProxy->fetchIntegerofObject(FormWidthIndex, formOop);
+	height = interpreterProxy->fetchIntegerofObject(FormHeightIndex, formOop);
+	depth = interpreterProxy->fetchIntegerofObject(FormDepthIndex, formOop);
+	buffer = ((void*) (interpreterProxy->fetchArrayofObject(FormBitsIndex, formOop)));
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	if (depth < 0) {
+		depth = depth * -1;
+	}
+	if (depth == 1) {
+		wordsPerRow = ((sqInt) (width + 31) >> 5);
+		numGrays = 1;
+		pixelMode = FT_PIXEL_MODE_MONO;
+	} else {
+		if (depth == 8) {
+			wordsPerRow = ((sqInt) (width + 3) >> 2);
+			numGrays = 256;
+			pixelMode = FT_PIXEL_MODE_GRAY;
+		} else {
+			return interpreterProxy->primitiveFail();
+		}
+	}
+	
+#ifndef WORDS_BIGENDIAN
+	depth = depth * -1;
+#endif
+;
+	interpreterProxy->storeIntegerofObjectwithValue(FormDepthIndex, formOop, depth);
+	pitch = wordsPerRow * 4;
+	bitmap->rows = height;
+	bitmap->width = width;
+	bitmap->pitch = pitch;
+	bitmap->buffer = buffer;
+	bitmap->num_grays = numGrays;
+	bitmap->pixel_mode = pixelMode;
+	return 1;
+}
+
+
+/*	Initialize the values in an FT_Bitmap from the given Form */
+/*	pixelMode */
+
+static int ftInitBitmapfromFormrenderMode(FT_Bitmap* bitmap, sqInt formOop, sqInt mode) {
+	sqInt depth;
+	sqInt numGrays;
+	sqInt wordsPerRow;
+	sqInt pitch;
+	unsigned char* buffer;
+	sqInt height;
+	sqInt width;
+
+	interpreterProxy->success(interpreterProxy->isPointers(formOop));
+	interpreterProxy->success((interpreterProxy->slotSizeOf(formOop)) >= FormInstSize);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	width = interpreterProxy->fetchIntegerofObject(FormWidthIndex, formOop);
+	height = interpreterProxy->fetchIntegerofObject(FormHeightIndex, formOop);
+	depth = interpreterProxy->fetchIntegerofObject(FormDepthIndex, formOop);
+	buffer = ((void*) (interpreterProxy->fetchArrayofObject(FormBitsIndex, formOop)));
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	if (depth < 0) {
+		depth = depth * -1;
+	}
+	if (depth == 1) {
+		wordsPerRow = ((sqInt) (width + 31) >> 5);
+		numGrays = 1;
+	} else {
+		if (depth == 8) {
+			wordsPerRow = ((sqInt) (width + 3) >> 2);
+			numGrays = 256;
+		} else {
+			return interpreterProxy->primitiveFail();
+		}
+	}
+	
+#ifndef WORDS_BIGENDIAN
+	depth = depth * -1;
+#endif
+;
+	interpreterProxy->storeIntegerofObjectwithValue(FormDepthIndex, formOop, depth);
+	pitch = wordsPerRow * 4;
+	bitmap->rows = height;
+	bitmap->width = width;
+	bitmap->pitch = pitch;
+	bitmap->buffer = buffer;
+	bitmap->num_grays = numGrays;
+	bitmap->pixel_mode = mode;
+	return 1;
+}
+
+static int ftParameterError(void) {
+	errorCode = 255;
+	return interpreterProxy->primitiveFail();
+}
+
+
+/*	Return a newly allocated String from the given 32-bit word */
+
+static sqInt ftStringFromEncodingValue(FT_Encoding encoding) {
+	unsigned char* ptr;
+	sqInt stringOop;
+
+	stringOop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classString(), sizeof(FT_Encoding));
+	;
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	ptr = interpreterProxy->firstIndexableField(stringOop);
+	;
+	ptr[0] = (encoding & 0xFF000000) >> 24;
+	ptr[1] = (encoding & 0x00FF0000) >> 16;
+	ptr[2] = (encoding & 0x0000FF00) >> 8;
+	ptr[3] = (encoding & 0x000000FF);
+	return stringOop;
+}
+
+
+/*	Note: This is coded so that plugins can be run from Squeak. */
+
+static VirtualMachine * getInterpreter(void) {
+	return interpreterProxy;
+}
+
+
+/*	Note: This is hardcoded so it can be run from Squeak.
+	The module name is used for validating a module *after*
+	it is loaded to check if it does really contain the module
+	we're thinking it contains. This is important! */
+
+EXPORT(const char*) getModuleName(void) {
+	return moduleName;
+}
+
+static sqInt halt(void) {
+	;
+}
+
+EXPORT(sqInt) initialiseModule(void) {
+	library = null;
+	
+#ifdef macintoshSqueak
+	fetchPreferences();
+#endif
+;
+	errorCode = FT_Init_FreeType(&library);
+	return errorCode == 0;
+}
+
+static sqInt msg(char * s) {
+	fprintf(stderr, "\n%s: %s", moduleName, s);
+}
+
+EXPORT(sqInt) primitiveCopyToExternalMemory(void) {
+	sqInt rcvr;
+	void *aPointer;
+	size_t byteSize;
+	char *aByteArray;
+
+	interpreterProxy->success(interpreterProxy->isBytes(interpreterProxy->stackValue(0)));
+	aByteArray = ((char *) (interpreterProxy->firstIndexableField(interpreterProxy->stackValue(0))));
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "FreeTypeExternalMemory"));
+	rcvr = interpreterProxy->stackValue(1);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	;
+	errorCode = 0;
+	byteSize = interpreterProxy->byteSizeOf((oopForPointer( aByteArray ) - 4));
+	;
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	aPointer = malloc(byteSize);
+	memcpy(aPointer,aByteArray,byteSize);
+	ftAllocateHandleInReceiverForPointer(aPointer);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(1);
+	return null;
+}
+
+
+/*	Call the library to release the given face record.
+	Nil out the pointer fields */
+
+EXPORT(sqInt) primitiveDoneFace(void) {
+	sqInt i;
+	sqInt rcvr;
+	FT_Face face;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(0);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	;
+
+	/* nil out all the fields */
+
+	errorCode = FT_Done_Face(face);
+	for (i = 0; i <= 23; i += 1) {
+		interpreterProxy->storePointerofObjectwithValue(i, rcvr, interpreterProxy->nilObject());
+	}
+	interpreterProxy->success(errorCode == 0);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	return null;
+}
+
+
+/*	Call the library to release the given face record.
+	Nil out the handle field, but do not nil the other fields,
+	as their values are needed even if the face cannot be re-opened
+	in the future due to a missing font file etc. */
+
+EXPORT(sqInt) primitiveDoneFacePreserveFields(void) {
+	sqInt rcvr;
+	FT_Face face;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(0);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	;
+
+	/* nil the handle field */
+
+	errorCode = FT_Done_Face(face);
+	interpreterProxy->storePointerofObjectwithValue(0, rcvr, interpreterProxy->nilObject());
+	interpreterProxy->success(errorCode == 0);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	return null;
+}
+
+
+/*	emboldens the outline in the face's glyphSlot by strength (expressed in 26.6 pixel format).
+	The new outline will be at most 4 times `strength' pixels wider and higher.  */
+
+EXPORT(sqInt) primitiveEmboldenFaceGlyphSlotOutline(void) {
+	FT_Face face;
+	sqInt rcvr;
+	sqInt strength;
+
+	strength = interpreterProxy->stackIntegerValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(1);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	errorCode = FT_Outline_Embolden( &face->glyph->outline, strength );
+	interpreterProxy->success(errorCode == 0);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(1);
+	return null;
+}
+
+
+/*	high byte is module error, low is generic error */
+
+EXPORT(sqInt) primitiveErrorCode(void) {
+	sqInt _return_value;
+
+	_return_value = interpreterProxy->positive32BitIntegerFor((FT_ERROR_BASE(errorCode)));
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->popthenPush(1, _return_value);
+	return null;
+}
+
+EXPORT(sqInt) primitiveErrorString(void) {
+	const struct ftError * ftError;
+	const char * str;
+
+	
+struct ftError { int errCode; const char* errMsg; };
+#undef __FTERRORS_H__
+#define FT_ERRORDEF( e, v, s )  { e, s },
+#define FT_ERROR_START_LIST     {
+#define FT_ERROR_END_LIST       { 0xFF, "Bad Squeak Method Parameter" }, { 0, NULL } };
+static const struct ftError ftErrors[] =
+#include FT_ERRORS_H
+;
+	ftError = ftErrors;
+	;
+	while ((str = ftError->errMsg) && (FT_ERROR_BASE(errorCode) != ftError->errCode)) {
+		ftError++;
+	}
+	;
+	if (!(str)) {
+		interpreterProxy->success(0);
+	}
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	interpreterProxy->popthenPush(1, ftAllocateStringForPointer(str));
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	return null;
+}
+
+EXPORT(sqInt) primitiveFreeExternalMemory(void) {
+	sqInt rcvr;
+	void* memPointer;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "FreeTypeExternalMemory"));
+	rcvr = interpreterProxy->stackValue(0);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	;
+
+	/* free the memory handle */
+
+	errorCode = 0;
+	memPointer = ftHandleValueFromReceiver(rcvr);
+	if (!(memPointer == null)) {
+		free(memPointer);
+	}
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	return null;
+}
+
+
+/*	Return the Freetype glyph index of the given character code, in the 
+	current encoding. 
+	Return value of 0 means 'undefined character code'. */
+
+EXPORT(sqInt) primitiveGetFaceCharIndex(void) {
+	sqInt rcvr;
+	FT_Face face;
+	sqInt result;
+	sqInt charIndex;
+	sqInt _return_value;
+
+	charIndex = interpreterProxy->stackIntegerValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(1);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	errorCode = 0;
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	result = FT_Get_Char_Index(face, charIndex);
+	_return_value = interpreterProxy->positive32BitIntegerFor(result);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->popthenPush(2, _return_value);
+	return null;
+}
+
+EXPORT(sqInt) primitiveGetFaceCharMap(void) {
+	sqInt stringOop;
+	FT_Face face;
+	sqInt rcvr;
+	FT_CharMap charmap;
+	FT_Encoding encoding;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(0);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	charmap = face->charmap;
+	if (!(charmap)) {
+		return null;
+	}
+	interpreterProxy->pushRemappableOop(rcvr);
+	encoding = charmap->encoding;
+	stringOop = ftStringFromEncodingValue(encoding);
+	rcvr = interpreterProxy->popRemappableOop();
+	interpreterProxy->storePointerofObjectwithValue(22, rcvr, stringOop);
+	interpreterProxy->storeIntegerofObjectwithValue(23, rcvr, charmap->platform_id);
+	interpreterProxy->storeIntegerofObjectwithValue(24, rcvr, charmap->encoding_id);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	return null;
+}
+
+EXPORT(sqInt) primitiveGetFaceCharMapsIntoArray(void) {
+	sqInt stringOop;
+	sqInt arrayOop;
+	FT_Face face;
+	sqInt rcvr;
+	sqInt i;
+	FT_CharMap * charmap;
+	int numCharmaps;
+	sqInt *array;
+
+	interpreterProxy->success(interpreterProxy->isIndexable(interpreterProxy->stackValue(0)));
+	array = ((int *) (interpreterProxy->firstIndexableField(interpreterProxy->stackValue(0))));
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(1);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	numCharmaps = face->num_charmaps;
+	arrayOop = oopForPointer(array) - 4;
+	interpreterProxy->success((interpreterProxy->slotSizeOf(arrayOop)) == numCharmaps);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	charmap = face->charmaps;
+	;
+	for (i = 0; i <= (numCharmaps - 1); i += 1) {
+		interpreterProxy->pushRemappableOop(arrayOop);
+		stringOop = ftStringFromEncodingValue((*charmap)->encoding);
+		arrayOop = interpreterProxy->popRemappableOop();
+		interpreterProxy->storePointerofObjectwithValue(i, arrayOop, stringOop);
+		charmap++;
+	}
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(1);
+	return null;
+}
+
+
+/*	return a String */
+
+EXPORT(sqInt) primitiveGetFaceGlyphName(void) {
+	sqInt string;
+	FT_Face face;
+	sqInt rcvr;
+	char buffer[100];
+	sqInt glyphIndex;
+
+	glyphIndex = interpreterProxy->stackIntegerValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(1);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	errorCode = FT_Get_Glyph_Name(face, glyphIndex, buffer, 100);
+	interpreterProxy->success(errorCode == 0);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	string = ftAllocateStringForPointer(buffer);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->popthenPush(2, string);
+	return null;
+}
+
+EXPORT(sqInt) primitiveGetKerningLeftRight(void) {
+	sqInt pointOop;
+	FT_Vector result;
+	sqInt rcvr;
+	FT_Face face;
+	sqInt kernMode;
+	sqInt leftGlyph;
+	sqInt rightGlyph;
+
+	leftGlyph = interpreterProxy->stackIntegerValue(1);
+	rightGlyph = interpreterProxy->stackIntegerValue(0);
+	
+		result.x=3;
+		result.y=4;;
+	;
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(2), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(2);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	errorCode = 0;
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	kernMode = FT_KERNING_UNSCALED;
+	;
+	FT_Get_Kerning(face, leftGlyph, rightGlyph, kernMode, &result);;
+	pointOop = interpreterProxy->makePointwithxValueyValue(result.x, result.y);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->popthenPush(3, pointOop);
+	return null;
+}
+
+
+/*	return a String */
+
+EXPORT(sqInt) primitiveGetPostscriptName(void) {
+	FT_Face face;
+	sqInt rcvr;
+	sqInt string;
+	char* buffer;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(0);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	buffer = 0;
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	buffer = FT_Get_Postscript_Name(face);
+	interpreterProxy->success(buffer != 0);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	string = ftAllocateStringForPointer(buffer);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->popthenPush(1, string);
+	return null;
+}
+
+
+/*	return the bytes from the OS/2 table */
+
+EXPORT(sqInt) primitiveGetSfntTableOS2(void) {
+	char *extraByteArrayPtr;
+	FT_Face face;
+	sqInt rcvr;
+	sqInt returnedHandle;
+	char *buffer;
+	sqInt _return_value;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(0);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	buffer = 0;
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	buffer = FT_Get_Sfnt_Table(face,ft_sfnt_os2);
+	if (buffer == 0) {
+		_return_value = interpreterProxy->integerObjectOf(-1);
+		if (interpreterProxy->failed()) {
+			ftParameterError();
+			return null;
+		}
+		interpreterProxy->popthenPush(1, _return_value);
+		return null;
+	}
+
+	/* Copy from the C bytecode buffer to the Smalltalk ByteArray */
+
+	returnedHandle = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classByteArray(), sizeof(TT_OS2));
+	extraByteArrayPtr = interpreterProxy->arrayValueOf(returnedHandle);
+	;
+	memcpy(extraByteArrayPtr, buffer, sizeof(TT_OS2));
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->popthenPush(1, returnedHandle);
+	return null;
+}
+
+
+/*	disabled becaus of yet implemented */
+
+static sqInt primitiveGetTrackKerningPointSizedegree(sqInt pointSize, sqInt degree) {
+	return interpreterProxy->primitiveFail();
+}
+
+EXPORT(sqInt) primitiveHasKerning(void) {
+	sqInt rcvr;
+	FT_Face face;
+	sqInt _return_value;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(0);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	errorCode = 0;
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	_return_value = (((FT_HAS_KERNING( face )) << 1) | 1);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->popthenPush(1, _return_value);
+	return null;
+}
+
+
+/*	Fill in the handle in an FT2Library structure with a copy of our global pointer. */
+
+EXPORT(sqInt) primitiveLibraryHandle(void) {
+	sqInt rcvr;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "FT2Library"));
+	rcvr = interpreterProxy->stackValue(0);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	errorCode = 0;
+	ftAllocateHandleInReceiverForPointer(library);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	return null;
+}
+
+
+/*	Load the glyph at the given index in the current charmap.
+	The default map upon opening a font is the 'unic' or Unicode charmap, if any. */
+
+EXPORT(sqInt) primitiveLoadCharacter(void) {
+	FT_Face face;
+	sqInt rcvr;
+	sqInt index;
+	sqInt flags;
+
+	index = interpreterProxy->stackIntegerValue(1);
+	flags = interpreterProxy->stackIntegerValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(2), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(2);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	errorCode = FT_Load_Char(face, index, flags);
+	interpreterProxy->success(errorCode == 0);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(2);
+	return null;
+}
+
+EXPORT(sqInt) primitiveLoadFaceBbox(void) {
+	sqInt pointOop;
+	sqInt rectOop;
+	FT_Face face;
+	sqInt rcvr;
+	sqInt aRectangle;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "Rectangle"));
+	aRectangle = interpreterProxy->stackValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(1);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	rectOop = aRectangle;
+	if (!(interpreterProxy->isPointers(rectOop))) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	if ((interpreterProxy->slotSizeOf(rectOop)) < 2) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	;
+	if (!(face->face_flags & FT_FACE_FLAG_SCALABLE)) {
+		interpreterProxy->success(0);
+	}
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	interpreterProxy->pushRemappableOop(rectOop);
+	pointOop = interpreterProxy->makePointwithxValueyValue(face->bbox.xMin, face->bbox.yMin);
+	rectOop = interpreterProxy->popRemappableOop();
+	interpreterProxy->storePointerofObjectwithValue(0, rectOop, pointOop);
+	interpreterProxy->pushRemappableOop(rectOop);
+	pointOop = interpreterProxy->makePointwithxValueyValue(face->bbox.xMax, face->bbox.yMax);
+	rectOop = interpreterProxy->popRemappableOop();
+	interpreterProxy->storePointerofObjectwithValue(1, rectOop, pointOop);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(1);
+	return null;
+}
+
+
+/*	Fill in many of the receiver's (an FT2Face) fields (other than its handle)
+	from the FT_Face record that it points to. */
+
+EXPORT(sqInt) primitiveLoadFaceFields(void) {
+	sqInt rcvr;
+	FT_Face face;
+	sqInt strOop;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(0);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	;
+	interpreterProxy->storeIntegerofObjectwithValue(1, rcvr, face->num_faces);
+	interpreterProxy->storeIntegerofObjectwithValue(2, rcvr, face->face_index);
+	interpreterProxy->storeIntegerofObjectwithValue(3, rcvr, face->face_flags);
+	interpreterProxy->storeIntegerofObjectwithValue(4, rcvr, face->style_flags);
+	interpreterProxy->storeIntegerofObjectwithValue(5, rcvr, face->num_glyphs);
+	interpreterProxy->pushRemappableOop(rcvr);
+	strOop = ftAllocateStringForPointer(face->family_name);
+	rcvr = interpreterProxy->popRemappableOop();
+	interpreterProxy->storePointerofObjectwithValue(6, rcvr, strOop);
+	interpreterProxy->pushRemappableOop(rcvr);
+	strOop = ftAllocateStringForPointer(face->style_name);
+	rcvr = interpreterProxy->popRemappableOop();
+	interpreterProxy->storePointerofObjectwithValue(7, rcvr, strOop);
+	interpreterProxy->storeIntegerofObjectwithValue(8, rcvr, face->num_fixed_sizes);
+	interpreterProxy->storeIntegerofObjectwithValue(10, rcvr, face->num_charmaps);
+	if (face->face_flags & FT_FACE_FLAG_SCALABLE) {
+		interpreterProxy->storeIntegerofObjectwithValue(13, rcvr, face->units_per_EM);
+		interpreterProxy->storeIntegerofObjectwithValue(14, rcvr, face->ascender);
+		interpreterProxy->storeIntegerofObjectwithValue(15, rcvr, face->descender);
+		interpreterProxy->storeIntegerofObjectwithValue(16, rcvr, face->height);
+		interpreterProxy->storeIntegerofObjectwithValue(17, rcvr, face->max_advance_width);
+		interpreterProxy->storeIntegerofObjectwithValue(18, rcvr, face->max_advance_height);
+		interpreterProxy->storeIntegerofObjectwithValue(19, rcvr, face->underline_position);
+		interpreterProxy->storeIntegerofObjectwithValue(20, rcvr, face->underline_thickness);
+	}
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	return null;
+}
+
+EXPORT(sqInt) primitiveLoadGlyph(void) {
+	FT_Face face;
+	sqInt rcvr;
+	sqInt index;
+	sqInt flags;
+
+	index = interpreterProxy->stackIntegerValue(1);
+	flags = interpreterProxy->stackIntegerValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(2), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(2);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	errorCode = FT_Load_Glyph(face, index, flags);
+	interpreterProxy->success(errorCode == 0);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(2);
+	return null;
+}
+
+
+/*	Assumes that primitiveLoadGlyph:flags: has been called earlier to set face->glyph. */
+
+EXPORT(sqInt) primitiveLoadGlyphSlotFromFace(void) {
+	FT_Glyph_Format *gfPtr;
+	FT_Face face;
+	sqInt rcvr;
+	sqInt gfOop;
+	FT_GlyphSlot gs;
+	sqInt btw;
+	sqInt aFace;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "FT2Face"));
+	aFace = interpreterProxy->stackValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "FT2GlyphSlot"));
+	rcvr = interpreterProxy->stackValue(1);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	errorCode = 0;
+	if ((interpreterProxy->slotSizeOf(rcvr)) < 8) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(aFace);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	gs = face->glyph;
+	if (!(gs)) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	;
+	interpreterProxy->storePointerofObjectwithValue(0, rcvr, aFace);
+	interpreterProxy->storeIntegerofObjectwithValue(1, rcvr, gs->linearHoriAdvance);
+	interpreterProxy->storeIntegerofObjectwithValue(2, rcvr, gs->linearVertAdvance);
+	interpreterProxy->storeIntegerofObjectwithValue(3, rcvr, gs->advance.x);
+	interpreterProxy->storeIntegerofObjectwithValue(4, rcvr, gs->advance.y);
+	interpreterProxy->pushRemappableOop(rcvr);
+	gfOop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classByteArray(), sizeof(FT_Glyph_Format));
+	;
+	btw =  4;
+	gfPtr = (FT_Glyph_Format *) pointerForOop(gfOop + btw);
+	;
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	*gfPtr = gs->format;
+	rcvr = interpreterProxy->popRemappableOop();
+	interpreterProxy->storePointerofObjectwithValue(5, rcvr, gfOop);
+	interpreterProxy->storeIntegerofObjectwithValue(6, rcvr, gs->bitmap_left);
+	interpreterProxy->storeIntegerofObjectwithValue(7, rcvr, gs->bitmap_top);
+	interpreterProxy->storeIntegerofObjectwithValue(8, rcvr, gs->metrics.width);
+	interpreterProxy->storeIntegerofObjectwithValue(9, rcvr, gs->metrics.height);
+	interpreterProxy->storeIntegerofObjectwithValue(10, rcvr, gs->metrics.horiBearingX);
+	interpreterProxy->storeIntegerofObjectwithValue(11, rcvr, gs->metrics.horiBearingY);
+	interpreterProxy->storeIntegerofObjectwithValue(12, rcvr, gs->metrics.horiAdvance);
+	interpreterProxy->storeIntegerofObjectwithValue(13, rcvr, gs->metrics.vertBearingX);
+	interpreterProxy->storeIntegerofObjectwithValue(14, rcvr, gs->metrics.vertBearingY);
+	interpreterProxy->storeIntegerofObjectwithValue(15, rcvr, gs->metrics.vertAdvance);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(1);
+	return null;
+}
+
+
+/*	Assumes that primitiveLoadGlyph:flags: has been called earlier to set face->glyph. */
+
+EXPORT(sqInt) primitiveLoadOutlineArraysFromFace(void) {
+	char * tags;
+	short* contours;
+	sqInt pointsSize;
+	sqInt i;
+	FT_Face face;
+	sqInt rcvr;
+	long * points;
+	sqInt contoursSize;
+	FT_GlyphSlot gs;
+	sqInt aFace;
+	sqInt array;
+	sqInt array1;
+	sqInt array2;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "FT2Face"));
+	aFace = interpreterProxy->stackValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "FT2Outline"));
+	rcvr = interpreterProxy->stackValue(1);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	errorCode = 0;
+	if ((interpreterProxy->slotSizeOf(rcvr)) < FT2OutlineInstSize) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(aFace);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	gs = face->glyph;
+	if (!(gs)) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	;
+	pointsSize = gs->outline.n_points;
+	/* begin fetchWordArray:ofObject:assureSize: */
+	array1 = interpreterProxy->fetchPointerofObject(FT2OutlinePointsIndex, rcvr);
+	if ((interpreterProxy->isWords(array1)) && ((interpreterProxy->slotSizeOf(array1)) == (pointsSize * 2))) {
+		points = interpreterProxy->arrayValueOf(array1);
+		goto l2;
+	}
+	points = null;
+l2:	/* end fetchWordArray:ofObject:assureSize: */;
+	if (points == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	/* begin fetchByteArray:ofObject:assureSize: */
+	array2 = interpreterProxy->fetchPointerofObject(FT2OutlineTagsIndex, rcvr);
+	if ((interpreterProxy->isBytes(array2)) && ((interpreterProxy->slotSizeOf(array2)) == pointsSize)) {
+		tags = interpreterProxy->arrayValueOf(array2);
+		goto l3;
+	}
+	tags = null;
+l3:	/* end fetchByteArray:ofObject:assureSize: */;
+	if (tags == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	for (i = 0; i <= (pointsSize - 1); i += 1) {
+		points[2 * i] = (gs->outline.points[i].x);
+		points[(2 * i) + 1] = (gs->outline.points[i].y);
+		tags[i] = (gs->outline.tags[i]);
+	}
+	contoursSize = gs->outline.n_contours;
+	/* begin fetchShortArray:ofObject:assureSize: */
+	array = interpreterProxy->fetchPointerofObject(FT2OutlineContoursIndex, rcvr);
+	if ((interpreterProxy->isWords(array)) && ((interpreterProxy->slotSizeOf(array)) == (((sqInt) (contoursSize + 1) >> 1)))) {
+		contours = interpreterProxy->arrayValueOf(array);
+		goto l1;
+	}
+	contours = null;
+l1:	/* end fetchShortArray:ofObject:assureSize: */;
+	for (i = 0; i <= (contoursSize - 1); i += 1) {
+		contours[i] = (gs->outline.contours[i]);
+	}
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(1);
+	return null;
+}
+
+
+/*	Assumes that primitiveLoadGlyph:flags: has been called earlier to set face->glyph. */
+
+EXPORT(sqInt) primitiveLoadOutlineSizesFromFace(void) {
+	sqInt rcvr;
+	FT_Face face;
+	FT_GlyphSlot gs;
+	sqInt aFace;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "FT2Face"));
+	aFace = interpreterProxy->stackValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "FT2Outline"));
+	rcvr = interpreterProxy->stackValue(1);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	errorCode = 0;
+	if ((interpreterProxy->slotSizeOf(rcvr)) < FT2OutlineInstSize) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(aFace);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	gs = face->glyph;
+	if (!(gs)) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	;
+	interpreterProxy->storeIntegerofObjectwithValue(FT2OutlineContoursSizeIndex, rcvr, gs->outline.n_contours);
+	interpreterProxy->storeIntegerofObjectwithValue(FT2OutlinePointsSizeIndex, rcvr, gs->outline.n_points);
+	interpreterProxy->storeIntegerofObjectwithValue(FT2OutlineFlagsIndex, rcvr, gs->outline.flags);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(1);
+	return null;
+}
+
+
+/*	high byte is module error, low is generic error */
+
+EXPORT(sqInt) primitiveModuleErrorCode(void) {
+	sqInt _return_value;
+
+	_return_value = interpreterProxy->positive32BitIntegerFor((FT_ERROR_MODULE(errorCode)));
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->popthenPush(1, _return_value);
+	return null;
+}
+
+
+/*	Fill in the receiver's (a FT2Face object) fields
+	from the address and fields of a newly opened FT_Face object. */
+
+EXPORT(sqInt) primitiveNewFaceFromFileAndIndex(void) {
+	char translatedFilePath[1024];
+	size_t byteSize;
+	FT_Face face;
+	sqInt rcvr;
+	char *fontFilePath;
+	sqInt anInteger;
+
+	interpreterProxy->success(interpreterProxy->isBytes(interpreterProxy->stackValue(1)));
+	fontFilePath = ((char *) (interpreterProxy->firstIndexableField(interpreterProxy->stackValue(1))));
+	anInteger = interpreterProxy->stackIntegerValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(2), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(2);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	;
+	errorCode = 0;
+	byteSize = interpreterProxy->byteSizeOf((oopForPointer( fontFilePath ) - 4));
+	;
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	if (byteSize > 1000) {
+		interpreterProxy->success(0);
+		return null;
+	}
+	interpreterProxy->ioFilenamefromStringofLengthresolveAliases(translatedFilePath, fontFilePath, byteSize, 1);
+	errorCode = FT_New_Face(library, translatedFilePath, anInteger, &face);
+	;
+	;
+	interpreterProxy->success(errorCode == 0);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	ftAllocateHandleInReceiverForPointer(face);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(2);
+	return null;
+}
+
+
+/*	Fill in the receiver's (a FT2Face object) fields
+	from the address and fields of a newly opened FT_Face object. */
+
+EXPORT(sqInt) primitiveNewMemoryFaceFromExternalMemoryAndIndex(void) {
+	FT_Face face;
+	sqInt rcvr;
+	void *memPointer;
+	sqInt aFreeTypeExternalMemory;
+	sqInt byteSize;
+	sqInt anInteger;
+
+	aFreeTypeExternalMemory = interpreterProxy->stackValue(2);
+	byteSize = interpreterProxy->stackIntegerValue(1);
+	anInteger = interpreterProxy->stackIntegerValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(3), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(3);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	;
+	errorCode = 0;
+	memPointer = ftHandleValueFromReceiver(aFreeTypeExternalMemory);
+	;
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	errorCode = FT_New_Memory_Face(library, memPointer, byteSize, anInteger, &face);
+	;
+	;
+	interpreterProxy->success(errorCode == 0);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	ftAllocateHandleInReceiverForPointer(face);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(3);
+	return null;
+}
+
+
+/*	Assumes that primitiveLoadGlyph:flags: has been called earlier to set face->glyph. */
+
+EXPORT(sqInt) primitiveNumberOfOutlineCountours(void) {
+	FT_Face face;
+	sqInt rcvr;
+	sqInt aFace;
+	sqInt contoursSize;
+	FT_GlyphSlot gs;
+	sqInt _return_value;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "FT2GlyphSlot"));
+	rcvr = interpreterProxy->stackValue(0);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	errorCode = 0;
+	if ((interpreterProxy->slotSizeOf(rcvr)) < FT2GlyphSlotInstSize) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	aFace = interpreterProxy->fetchPointerofObject(FT2GlyphSlotFaceIndex, rcvr);
+	face = ftHandleValueFromReceiver(aFace);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	gs = face->glyph;
+	if (!(gs)) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	;
+	contoursSize = gs->outline.n_contours;
+	_return_value = ((contoursSize << 1) | 1);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->popthenPush(1, _return_value);
+	return null;
+}
+
+
+/*	Render this face into the given form */
+
+EXPORT(sqInt) primitiveRenderGlyphIntoForm(void) {
+	FT_Face face;
+	FT_Bitmap bitmap;
+	sqInt faceOop;
+	sqInt formOop;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "Form"));
+	formOop = interpreterProxy->stackValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "FT2Face"));
+	faceOop = interpreterProxy->stackValue(1);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(faceOop);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	ftInitBitmapfromForm(&bitmap, formOop);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	errorCode = FT_Outline_Get_Bitmap(library, &face->glyph->outline, &bitmap);
+	interpreterProxy->success(errorCode == 0);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(1);
+	return null;
+}
+
+
+/*	Render this face into the given form */
+
+EXPORT(sqInt) primitiveRenderGlyphIntoFormWithRenderMode(void) {
+	FT_Bitmap bitmap;
+	FT_Face face;
+	sqInt faceOop;
+	sqInt formOop;
+	sqInt mode;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "Form"));
+	formOop = interpreterProxy->stackValue(1);
+	mode = interpreterProxy->stackIntegerValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(2), "FT2Face"));
+	faceOop = interpreterProxy->stackValue(2);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(faceOop);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	ftInitBitmapfromFormrenderMode(&bitmap, formOop, mode);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	errorCode = FT_Outline_Get_Bitmap(library, &face->glyph->outline, &bitmap);
+	interpreterProxy->success(errorCode == 0);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(2);
+	return null;
+}
+
+EXPORT(sqInt) primitiveResetErrorCode(void) {
+	sqInt oldError;
+	sqInt _return_value;
+
+	oldError = errorCode;
+	errorCode = 0;
+	_return_value = interpreterProxy->positive32BitIntegerFor(oldError);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->popthenPush(1, _return_value);
+	return null;
+}
+
+EXPORT(sqInt) primitiveSetFaceCharMap(void) {
+	FT_Face face;
+	sqInt rcvr;
+	FT_Encoding encoding;
+	sqInt encodingString;
+
+	encodingString = interpreterProxy->stackValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(1);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	encoding = ftEncodingValueFromString(encodingString);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	;
+	errorCode = FT_Select_Charmap(face, encoding);
+	interpreterProxy->success(errorCode == 0);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(1);
+	return null;
+}
+
+EXPORT(sqInt) primitiveSetPixelSizes(void) {
+	FT_Face face;
+	sqInt rcvr;
+	sqInt x;
+	sqInt y;
+
+	x = interpreterProxy->stackIntegerValue(1);
+	y = interpreterProxy->stackIntegerValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(2), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(2);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	errorCode = FT_Set_Pixel_Sizes(face, x, y);
+	interpreterProxy->success(errorCode == 0);
+	if (interpreterProxy->failed()) {
+		return null;
+	}
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(2);
+	return null;
+}
+
+EXPORT(sqInt) primitiveSetTransform(void) {
+	sqInt *deltasqIntPtr;
+	FT_Face face;
+	sqInt rcvr;
+	FT_Vector delta;
+	sqInt *matrixsqIntPtr;
+	FT_Matrix matrix;
+	sqInt matrixWordArray;
+	sqInt deltaWordArray;
+
+	matrixWordArray = interpreterProxy->stackValue(1);
+	deltaWordArray = interpreterProxy->stackValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(2), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(2);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	matrixsqIntPtr = interpreterProxy->arrayValueOf(matrixWordArray);
+	deltasqIntPtr = interpreterProxy->arrayValueOf(deltaWordArray);
+	delta.x = deltasqIntPtr[0]; delta.y = deltasqIntPtr[1];;
+	matrix.xx = matrixsqIntPtr[0]; matrix.xy = matrixsqIntPtr[1]; 
+		matrix.yx = matrixsqIntPtr[2]; matrix.yy = matrixsqIntPtr[3]; ;
+	if (!(interpreterProxy->failed())) {
+		FT_Set_Transform( face, &matrix, &delta);
+	}
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(2);
+	return null;
+}
+
+EXPORT(sqInt) primitiveTransformFaceGlyphSlotOutline(void) {
+	FT_Face face;
+	sqInt rcvr;
+	sqInt *matrixsqIntPtr;
+	FT_Matrix matrix;
+	sqInt matrixWordArray;
+
+	matrixWordArray = interpreterProxy->stackValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(1);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	matrixsqIntPtr = interpreterProxy->arrayValueOf(matrixWordArray);
+	matrix.xx = matrixsqIntPtr[0]; matrix.xy = matrixsqIntPtr[1]; 
+		matrix.yx = matrixsqIntPtr[2]; matrix.yy = matrixsqIntPtr[3]; ;
+	if (!(interpreterProxy->failed())) {
+		FT_Outline_Transform( &face->glyph->outline, &matrix );
+	}
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(1);
+	return null;
+}
+
+EXPORT(sqInt) primitiveTranslateFaceGlyphSlotOutline(void) {
+	sqInt *deltasqIntPtr;
+	FT_Face face;
+	sqInt rcvr;
+	FT_Vector delta;
+	sqInt deltaWordArray;
+
+	deltaWordArray = interpreterProxy->stackValue(0);
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(1), "FT2Face"));
+	rcvr = interpreterProxy->stackValue(1);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	face = ftHandleValueFromReceiver(rcvr);
+	if (face == null) {
+		interpreterProxy->primitiveFail();
+		return null;
+	}
+	deltasqIntPtr = interpreterProxy->arrayValueOf(deltaWordArray);
+	delta.x = deltasqIntPtr[0]; delta.y = deltasqIntPtr[1];;
+	if (!(interpreterProxy->failed())) {
+		FT_Outline_Translate( &face->glyph->outline, delta.x, delta.y );
+	}
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	interpreterProxy->pop(1);
+	return null;
+}
+
+EXPORT(sqInt) primitiveVersion(void) {
+	sqInt rcvr;
+	int amajor;
+	int apatch;
+	int aminor;
+
+	interpreterProxy->success(interpreterProxy->isKindOf(interpreterProxy->stackValue(0), "FT2Version"));
+	rcvr = interpreterProxy->stackValue(0);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	errorCode = 0;
+	FT_Library_Version(library, &amajor, &aminor, &apatch);
+	;
+	interpreterProxy->storeIntegerofObjectwithValue(0, rcvr, amajor);
+	;
+	interpreterProxy->storeIntegerofObjectwithValue(1, rcvr, aminor);
+	;
+	interpreterProxy->storeIntegerofObjectwithValue(2, rcvr, apatch);
+	if (interpreterProxy->failed()) {
+		ftParameterError();
+		return null;
+	}
+	return null;
+}
+
+
+/*	Note: This is coded so that is can be run from Squeak. */
+
+EXPORT(sqInt) setInterpreter(struct VirtualMachine* anInterpreter) {
+	sqInt ok;
+
+	interpreterProxy = anInterpreter;
+	ok = interpreterProxy->majorVersion() == VM_PROXY_MAJOR;
+	if (ok == 0) {
+		return 0;
+	}
+	ok = interpreterProxy->minorVersion() >= VM_PROXY_MINOR;
+	return ok;
+}
+
+EXPORT(sqInt) shutdownModule(void) {
+	errorCode = FT_Done_FreeType(library);
+	if (errorCode == 0) {
+		library = null;
+	}
+	return errorCode == 0;
+}
+
+static sqInt sqAssert(sqInt aBool) {
+	/* missing DebugCode */;
+}
+
+
+#ifdef SQUEAK_BUILTIN_PLUGIN
+
+
+void* FT2Plugin_exports[][3] = {
+	{"FT2Plugin", "primitiveFreeExternalMemory", (void*)primitiveFreeExternalMemory},
+	{"FT2Plugin", "shutdownModule", (void*)shutdownModule},
+	{"FT2Plugin", "setInterpreter", (void*)setInterpreter},
+	{"FT2Plugin", "primitiveModuleErrorCode", (void*)primitiveModuleErrorCode},
+	{"FT2Plugin", "primitiveRenderGlyphIntoForm", (void*)primitiveRenderGlyphIntoForm},
+	{"FT2Plugin", "primitiveTransformFaceGlyphSlotOutline", (void*)primitiveTransformFaceGlyphSlotOutline},
+	{"FT2Plugin", "primitiveGetPostscriptName", (void*)primitiveGetPostscriptName},
+	{"FT2Plugin", "primitiveRenderGlyphIntoFormWithRenderMode", (void*)primitiveRenderGlyphIntoFormWithRenderMode},
+	{"FT2Plugin", "primitiveLibraryHandle", (void*)primitiveLibraryHandle},
+	{"FT2Plugin", "initialiseModule", (void*)initialiseModule},
+	{"FT2Plugin", "primitiveTranslateFaceGlyphSlotOutline", (void*)primitiveTranslateFaceGlyphSlotOutline},
+	{"FT2Plugin", "primitiveSetTransform", (void*)primitiveSetTransform},
+	{"FT2Plugin", "primitiveLoadFaceBbox", (void*)primitiveLoadFaceBbox},
+	{"FT2Plugin", "primitiveNewFaceFromFileAndIndex", (void*)primitiveNewFaceFromFileAndIndex},
+	{"FT2Plugin", "primitiveLoadFaceFields", (void*)primitiveLoadFaceFields},
+	{"FT2Plugin", "primitiveGetSfntTableOS2", (void*)primitiveGetSfntTableOS2},
+	{"FT2Plugin", "primitiveDoneFacePreserveFields", (void*)primitiveDoneFacePreserveFields},
+	{"FT2Plugin", "primitiveErrorString", (void*)primitiveErrorString},
+	{"FT2Plugin", "primitiveNumberOfOutlineCountours", (void*)primitiveNumberOfOutlineCountours},
+	{"FT2Plugin", "primitiveSetFaceCharMap", (void*)primitiveSetFaceCharMap},
+	{"FT2Plugin", "primitiveResetErrorCode", (void*)primitiveResetErrorCode},
+	{"FT2Plugin", "primitiveSetPixelSizes", (void*)primitiveSetPixelSizes},
+	{"FT2Plugin", "primitiveVersion", (void*)primitiveVersion},
+	{"FT2Plugin", "primitiveGetFaceGlyphName", (void*)primitiveGetFaceGlyphName},
+	{"FT2Plugin", "primitiveGetKerningLeftRight", (void*)primitiveGetKerningLeftRight},
+	{"FT2Plugin", "getModuleName", (void*)getModuleName},
+	{"FT2Plugin", "primitiveLoadOutlineSizesFromFace", (void*)primitiveLoadOutlineSizesFromFace},
+	{"FT2Plugin", "primitiveLoadGlyph", (void*)primitiveLoadGlyph},
+	{"FT2Plugin", "primitiveEmboldenFaceGlyphSlotOutline", (void*)primitiveEmboldenFaceGlyphSlotOutline},
+	{"FT2Plugin", "primitiveGetFaceCharMap", (void*)primitiveGetFaceCharMap},
+	{"FT2Plugin", "primitiveDoneFace", (void*)primitiveDoneFace},
+	{"FT2Plugin", "primitiveErrorCode", (void*)primitiveErrorCode},
+	{"FT2Plugin", "primitiveHasKerning", (void*)primitiveHasKerning},
+	{"FT2Plugin", "primitiveGetFaceCharMapsIntoArray", (void*)primitiveGetFaceCharMapsIntoArray},
+	{"FT2Plugin", "primitiveLoadCharacter", (void*)primitiveLoadCharacter},
+	{"FT2Plugin", "primitiveCopyToExternalMemory", (void*)primitiveCopyToExternalMemory},
+	{"FT2Plugin", "primitiveNewMemoryFaceFromExternalMemoryAndIndex", (void*)primitiveNewMemoryFaceFromExternalMemoryAndIndex},
+	{"FT2Plugin", "primitiveLoadOutlineArraysFromFace", (void*)primitiveLoadOutlineArraysFromFace},
+	{"FT2Plugin", "primitiveLoadGlyphSlotFromFace", (void*)primitiveLoadGlyphSlotFromFace},
+	{"FT2Plugin", "primitiveGetFaceCharIndex", (void*)primitiveGetFaceCharIndex},
+	{NULL, NULL, NULL}
+};
+
+
+#endif /* ifdef SQ_BUILTIN_PLUGIN */
+



More information about the Vm-dev mailing list