code: purgatorio

Download patch

ref: e17484e9d82ce7db8472e6abfa71144ddc184ce4
parent: 7975eec3e602fd5bc3e93c78f4166259190f2fe9
author: henesy <devnull@localhost>
date: Sun Nov 4 06:37:54 EST 2018

include Nt

diff: cannot open b/DragonFly/386/bin//null: file does not exist: 'b/DragonFly/386/bin//null' diff: cannot open b/DragonFly/386/include//null: file does not exist: 'b/DragonFly/386/include//null' diff: cannot open b/DragonFly/386/lib//null: file does not exist: 'b/DragonFly/386/lib//null' diff: cannot open b/DragonFly/386//null: file does not exist: 'b/DragonFly/386//null' diff: cannot open b/DragonFly//null: file does not exist: 'b/DragonFly//null' diff: cannot open b/Irix/mips/bin//null: file does not exist: 'b/Irix/mips/bin//null' diff: cannot open b/Irix/mips/include//null: file does not exist: 'b/Irix/mips/include//null' diff: cannot open b/Irix/mips//null: file does not exist: 'b/Irix/mips//null' diff: cannot open b/Irix//null: file does not exist: 'b/Irix//null' diff: cannot open b/Nt/386/bin//null: file does not exist: 'b/Nt/386/bin//null' diff: cannot open b/Nt/386/include//null: file does not exist: 'b/Nt/386/include//null' diff: cannot open b/Nt/386//null: file does not exist: 'b/Nt/386//null' diff: cannot open b/Nt//null: file does not exist: 'b/Nt//null' diff: cannot open b/include/freetype/cache//null: file does not exist: 'b/include/freetype/cache//null' diff: cannot open b/include/freetype/config//null: file does not exist: 'b/include/freetype/config//null' diff: cannot open b/include/freetype/internal//null: file does not exist: 'b/include/freetype/internal//null' diff: cannot open b/include/freetype//null: file does not exist: 'b/include/freetype//null' diff: cannot open b/include//null: file does not exist: 'b/include//null'
--- /dev/null
+++ b/CHANGES
@@ -1,0 +1,956 @@
+20140525
+	implement & in replacement text in sed
+20140524
+	utflen in styx.b (probably ought to be in Sys) supporting 21-bit unicode (issue 314)
+	allow slashes in anames [fixed by kristofwyzc, issue 312]
+20140518
+	sh(2): exec -> run [issue 311]
+20140501
+	add -s option to dns in cs(8) [issue 310]
+	don't send nil soa to dnscache [issue 309]
+20140302
+	utils/cc/funct.c - remove out-of-bounds reference
+	os/ipaq1110, ip/ipaux.c, os/sa1110 - add default cases to keep compiler happy
+20140223
+	/dis/sig: use raise not exit for errors
+20140105
+	incorrect check on keyname in getauthinfo [issue 306]
+20130906
+	remove redundant code
+20130529
+	appl/cmd/cpu.b: use Dial, and neither test /dev/draw/new nor bind #d (which is wrong anyway, it's #i for drawing now)
+20130423
+	mkfiles/mkfile-MacOSX-386: set 32-bit mode, and macosx-version-min to 10.6 [via http://debu.gs/entries/interlude-inferno-at-work]
+20121210
+	utils/awk/run.c - prevent free of pointer still in use [cinap]
+20121205
+	appl/cmd/mk/mksubdirs [issue 290 change suggested by powerman]
+20120918
+	remove unused/unusable debug/setdebug from appl/lib/auth9.b and replace Keyring by Crypt
+20120820
+	emu/port/devip.c reset headers flag in Conv
+20120725
+	increase KSTACK for Linux/arm
+20120615
+	add configuration emu/FreeBSD/emu-g [powerman]
+20120509
+	utils/libmach: add missing user stack top initialisers, minor changes to sync with 9
+20120507
+	mkfiles/mkfile-MacOSX-386 change cc to gcc
+	emu/MacOSX/win.c null out drawcursor
+20120424
+	utils/cc/Posix.c and utils/c2l/Posix.c: correct definition of mydup for POSIX dup/dup2
+	libbio/bprint.c error handling if flush or print fails
+20120305
+	add -I$ROOT/(Plan9|Inferno)/include to CFLAGS in mkfiles/^(mkfile-Plan9* mkfile-Inferno*)
+		change specific object type to $OBJTYPE in the same
+	libmath/fdlibm/fdlibm.h and libmath/dtoa.c, if USE_FPdbleword defined, use FPdbleword to crack doubles into integers
+20120304
+	rabin(2) added (preliminary)
+20120213
+	styxservers: add .error operation (preliminary)
+20120116
+	lib9.h: internally rename qsort as infqsort to avoid C library clash
+	lib9/qsort.c: include lib9.h
+	lib9/mkfile: move qsort to IMPORTFILES from COMMONFILES
+20120103
+	avoid re-defining isnan; use isNaN instead
+20111231
+	Linux/*/include/emu.h adjustments for USE_PTHREADS for non-x86 processors
+20111221
+	add `...` uninterpreted string literals to limbo/lex.c, appl/cmd/limbo/lex.b
+20111215
+	liblogfs,libnandfs: use logfsos.h (added to include) to make library source independent of os
+	add fonts/vera
+	add fonts/courier
+20111214
+	change Linux port to use pthreads instead of clone directly
+	emu/Linux: rename os.c to os-clone.c; rename osp.c to os.c
+	emu/Linux/mkfile: remove -lrt, add kproc-pthreads.$O
+	Linux/*/include: define USE_PTHREADS
+	Linux/386/include/emu.h: increase KSTACK to 32k for Linux gethost* functions
+20111003
+	libinterp/heap.c:/^dtype discount size of map [issue 258]
+20110820
+	emu/*/devfs.c, emu/port/devfs-posix.c - stubs for osdisksize, Linux implementation of osdisksize
+	emu/port/devfs-posix.c - also try SOCK_DGRAM for AF_UNIX [issue 269]
+20110819
+	appl/cmd/mk/mk.b - use raise "fail:..." for exit status [issue 268]
+20110629
+	change x86 getcallerpc to avoid use of %ebp [issue 266]
+	change type of getcallerpc to uintptr from ulong
+20110619
+	emu/port/devfs-posix.c: put major/minor st_dev into path without mapping (with luck)
+	emu/port/kproc-pthreads.c: ensure pthread stack is at least PTHREAD_STACK_MIN (plus slop)
+20110526
+	change osyield in Windows to use SwitchToThread instead of sleep(0) [e-mail list]
+20110525
+	utils/[5678kqv]c/mkfile - include -I. before $CFLAGS to ensure right gc.h [issue 264]
+20110516
+	merge changes from vac branch of mechiel-inferno-os (googlecode)
+20110426
+	emu/Linux/asm-arm.S linux system call interface changed [issue 215, mechiel]
+20110419
+	libinterp/tk.c:/^Tk_rect shouldn't return non-canonical rectangles
+	/appl/wm/mand.b handle reshape to empty rectangles
+20110408
+	appl/lib/json.b - have writeval produce same (correct) form as .text for Real [issue 230]
+20110407
+	fix embarrassingly broken Lists->delete; add Lists->find [issue 257]
+	add some extra explanation to sys-dup(2) about fildes
+20110404
+	update Nt/386/bin
+	/limbo/com.c - count constants in qualifiers, not qualifiers [issue 212, mechiel]
+	/appl/cmd/limbo/com.b [also issue 212]
+20110403
+	secstore(2) and secstore(1) updated to implement writing [issue 256, mechiel]
+20110402
+	revision to devsrv.c change [issue 244] to avoid two calls to delwaiting
+20110330
+	call strtol not atoi for hex numbers [issue 255, mechiel]
+20110329
+	utils/mkdir/mkdir.c - add -p option [mechiel, issue 250]
+	emu/Linux/mkfile - try searching -lpthread after -lrt for sem_* [issue 247]
+	emu/port/devfs-posix.c - treat unix domain sockets as files (open/read/write/close) [npe, rsc, issue 254]
+	emu/port/devfs-posix.c - use volatile correctly; slight code tidy
+	emu/lib9/errstr-posix.c replace EINTR's error string by Eintr's text
+20110315
+	libtk/textw.c - fix mysterious control characters for editing (D and K) [issue 253, fix from mechiel]
+20110225
+	split emu.h from lib9.h for all platforms
+	kproc in emu is now a void type as in os
+20110224
+	move private mem flag to Progs [issue 240, mechiel]
+20110224
+20110208
+	emu/Linux/os.c - use -lrt's semaphores instead of signals
+	emu/Linux/mkfile - add -lrt to library list, and push out separation of X11LIBS from SYSLIBS for emu-g done ages ago
+20110126
+	emu/MacOSX/os.c - move a free to a more sensible place
+20110117
+	emu/Nt/ipif.c changed to work with ipv6 interface changes
+20110116
+	add Plan9/arm support [provided by richard miller]
+20110110	
+	utils/libmach/qdb.c [issue 245] restore renaming of qdiv as qmuldiv
+20110104
+	emu/MacOSX/win.c detect double clicks [issue 232, jas]
+	emu/MacOSX/os.c replace erendezvous by a per-kproc semaphore for osblock/osready
+20101220
+	changes to srv(3) to notify client when server vanishes [issue 244, thanks to powerman and roger]
+20101205
+	change a few types in ipif-posix.c to appease the gods
+	emu/MacOSX/mkfile - include portmkfile at correct point for LIBFILES to work (and other, minor, changes) [issue 24]
+20101127
+	emu/port/*ip*.[ch] and emu/Nt/ipif*.c updated with new interface for ipv6 support [mechiel] [issue 193]
+	emu/Linux/os.c address compilation warnings (setfcr etc still to do)
+20101125
+	asm/assem.c don't attempt to use missing src (issue 243)
+20100925
+	appl/lib/w3c/uris.b - handle existing Unicode characters if they happen not to have been encoded into string
+	appl/svc/httpd/parser.b - similar [response to issue 233]
+20100914
+	emu/Nt/os.c - replace trap handling
+20100822
+	correct handling of mouse focus in sub-widgets of widget windowed in text [issue 241]
+	add various warnings to mkfile-Linux-386
+20100821
+	correct handling of mouse focus in sub-widgets of widget windowed in canvas [issue 241]
+20100819
+	failed to push Solaris/sparc/include/lib9.h with u64int change [issue 151]
+	appl/cmd/ar.b eliminate false error return
+20100810
+	initial introduction of crypt-*(2) and ipints(2)
+	replace keyring.m in module/runt.m by ipints.m and crypt.m; compensate in libinterp and libkeyring by using keyringif.m to generate Keyring's interface
+20100802
+	various changes held back by accident, notably stackv in stack(1), better diagnostics by cat(1)
+20100801
+	libtk/coval.c - simplify vlong expression for some compilers [issue 216, mechiel]
+20100727
+	on Linux and MacOSX, look at faulting address to decide if it's dereference of nil
+20100722
+	include/bio.h add varargck and repair resulting diagnostics in utils and limbo/ [issue 237, mechiel]
+20100719
+	appl/cmd/disk/mkfs.b change getname/getpath to cope with missing newline [issue 236]
+20100715
+	appl/wm/toolbar.b changed not to create new /chan/snarf if one exists, unless -p (private) option given [toolbar(1)]
+	utils/cc/macbody - add overlooked change to implement __VA_ARGS__
+	other minor updates to the compilers to resync
+20100714
+	correctly initialise types in utils/cc/sub.c
+20100504
+	change lib9/strtoull.c for MS
+20100503
+	updated libmach/8db.c to avoid [] initialisers
+20100501
+	update libmach to compensate for MS compiler
+20100426
+	updated libmach
+	updated compiler suites (continuing)
+20100425
+	appl/wm/wm.b shorten processing of wmctl close if client hadn't started
+20100406
+	fix handling of boundary case in libtk/utils.c
+20100402
+	add new option OPTflags to libtk for later use
+20100325
+	more swizzling of libtk for later use. revised radio and check buttons.
+20100322
+	a few tweaks to Tk for later use
+20100320
+	appl/lib/json.b dis/lib/json.dis - use %f not string <real-value> to ensure json value acceptable [issue 230, powerman]
+20100310
+	stop tabs(2) from issuing pointless tk cmd that produces diagnostics
+20100305
+	add emu/Linux/audio-oss.c from saoret.one [issue 226]
+20100226
+	mention -n nvram option in keyfs(4)
+20100220
+	appl/cmd/keyfs.b wasn't clunking fids on error in remove [issue 225]
+20100213
+	apply saoret.one's changes for thumb [issue 155]
+20100205
+	update man pages to replace most references to Styx by 9P
+	update man pages to replace references to sys-dial(2) by dial(2)
+	add DragonFly files (from fgudin and extrudedaluminiu, issue 181); possibly should automatically keep aligned with FreeBSD
+	fpe handling in OpenBSD and FreeBSD [mechiel, issue 190]
+	appl/cmd/vacfs.b apply fix from mechiel [issue 204]
+20100203
+	appl/lib/cfg.b treat \r as white space [issue 69, issue 70]
+	add u64int to lib9.h files that needed it
+	add sha2.c sha256block.c sha512block.c to libsec/port and include/libsec.h [issue 185, mechiel]
+	add new sha functions to module/keyring.m and libinterp/keyring.c
+20100115
+	appl/cmd/tarfs.b man/4/tarfs changes to permission handling from mechiel [issue 220]
+	appl/spree/mkfile add explicit -I$ROOT/module [issue 209, powerman]
+20100110
+	appl/cmd/tcs.b [issue 12, arvindht]: process unconverted bytes next cycle, flush conversion state; improve error checking
+20091219
+	change default roots in Nt utils to c:\inferno
+20091215
+	factotum(2) updated to include keyspec in signature
+	appl/cmd/mount.b uses -k value as keyspec if -9 selected [not to much purpose with current factotum's p9any]
+	bind(1) [for mount] updated to describe -k used for keyspec if -9 selected
+20091214
+	switch more commands to use dial(2)
+	change emu/Linux/emu-g not to require X11 libs (again)
+20091213
+	temper the tendancy of port/dis.c to yield during idle gc: it's compensating for os scheduling, but yield less often
+20091208
+	add mkdir -p to makemk.sh to ensure output directories exist [issue 213]
+20091127
+	problems fixed in styxconv(2), which can now convert both ways [rog]
+20091119
+	emu/port/devfs-posix.c	missing waserror in dirread (obscure but possible failure)
+20091007
+	remove intermediate exception-raising function from charon implementation
+20091004
+	restore "keyring" to lib section of emu/Plan9/emu
+20090930
+	emu/*/ipif*.c make "hangup" act as in native Inferno; also delete unused so_setsockopt
+	provide correct version of devmnt.c
+20090928
+	update import(4) to remove the restriction to Plan 9 (can use Inferno's own factotum)
+	(emu os)^/port/devmnt.c fix from plan 9 (don't access vanished data)
+20090830
+	check subexp length in ed [cmbrannon79]
+20090825
+	add netmkaddr call to /appl/cmd/ftpfs.b; send errors to standard error
+20090824
+	delete unused (and somewhat incomplete) pin support
+20090822
+	in the what were we thinking dept: appl/cmd/touch.b and dis/touch.dis updated to avoid using an Arg after nil'ing it [thanks to cmbrannon]
+	make progmode propagate to pgrps; recover from exceptions in pgrp creation
+20090821
+	emu/Nt/^(os.c ie-os.c) add #include <excpt.h>
+20090819
+	appl/cmd/mk/mk.b replace maketmp/mktemp (issue 202, mechiel); also old change: don't persist with bulkmtime on non-directories
+20090816
+	registry(4) Event.post increased rootvers when entries are written or removed (issue 179, powerman)
+20090809
+	bring mkfs(8) up to date (issue 176)
+	remove -q options from mkfs and mkext (-q was a transitional option to suppress quoting of file names)
+20090806
+	increase `backlog' value in all listen calls in hosted Inferno (emu/*/ipif*.c) [powerman]
+20090805
+	further checking added to libinterp/keyring.c: rejects incorrect states and out of bounds values of f->n
+	add lib/emptydirs and mkdirs target to /mkfile (utils/mkdir needs to be changed for Windows use)
+20090730
+	improve the error checking in strtosk and strtopk to help detect mangled or inappropriate keys
+20090728
+	emu/port/main.c: put host's working directory name as emuwdir
+	document initial environment variables in emu(1)
+	appl/lib/bufio.b dis/lib/bufio.dis [issue 199] don't lose track of actual file seek offset (following second suggestion of mjl)
+	issue 196: after general apologies for appl/svc/httpd/cache.b (don't look if you don't need it, not one of ours, etc. etc.) will patch as suggested by extrudedaluminiu(!) [vs]
+20090719
+	correct order of operands to memset(!), eg in ipif [mjl]
+20090718
+	fix appl/cmd/stream.b error exits to include fail: [mjl]
+20090717
+	fix appl/lib/ip.b (see issue 186) [mjl]
+	re-enable XK_ keys in port/win-x11a.c [mjl]
+20090716
+	add segflush calls to comp-386.c [probably need different name eventually to avoid time wasting when not needed]
+20090630
+	add sig (see man(1)) [via p9p and caerwyn]
+20090627
+	push changes described for arm in 20090330 (but not previously pushed)
+	begin change of inferno-os.googlecode.com from svn to mercurial
+200090612
+	added support for Linux-power (ericvh; and further simplified)
+20090605
+	appl/cmd/disk/kfs.b dis/disk/kfs.dis - don't try to update super block if readonly(!) [issue 175]
+20090526
+	emu/Nt/os.c allow /dev/hoststdin input on file or pipe (thanks to caerwyn, issue 173)
+	emu/port/devfs-posix.c correct handling of error return from pread (issue 172, but goes beyond that)
+	emu/port/exportfs.c os/port/exportfs.c use vlong for offset
+20090524
+	appl/cmd/tarfs.b dis/tarfs.dis - remove accidentally small limit on file size in tar file (issue 172)
+20090521
+	module/vac.m appl/cmd/vacfs.b appl/lib/vac.b [issue 152] (Mecchiel)
+20090505
+	add -h/-t header/trailer options to man2html
+20090430
+	filter-deflate(2), appl/lib/^(inflate.b deflate.b): changes from mjl to support zlib headers for deflate streams as well as gzip's
+20090417
+	add m4(1) in its initial form (might split the macro processing proper off into a library module)
+20090409
+	tools/odbc/odbc.c data read should return 0 if no columns or rows (issue 170)
+20090408
+	tools/odbc/odbc.c use strecpy and more care in allocation (issue 169)
+20090403
+	change ,2 to ,#function in Solaris sparc assembler files (apparently works in gcc and sun's)
+	make appl/wm/brutus.b pass input to its widgets (issue 105)
+	enable fullscreen mode in MacOSX (issue 148)
+20090402
+	add missing emu/Linux/segflush-*.c files and remove ARM segflush from os.c
+20090402
+	ramfile and logfile shouldn't set Sys->MCREATE (issue 137)
+20090401
+	appl/cmd/limbo/typecheck.b check correctly for function prevented from inline expansion
+20090330
+	use (low, high) order for words in vlong and fp on arm: libinterp/comp-arm.c, Inferno/arm/include/^(lib9.h u.h)
+		also os/*/fpi.h (for arm platforms), exchanging order of ulongs in Double
+		also libkern/^(vlrt-arm.c vlop-arm.s vlop-thumb.s frexp-arm.c frexp-thumb.c)
+	include changes from richard miller for little-endian mips (spim) and Linux/spim hosted
+	libmath/dtoa.c: use simpler code to avoid gcc bug on mips and perhaps other platforms (rmiller)
+20090330-branches/forse
+	include appl/cmd/ssh source (won't compile here because it needs the keyring changes)
+20090325-branches/forse
+	emu/* adopt changes to Chan (Dev* dev pointer instead of int type)
+20090320
+	emu/port/win-x11a.c: unintuitively use xdisplay not xkbdcon to send to kbdproc (with big stack) to change cursor
+		(the big stack is needed because XCreateBitmapFromData and XPutImage pass control to theme-related code that uses lots of stack space)
+	use uname not aname for user name in libstyx and set aname to "" by default
+	make odbc's new file have mode 666 so others can open it
+	add styxsetowner function to styxserver.h to set default owner (eve)
+	move styxserver.h to inferno's include directory
+20090222
+	appl/cmd/ndb/registry.b and dis/registry.dis - implement flush for event file (issue 162)
+20090217
+	appl/cmd/limbo/stubs.b limbo/stubs.c - include length parameter to builtinmod (could just be 0 in most cases)
+	change f->ret/destroy code in stubs.c/stubs.b to destroy correctly in case of exceptions
+20090202
+	emu/port/win-x11a.c: might as well try this everywhere now
+20090127
+	libinterp/xec.c: fix gc problem with self
+20090122
+	libinterp/string.c: slicer can return H for empty slice after bounds check (brucee)
+20081119
+	os/pc/^(main.c fns.h) more idle idlehands
+20081112
+	emu/Linux/asm-arm.S old failure to use different regs for swp finally changed here
+	libmath/blas.c compensate for gcc bug on arm
+20081107
+	replace calls to calloc by malloc
+20081106
+	os/port/dis.c prevent new spawns during killgrp
+	also synchronise two killgrps of the same group
+20081105
+	emu/port/dis.c prevent new spawns during killgrp [#117]
+20081022
+	sh: ignore leading white space in fail: strings, and change empty tail to "failed"
+	/emu/port/devfs-posix.c don't call readdir after it has returned end of file
+20081021
+	/appl/cmd/auth/ai2key.b new command to convert authinfo files to factotum keys
+	/appl/cmd/auth/factotum/proto/infauth.b allow new key format
+20081019
+	/appl/cmd/man2html.b implement "\ " => "&nbsp;"
+	/man/3/prog change way a literal " was formatted
+	/man/8/srv deleted (obsolete)
+	removed reference to srv(8) from sys-pctl(2)
+20080909
+	/appl/cmd/puttar.b add extra empty block at end of archive as required by format
+20080907
+	include some changes from acme-sac in emu/Nt/devfs.c; need further control of usesec (or discard it)
+20080723
+	rename Inferno's yacc to iyacc to avoid clash with system's own (now that Linux and others distribute it)
+20080707
+	update emu/port/win-x11a.c (fix someone's earlier patch to stop using undefined value)
+	emu/port/main.c mark obsolete options and remove from usage
+20080705
+	update utils/sed, eliminating anonymous unions (just by commenting them out, to keep source in step with 9)
+		and several other changes for portability
+20080703
+	remove anonymous unions (and unused structs) from unpacking structures in emu/Nt/vlrt.c, not that it's used
+20080617
+	win-x11a.c add sqweek's change to pass on KeyRelease values (but perhaps 1-byte values are no longer enough?)
+20080614
+	change os/port/devcons.c to use error not panic in sysfatal
+20080612
+	change several libmp/port functions to use sysfatal not abort
+	change emu/port/main.c to have sysfatal call error not exit
+20080611
+	Keyring->dhparams to use DSAprimes in special case
+	IPint.random now ignores minint (will go next revision)
+	BigInt -> mpint*
+	checkIPint in libinterp/ipint.c
+	default keys in auth/createsignerkey are 1024 not 512 bits
+	update os/boot/pc
+20080610
+	push sh-mload(1) and changes to sh-expr(1)
+20080609
+	_tas type changed from ulong to int
+20080530
+	issue 91: _declspec changed to __declspec in Nt files
+	issue 92: argv0 declaration changed to extern from static in emu/Nt/win.c
+20080529
+	limbo/stubs.c: allow pick adt types
+20080528
+	emu/port/win-x11a.c screen depth checks from drawterm via tim@nop.cx
+20080524
+	add missing NetBSD files
+20080522
+	dis/lib/msgio.dis appl/lib/msgio.b - fix incorrect check for 16rFF
+	add OpenBSD changes from tim@nop.cx (more changes to follow shortly that cause changes elsewhere)
+20080416
+	fix emu/Nt/os.c use of wrong name for null value
+	move win/win-x11a references to emu/*/emu config files from emu/*/mkfile
+20080415
+	googlecode update with correct dis files for acme
+	tidier code for hoststderr
+	emu/port/win-x11a.c changes that attempt to satisfy libxcb's locking requirements
+20080322
+	enable hoststderr, following acme-sac
+20080319
+	ip/sntp neither read nor set the time correctly
+20080311
+	in appl/lib/names.b define "" as valid prefix for anything
+20080304
+	auth/secstore uses dial module
+20080210
+	add auth/dsagen
+20080204
+	emu/*/*ipif*.c and devip.c: try to allow local address to be set (changes so_bind signature in emu/ip.h)
+20080201
+	change foldbranch in limbo/gen.c to prevent loss of `no return value' diagnostics
+20080131
+	update emu/Nt/^(os.c ie-os.c ie-win.c ie emu), but properly this time [issue 81]
+	remove _USE_32BIT_TIME_T from Nt/386/include/lib9.h, and time() def'n from emu/Nt/*.c [issue 81]
+20080130
+	failed to return nil from Jvalue.get in appl/lib/json.b if member name didn't match
+	similar problem in appl/lib/ubfa.b
+	add msgio(2)
+20080124
+	fix emu/port/devssl.c os/port/devssl.c not to keep the directory numbers(!)
+20080122
+	update appl/lib/db.b: allow for split i/o on pipes or tcp/ip; eliminate lock process
+	eliminate more unused identifier warnings (courtesy acme-sac)
+20080121
+	skip trailing '=' in b64 rep of IPint
+20080120
+	forgot to push updated appl/lib/x509.b during keyring changes
+20080116
+	add rsa to factotum
+	set but not used changes from Acme-sac
+	mdb(1) changes from Acme-sac
+	ftpfs uses new dial(2)
+	add qbypass to emu/port/qio.c
+	sed fix issue 49
+	add blowfish to keyring-crypt(2)
+	add challenge/response to factotum(2)
+20080115
+	add blowfish to keyring (not yet documented)
+	add explicit public and private key types to keyring (in development: not yet documented)
+	add IPint.mod, IPint.iptob64z
+20080111
+	add newuser to newns(2)
+20080109
+	Sys->iounit should accept any valid file descriptor, not just ORDWR
+20071227
+	add styxflush(2) etc.
+	add NetBSD, emu/NetBSD
+20071217
+	emu/port/devmnt.c needs volatile for alloc
+20071213
+	emu/port/dev.c needs volatile for alloc
+20071129
+	emu/port/devip.c: moan about bad IP addresses
+20071127
+	added /module/dial.m and /appl/lib/dial.b
+20071031
+	module/keyring.m and libinterp/keyring.c: add algorithm-specific adts for public key systems
+	appl/lib/spki/spki.b: correct names for dsa parameters
+20071030
+	libkeyring/rsaalg.c should call rsaprivfree not free
+20071027
+	appl/lib/names.b correction for "/" as prefix
+20071019
+	change emu/port/devfs-posix.c to update uid/gid map incrementally
+20071015
+	add cap creation to infauth in server role in factotum
+20071011
+	remove obsolete references to sh-exception(2)
+20071010
+	add abhey's changes for cmd key as unicode compose key for MacOS X to emu/MacOSX/win.c
+20071008
+	nemo's change to emu/port/random.c; really the file needs a little rewriting for clarity (too many overlapping states)
+20071002
+	ensure fmtdef.h included by some lib9 functions so that va_copy is defined on older systems that lack that needless notion
+	<{} and >{} added to sh(1)
+20070929
+	move emu/MacOSX/mkfile to .../mkfile-x11 and replace it by the variant that builds for Carbon, now the default
+20070927
+	add working drawcursor to emu/MacOSX/win.c, based on mirtchovski's changes (but mapping general cursor images to Mac's form)
+20070910
+	update spki(2) [change handling of hashes, add signature functions] appl/lib/spki/spki.b module/spki.m, updated for GSoC
+20070906
+	add toreal to string(2)
+20070905
+	/appl/cmd/ed.b (caerwyn's fix for g/.../d)
+	also /appl/lib/ecmascript/builtin.b (toupper fix)
+20070902
+	make /appl/lib/daytime.b accept Daytime->text's output; add string2tm to man page (issue 59)
+20070901
+	add andrey's changes to emu/MacOSX/win.c (used by emu/MacOSX/mkfile-a)
+	add saoret's changes to dis/lookman, dis/man (issue 58)
+	add micah.stetson's change to /appl/cmd/src.b (issue 57)
+20070817
+	two old changes that weren't in the distribution...
+	libkeyring/rsaalg.c: previously failed to ensure the output key was the right length (really rsagen should do that)
+	libinterp/alt.c: use a better random number generator
+20070814
+	bufio.b didn't update the buffer pointers correctly on write errors
+20070807
+	libinterp/keyring.c don't include owner= if owner is nil or ""
+	add auth/rsagen
+20070806
+	/module/lists.m add PATH(!), also simplify concat implementation
+20070725
+	/dis/man initialise fils correctly to empty list and remove hack (issue 56)
+20070720
+	utils/5l/asm.c: ensure SBZ field in MOV is regarded as MBZ (ie, force to zero)
+20070714
+	add Sys->readn, update sys-read(2)
+	copy two repairs from emu/port/inferno.c to os/port/inferno.c
+	remove readn implementation from several commands
+	print correct diagnostic in appl/cmd/crypt.b
+	prevent window titlebars from being dragged out of the main window in wm/wm.b
+20070619
+	remembered to include /appl/cmd/trfs.b /dis/trfs.dis
+20070614
+	/appl/lib/venti.b bug fixes, a few more errstrs, remove prints to stderr
+	add initial module/vac.m appl/lib/vac.b from mjl (gsoc project ventivac)
+	add initial /appl/cmd/^(vacfs.b vacget.b vacput.b) /man/4/vacfs /man/1/vacget from mjl (gsoc:ventivac)
+	include omitted man/mkfile man/lib
+20070608
+	update /lib9 functions to use silly va_copy (and then va_end) instead of just assigning, to account for silly C implementations
+	change /appl/cmd/mc.b not to require Draw or Env (so lc works on smaller systems)
+	update acme to include the font size data (eg, for use by mc(1))
+20070607
+	/appl/wm/man.b /appl/lib/man.b to allow 10.1 etc as section references
+20070605
+	add another xopen #define to lib9.h includes for Linux
+	copy plan9 acme's colormix
+20070601
+	/appl/cmd/ls.b /dis/ls.dis /man/1/ls: document new -F option and -T option
+	/appl/cmd/auth/factotum/factotum.b: ignore empty writes, don't fail; make a few diagnostics match plan 9
+	rename /appl/cmd/mc.b to /appl/cmd/calc.b; also /man/1/mc to /man/1/calc; /dis/mc.dis to /dis/calc.dis
+	add /appl/cmd/mc.b (initial version)
+	replace /dis/lc.dis by /dis/lc; remove /appl/cmd/lc.b
+	remove /appl/cmd/mathcalc.b /dis/mathcalc.dis /man/1/mathcalc
+20070510
+	quickly remove references to udp's "oldheaders" because plan 9 removed it
+	remove obootpd completely
+20070418
+	add scan code to X11 (issue 45)
+20070411
+	if mkconfig has been changed from the distribution, use it to set parameters in makemk.sh (issue 41)
+	add iso8859-15 (what? will the line stretch on to the crack of doom?) (issue 43)
+20070410
+	fix some porting errors in /appl/cmd/look.b
+	document look's -r option in look(1)
+20070407
+	/os/port/^(portdat.h lib.h portfns.h xalloc.c) compatiblity changes with plan 9
+	/os/pc ether drivers updated to match plan 9, and os/ip (and a few files in /os/port) also updated, including removing some unreachable code
+	/os/ip/tcp.c changes from plan 9 for out-of-sequence segments
+20070319
+	emu/port/devsrv.c and os/port/devsrv.c delete wc at correct time
+20070312
+	rename -D and -k options to plumb (old ones still accepted); add -i option to take data from standard input; update man page
+	enable 64-bit seeks in /emu/Nt/devfs.c
+20070302
+	change /mkfile to build yacc earlier, mainly to make bootstrap of a new host easier (makemk.sh and mk install)
+	change /utils/mkfile not to build k[acl] and q[acl] on Plan 9, since the system ones are the same
+20070228
+	make array bounds checking the default for on-the-fly compilers (emu/port/main.c)
+	improve wording in security-ssl(2) and ssl(3)
+20070227
+	/include/fcall.h: ensure unsigned promotion to counter ansi sign-extending rules for GBIT64
+	/libmemdraw/draw.c: copy fix to memfillcolor
+20070220
+	add 0x92 as chip ID for ether91c111.c
+20070217
+	repair /appl/lib/libc.b and /appl/lib/libc0.b strncmp implementations (used only by c2l output) [inferno-os issue 9]
+	/emu/port/devip.c, get socket fd on reopen of ctl
+	/appl/acme/exec.b, trim string correctly [inferno-os issue 11]
+20070216
+	add /module/lists.m, /appl/lib/lists.b, and lists(2)
+20070209
+	remove debugging -d option to exportfs call in emu/Plan9/devsrv9.c(!)
+20070206
+	/appl/svc/auth.sh: replace exit by raise
+	/man/2/styxservers: document replychan and replydirect
+20070201
+	update US timezone files to save energy
+20070131
+	add /appl/lib/convcs/utf16_btos.b, utf16_stob.b etc [rog]
+20070130
+	fix wording in some of the licence files (eg, remove references to old liberal licence)
+20070123
+	check lengths properly in devenv.c
+	move all of doc into lib/proto/inferno from lib/proto/src
+20070122
+	add doc/port.ms, doc/port.pdf to src proto.  add brief instructions for source rebuild to port.ms
+20070118
+	add json(2) {/appl/lib/json.b, /module/json.m, /dis/lib/json.dis} for RFC4627 notation [json(6)]
+20070117
+	remove duplicate libmp/libsec reference from /mkfile (i assume it wasn't necessary to visit them twice!)
+20070116
+	move Man from /dis/man.dis (which vanished a few changes ago) to /dis/lib/man.dis.  honestly.  wm/man works again.
+20070114
+	remove some unused static declarations in /utils/mk/shprint.c
+20070111
+	delete drawxflush from devdraw.c (call drawq(un)?lock instead)
+20070107
+	have emu (/emu/port/main.c) check environment variables INFERNO and ROOT before EMU and -r, for inferno root directory
+		(haven't yet changed the build system and mkfiles to match)
+	remove /include/libcrypt_o.h since the library isn't used
+	add complete(2)
+20070103
+	replace man.dis by Salva Peiró's sh version of plan 9's man script
+20061221
+	add data2c to Irix package prototype
+	remove unwanted .dis/.sbl files from /appl packages
+	change liblogfs to GPLv2 from proprietary, to fit google code
+	correct cmd(3) to account for new stderr file
+20061219
+	cmd(3) and thus os(1) change to separate standard output and error streams
+	all /emu/*/cmd.c change to account for that (original changes to devcmd.c and MacOSX/cmd.c courtesy Cibernet)
+20061215
+	replaced things like <???> because gcc annoyingly whines even with 1950's trigraphs off
+	libtk/textu.c: uninitialised field in boundary case
+	libtk/textw.c: possibly uninitialised value; leave unchanged
+	utils/ql/l.h: uchar as to ushort, because of extra ops
+20061214
+	added fopen to xml.m to allow bufio->sopen and others to be used
+20061213
+	added MacOSX/386 components
+20061013
+	updated /os/ip/lookbackmedium.c and /os/ip/rudp.c
+20061021
+	change /os/port/exportfs.c to allow negotiating up to 64k msize
+	(matching /emu/port/exportfs.c)
+20060809
+	/appl/lib/newns.b uses String->unquoted, if it can load it
+20060803
+	/libtk/textw.c: default page up/down scrolls 0.75 of a page (to give context); also allows fractional value
+20060801
+	/utils/data2s/data2s.c: allocate at least one linker byte to empty files to avoid complaints
+20060715
+	/appl/lib/pop3.b remove defaultserver(); update pop3(2) to remove references to /services
+	similarly update smtp(2)
+	avoid some boundary cases in /appl/charon/^(build.b layout.b)
+20060625
+	added caerwynj@gmail.com changes to /appl/acme/acme/mail/src/Mailpop3.b
+20060622
+	/appl/lib/sets*.b: correct op's implementation of 2r1101
+20060613
+	added csv(2), /module/csv.m, /appl/lib/csv.b
+20060608
+	preliminary rfc822(2), /appl/lib/rfc822.b
+20060605
+	/appl/lib/chanfill.b: remove alt => *
+20060601
+	fix /appl/lib/dis.b to save the real array once read in
+20060526
+	/appl/lib/venti.b: fix g64's byte ordering [not that it is, or can be called yet]
+20060524
+	copy end fix to lib*/utfecpy.c
+20060523
+	w3c-uris(2): add a .copy() operation
+20060518
+	/Nt/386/include/lib9.h define _USE_32BIT_TIME_T and deprecate `deprecated' warnings
+20060504
+	remove use of HEAP_ALIGN from /*/port/devprof.c; change Heap.pad to Heap.hprof in /include/interp.h
+20060426
+	correct text and selection colours in wm/sh for loss-of-focus and holding modes
+20060423
+	add /appl/lib/w3c/uris.b w3c-uris(2) /module/uris.m
+20060419
+	/emu/port/devcmd.c: correct wakeup state for started command
+20060412
+	/appl/svc/webget	include caerwyn's changes
+20060411
+	put `|| exit 1' after each (command-list) in the mkfiles, just for bash
+20060410
+	/appl/cmd/limbo/typecheck.b /limbo/typecheck.c - stop wrong warning wrt use of ref fn
+20060313
+	remembered to install cddb port from last year... cddb(7)
+20060312
+	/emu/Nt/win.c; #define windows names out of the way to remove IPoint etc
+	/emu/Nt/os.c, simplify osblock/osready and eliminate erendezvous
+	/emu/port/devcons.c, tug into line with /os/port, to prepare for single-window changes
+	echo ^U on CAN (ctrl-U)
+20060311
+	replace Limbo version of shutdown by sh script; it's still a bit silly
+20060309
+	/*/port/inferno.c: 0 or -1 return value from dial functions
+	/os/port/portmkfile: remove reference to ../kfs
+	/man/8/httpd document -a; /appl/svc/httpd/httpd.b
+	/libmp/port/mptouv.c sign extension fix from 9
+	/module/keyring.m, /libinterp/ipint.c: add some bitwise operators
+	change (undocumented) /appl/cmd/test.b so that `host' mkfiles will work in Inferno
+		should probably change the mkfiles to replace it
+20060303
+	/emu/Plan9/win.c replace ldepthof
+20060302
+	add KPX11 flag to hosted kproc to boost the stack for silly x11 & co.
+	put keyboard and cursor processing into a separate kproc with big stack in /emu/port/win-x11a.c
+	change various os.c to match
+20060301
+	/appl/cmd/rioimport.b fix initialisation race
+20060227
+	fix /utils/ql/l.h: oprange should be [ALAST] (with extra 405xx opcodes), also AEND->ALIST elsewhere
+	put faster gethunk in ql and kl (mimic other compilers)
+20060226
+	enable /emu/port/devpointer.c, with changes to /emu/*/win*.c to call mousetrack, /emu/port/main.c to bind #m,
+		and code for pointer and cursor removed from devcons.c
+	update Nt/win.c and port/win-x11a.c from drawterm to get/put host snarf buffer
+	change devmem.c from #m to #% not to clash with pointer
+20060225
+	add /emu/port/devsnarf.c (#^) and put clipread from drawterm in /emu/Nt/win.c
+20060224
+	modify /appl/lib/secstore.b, /module/secstore.m, secstore(2) [add dial, auth, mkseckey, mkfilekey, remove]
+	add /appl/cmd/auth/secstore.b, secstore(1)
+	remove strange exception handling in /appl/cmd/dd.b
+	add dhcpclient(2)
+20060223
+	add /appl/cmd/auth/aescbc.c
+	add /appl/cmd/crypt.b [rog]
+	add crypt(1)
+	add /appl/lib/secstore.b /module/secstore.m secstore(2)
+20060221
+	/libsec/port/hmac.c: treat existing but not seeded digest correctly
+	/libinterp/ipint.c, /module/keyring.m, add new operator `invert'
+20060220
+	add ida(2), /appl/lib/ida, /module/ida.m
+20060216
+	add ubfa(2), ubfa(6), /module/ubfa.m, /appl/lib/ubfa.b
+20060214
+	[rog] add cursor changing support to tk, wm, wmlib (eg, for acme)
+20060213
+	remove libcrypt_o from distribution
+20060211
+	add /man/1/9win [rog]
+	change /appl/cmd/auth/keyfs.b to confirm key only when creating the file [rog]
+	punt floating-point conversions in powerpc jit on macos for time being
+		(have particular values in certain FP registers when native)
+20060210
+	update /libmemdraw/draw.c to include 9's changes for concurrent use
+	remove canlock as assembly language interface, replaced by _tas
+	replace native use of tas by _tas; make declarations all agree
+	add holdon/holdoff ctl request to wm/sh
+	wmproxy in appl/lib/wmlib.b does not create new pgrp
+20060206
+	update /appl/cmd/cp.b with digbyt's changes (mode/uid/gid correct on copied directories)
+20060203
+	update /appl/cmd/ip/dhcp.b /appl/cmd/lib/dhcpclient.b
+	update /os/init/i4e.b to use it
+	add /man/8/dhcp
+20060118
+	add ksize(10.1), kstrip(10.1), /utils/kstrip
+	new _MAGIC definitions in utils/libmach/a.out.h
+20060114
+	change /os/boot/arm1110 mkfile to work on unix and windows; add to /lib/proto/os
+20060111
+	-s (exportonly) -x/-y (geometry) options to 9win (TODO: rog, manual page!)
+	wm/sh.b: correct hold mode; remove little-used and undocumented history file
+20060109
+	delete #pragma from flate.h
+	ensure lib9 compiles replacement sbrk for MacOSX
+20060106
+	update compilers
+	update compilers' manual page
+	fix os/port/portmkfile for Plan 9: don't use $OBJDIR but Inferno/$OBJTYPE
+	have os/port/portmkfile check for i$CONF.p9 and use that not i$CONF for acid
+	add srclist(10.1)
+20060105
+	account for new definition of rendezvous (void* not ulong)
+	add dummy setmalloctag to utils where needed (for Plan 9)
+	set profileflg only for ATEXT in utils/?c/txt.c
+	update /os/boot/pc
+20060103
+	/os/ip updated from Plan 9
+	/os/ip/^(bootp.c dhcp.c ihbootp.c) changed to use announce not connect for udp
+20051215
+	/man/6/keytext added
+20051207
+	/tools/odbc.c portability changes, and fix modes on several files
+20051202
+	/emu/Plan9/devfs.c strip Inferno root from file system diagnostics
+20051130
+	change /appl/svc/httpd to use lock(2) not lockprocs
+20051123
+	/appl/cmd/bind.b changed not to use arg.dis, implement -q, and diagnostic change
+	/appl/cmd/mount.b acquired a -q option as well
+20051114
+	avoid limit==0 in wm/memory.b
+20051108
+	have poolmaxsize return 0 for pool of size 0
+	remove /os/*/u.h (in favour of /$SYSTARG/$OBJTYPE/include/u.h)
+	update mkfiles accordingly
+	adjust mkfiles for libsec and libmp compilation for native kernels
+20051107
+	added /os/manga
+20051101
+	fixed /os/port/devloopback.c
+	updated netif.c netif.h
+20051028
+	updated gettar(1) and /appl/cmd/gettar.b
+20051025
+	fix British Summer Time in locales
+20051021
+	updated /appl/lib/newns.b and namespace(6) for environment variable substitution
+20051018
+	moved in changes from home to os/port: cis.c devbridge.c ethermii.c portclock.c devuart.c devbench.c random.c portfns.h tod.c uart.h
+	- mainly for changes to implement fasttick and timers
+20051017
+	/limbo/ecom.c and /appl/cmd/limbo/ecom.c: ensure src set in temporary Node to avoid `no file specified' in sbl.[bc]
+20050925
+	added format(2)
+20050922
+	iostats(4) added
+20050919
+	improve behaviour in wm/sh when in raw mode
+20050916
+	/appl/lib/styx.b: return value for Rmsg.unpack for Rstat didn't include len[2]
+20050912
+	update /appl/lib/disks.b, disks(2)
+	update /appl/cmd/disk/format.b
+	add /appl/cmd/disk/prep, /appl/cmd/disk/mbr.b
+	replace format(8) by prep(8)
+	delete undocumented /appl/cmd/disk/part.b
+20050908
+	added disks(2) and scsiio(2)
+20050906
+	os/port/devsrv.c and emu/port/devsrv.c to allow setting length by wstat (also DMAPPEND)
+	appl/cmd/dossrv.b fix to interpret aname:offset
+	usb updated to support current native uhci drivers
+	/appl/lib/usb/usbmass.b changed to work with new driver and more devices
+20050901
+	new /appl/cmd/ip/sntp.b, sntp(8)
+20050824
+	cp(1): added -gux options
+20050810
+	mangaload(8): new
+20050812
+	/appl/cmd/limbo/nodes.b didn't always initialise n.c (eg, a != a)
+20050712
+	updated utils/[12][acl] to match Plan 9's
+20050627
+	added streamcp (renamed fcp since that's what plan 9 calls a similar thing)
+20050626
+	added write lock to emu/port/devip.c to stop Linux (and perhaps others) splitting socket writes by different processes
+20050620
+	added w3c-xpointers(2) [/module/xpointers.m; /appl/lib/w3c/xpointers.b]
+20050617
+	fixed qid array reference in /appl/cmd/lockfs.b [cjones83]
+20050610
+	updated lib/ndb/dns
+	fixed count < 0 when reading beyond end of file in disk/kfs
+20050526
+	fixed factotum's p9any to use user= attribute in key not /dev/user
+	fix /appl/lib/daytime.b's handling of dlpairs; also read /env/timezone if that's there
+	update /appl/lib/w3c/css.b to read CSS2.1
+	add w3c-css(2); possibly should move module file to w3c/css.m?
+20050518
+	added GPL/LGPL notice files
+	made single mk.b from many included source files
+	added MIT-template or LGPL NOTICE files to lib* directories
+	updated doc/port.ms
+	included libmp and libsec in lib/proto/src (Lucent Public License), not yet used
+	fix bug in cmd(3) introduced by killonclose
+20050425
+	add sexprs(6)
+	add truerand/ntruerand and nsec[defined as osnsec] to lib9.h
+	redefine fmax and log2 in lib9.h
+	some/all FreeBSD-5.x-y don't initialise rfork_thread's procmask from parent (contrary to docs); compensate in FreeBSD/os.c
+	finally copy last year's changes to 1c from home
+	call logs->init in applylog
+	changed /appl/cmd/cmp.b to work correctly for differing buffer sizes, errors, etc.
+	included /os/pc/sd53c8xx.[in] and added /utils/na [not compiled by default]
+	mask off OEXCL in (emu/port os/port)^/sysfile.c:/^kcreate's openmode
+	wm/sh.b: keep menuitem 0 if noscroll selected
+	added units(1)
+20050413
+	licence following MIT-template replaces `free for all' instances
+	"-N nice" option in os(1)
+	geodesy(2) is new
+	ebook(1) is newly released (Open Ebook browser)
+	wm-sh(1) has a rearranged menu, with scroll/noscroll option added
+	/doc/asm.ms has been updated
+	section 10 has been updated
+	limbo compiler will make simple functions inline if possible
+	limbo compiler supports `ref fn' type
+	/doc/limbo/addendum.ms [also .ps .pdf] updated to reflect `ref fn' and other changes
+	keyring-ipint(2) has a few new operations (shl, shr, copy)
+	DigestState has new copy operation replacing cloneDigestState
+	Keyring has new functions certtoattr, pktoattr and sktoattr each returning
+		a string containing attr=value ... representations of certificates and keys
+	u.h has been updated for all platforms, hosted and native
+		new ptrint, u8int, u16int, u64int, FPdbleword, and more accurate varargs for < 4 byte values
+	lib9.h has extra encode/decode functions moved from libcrypt
+	string.m has new quotec function [TODO: man page]
+	crypt/ssl3.b handles a particular certificate type better
+	charon has several bug fixes in javascript, notably parsing of certain expressions
+	/doc/descent/* `Descent into Limbo' updated
+	internally libinterp uses a different representation for parts of the linkage table
+	/doc/lprof.ms [also .ps and .pdf] gives overview of Limbo profiling
+	/doc/ebookimp.ms [also .ps and .pdf] discusses implementation of its XML browsing
+	/doc/compiler.ms has been updated
+	/doc/dis.ms  eclr has been removed
+	emu(1) -b enables bounds checking in JIT
+	cs(8) handles general query (!attr=val ...)
+	mkfs/mkext(8) handles big archives
+	emuinit tries sh -c on command if not immediately dis
+	/appl/lib/string.b: rewritten unquoted for correct handling of embedded quotes
+	limbo warns about unused local variables
+	limbo: -F enables new implementation of function ref
+	limbo: -O runs optimiser
+	mount -9 uses 9fs not styx as service address
+	cmd(3) adds "killonclose" and parameter to "nice"
+	TODO: group check in styxserver
+	styxlisten accumulates algs correctly
+	os/port/mkdevc builds vgacursor table
+	touch uses OEXCL
+	/appl/lib/debug knows about ref fn
+	ecmascript: for(... in ...) parsed correctly
+	getuserpasswd added to factotum(2)
+	/appl/lib/print reincorporated
+	wm/clock
+	ftpfs calls factotum (getuserpasswd)
+	hoststdin/hoststdout/hoststderr [preliminary]
+	/os/boot/pc updated, as is its shipping list
+20041217
+	base point
--- /dev/null
+++ b/DragonFly/386/include/emu.h
@@ -1,0 +1,30 @@
+/*
+ * system- and machine-specific declarations for emu:
+ * floating-point save and restore, signal handling primitive, and
+ * implementation of the current-process variable `up'.
+ */
+
+/*
+ * This structure must agree with FPsave and FPrestore asm routines
+ */
+typedef struct FPU FPU;
+struct FPU
+{
+	uchar	env[28];
+};
+
+#define KSTACK (32 * 1024)
+
+static __inline Proc *getup(void) {
+	Proc *p;
+	__asm__(	"movl	%%esp, %%eax\n\t"
+			: "=a" (p)
+	);
+	return *(Proc **)((unsigned long)p & ~(KSTACK - 1));
+};
+
+#define	up	(getup())
+
+typedef sigjmp_buf osjmpbuf;
+#define	ossetjmp(buf)	sigsetjmp(buf, 1)
+
--- /dev/null
+++ b/DragonFly/386/include/fpuctl.h
@@ -1,0 +1,76 @@
+/*
+ * Linux 386 fpu support
+ * Mimic Plan9 floating point support
+ */
+
+static void
+setfcr(ulong fcr)
+{
+	__asm__(	"xorb	$0x3f, %%al\n\t"
+			"pushw	%%ax\n\t"
+			"fwait\n\t"
+			"fldcw	(%%esp)\n\t"
+			"popw	%%ax\n\t"
+			: /* no output */
+			: "al" (fcr)
+	);
+}
+
+static ulong
+getfcr(void)
+{
+	ulong fcr = 0;
+
+	__asm__(	"pushl	%%eax\n\t"
+			"fwait\n\t"
+			"fstcw	(%%esp)\n\t"
+			"popl	%%eax\n\t"
+			"xorb	$0x3f, %%al\n\t"
+			: "=a"  (fcr)
+			: "eax"	(fcr)
+	);
+	return fcr; 
+}
+
+static ulong
+getfsr(void)
+{
+	ulong fsr = -1;
+
+	__asm__(	"fwait\n\t"
+			"fstsw	(%%eax)\n\t"
+			"movl	(%%eax), %%eax\n\t"
+			"andl	$0xffff, %%eax\n\t"
+			: "=a"  (fsr)
+			: "eax" (&fsr)
+	);
+	return fsr;
+}
+
+static void
+setfsr(ulong fsr)
+{
+	__asm__("fclex\n\t");
+}
+
+/* FCR */
+#define	FPINEX	(1<<5)
+#define	FPUNFL	((1<<4)|(1<<1))
+#define	FPOVFL	(1<<3)
+#define	FPZDIV	(1<<2)
+#define	FPINVAL	(1<<0)
+#define	FPRNR	(0<<10)
+#define	FPRZ	(3<<10)
+#define	FPRPINF	(2<<10)
+#define	FPRNINF	(1<<10)
+#define	FPRMASK	(3<<10)
+#define	FPPEXT	(3<<8)
+#define	FPPSGL	(0<<8)
+#define	FPPDBL	(2<<8)
+#define	FPPMASK	(3<<8)
+/* FSR */
+#define	FPAINEX	FPINEX
+#define	FPAOVFL	FPOVFL
+#define	FPAUNFL	FPUNFL
+#define	FPAZDIV	FPZDIV
+#define	FPAINVAL	FPINVAL
--- /dev/null
+++ b/DragonFly/386/include/lib9.h
@@ -1,0 +1,474 @@
+/* define _BSD_SOURCE to use ISO C, POSIX, and 4.3BSD things. */
+#ifndef _BSD_SOURCE
+#define _BSD_SOURCE
+#endif
+/* these aren't really needed because FreeBSD does the right thing and makes off_t 64 bits, full stop */
+#define _LARGEFILE64_SOURCE	1
+#define _FILE_OFFSET_BITS 64
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include "math.h"
+#include <fcntl.h>
+#include <setjmp.h>
+#include <float.h>
+#include <time.h>
+
+#define	getwd	infgetwd
+
+#define	round	infround
+#define	fmax	inffmax
+#define	log2	inflog2
+
+#ifndef EMU
+typedef struct Proc Proc;
+#endif
+
+/*
+ * math module dtoa
+ */
+#define __LITTLE_ENDIAN
+
+#define	nil		((void*)0)
+
+typedef unsigned char	uchar;
+typedef signed char	schar;
+typedef unsigned long	ulong;
+typedef unsigned int Rune;
+typedef long long int	vlong;
+typedef unsigned long long int	uvlong;
+typedef unsigned int u32int;
+typedef uvlong u64int;
+typedef unsigned int	mpdigit;	/* for /sys/include/mp.h */
+typedef unsigned short u16int;
+typedef unsigned char u8int;
+typedef unsigned long uintptr;
+
+typedef signed char	int8;
+typedef unsigned char	uint8;
+typedef short	int16;
+typedef unsigned short	uint16;
+typedef int	int32;
+typedef unsigned int	uint32;
+typedef long long	int64;
+typedef unsigned long long	uint64;
+
+#define	USED(x)		if(x){}else{}
+#define	SET(x)
+
+#undef nelem
+#define	nelem(x)	(sizeof(x)/sizeof((x)[0]))
+#undef offsetof
+#define	offsetof(s, m)	(ulong)(&(((s*)0)->m))
+#undef assert
+#define	assert(x)	if(x){}else _assert("x")
+
+/*
+ * most mem and string routines are declared by ANSI/POSIX files above
+ */
+
+extern	char*	strecpy(char*, char*, char*);
+extern	char*	strdup(const char*);
+extern	int	cistrncmp(char*, char*, int);
+extern	int	cistrcmp(char*, char*);
+extern	char*	cistrstr(char*, char*);
+extern	int	tokenize(char*, char**, int);
+
+enum
+{
+	UTFmax		= 4,		/* maximum bytes per rune */
+	Runesync	= 0x80,		/* cannot represent part of a UTF sequence (<) */
+	Runeself	= 0x80,		/* rune and UTF sequences are the same (<) */
+	Runeerror	= 0xFFFD,	/* decoding error in UTF */
+	Runemax		= 0x10FFFF,	/* 21-bit rune */
+	Runemask	= 0x1FFFFF,	/* bits used by runes (see grep) */
+};
+
+/*
+ * rune routines
+ */
+extern	int	runetochar(char*, Rune*);
+extern	int	chartorune(Rune*, char*);
+extern	int	runelen(long);
+extern	int	runenlen(Rune*, int);
+extern	int	fullrune(char*, int);
+extern	int	utflen(char*);
+extern	int	utfnlen(char*, long);
+extern	char*	utfrune(char*, long);
+extern	char*	utfrrune(char*, long);
+extern	char*	utfutf(char*, char*);
+extern	char*	utfecpy(char*, char*, char*);
+
+extern	Rune*	runestrcat(Rune*, Rune*);
+extern	Rune*	runestrchr(Rune*, Rune);
+extern	int	runestrcmp(Rune*, Rune*);
+extern	Rune*	runestrcpy(Rune*, Rune*);
+extern	Rune*	runestrncpy(Rune*, Rune*, long);
+extern	Rune*	runestrecpy(Rune*, Rune*, Rune*);
+extern	Rune*	runestrdup(Rune*);
+extern	Rune*	runestrncat(Rune*, Rune*, long);
+extern	int	runestrncmp(Rune*, Rune*, long);
+extern	Rune*	runestrrchr(Rune*, Rune);
+extern	long	runestrlen(Rune*);
+extern	Rune*	runestrstr(Rune*, Rune*);
+
+extern	Rune	tolowerrune(Rune);
+extern	Rune	totitlerune(Rune);
+extern	Rune	toupperrune(Rune);
+extern	int	isalpharune(Rune);
+extern	int	islowerrune(Rune);
+extern	int	isspacerune(Rune);
+extern	int	istitlerune(Rune);
+extern	int	isupperrune(Rune);
+
+/*
+ * malloc
+ */
+extern	void*	malloc(size_t);
+extern	void*	mallocz(ulong, int);
+extern	void	free(void*);
+extern	ulong	msize(void*);
+extern	void*	calloc(size_t, size_t);
+extern	void*	realloc(void*, size_t);
+extern	void		setmalloctag(void*, ulong);
+extern	void		setrealloctag(void*, ulong);
+extern	ulong	getmalloctag(void*);
+extern	ulong	getrealloctag(void*);
+extern	void*	malloctopoolblock(void*);
+
+/*
+ * print routines
+ */
+typedef struct Fmt	Fmt;
+struct Fmt{
+	uchar	runes;			/* output buffer is runes or chars? */
+	void	*start;			/* of buffer */
+	void	*to;			/* current place in the buffer */
+	void	*stop;			/* end of the buffer; overwritten if flush fails */
+	int	(*flush)(Fmt *);	/* called when to == stop */
+	void	*farg;			/* to make flush a closure */
+	int	nfmt;			/* num chars formatted so far */
+	va_list	args;			/* args passed to dofmt */
+	int	r;			/* % format Rune */
+	int	width;
+	int	prec;
+	ulong	flags;
+};
+
+enum{
+	FmtWidth	= 1,
+	FmtLeft		= FmtWidth << 1,
+	FmtPrec		= FmtLeft << 1,
+	FmtSharp	= FmtPrec << 1,
+	FmtSpace	= FmtSharp << 1,
+	FmtSign		= FmtSpace << 1,
+	FmtZero		= FmtSign << 1,
+	FmtUnsigned	= FmtZero << 1,
+	FmtShort	= FmtUnsigned << 1,
+	FmtLong		= FmtShort << 1,
+	FmtVLong	= FmtLong << 1,
+	FmtComma	= FmtVLong << 1,
+	FmtByte	= FmtComma << 1,
+
+	FmtFlag		= FmtByte << 1
+};
+
+extern	int	print(char*, ...);
+extern	char*	seprint(char*, char*, char*, ...);
+extern	char*	vseprint(char*, char*, char*, va_list);
+extern	int	snprint(char*, int, char*, ...);
+extern	int	vsnprint(char*, int, char*, va_list);
+extern	char*	smprint(char*, ...);
+extern	char*	vsmprint(char*, va_list);
+extern	int	sprint(char*, char*, ...);
+extern	int	fprint(int, char*, ...);
+extern	int	vfprint(int, char*, va_list);
+
+extern	int	runesprint(Rune*, char*, ...);
+extern	int	runesnprint(Rune*, int, char*, ...);
+extern	int	runevsnprint(Rune*, int, char*, va_list);
+extern	Rune*	runeseprint(Rune*, Rune*, char*, ...);
+extern	Rune*	runevseprint(Rune*, Rune*, char*, va_list);
+extern	Rune*	runesmprint(char*, ...);
+extern	Rune*	runevsmprint(char*, va_list);
+
+extern	int	fmtfdinit(Fmt*, int, char*, int);
+extern	int	fmtfdflush(Fmt*);
+extern	int	fmtstrinit(Fmt*);
+extern	char*	fmtstrflush(Fmt*);
+extern	int	runefmtstrinit(Fmt*);
+extern	Rune*	runefmtstrflush(Fmt*);
+
+extern	int	fmtinstall(int, int (*)(Fmt*));
+extern	int	dofmt(Fmt*, char*);
+extern	int	dorfmt(Fmt*, Rune*);
+extern	int	fmtprint(Fmt*, char*, ...);
+extern	int	fmtvprint(Fmt*, char*, va_list);
+extern	int	fmtrune(Fmt*, int);
+extern	int	fmtstrcpy(Fmt*, char*);
+extern	int	fmtrunestrcpy(Fmt*, Rune*);
+/*
+ * error string for %r
+ * supplied on per os basis, not part of fmt library
+ */
+extern	int	errfmt(Fmt *f);
+
+/*
+ * quoted strings
+ */
+extern	char	*unquotestrdup(char*);
+extern	Rune	*unquoterunestrdup(Rune*);
+extern	char	*quotestrdup(char*);
+extern	Rune	*quoterunestrdup(Rune*);
+extern	int	quotestrfmt(Fmt*);
+extern	int	quoterunestrfmt(Fmt*);
+extern	void	quotefmtinstall(void);
+extern	int	(*doquote)(int);
+
+/*
+ * random number
+ */
+extern	int	nrand(int);
+extern	ulong	truerand(void);
+extern	ulong	ntruerand(ulong);
+
+/*
+ * math
+ */
+extern	int	isNaN(double);
+extern	int	isInf(double, int);
+extern	double	pow(double, double);
+
+/*
+ * Time-of-day
+ */
+
+typedef struct Tm Tm;
+struct Tm {
+	int	sec;
+	int	min;
+	int	hour;
+	int	mday;
+	int	mon;
+	int	year;
+	int	wday;
+	int	yday;
+	char	zone[4];
+	int	tzoff;
+};
+extern	vlong	osnsec(void);
+#define	nsec	osnsec
+	
+/*
+ * one-of-a-kind
+ */
+extern	void	_assert(char*);
+extern	double	charstod(int(*)(void*), void*);
+extern	char*	cleanname(char*);
+extern	double	frexp(double, int*);
+extern	uintptr	getcallerpc(void*);
+extern	int	getfields(char*, char**, int, int, char*);
+extern	char*	getuser(void);
+extern	char*	getwd(char*, int);
+extern	double	ipow10(int);
+extern	double	ldexp(double, int);
+extern	double	modf(double, double*);
+#define	pow10	infpow10
+extern	double	pow10(int);
+extern	vlong	strtoll(const char*, char**, int);
+#define	qsort	infqsort
+extern	void	qsort(void*, long, long, int (*)(void*, void*));
+extern	uvlong	strtoull(const char*, char**, int);
+extern	void	sysfatal(char*, ...);
+extern	int	dec64(uchar*, int, char*, int);
+extern	int	enc64(char*, int, uchar*, int);
+extern	int	dec32(uchar*, int, char*, int);
+extern	int	enc32(char*, int, uchar*, int);
+extern	int	dec16(uchar*, int, char*, int);
+extern	int	enc16(char*, int, uchar*, int);
+extern	int	encodefmt(Fmt*);
+
+/*
+ *  synchronization
+ */
+typedef
+struct Lock {
+	int	val;
+	int	pid;
+} Lock;
+
+extern int	_tas(int*);
+
+extern	void	lock(Lock*);
+extern	void	unlock(Lock*);
+extern	int	canlock(Lock*);
+
+typedef struct QLock QLock;
+struct QLock
+{
+	Lock	use;			/* to access Qlock structure */
+	Proc	*head;			/* next process waiting for object */
+	Proc	*tail;			/* last process waiting for object */
+	int	locked;			/* flag */
+};
+
+extern	void	qlock(QLock*);
+extern	void	qunlock(QLock*);
+extern	int	canqlock(QLock*);
+extern	void	_qlockinit(ulong (*)(ulong, ulong));	/* called only by the thread library */
+
+typedef
+struct RWLock
+{
+	Lock	l;			/* Lock modify lock */
+	QLock	x;			/* Mutual exclusion lock */
+	QLock	k;			/* Lock for waiting writers */
+	int	readers;		/* Count of readers in lock */
+} RWLock;
+
+extern	int	canrlock(RWLock*);
+extern	int	canwlock(RWLock*);
+extern	void	rlock(RWLock*);
+extern	void	runlock(RWLock*);
+extern	void	wlock(RWLock*);
+extern	void	wunlock(RWLock*);
+
+/*
+ * network dialing
+ */
+#define NETPATHLEN 40
+
+/*
+ * system calls
+ *
+ */
+#define	STATMAX	65535U	/* max length of machine-independent stat structure */
+#define	DIRMAX	(sizeof(Dir)+STATMAX)	/* max length of Dir structure */
+#define	ERRMAX	128	/* max length of error string */
+
+#define	MORDER	0x0003	/* mask for bits defining order of mounting */
+#define	MREPL	0x0000	/* mount replaces object */
+#define	MBEFORE	0x0001	/* mount goes before others in union directory */
+#define	MAFTER	0x0002	/* mount goes after others in union directory */
+#define	MCREATE	0x0004	/* permit creation in mounted directory */
+#define	MCACHE	0x0010	/* cache some data */
+#define	MMASK	0x0017	/* all bits on */
+
+#define	OREAD	0	/* open for read */
+#define	OWRITE	1	/* write */
+#define	ORDWR	2	/* read and write */
+#define	OEXEC	3	/* execute, == read but check execute permission */
+#define	OTRUNC	16	/* or'ed in (except for exec), truncate file first */
+#define	OCEXEC	32	/* or'ed in, close on exec */
+#define	ORCLOSE	64	/* or'ed in, remove on close */
+#define	OEXCL	0x1000	/* or'ed in, exclusive use (create only) */
+
+#define	AEXIST	0	/* accessible: exists */
+#define	AEXEC	1	/* execute access */
+#define	AWRITE	2	/* write access */
+#define	AREAD	4	/* read access */
+
+/* bits in Qid.type */
+#define QTDIR		0x80		/* type bit for directories */
+#define QTAPPEND	0x40		/* type bit for append only files */
+#define QTEXCL		0x20		/* type bit for exclusive use files */
+#define QTMOUNT		0x10		/* type bit for mounted channel */
+#define QTAUTH		0x08		/* type bit for authentication file */
+#define QTFILE		0x00		/* plain file */
+
+/* bits in Dir.mode */
+#define DMDIR		0x80000000	/* mode bit for directories */
+#define DMAPPEND	0x40000000	/* mode bit for append only files */
+#define DMEXCL		0x20000000	/* mode bit for exclusive use files */
+#define DMMOUNT		0x10000000	/* mode bit for mounted channel */
+#define DMAUTH		0x08000000	/* mode bit for authentication file */
+#define DMREAD		0x4		/* mode bit for read permission */
+#define DMWRITE		0x2		/* mode bit for write permission */
+#define DMEXEC		0x1		/* mode bit for execute permission */
+
+typedef
+struct Qid
+{
+	uvlong	path;
+	ulong	vers;
+	uchar	type;
+} Qid;
+
+typedef
+struct Dir {
+	/* system-modified data */
+	ushort	type;	/* server type */
+	uint	dev;	/* server subtype */
+	/* file data */
+	Qid	qid;	/* unique id from server */
+	ulong	mode;	/* permissions */
+	ulong	atime;	/* last read time */
+	ulong	mtime;	/* last write time */
+	vlong	length;	/* file length */
+	char	*name;	/* last element of path */
+	char	*uid;	/* owner name */
+	char	*gid;	/* group name */
+	char	*muid;	/* last modifier name */
+} Dir;
+
+extern	Dir*	dirstat(char*);
+extern	Dir*	dirfstat(int);
+extern	int	dirwstat(char*, Dir*);
+extern	int	dirfwstat(int, Dir*);
+extern	long	dirread(int, Dir**);
+extern	void	nulldir(Dir*);
+extern	long	dirreadall(int, Dir**);
+
+typedef
+struct Waitmsg
+{
+	int pid;	/* of loved one */
+	ulong time[3];	/* of loved one & descendants */
+	char	*msg;
+} Waitmsg;
+
+extern	void	_exits(char*);
+
+extern	void	exits(char*);
+extern	int	create(char*, int, int);
+extern	int	errstr(char*, uint);
+
+extern	void	perror(const char*);
+extern	long	readn(int, void*, long);
+extern	int	remove(const char*);
+extern	void	rerrstr(char*, uint);
+extern	vlong	seek(int, vlong, int);
+extern	int	segflush(void*, ulong);
+extern	void	werrstr(char*, ...);
+
+extern char *argv0;
+#define	ARGBEGIN	for((argv0||(argv0=*argv)),argv++,argc--;\
+			    argv[0] && argv[0][0]=='-' && argv[0][1];\
+			    argc--, argv++) {\
+				char *_args, *_argt;\
+				Rune _argc;\
+				_args = &argv[0][1];\
+				if(_args[0]=='-' && _args[1]==0){\
+					argc--; argv++; break;\
+				}\
+				_argc = 0;\
+				while(*_args && (_args += chartorune(&_argc, _args)))\
+				switch(_argc)
+#define	ARGEND		SET(_argt);USED(_argt);USED(_argc); USED(_args);}USED(argv); USED(argc);
+#define	ARGF()		(_argt=_args, _args="",\
+				(*_argt? _argt: argv[1]? (argc--, *++argv): 0))
+#define	EARGF(x)	(_argt=_args, _args="",\
+				(*_argt? _argt: argv[1]? (argc--, *++argv): ((x), abort(), (char*)0)))
+
+#define	ARGC()		_argc
+
+/*
+ *	Extensions for Inferno to basic libc.h
+ */
+
+#define	setbinmode()
+
binary files /dev/null b/Irix/mips/bin/awk differ
binary files /dev/null b/Irix/mips/bin/data2c differ
binary files /dev/null b/Irix/mips/bin/iyacc differ
binary files /dev/null b/Irix/mips/bin/mk differ
binary files /dev/null b/Irix/mips/bin/mkext differ
--- /dev/null
+++ b/Irix/mips/include/emu.h
@@ -1,0 +1,22 @@
+/*
+ * system- and machine-specific declarations for emu:
+ * floating-point save and restore, signal handling primitive, and
+ * implementation of the current-process variable `up'.
+ */
+
+extern	Proc**	Xup;
+#define	up	(*Xup)
+
+typedef	struct	FPU	FPU;
+
+/*
+ * This structure must agree with FPsave and FPrestore asm routines
+ */
+struct FPU
+{
+	ulong	fcr31;
+};
+
+typedef sigjmp_buf osjmpbuf;
+#define	ossetjmp(buf)	sigsetjmp(buf, 1)
+
--- /dev/null
+++ b/Irix/mips/include/lib9.h
@@ -1,0 +1,456 @@
+#define _LARGEFILE64_SOURCE	1
+#define _FILE_OFFSET_BITS 64
+#include <sys/types.h>
+#include <sys/stat.h>
+#define _POSIX_SOURCE
+#include <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include "math.h"
+#include <fcntl.h>
+#include <setjmp.h>
+#include <float.h>
+#include <sys/bsd_types.h>
+#include <time.h>
+
+#define	getwd	infgetwd
+
+#ifndef EMU
+typedef struct Proc Proc;
+#endif
+
+#define	nil		((void*)0)
+
+typedef unsigned char	uchar;
+typedef signed char	schar;
+typedef unsigned int Rune;
+typedef long long int	vlong;
+typedef unsigned long long int	uvlong;
+typedef unsigned int u32int;
+typedef uvlong u64int;
+
+typedef unsigned int	mpdigit;	/* for /sys/include/mp.h */
+typedef unsigned short u16int;
+typedef unsigned char u8int;
+typedef unsigned long uintptr;
+
+typedef signed char	int8;
+typedef unsigned char	uint8;
+typedef short	int16;
+typedef unsigned short	uint16;
+typedef int	int32;
+typedef unsigned int	uint32;
+typedef long long	int64;
+typedef unsigned long long	uint64;
+
+#define	USED(x)		if(x){}else{}
+#define	SET(x)
+
+#undef nelem
+#define	nelem(x)	(sizeof(x)/sizeof((x)[0]))
+#undef offsetof
+#define	offsetof(s, m)	(ulong)(&(((s*)0)->m))
+#undef assert
+#define	assert(x)	if(x){}else _assert("x")
+
+/*
+ * most mem and string routines are declared by ANSI/POSIX files above
+ */
+
+extern	char*	strecpy(char*, char*, char*);
+extern	char*	strdup(const char*);
+extern	int	cistrncmp(char*, char*, int);
+extern	int	cistrcmp(char*, char*);
+extern	char*	cistrstr(char*, char*);
+extern	int	tokenize(char*, char**, int);
+
+enum
+{
+	UTFmax		= 4,		/* maximum bytes per rune */
+	Runesync	= 0x80,		/* cannot represent part of a UTF sequence (<) */
+	Runeself	= 0x80,		/* rune and UTF sequences are the same (<) */
+	Runeerror	= 0xFFFD,	/* decoding error in UTF */
+	Runemax		= 0x10FFFF,	/* 21-bit rune */
+	Runemask	= 0x1FFFFF,	/* bits used by runes (see grep) */
+};
+
+/*
+ * rune routines
+ */
+extern	int	runetochar(char*, Rune*);
+extern	int	chartorune(Rune*, char*);
+extern	int	runelen(long);
+extern	int	runenlen(Rune*, int);
+extern	int	fullrune(char*, int);
+extern	int	utflen(char*);
+extern	int	utfnlen(char*, long);
+extern	char*	utfrune(char*, long);
+extern	char*	utfrrune(char*, long);
+extern	char*	utfutf(char*, char*);
+extern	char*	utfecpy(char*, char*, char*);
+
+extern	Rune*	runestrcat(Rune*, Rune*);
+extern	Rune*	runestrchr(Rune*, Rune);
+extern	int	runestrcmp(Rune*, Rune*);
+extern	Rune*	runestrcpy(Rune*, Rune*);
+extern	Rune*	runestrncpy(Rune*, Rune*, long);
+extern	Rune*	runestrecpy(Rune*, Rune*, Rune*);
+extern	Rune*	runestrdup(Rune*);
+extern	Rune*	runestrncat(Rune*, Rune*, long);
+extern	int	runestrncmp(Rune*, Rune*, long);
+extern	Rune*	runestrrchr(Rune*, Rune);
+extern	long	runestrlen(Rune*);
+extern	Rune*	runestrstr(Rune*, Rune*);
+
+extern	Rune	tolowerrune(Rune);
+extern	Rune	totitlerune(Rune);
+extern	Rune	toupperrune(Rune);
+extern	int	isalpharune(Rune);
+extern	int	islowerrune(Rune);
+extern	int	isspacerune(Rune);
+extern	int	istitlerune(Rune);
+extern	int	isupperrune(Rune);
+
+/*
+ * malloc
+ */
+extern	void*	malloc(size_t);
+extern	void*	mallocz(ulong, int);
+extern	void	free(void*);
+extern	ulong	msize(void*);
+extern	void*	calloc(size_t, size_t);
+extern	void*	realloc(void*, size_t);
+extern	void		setmalloctag(void*, ulong);
+extern	void		setrealloctag(void*, ulong);
+extern	ulong	getmalloctag(void*);
+extern	ulong	getrealloctag(void*);
+extern	void*	malloctopoolblock(void*);
+
+/*
+ * print routines
+ */
+typedef struct Fmt	Fmt;
+struct Fmt{
+	uchar	runes;			/* output buffer is runes or chars? */
+	void	*start;			/* of buffer */
+	void	*to;			/* current place in the buffer */
+	void	*stop;			/* end of the buffer; overwritten if flush fails */
+	int	(*flush)(Fmt *);	/* called when to == stop */
+	void	*farg;			/* to make flush a closure */
+	int	nfmt;			/* num chars formatted so far */
+	va_list	args;			/* args passed to dofmt */
+	int	r;			/* % format Rune */
+	int	width;
+	int	prec;
+	ulong	flags;
+};
+extern	vlong	osnsec(void);
+#define	nsec	osnsec
+
+enum{
+	FmtWidth	= 1,
+	FmtLeft		= FmtWidth << 1,
+	FmtPrec		= FmtLeft << 1,
+	FmtSharp	= FmtPrec << 1,
+	FmtSpace	= FmtSharp << 1,
+	FmtSign		= FmtSpace << 1,
+	FmtZero		= FmtSign << 1,
+	FmtUnsigned	= FmtZero << 1,
+	FmtShort	= FmtUnsigned << 1,
+	FmtLong		= FmtShort << 1,
+	FmtVLong	= FmtLong << 1,
+	FmtComma	= FmtVLong << 1,
+	FmtByte	= FmtComma << 1,
+
+	FmtFlag		= FmtByte << 1
+};
+
+extern	int	print(char*, ...);
+extern	char*	seprint(char*, char*, char*, ...);
+extern	char*	vseprint(char*, char*, char*, va_list);
+extern	int	snprint(char*, int, char*, ...);
+extern	int	vsnprint(char*, int, char*, va_list);
+extern	char*	smprint(char*, ...);
+extern	char*	vsmprint(char*, va_list);
+extern	int	sprint(char*, char*, ...);
+extern	int	fprint(int, char*, ...);
+extern	int	vfprint(int, char*, va_list);
+
+extern	int	runesprint(Rune*, char*, ...);
+extern	int	runesnprint(Rune*, int, char*, ...);
+extern	int	runevsnprint(Rune*, int, char*, va_list);
+extern	Rune*	runeseprint(Rune*, Rune*, char*, ...);
+extern	Rune*	runevseprint(Rune*, Rune*, char*, va_list);
+extern	Rune*	runesmprint(char*, ...);
+extern	Rune*	runevsmprint(char*, va_list);
+
+extern	int	fmtfdinit(Fmt*, int, char*, int);
+extern	int	fmtfdflush(Fmt*);
+extern	int	fmtstrinit(Fmt*);
+extern	char*	fmtstrflush(Fmt*);
+extern	int	runefmtstrinit(Fmt*);
+extern	Rune*	runefmtstrflush(Fmt*);
+
+extern	int	fmtinstall(int, int (*)(Fmt*));
+extern	int	dofmt(Fmt*, char*);
+extern	int	dorfmt(Fmt*, Rune*);
+extern	int	fmtprint(Fmt*, char*, ...);
+extern	int	fmtvprint(Fmt*, char*, va_list);
+extern	int	fmtrune(Fmt*, int);
+extern	int	fmtstrcpy(Fmt*, char*);
+extern	int	fmtrunestrcpy(Fmt*, Rune*);
+/*
+ * error string for %r
+ * supplied on per os basis, not part of fmt library
+ */
+extern	int	errfmt(Fmt *f);
+
+/*
+ * quoted strings
+ */
+extern	char	*unquotestrdup(char*);
+extern	Rune	*unquoterunestrdup(Rune*);
+extern	char	*quotestrdup(char*);
+extern	Rune	*quoterunestrdup(Rune*);
+extern	int	quotestrfmt(Fmt*);
+extern	int	quoterunestrfmt(Fmt*);
+extern	void	quotefmtinstall(void);
+extern	int	(*doquote)(int);
+
+/*
+ * random number
+ */
+extern	ulong	truerand(void);
+extern	ulong	ntruerand(ulong);
+
+/*
+ * math
+ */
+extern	int	isNaN(double);
+extern	int	isInf(double, int);
+
+/*
+ * Time-of-day
+ */
+
+typedef struct Tm Tm;
+struct Tm {
+	int	sec;
+	int	min;
+	int	hour;
+	int	mday;
+	int	mon;
+	int	year;
+	int	wday;
+	int	yday;
+	char	zone[4];
+	int	tzoff;
+};
+	
+/*
+ * one-of-a-kind
+ */
+extern	void	_assert(char*);
+extern	double	charstod(int(*)(void*), void*);
+extern	char*	cleanname(char*);
+extern	uintptr	getcallerpc(void*);
+extern	int	getfields(char*, char**, int, int, char*);
+extern	char*	getuser(void);
+extern	char*	getwd(char*, int);
+extern	double	ipow10(int);
+#define	pow10	infpow10
+extern	double	pow10(int);
+extern	vlong	strtoll(const char*, char**, int);
+#define	qsort	infqsort
+extern	void	qsort(void*, long, long, int (*)(void*, void*));
+extern	uvlong	strtoull(const char*, char**, int);
+extern	void	sysfatal(char*, ...);
+extern	int	dec64(uchar*, int, char*, int);
+extern	int	enc64(char*, int, uchar*, int);
+extern	int	dec32(uchar*, int, char*, int);
+extern	int	enc32(char*, int, uchar*, int);
+extern	int	dec16(uchar*, int, char*, int);
+extern	int	enc16(char*, int, uchar*, int);
+extern	int	encodefmt(Fmt*);
+
+/*
+ *  synchronization
+ */
+typedef
+struct Lock {
+	int	val;
+	int	pid;
+} Lock;
+
+extern int	_tas(int*);
+
+extern	void	lock(Lock*);
+extern	void	unlock(Lock*);
+extern	int	canlock(Lock*);
+
+typedef struct QLock QLock;
+struct QLock
+{
+	Lock	use;			/* to access Qlock structure */
+	Proc	*head;			/* next process waiting for object */
+	Proc	*tail;			/* last process waiting for object */
+	int	locked;			/* flag */
+};
+
+extern	void	qlock(QLock*);
+extern	void	qunlock(QLock*);
+extern	int	canqlock(QLock*);
+extern	void	_qlockinit(ulong (*)(ulong, ulong));	/* called only by the thread library */
+
+typedef
+struct RWLock
+{
+	Lock	l;			/* Lock modify lock */
+	QLock	x;			/* Mutual exclusion lock */
+	QLock	k;			/* Lock for waiting writers */
+	int	readers;		/* Count of readers in lock */
+} RWLock;
+
+extern	int	canrlock(RWLock*);
+extern	int	canwlock(RWLock*);
+extern	void	rlock(RWLock*);
+extern	void	runlock(RWLock*);
+extern	void	wlock(RWLock*);
+extern	void	wunlock(RWLock*);
+
+/*
+ * network dialing
+ */
+#define NETPATHLEN 40
+
+/*
+ * system calls
+ *
+ */
+#define	STATMAX	65535U	/* max length of machine-independent stat structure */
+#define	DIRMAX	(sizeof(Dir)+STATMAX)	/* max length of Dir structure */
+#define	ERRMAX	128	/* max length of error string */
+
+#define	MORDER	0x0003	/* mask for bits defining order of mounting */
+#define	MREPL	0x0000	/* mount replaces object */
+#define	MBEFORE	0x0001	/* mount goes before others in union directory */
+#define	MAFTER	0x0002	/* mount goes after others in union directory */
+#define	MCREATE	0x0004	/* permit creation in mounted directory */
+#define	MCACHE	0x0010	/* cache some data */
+#define	MMASK	0x0017	/* all bits on */
+
+#define	OREAD	0	/* open for read */
+#define	OWRITE	1	/* write */
+#define	ORDWR	2	/* read and write */
+#define	OEXEC	3	/* execute, == read but check execute permission */
+#define	OTRUNC	16	/* or'ed in (except for exec), truncate file first */
+#define	OCEXEC	32	/* or'ed in, close on exec */
+#define	ORCLOSE	64	/* or'ed in, remove on close */
+#define	OEXCL	0x1000	/* or'ed in, exclusive use (create only) */
+
+#define	AEXIST	0	/* accessible: exists */
+#define	AEXEC	1	/* execute access */
+#define	AWRITE	2	/* write access */
+#define	AREAD	4	/* read access */
+
+/* bits in Qid.type */
+#define QTDIR		0x80		/* type bit for directories */
+#define QTAPPEND	0x40		/* type bit for append only files */
+#define QTEXCL		0x20		/* type bit for exclusive use files */
+#define QTMOUNT		0x10		/* type bit for mounted channel */
+#define QTAUTH		0x08		/* type bit for authentication file */
+#define QTFILE		0x00		/* plain file */
+
+/* bits in Dir.mode */
+#define DMDIR		0x80000000	/* mode bit for directories */
+#define DMAPPEND	0x40000000	/* mode bit for append only files */
+#define DMEXCL		0x20000000	/* mode bit for exclusive use files */
+#define DMMOUNT		0x10000000	/* mode bit for mounted channel */
+#define DMAUTH		0x08000000	/* mode bit for authentication file */
+#define DMREAD		0x4		/* mode bit for read permission */
+#define DMWRITE		0x2		/* mode bit for write permission */
+#define DMEXEC		0x1		/* mode bit for execute permission */
+
+typedef
+struct Qid
+{
+	uvlong	path;
+	ulong	vers;
+	uchar	type;
+} Qid;
+
+typedef
+struct Dir {
+	/* system-modified data */
+	ushort	type;	/* server type */
+	uint	dev;	/* server subtype */
+	/* file data */
+	Qid	qid;	/* unique id from server */
+	ulong	mode;	/* permissions */
+	ulong	atime;	/* last read time */
+	ulong	mtime;	/* last write time */
+	vlong	length;	/* file length */
+	char	*name;	/* last element of path */
+	char	*uid;	/* owner name */
+	char	*gid;	/* group name */
+	char	*muid;	/* last modifier name */
+} Dir;
+
+extern	Dir*	dirstat(char*);
+extern	Dir*	dirfstat(int);
+extern	int	dirwstat(char*, Dir*);
+extern	int	dirfwstat(int, Dir*);
+extern	long	dirread(int, Dir**);
+extern	void	nulldir(Dir*);
+extern	long	dirreadall(int, Dir**);
+
+typedef
+struct Waitmsg
+{
+	int pid;	/* of loved one */
+	ulong time[3];	/* of loved one & descendants */
+	char	*msg;
+} Waitmsg;
+
+extern	void	_exits(char*);
+
+extern	void	exits(char*);
+extern	int	create(char*, int, int);
+extern	int	errstr(char*, uint);
+
+extern	void	perror(const char*);
+extern	long	readn(int, void*, long);
+extern	int	remove(const char*);
+extern	void	rerrstr(char*, uint);
+extern	vlong	seek(int, vlong, int);
+extern	void	werrstr(char*, ...);
+
+extern char *argv0;
+#define	ARGBEGIN	for((argv0||(argv0=*argv)),argv++,argc--;\
+			    argv[0] && argv[0][0]=='-' && argv[0][1];\
+			    argc--, argv++) {\
+				char *_args, *_argt;\
+				Rune _argc;\
+				_args = &argv[0][1];\
+				if(_args[0]=='-' && _args[1]==0){\
+					argc--; argv++; break;\
+				}\
+				_argc = 0;\
+				while(*_args && (_args += chartorune(&_argc, _args)))\
+				switch(_argc)
+#define	ARGEND		SET(_argt);USED(_argt);USED(_argc); USED(_args);}USED(argv); USED(argc);
+#define	ARGF()		(_argt=_args, _args="",\
+				(*_argt? _argt: argv[1]? (argc--, *++argv): 0))
+#define	EARGF(x)	(_argt=_args, _args="",\
+				(*_argt? _argt: argv[1]? (argc--, *++argv): ((x), abort(), (char*)0)))
+
+#define	ARGC()		_argc
+
+/*
+ *	Extensions for Inferno to basic libc.h
+ */
+
+#define	setbinmode()
+
--- /dev/null
+++ b/NOTICE
@@ -1,0 +1,32 @@
+This Inferno® distribution includes software from various sources and
+different portions are therefore subject to different licence terms.
+The most stringent is the GNU Public License (version 2), which governs the collection.
+Individual components might have their own NOTICE and licence files (LICENCE
+or COPYING) that cover their content.  All of them allow modification and redistribution.
+They are all compatible with the GPLv2.
+
+The following copyright notice covers the contents of this
+distribution unless otherwise specified by a given file, directory, or
+directory tree:
+
+Inferno® Copyright © 1996-1999 Lucent Technologies Inc.  All rights reserved.
+Inferno revisions Copyright © 1997-1999 Vita Nuova Limited.  All rights reserved.
+Inferno revisions Copyright © 2000-2015 Vita Nuova Holdings Limited.  All rights reserved.
+Inferno new material Copyright © 2000-2015 Vita Nuova Holdings Limited.  All rights reserved.
+
+Inferno, Styx, Dis and Limbo are registered trademarks of Vita Nuova Holdings Limited in the USA and other countries.
+Plan 9 is a registered trademark of Lucent Technologies Inc.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License (`GPL') as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
binary files /dev/null b/Nt/386/bin/awk.exe differ
binary files /dev/null b/Nt/386/bin/c2l.exe differ
binary files /dev/null b/Nt/386/bin/cat.exe differ
binary files /dev/null b/Nt/386/bin/cp.exe differ
binary files /dev/null b/Nt/386/bin/data2c.exe differ
binary files /dev/null b/Nt/386/bin/echo.exe differ
binary files /dev/null b/Nt/386/bin/format.exe differ
binary files /dev/null b/Nt/386/bin/gzip.exe differ
binary files /dev/null b/Nt/386/bin/infdb.exe differ
binary files /dev/null b/Nt/386/bin/iyacc.exe differ
binary files /dev/null b/Nt/386/bin/mk.exe differ
binary files /dev/null b/Nt/386/bin/mkdir.exe differ
binary files /dev/null b/Nt/386/bin/mkext.exe differ
binary files /dev/null b/Nt/386/bin/mv.exe differ
binary files /dev/null b/Nt/386/bin/rcsh.exe differ
binary files /dev/null b/Nt/386/bin/rm.exe differ
binary files /dev/null b/Nt/386/bin/sed.exe differ
binary files /dev/null b/Nt/386/bin/test.exe differ
binary files /dev/null b/Nt/386/bin/tr.exe differ
--- /dev/null
+++ b/Nt/386/include/emu.h
@@ -1,0 +1,24 @@
+/*
+ * system- and machine-specific declarations for emu:
+ * floating-point save and restore, signal handling primitive, and
+ * implementation of the current-process variable `up'.
+ */
+
+/*
+ * This structure must agree with FPsave and FPrestore asm routines
+ */
+typedef	struct	FPU	FPU;
+struct FPU
+{
+	uchar	env[28];
+};
+
+extern	void		sleep(int);
+
+/* Set up private thread space */
+extern	__declspec(thread) Proc*	up;
+#define Sleep	NTsleep
+
+typedef jmp_buf osjmpbuf;
+#define	ossetjmp(buf)	setjmp(buf)
+
--- /dev/null
+++ b/Nt/386/include/lib9.h
@@ -1,0 +1,496 @@
+#define _POSIX_SOURCE
+#include <stdlib.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <string.h>
+#include "math.h"
+#include <fcntl.h>
+#include <setjmp.h>
+#include <float.h>
+#include <time.h>
+#include <process.h>
+#include <io.h>
+#include <direct.h>
+
+#define	getwd	infgetwd
+#define	strtod	infstrtod
+#define	strtoll	infstrtoll
+#define	strtoull	infstrtoull
+#ifndef INFERNO_KEEPENVIRON
+/* environ is perfectly legal as the name of a local, field name or struct, but windows redefines it */
+/* the extern char** environ is only needed by two programs, so #undef it for everything else */
+#undef environ
+#endif
+
+/* do-it-yourself isinf and isnan */
+#ifndef isnan
+#define isnan(x) _isnan(x)
+#endif
+#ifndef isinf
+#define isinf(x) (!_finite(x))
+#endif
+
+#ifndef EMU
+typedef struct Proc Proc;
+#endif
+
+/*
+ * math module dtoa
+ */
+#define __LITTLE_ENDIAN
+
+   /* there must be a Win32 header macro for endian-ness!!! */
+
+/*
+ * disable various silly warnings
+ * 4018 signed/unsigned comparison
+ * 4245 signed/unsigned conversion
+ * 4244 long to char conversion
+ * 4068	unknown pragma
+ * 4090 different volatile quals
+ * 4554 operator precedence
+ * 4146 unary - on unsigned type
+ * 4996 `deprecated' functions: they often suggest non-portable replacements
+ */
+#pragma warning( disable : 4305 4244 4102 4761 4018 4245 4244 4068 4090 4554 4146 4996)
+
+#define	nil		((void*)0)
+
+typedef unsigned char	uchar;
+typedef unsigned int	uint;
+typedef unsigned long	ulong;
+typedef signed char	schar;
+typedef unsigned short	ushort;
+typedef unsigned int Rune;
+typedef __int64		vlong;
+typedef unsigned __int64		uvlong;
+typedef unsigned int u32int;
+typedef uvlong u64int;
+
+typedef unsigned int	mpdigit;	/* for /sys/include/mp.h */
+typedef unsigned short u16int;
+typedef unsigned char u8int;
+typedef unsigned long uintptr;
+
+typedef signed char	int8;
+typedef unsigned char	uint8;
+typedef short	int16;
+typedef unsigned short	uint16;
+typedef int	int32;
+typedef unsigned int	uint32;
+typedef long long	int64;
+typedef unsigned long long	uint64;
+
+#define	USED(x)		if(x){}else{}
+#define	SET(x)
+
+#undef nelem
+#define	nelem(x)	(sizeof(x)/sizeof((x)[0]))
+#undef offsetof
+#define	offsetof(s, m)	(ulong)(&(((s*)0)->m))
+#undef assert
+#define	assert(x)	if(x){}else _assert("x")
+
+/*
+ * most mem and string routines are declared by ANSI/POSIX files above
+ */
+
+extern	char*	strecpy(char*, char*, char*);
+extern	char*	strdup(const char*);
+extern	int	cistrncmp(char*, char*, int);
+extern	int	cistrcmp(char*, char*);
+extern	char*	cistrstr(char*, char*);
+extern	int	tokenize(char*, char**, int);
+extern	double	strtod(const char*, char**);
+extern	vlong	strtoll(const char*, char**, int);
+#define	qsort	infqsort
+extern	void	qsort(void*, long, long, int (*)(void*, void*));
+extern	uvlong	strtoull(const char*, char**, int);
+
+enum
+{
+	UTFmax		= 4,		/* maximum bytes per rune */
+	Runesync	= 0x80,		/* cannot represent part of a UTF sequence (<) */
+	Runeself	= 0x80,		/* rune and UTF sequences are the same (<) */
+	Runeerror	= 0xFFFD,	/* decoding error in UTF */
+	Runemax		= 0x10FFFF,	/* 21-bit rune */
+	Runemask	= 0x1FFFFF,	/* bits used by runes (see grep) */
+};
+
+/*
+ * rune routines
+ */
+extern	int	runetochar(char*, Rune*);
+extern	int	chartorune(Rune*, char*);
+extern	int	runelen(long);
+extern	int	runenlen(Rune*, int);
+extern	int	fullrune(char*, int);
+extern	int	utflen(char*);
+extern	int	utfnlen(char*, long);
+extern	char*	utfrune(char*, long);
+extern	char*	utfrrune(char*, long);
+extern	char*	utfutf(char*, char*);
+extern	char*	utfecpy(char*, char*, char*);
+
+extern	Rune*	runestrcat(Rune*, Rune*);
+extern	Rune*	runestrchr(Rune*, Rune);
+extern	int	runestrcmp(Rune*, Rune*);
+extern	Rune*	runestrcpy(Rune*, Rune*);
+extern	Rune*	runestrncpy(Rune*, Rune*, long);
+extern	Rune*	runestrecpy(Rune*, Rune*, Rune*);
+extern	Rune*	runestrdup(Rune*);
+extern	Rune*	runestrncat(Rune*, Rune*, long);
+extern	int	runestrncmp(Rune*, Rune*, long);
+extern	Rune*	runestrrchr(Rune*, Rune);
+extern	long	runestrlen(Rune*);
+extern	Rune*	runestrstr(Rune*, Rune*);
+
+extern	Rune	tolowerrune(Rune);
+extern	Rune	totitlerune(Rune);
+extern	Rune	toupperrune(Rune);
+extern	int	isalpharune(Rune);
+extern	int	islowerrune(Rune);
+extern	int	isspacerune(Rune);
+extern	int	istitlerune(Rune);
+extern	int	isupperrune(Rune);
+
+/*
+ * malloc
+ */
+extern	void*	malloc(size_t);
+extern	void*	mallocz(ulong, int);
+extern	void	free(void*);
+extern	ulong	msize(void*);
+extern	void*	calloc(size_t, size_t);
+extern	void*	realloc(void*, size_t);
+extern	void		setmalloctag(void*, ulong);
+extern	void		setrealloctag(void*, ulong);
+extern	ulong	getmalloctag(void*);
+extern	ulong	getrealloctag(void*);
+extern	void*	malloctopoolblock(void*);
+
+/*
+ * print routines
+ */
+typedef struct Fmt	Fmt;
+struct Fmt{
+	uchar	runes;			/* output buffer is runes or chars? */
+	void	*start;			/* of buffer */
+	void	*to;			/* current place in the buffer */
+	void	*stop;			/* end of the buffer; overwritten if flush fails */
+	int	(*flush)(Fmt *);	/* called when to == stop */
+	void	*farg;			/* to make flush a closure */
+	int	nfmt;			/* num chars formatted so far */
+	va_list	args;			/* args passed to dofmt */
+	int	r;			/* % format Rune */
+	int	width;
+	int	prec;
+	ulong	flags;
+};
+
+enum{
+	FmtWidth	= 1,
+	FmtLeft		= FmtWidth << 1,
+	FmtPrec		= FmtLeft << 1,
+	FmtSharp	= FmtPrec << 1,
+	FmtSpace	= FmtSharp << 1,
+	FmtSign		= FmtSpace << 1,
+	FmtZero		= FmtSign << 1,
+	FmtUnsigned	= FmtZero << 1,
+	FmtShort	= FmtUnsigned << 1,
+	FmtLong		= FmtShort << 1,
+	FmtVLong	= FmtLong << 1,
+	FmtComma	= FmtVLong << 1,
+	FmtByte	= FmtComma << 1,
+
+	FmtFlag		= FmtByte << 1
+};
+
+extern	int	print(char*, ...);
+extern	char*	seprint(char*, char*, char*, ...);
+extern	char*	vseprint(char*, char*, char*, va_list);
+extern	int	snprint(char*, int, char*, ...);
+extern	int	vsnprint(char*, int, char*, va_list);
+extern	char*	smprint(char*, ...);
+extern	char*	vsmprint(char*, va_list);
+extern	int	sprint(char*, char*, ...);
+extern	int	fprint(int, char*, ...);
+extern	int	vfprint(int, char*, va_list);
+
+extern	int	runesprint(Rune*, char*, ...);
+extern	int	runesnprint(Rune*, int, char*, ...);
+extern	int	runevsnprint(Rune*, int, char*, va_list);
+extern	Rune*	runeseprint(Rune*, Rune*, char*, ...);
+extern	Rune*	runevseprint(Rune*, Rune*, char*, va_list);
+extern	Rune*	runesmprint(char*, ...);
+extern	Rune*	runevsmprint(char*, va_list);
+
+extern	int	fmtfdinit(Fmt*, int, char*, int);
+extern	int	fmtfdflush(Fmt*);
+extern	int	fmtstrinit(Fmt*);
+extern	char*	fmtstrflush(Fmt*);
+extern	int	runefmtstrinit(Fmt*);
+extern	Rune*	runefmtstrflush(Fmt*);
+
+extern	int	fmtinstall(int, int (*)(Fmt*));
+extern	int	dofmt(Fmt*, char*);
+extern	int	dorfmt(Fmt*, Rune*);
+extern	int	fmtprint(Fmt*, char*, ...);
+extern	int	fmtvprint(Fmt*, char*, va_list);
+extern	int	fmtrune(Fmt*, int);
+extern	int	fmtstrcpy(Fmt*, char*);
+extern	int	fmtrunestrcpy(Fmt*, Rune*);
+/*
+ * error string for %r
+ * supplied on per os basis, not part of fmt library
+ */
+extern	int	errfmt(Fmt *f);
+
+/*
+ * quoted strings
+ */
+extern	char	*unquotestrdup(char*);
+extern	Rune	*unquoterunestrdup(Rune*);
+extern	char	*quotestrdup(char*);
+extern	Rune	*quoterunestrdup(Rune*);
+extern	int	quotestrfmt(Fmt*);
+extern	int	quoterunestrfmt(Fmt*);
+extern	void	quotefmtinstall(void);
+extern	int	(*doquote)(int);
+
+/*
+ * random number
+ */
+extern	ulong	truerand(void);
+extern	ulong	ntruerand(ulong);
+
+/*
+ * math
+ */
+extern	int	isNaN(double);
+extern	int	isInf(double, int);
+
+#define	PIO2	1.570796326794896619231e0
+#define	PI	(PIO2+PIO2)
+
+/*
+ * Time-of-day
+ */
+
+typedef struct Tm Tm;
+struct Tm {
+	int	sec;
+	int	min;
+	int	hour;
+	int	mday;
+	int	mon;
+	int	year;
+	int	wday;
+	int	yday;
+	char	zone[4];
+	int	tzoff;
+};
+extern	vlong	osnsec(void);
+#define	nsec	osnsec
+	
+/*
+ * one-of-a-kind
+ */
+extern	void	_assert(char*);
+extern	double	charstod(int(*)(void*), void*);
+extern	char*	cleanname(char*);
+extern	uintptr	getcallerpc(void*);
+extern	int	getfields(char*, char**, int, int, char*);
+extern	char*	getuser(void);
+extern	char*	getuser(void);
+extern	char*	getwd(char*, int);
+extern	char*	getwd(char*, int);
+extern	double	ipow10(int);
+extern	double	pow10(int);
+extern	void	sysfatal(char*, ...);
+extern	int	dec64(uchar*, int, char*, int);
+extern	int	enc64(char*, int, uchar*, int);
+extern	int	dec32(uchar*, int, char*, int);
+extern	int	enc32(char*, int, uchar*, int);
+extern	int	dec16(uchar*, int, char*, int);
+extern	int	enc16(char*, int, uchar*, int);
+extern	int	encodefmt(Fmt*);
+
+/*
+ *  synchronization
+ */
+typedef
+struct Lock {
+	int	val;
+	int	pid;
+} Lock;
+
+extern int	_tas(int*);
+
+extern	void	lock(Lock*);
+extern	void	unlock(Lock*);
+extern	int	canlock(Lock*);
+
+typedef struct QLock QLock;
+struct QLock
+{
+	Lock	use;			/* to access Qlock structure */
+	Proc	*head;			/* next process waiting for object */
+	Proc	*tail;			/* last process waiting for object */
+	int	locked;			/* flag */
+};
+
+extern	void	qlock(QLock*);
+extern	void	qunlock(QLock*);
+extern	int	canqlock(QLock*);
+extern	void	_qlockinit(ulong (*)(ulong, ulong));	/* called only by the thread library */
+
+typedef
+struct RWLock
+{
+	Lock	l;			/* Lock modify lock */
+	QLock	x;			/* Mutual exclusion lock */
+	QLock	k;			/* Lock for waiting writers */
+	int	readers;		/* Count of readers in lock */
+} RWLock;
+
+extern	int	canrlock(RWLock*);
+extern	int	canwlock(RWLock*);
+extern	void	rlock(RWLock*);
+extern	void	runlock(RWLock*);
+extern	void	wlock(RWLock*);
+extern	void	wunlock(RWLock*);
+
+/*
+ * network dialing
+ */
+#define NETPATHLEN 40
+
+/*
+ * system calls
+ *
+ */
+#define	STATMAX	65535U	/* max length of machine-independent stat structure */
+#define	DIRMAX	(sizeof(Dir)+STATMAX)	/* max length of Dir structure */
+#define	ERRMAX	128	/* max length of error string */
+
+#define	MORDER	0x0003	/* mask for bits defining order of mounting */
+#define	MREPL	0x0000	/* mount replaces object */
+#define	MBEFORE	0x0001	/* mount goes before others in union directory */
+#define	MAFTER	0x0002	/* mount goes after others in union directory */
+#define	MCREATE	0x0004	/* permit creation in mounted directory */
+#define	MCACHE	0x0010	/* cache some data */
+#define	MMASK	0x0017	/* all bits on */
+
+#define	OREAD	0	/* open for read */
+#define	OWRITE	1	/* write */
+#define	ORDWR	2	/* read and write */
+#define	OEXEC	3	/* execute, == read but check execute permission */
+#define	OTRUNC	16	/* or'ed in (except for exec), truncate file first */
+#define	OCEXEC	32	/* or'ed in, close on exec */
+#define	ORCLOSE	64	/* or'ed in, remove on close */
+#define	OEXCL	0x1000	/* or'ed in, exclusive use (create only) */
+
+#define	AEXIST	0	/* accessible: exists */
+#define	AEXEC	1	/* execute access */
+#define	AWRITE	2	/* write access */
+#define	AREAD	4	/* read access */
+
+/* bits in Qid.type */
+#define QTDIR		0x80		/* type bit for directories */
+#define QTAPPEND	0x40		/* type bit for append only files */
+#define QTEXCL		0x20		/* type bit for exclusive use files */
+#define QTMOUNT		0x10		/* type bit for mounted channel */
+#define QTAUTH		0x08		/* type bit for authentication file */
+#define QTFILE		0x00		/* plain file */
+
+/* bits in Dir.mode */
+#define DMDIR		0x80000000	/* mode bit for directories */
+#define DMAPPEND	0x40000000	/* mode bit for append only files */
+#define DMEXCL		0x20000000	/* mode bit for exclusive use files */
+#define DMMOUNT		0x10000000	/* mode bit for mounted channel */
+#define DMAUTH		0x08000000	/* mode bit for authentication file */
+#define DMREAD		0x4		/* mode bit for read permission */
+#define DMWRITE		0x2		/* mode bit for write permission */
+#define DMEXEC		0x1		/* mode bit for execute permission */
+
+typedef
+struct Qid
+{
+	uvlong	path;
+	ulong	vers;
+	uchar	type;
+} Qid;
+
+typedef
+struct Dir {
+	/* system-modified data */
+	ushort	type;	/* server type */
+	uint	dev;	/* server subtype */
+	/* file data */
+	Qid	qid;	/* unique id from server */
+	ulong	mode;	/* permissions */
+	ulong	atime;	/* last read time */
+	ulong	mtime;	/* last write time */
+	vlong	length;	/* file length */
+	char	*name;	/* last element of path */
+	char	*uid;	/* owner name */
+	char	*gid;	/* group name */
+	char	*muid;	/* last modifier name */
+} Dir;
+
+extern	Dir*	dirstat(char*);
+extern	Dir*	dirfstat(int);
+extern	int	dirwstat(char*, Dir*);
+extern	int	dirfwstat(int, Dir*);
+extern	long	dirread(int, Dir**);
+extern	void	nulldir(Dir*);
+extern	long	dirreadall(int, Dir**);
+
+typedef
+struct Waitmsg
+{
+	int pid;	/* of loved one */
+	ulong time[3];	/* of loved one & descendants */
+	char	*msg;
+} Waitmsg;
+
+extern	void	_exits(char*);
+
+extern	void	exits(char*);
+extern	int	create(char*, int, int);
+extern	int	errstr(char*, uint);
+
+extern	long	readn(int, void*, long);
+extern	void	rerrstr(char*, uint);
+extern	vlong	seek(int, vlong, int);
+extern	int	segflush(void*, ulong);
+extern	void	werrstr(char*, ...);
+
+extern char *argv0;
+#define	ARGBEGIN	for((argv0||(argv0=*argv)),argv++,argc--;\
+			    argv[0] && argv[0][0]=='-' && argv[0][1];\
+			    argc--, argv++) {\
+				char *_args, *_argt;\
+				Rune _argc;\
+				_args = &argv[0][1];\
+				if(_args[0]=='-' && _args[1]==0){\
+					argc--; argv++; break;\
+				}\
+				_argc = 0;\
+				while(*_args && (_args += chartorune(&_argc, _args)))\
+				switch(_argc)
+#define	ARGEND		(_argt=0);USED(_argt);USED(_argc); USED(_args);}USED(argv); USED(argc);
+#define	ARGF()		(_argt=_args, _args="",\
+				(*_argt? _argt: argv[1]? (argc--, *++argv): 0))
+#define	EARGF(x)	(_argt=_args, _args="",\
+				(*_argt? _argt: argv[1]? (argc--, *++argv): ((x), abort(), (char*)0)))
+
+#define	ARGC()		_argc
+
+/*
+ *	Extensions for Inferno to basic libc.h
+ */
+
+extern	void	setbinmode(void);
+extern	void*	sbrk(int);
--- /dev/null
+++ b/bitbucket-pipelines.yml
@@ -1,0 +1,10 @@
+image: i386/gcc:6.1
+
+pipelines:
+  default:
+    - step:
+        script:
+          - PATH=$PATH:$PWD/Linux/386/bin MKFLAGS='SYSHOST=Linux OBJTYPE=386 ROOT='$PWD 
+          - mk $MKFLAGS mkdirs
+          - mk $MKFLAGS emuinstall
+          - emu cat /dev/sysctl || echo ' -' exited with status $? '(ignored)'
--- /dev/null
+++ b/include/NOTICE
@@ -1,0 +1,29 @@
+This copyright NOTICE applies to all files in this directory and
+subdirectories, unless another copyright notice appears in a given
+file or subdirectory.  If you take substantial code from this software to use in
+other programs, you must somehow include with it an appropriate
+copyright notice that includes the copyright notice and the other
+notices below.  It is fine (and often tidier) to do that in a separate
+file such as NOTICE, LICENCE or COPYING.
+
+	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
+	Revisions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com).  All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
--- /dev/null
+++ b/include/a.out.h
@@ -1,0 +1,1 @@
+#include "../utils/include/a.out.h"
--- /dev/null
+++ b/include/bio.h
@@ -1,0 +1,69 @@
+#pragma	src	"/usr/inferno/libbio"
+
+typedef	struct	Biobuf	Biobuf;
+
+enum
+{
+	Bsize		= 8*1024,
+	Bungetsize	= UTFmax+1,		/* space for ungetc */
+	Bmagic		= 0x314159,
+	Beof		= -1,
+	Bbad		= -2,
+
+	Binactive	= 0,		/* states */
+	Bractive,
+	Bwactive,
+	Bracteof,
+
+	Bend
+};
+
+struct	Biobuf
+{
+	int	icount;		/* neg num of bytes at eob */
+	int	ocount;		/* num of bytes at bob */
+	int	rdline;		/* num of bytes after rdline */
+	int	runesize;	/* num of bytes of last getrune */
+	int	state;		/* r/w/inactive */
+	int	fid;		/* open file */
+	int	flag;		/* magic if malloc'ed */
+	vlong	offset;		/* offset of buffer in file */
+	int	bsize;		/* size of buffer */
+	uchar*	bbuf;		/* pointer to beginning of buffer */
+	uchar*	ebuf;		/* pointer to end of buffer */
+	uchar*	gbuf;		/* pointer to good data in buf */
+	uchar	b[Bungetsize+Bsize];
+};
+
+/* Dregs, redefined as functions for backwards compatibility */
+#define	BGETC(bp)	Bgetc(bp)
+#define	BPUTC(bp,c)	Bputc(bp,c)
+#define	BOFFSET(bp)	Boffset(bp)
+#define	BLINELEN(bp)	Blinelen(bp)
+#define	BFILDES(bp)	Bfildes(bp)
+
+int	Bbuffered(Biobuf*);
+int	Bfildes(Biobuf*);
+int	Bflush(Biobuf*);
+int	Bgetc(Biobuf*);
+int	Bgetd(Biobuf*, double*);
+long	Bgetrune(Biobuf*);
+int	Binit(Biobuf*, int, int);
+int	Binits(Biobuf*, int, int, uchar*, int);
+int	Blinelen(Biobuf*);
+vlong	Boffset(Biobuf*);
+Biobuf*	Bopen(char*, int);
+int	Bprint(Biobuf*, char*, ...);
+int	Bvprint(Biobuf*, char*, va_list);
+int	Bputc(Biobuf*, int);
+int	Bputrune(Biobuf*, long);
+void*	Brdline(Biobuf*, int);
+char*	Brdstr(Biobuf*, int, int);
+long	Bread(Biobuf*, void*, long);
+vlong	Bseek(Biobuf*, vlong, int);
+int	Bterm(Biobuf*);
+int	Bungetc(Biobuf*);
+int	Bungetrune(Biobuf*);
+long	Bwrite(Biobuf*, void*, long);
+
+#pragma	varargck	argpos	Bprint	2
--- /dev/null
+++ b/include/cursor.h
@@ -1,0 +1,19 @@
+/*
+ * This is a separate file because image.h cannot be
+ * included in many of the graphics drivers due to
+ * name conflicts
+ */
+
+typedef struct Drawcursor Drawcursor;
+struct Drawcursor
+{
+	int	hotx;
+	int	hoty;
+	int	minx;
+	int	miny;
+	int	maxx;
+	int	maxy;
+	uchar*	data;
+};
+
+void	drawcursor(Drawcursor*);
--- /dev/null
+++ b/include/draw.h
@@ -1,0 +1,552 @@
+#pragma src "/usr/inferno/libdraw"
+
+#pragma	varargck	argpos	_drawprint	2
+
+typedef struct	Cachefont Cachefont;
+typedef struct	Cacheinfo Cacheinfo;
+typedef struct	Cachesubf Cachesubf;
+typedef struct	Display Display;
+typedef struct	Font Font;
+typedef struct	Fontchar Fontchar;
+typedef struct	Image Image;
+typedef struct	Mouse Mouse;
+typedef struct	Point Point;
+typedef struct	Rectangle Rectangle;
+typedef struct	RGB RGB;
+typedef struct	Refreshq Refreshq;
+typedef struct	Screen Screen;
+typedef struct	Subfont Subfont;
+
+#pragma varargck	type	"R"	Rectangle
+#pragma varargck	type	"P"	Point
+extern	int	Rfmt(Fmt*);
+extern	int	Pfmt(Fmt*);
+
+enum
+{
+	DOpaque		= 0xFFFFFFFF,
+	DTransparent	= 0x00000000,		/* only useful for allocimage, memfillcolor */
+	DBlack		= 0x000000FF,
+	DWhite		= 0xFFFFFFFF,
+	DRed		= 0xFF0000FF,
+	DGreen		= 0x00FF00FF,
+	DBlue		= 0x0000FFFF,
+	DCyan		= 0x00FFFFFF,
+	DMagenta		= 0xFF00FFFF,
+	DYellow		= 0xFFFF00FF,
+	DPaleyellow	= 0xFFFFAAFF,
+	DDarkyellow	= 0xEEEE9EFF,
+	DDarkgreen	= 0x448844FF,
+	DPalegreen	= 0xAAFFAAFF,
+	DMedgreen	= 0x88CC88FF,
+	DDarkblue	= 0x000055FF,
+	DPalebluegreen= 0xAAFFFFFF,
+	DPaleblue		= 0x0000BBFF,
+	DBluegreen	= 0x008888FF,
+	DGreygreen	= 0x55AAAAFF,
+	DPalegreygreen	= 0x9EEEEEFF,
+	DYellowgreen	= 0x99994CFF,
+	DMedblue		= 0x000099FF,
+	DGreyblue	= 0x005DBBFF,
+	DPalegreyblue	= 0x4993DDFF,
+	DPurpleblue	= 0x8888CCFF,
+
+	DNotacolor	= 0xFFFFFF00,
+	DNofill		= DNotacolor,
+	
+};
+
+enum
+{
+	Displaybufsize	= 8000,
+	ICOSSCALE	= 1024,
+	Borderwidth =	4,
+};
+
+enum
+{
+	/* refresh methods */
+	Refbackup	= 0,
+	Refnone		= 1,
+	Refmesg		= 2
+};
+#define	NOREFRESH	((void*)-1)
+
+enum
+{
+	/* line ends */
+	Endsquare	= 0,
+	Enddisc		= 1,
+	Endarrow	= 2,
+	Endmask		= 0x1F
+};
+
+#define	ARROW(a, b, c)	(Endarrow|((a)<<5)|((b)<<14)|((c)<<23))
+
+/*
+ * image channel descriptors 
+ */
+enum {
+	CRed = 0,
+	CGreen,
+	CBlue,
+	CGrey,
+	CAlpha,
+	CMap,
+	CIgnore,
+	NChan,
+};
+
+#define __DC(type, nbits)	((((type)&15)<<4)|((nbits)&15))
+#define CHAN1(a,b)	__DC(a,b)
+#define CHAN2(a,b,c,d)	(CHAN1((a),(b))<<8|__DC((c),(d)))
+#define CHAN3(a,b,c,d,e,f)	(CHAN2((a),(b),(c),(d))<<8|__DC((e),(f)))
+#define CHAN4(a,b,c,d,e,f,g,h)	(CHAN3((a),(b),(c),(d),(e),(f))<<8|__DC((g),(h)))
+
+#define NBITS(c) ((c)&15)
+#define TYPE(c) (((c)>>4)&15)
+
+enum {
+	GREY1	= CHAN1(CGrey, 1),
+	GREY2	= CHAN1(CGrey, 2),
+	GREY4	= CHAN1(CGrey, 4),
+	GREY8	= CHAN1(CGrey, 8),
+	CMAP8	= CHAN1(CMap, 8),
+	RGB15	= CHAN4(CIgnore, 1, CRed, 5, CGreen, 5, CBlue, 5),
+	RGB16	= CHAN3(CRed, 5, CGreen, 6, CBlue, 5),
+	RGB24	= CHAN3(CRed, 8, CGreen, 8, CBlue, 8),
+	RGBA32	= CHAN4(CRed, 8, CGreen, 8, CBlue, 8, CAlpha, 8),
+	ARGB32	= CHAN4(CAlpha, 8, CRed, 8, CGreen, 8, CBlue, 8),	/* stupid VGAs */
+	XRGB32  = CHAN4(CIgnore, 8, CRed, 8, CGreen, 8, CBlue, 8),
+	BGR24	= CHAN3(CBlue, 8, CGreen, 8, CRed, 8),
+	ABGR32	= CHAN4(CAlpha, 8, CBlue, 8, CGreen, 8, CRed, 8),
+	XBGR32	= CHAN4(CIgnore, 8, CBlue, 8, CGreen, 8, CRed, 8),
+};
+
+/* compositing operators */
+
+typedef enum
+{
+	SinD		= 1<<3,
+	DinS		= 1<<2,
+	SoutD	= 1<<1,
+	DoutS	= 1 <<0,
+
+	S		= SinD|SoutD,
+	SoverD	= SinD|SoutD|DoutS,
+	SatopD	= SinD|DoutS,
+	SxorD	= SoutD|DoutS,
+
+	D		= DinS|DoutS,
+	DoverS	= DinS|DoutS|SoutD,
+	DatopS	= DinS|SoutD,
+	DxorS	= DoutS|SoutD,
+
+	Clear	= 0,
+
+	Ncomp	= 12,
+} Drawop;
+
+extern	char*	chantostr(char*, ulong);
+extern	ulong	strtochan(char*);
+extern	int		chantodepth(ulong);
+
+struct	Point
+{
+	int	x;
+	int	y;
+};
+
+struct Rectangle
+{
+	Point	min;
+	Point	max;
+};
+
+typedef void	(*Reffn)(Image*, Rectangle, void*);
+
+struct Screen
+{
+	Display	*display;	/* display holding data */
+	int	id;		/* id of system-held Screen */
+	Image	*image;		/* unused; for reference only */
+	Image	*fill;		/* color to paint behind windows */
+};
+
+struct Refreshq
+{
+	Reffn		reffn;
+	void		*refptr;
+	Rectangle	r;
+	Refreshq	*next;
+};
+
+struct Display
+{
+	void*	qlock;
+	int		locking;	/*program is using lockdisplay */
+	int		dirno;
+	void	*datachan;
+	void	*refchan;
+	void	*ctlchan;
+	int		imageid;
+	int		local;
+	int		depth;
+	ulong	chan;
+	void		(*error)(Display*, char*);
+	char		*devdir;
+	char		*windir;
+	char		oldlabel[64];
+	ulong		dataqid;
+	Image		*white;
+	Image		*black;
+	Image		*image;
+	Image		*opaque;
+	Image		*transparent;
+	uchar		buf[Displaybufsize+1];	/* +1 for flush message */
+	int			bufsize;
+	uchar		*bufp;
+	Font		*defaultfont;
+	Subfont		*defaultsubfont;
+	Image		*windows;
+	void		*limbo;
+	Refreshq	*refhead;
+	Refreshq	*reftail;
+};
+
+struct Image
+{
+	Display		*display;	/* display holding data */
+	int		id;		/* id of system-held Image */
+	Rectangle	r;		/* rectangle in data area, local coords */
+	Rectangle 	clipr;		/* clipping region */
+	int		depth;		/* number of bits per pixel */
+	ulong	chan;
+	int		repl;		/* flag: data replicates to tile clipr */
+	Screen		*screen;	/* 0 if not a window */
+	Image		*next;	/* next in list of windows */
+	Reffn		reffn;
+	void		*refptr;
+};
+
+struct RGB
+{
+	ulong	red;
+	ulong	green;
+	ulong	blue;
+};
+
+/*
+ * Subfonts
+ *
+ * given char c, Subfont *f, Fontchar *i, and Point p, one says
+ *	i = f->info+c;
+ *	draw(b, Rect(p.x+i->left, p.y+i->top,
+ *		p.x+i->left+((i+1)->x-i->x), p.y+i->bottom),
+ *		color, f->bits, Pt(i->x, i->top));
+ *	p.x += i->width;
+ * to draw characters in the specified color (itself an Image) in Image b.
+ */
+
+struct	Fontchar
+{
+	int		x;		/* left edge of bits */
+	uchar		top;		/* first non-zero scan-line */
+	uchar		bottom;		/* last non-zero scan-line + 1 */
+	char		left;		/* offset of baseline */
+	uchar		width;		/* width of baseline */
+};
+
+struct	Subfont
+{
+	char		*name;
+	short		n;		/* number of chars in font */
+	uchar		height;		/* height of image */
+	char		ascent;		/* top of image to baseline */
+	Fontchar 	*info;		/* n+1 character descriptors */
+	Image		*bits;		/* of font */
+	int		ref;
+};
+
+enum
+{
+	/* starting values */
+	LOG2NFCACHE =	6,
+	NFCACHE =	(1<<LOG2NFCACHE),	/* #chars cached */
+	NFLOOK =	5,			/* #chars to scan in cache */
+	NFSUBF =	2,			/* #subfonts to cache */
+	/* max value */
+	MAXFCACHE =	1024+NFLOOK,		/* upper limit */
+	MAXSUBF =	50,			/* generous upper limit */
+	/* deltas */
+	DSUBF = 	4,
+	/* expiry ages */
+	SUBFAGE	=	10000,
+	CACHEAGE =	10000
+};
+
+struct Cachefont
+{
+	Rune		min;	/* lowest rune value to be taken from subfont */
+	Rune		max;	/* highest rune value+1 to be taken from subfont */
+	int		offset;	/* position in subfont of character at min */
+	char		*name;			/* stored in font */
+	char		*subfontname;		/* to access subfont */
+};
+
+struct Cacheinfo
+{
+	ushort		x;		/* left edge of bits */
+	uchar		width;		/* width of baseline */
+	schar		left;		/* offset of baseline */
+	Rune		value;	/* value of character at this slot in cache */
+	ushort		age;
+};
+
+struct Cachesubf
+{
+	ulong		age;	/* for replacement */
+	Cachefont	*cf;	/* font info that owns us */
+	Subfont		*f;	/* attached subfont */
+};
+
+struct Font
+{
+	char		*name;
+	Display		*display;
+	short		height;	/* max height of image, interline spacing */
+	short		ascent;	/* top of image to baseline */
+	short		width;	/* widest so far; used in caching only */	
+	short		nsub;	/* number of subfonts */
+	ulong		age;	/* increasing counter; used for LRU */
+	int		maxdepth;	/* maximum depth of all loaded subfonts */
+	int		ncache;	/* size of cache */
+	int		nsubf;	/* size of subfont list */
+	Cacheinfo	*cache;
+	Cachesubf	*subf;
+	Cachefont	**sub;	/* as read from file */
+	Image		*cacheimage;
+};
+
+#define	Dx(r)	((r).max.x-(r).min.x)
+#define	Dy(r)	((r).max.y-(r).min.y)
+
+/*
+ * Image management
+ */
+extern Image*	_allocimage(Image*, Display*, Rectangle, ulong, int, ulong, int, int);
+extern Image*	allocimage(Display*, Rectangle, ulong, int, ulong);
+extern uchar*	bufimage(Display*, int);
+extern int	bytesperline(Rectangle, int);
+extern void	closedisplay(Display*);
+extern void	drawerror(Display*, char*);
+extern int	_drawprint(int, char*, ...);
+extern int	flushimage(Display*, int);
+extern int	freeimage(Image*);
+extern int	_freeimage1(Image*);
+extern int	geninitdraw(char*, void(*)(Display*, char*), char*, char*, char*, int);
+extern int	initdraw(void(*)(Display*, char*), char*, char*);
+extern Display*	initdisplay(char*, char*, void(*)(Display*, char*));
+extern int	loadimage(Image*, Rectangle, uchar*, int);
+extern int	cloadimage(Image*, Rectangle, uchar*, int);
+extern int	getwindow(Display*, int);
+extern int	gengetwindow(Display*, char*, Image**, Screen**, int);
+extern Image* readimage(Display*, int, int);
+extern Image* creadimage(Display*, int, int);
+extern int	unloadimage(Image*, Rectangle, uchar*, int);
+extern int	wordsperline(Rectangle, int);
+extern int	writeimage(int, Image*, int);
+extern Image*	namedimage(Display*, char*);
+extern int	nameimage(Image*, char*, int);
+extern Image* allocimagemix(Display*, ulong, ulong);
+
+/*
+ * Colors
+ */
+extern	void	readcolmap(Display*, RGB*);
+extern	void	writecolmap(Display*, RGB*);
+extern	ulong	setalpha(ulong, uchar);
+
+/*
+ * Windows
+ */
+extern Screen*	allocscreen(Image*, Image*, int);
+extern Image*	_allocwindow(Image*, Screen*, Rectangle, int, ulong);
+extern Image*	allocwindow(Screen*, Rectangle, int, ulong);
+extern void	bottomnwindows(Image**, int);
+extern void	bottomwindow(Image*);
+extern int	freescreen(Screen*);
+extern Screen*	publicscreen(Display*, int, ulong);
+extern void	topnwindows(Image**, int);
+extern void	topwindow(Image*);
+extern int	originwindow(Image*, Point, Point);
+
+/*
+ * Geometry
+ */
+extern Point		Pt(int, int);
+extern Rectangle	Rect(int, int, int, int);
+extern Rectangle	Rpt(Point, Point);
+extern Point		addpt(Point, Point);
+extern Point		subpt(Point, Point);
+extern Point		divpt(Point, int);
+extern Point		mulpt(Point, int);
+extern int		eqpt(Point, Point);
+extern int		eqrect(Rectangle, Rectangle);
+extern Rectangle	insetrect(Rectangle, int);
+extern Rectangle	rectaddpt(Rectangle, Point);
+extern Rectangle	rectsubpt(Rectangle, Point);
+extern Rectangle	canonrect(Rectangle);
+extern int		rectXrect(Rectangle, Rectangle);
+extern int		rectinrect(Rectangle, Rectangle);
+extern void		combinerect(Rectangle*, Rectangle);
+extern int		rectclip(Rectangle*, Rectangle);
+extern int		ptinrect(Point, Rectangle);
+extern void		replclipr(Image*, int, Rectangle);
+extern int		drawreplxy(int, int, int);	/* used to be drawsetxy */
+extern Point	drawrepl(Rectangle, Point);
+extern int		rgb2cmap(int, int, int);
+extern int		cmap2rgb(int);
+extern int		cmap2rgba(int);
+extern void		icossin(int, int*, int*);
+extern void		icossin2(int, int, int*, int*);
+
+/*
+ * Graphics
+ */
+extern void	draw(Image*, Rectangle, Image*, Image*, Point);
+extern void	drawop(Image*, Rectangle, Image*, Image*, Point, Drawop);
+extern void	gendraw(Image*, Rectangle, Image*, Point, Image*, Point);
+extern void	gendrawop(Image*, Rectangle, Image*, Point, Image*, Point, Drawop);
+extern void	line(Image*, Point, Point, int, int, int, Image*, Point);
+extern void	lineop(Image*, Point, Point, int, int, int, Image*, Point, Drawop);
+extern void	poly(Image*, Point*, int, int, int, int, Image*, Point);
+extern void	polyop(Image*, Point*, int, int, int, int, Image*, Point, Drawop);
+extern void	fillpoly(Image*, Point*, int, int, Image*, Point);
+extern void	fillpolyop(Image*, Point*, int, int, Image*, Point, Drawop);
+extern Point	string(Image*, Point, Image*, Point, Font*, char*);
+extern Point	stringop(Image*, Point, Image*, Point, Font*, char*, Drawop);
+extern Point	stringn(Image*, Point, Image*, Point, Font*, char*, int);
+extern Point	stringnop(Image*, Point, Image*, Point, Font*, char*, int, Drawop);
+extern Point	runestring(Image*, Point, Image*, Point, Font*, Rune*);
+extern Point	runestringop(Image*, Point, Image*, Point, Font*, Rune*, Drawop);
+extern Point	runestringn(Image*, Point, Image*, Point, Font*, Rune*, int);
+extern Point	runestringnop(Image*, Point, Image*, Point, Font*, Rune*, int, Drawop);
+extern Point	stringbg(Image*, Point, Image*, Point, Font*, char*, Image*, Point);
+extern Point	stringbgop(Image*, Point, Image*, Point, Font*, char*, Image*, Point, Drawop);
+extern Point	stringnbg(Image*, Point, Image*, Point, Font*, char*, int, Image*, Point);
+extern Point	stringnbgop(Image*, Point, Image*, Point, Font*, char*, int, Image*, Point, Drawop);
+extern Point	runestringbg(Image*, Point, Image*, Point, Font*, Rune*, Image*, Point);
+extern Point	runestringbgop(Image*, Point, Image*, Point, Font*, Rune*, Image*, Point, Drawop);
+extern Point	runestringnbg(Image*, Point, Image*, Point, Font*, Rune*, int, Image*, Point);
+extern Point	runestringnbgop(Image*, Point, Image*, Point, Font*, Rune*, int, Image*, Point, Drawop);
+extern Point	_string(Image*, Point, Image*, Point, Font*, char*, Rune*, int, Rectangle, Image*, Point, Drawop);
+extern Point	stringsubfont(Image*, Point, Image*, Subfont*, char*);
+extern int		bezier(Image*, Point, Point, Point, Point, int, int, int, Image*, Point);
+extern int		bezierop(Image*, Point, Point, Point, Point, int, int, int, Image*, Point, Drawop);
+extern int		bezspline(Image*, Point*, int, int, int, int, Image*, Point);
+extern int		bezsplineop(Image*, Point*, int, int, int, int, Image*, Point, Drawop);
+extern int		getbezsplinepts(Point*, int, Point**);
+extern int		fillbezier(Image*, Point, Point, Point, Point, int, Image*, Point);
+extern int		fillbezierop(Image*, Point, Point, Point, Point, int, Image*, Point, Drawop);
+extern int		fillbezspline(Image*, Point*, int, int, Image*, Point);
+extern int		fillbezsplineop(Image*, Point*, int, int, Image*, Point, Drawop);
+extern void	ellipse(Image*, Point, int, int, int, Image*, Point);
+extern void	ellipseop(Image*, Point, int, int, int, Image*, Point, Drawop);
+extern void	fillellipse(Image*, Point, int, int, Image*, Point);
+extern void	fillellipseop(Image*, Point, int, int, Image*, Point, Drawop);
+extern void	arc(Image*, Point, int, int, int, Image*, Point, int, int);
+extern void	arcop(Image*, Point, int, int, int, Image*, Point, int, int, Drawop);
+extern void	fillarc(Image*, Point, int, int, Image*, Point, int, int);
+extern void	fillarcop(Image*, Point, int, int, Image*, Point, int, int, Drawop);
+extern void	border(Image*, Rectangle, int, Image*, Point);
+extern void	borderop(Image*, Rectangle, int, Image*, Point, Drawop);
+
+/*
+ * Font management
+ */
+extern Font*	openfont(Display*, char*);
+extern Font*	buildfont(Display*, char*, char*);
+extern void	freefont(Font*);
+extern Font*	mkfont(Subfont*, Rune);
+extern int	cachechars(Font*, char**, Rune**, ushort*, int, int*, char**);
+extern void	agefont(Font*);
+extern Subfont*	allocsubfont(char*, int, int, int, Fontchar*, Image*);
+extern Subfont*	lookupsubfont(Display*, char*);
+extern void	installsubfont(char*, Subfont*);
+extern void	uninstallsubfont(Subfont*);
+extern void	freesubfont(Subfont*);
+extern Subfont*	readsubfont(Display*, char*, int, int);
+extern Subfont*	readsubfonti(Display*, char*, int, Image*, int);
+extern int	writesubfont(int, Subfont*);
+extern void	_unpackinfo(Fontchar*, uchar*, int);
+extern Point	stringsize(Font*, char*);
+extern int	stringwidth(Font*, char*);
+extern int	stringnwidth(Font*, char*, int);
+extern Point	runestringsize(Font*, Rune*);
+extern int	runestringwidth(Font*, Rune*);
+extern int	runestringnwidth(Font*, Rune*, int);
+extern Point	strsubfontwidth(Subfont*, char*);
+extern int	loadchar(Font*, Rune, Cacheinfo*, int, int, char**);
+extern char*	subfontname(char*, char*, int);
+extern Subfont*	_getsubfont(Display*, char*);
+extern Subfont*	getdefont(Display*);
+extern int		lockdisplay(Display*);
+extern void	unlockdisplay(Display*);
+extern int		drawlsetrefresh(ulong, int, void*, void*);
+
+/* Compositing operator utility */
+extern void	_setdrawop(Display*, Drawop);
+
+/*
+ * Predefined 
+ */
+extern	uchar	defontdata[];
+extern	int		sizeofdefont;
+extern	Point		ZP;
+extern	Rectangle	ZR;
+
+/*
+ * Set up by initdraw()
+ */
+extern	int	_cursorfd;
+extern	int	_drawdebug;	/* set to 1 to see errors from flushimage */
+
+#define	BGSHORT(p)		(((p)[0]<<0) | ((p)[1]<<8))
+#define	BGLONG(p)		((BGSHORT(p)<<0) | (BGSHORT(p+2)<<16))
+#define	BPSHORT(p, v)		((p)[0]=(v), (p)[1]=((v)>>8))
+#define	BPLONG(p, v)		(BPSHORT(p, (v)), BPSHORT(p+2, (v)>>16))
+
+/*
+ * Compressed image file parameters
+ */
+#define	NMATCH	3		/* shortest match possible */
+#define	NRUN	(NMATCH+31)	/* longest match possible */
+#define	NMEM	1024		/* window size */
+#define	NDUMP	128		/* maximum length of dump */
+#define	NCBLOCK	6000		/* size of compressed blocks */
+extern	void	_twiddlecompressed(uchar*, int);
+extern	int	_compblocksize(Rectangle, int);
+
+/* XXX backwards helps; should go */
+extern	ulong	drawld2chan[];
+extern	void		drawsetdebug(int);
+
+/*
+ * Inferno interface
+ */
+extern	Font*	font_open(Display*, char*);
+extern	void	font_close(Font*);
+
+/*
+ * Macros to convert between C and Limbo types
+ */
+#define	IRECT(r)	(*(Rectangle*)&(r))
+#define	DRECT(r)	(*(Draw_Rect*)&(r))
+#define	IPOINT(p)	(*(Point*)&(p))
+#define	DPOINT(p)	(*(Draw_Point*)&(p))
+
+#define P2P(p1, p2)	(p1).x = (p2).x, (p1).y = (p2).y
+#define R2R(r1, r2)	(r1).min.x = (r2).min.x, (r1).min.y = (r2).min.y,\
+			(r1).max.x = (r2).max.x, (r1).max.y = (r2).max.y
+extern Image*	display_open(Display*, char*);
--- /dev/null
+++ b/include/drawif.h
@@ -1,0 +1,12 @@
+extern Font*		checkfont(Draw_Font*);
+extern Image*		checkimage(Draw_Image*);
+extern Screen*		checkscreen(Draw_Screen*);
+extern Display*		checkdisplay(Draw_Display*);
+extern void		freedrawdisplay(Heap*, int);
+extern void		freedrawfont(Heap*, int);
+extern void		freedrawimage(Heap*, int);
+extern void		freedrawscreen(Heap*, int);
+extern Font*		lookupfont(Draw_Font*);
+extern Image*		lookupimage(Draw_Image*);
+extern Screen*		lookupscreen(Draw_Screen*);
+extern Draw_Image*	mkdrawimage(Image*, Draw_Screen*, Draw_Display*, void*);
--- /dev/null
+++ b/include/dynld.h
@@ -1,0 +1,44 @@
+/* uncomment these lines when installed in /sys/include */
+/*
+#pragma src "/sys/src/libdynld"
+#pragma	lib	"libdynld.a"
+*/
+
+typedef struct Dynobj Dynobj;
+typedef struct Dynsym Dynsym;
+
+struct Dynobj
+{
+	ulong	size;		/* total size in bytes */
+	ulong	text;		/* bytes of text */
+	ulong	data;		/* bytes of data */
+	ulong	bss;		/* bytes of bss */
+	uchar*	base;	/* start of text, data, bss */
+	int	nexport;
+	Dynsym*	export;	/* export table */
+	int	nimport;
+	Dynsym**	import;	/* import table */
+};
+
+/*
+ * this structure is known to the linkers
+ */
+struct Dynsym
+{
+	ulong	sig;
+	ulong	addr;
+	char	*name;
+};
+
+extern Dynsym*	dynfindsym(char*, Dynsym*, int);
+extern void	dynfreeimport(Dynobj*);
+extern void*	dynimport(Dynobj*, char*, ulong);
+extern int	dynloadable(void*, long (*r)(void*,void*,long), vlong(*sk)(void*,vlong,int));
+extern Dynobj*	dynloadfd(int, Dynsym*, int, ulong);
+extern Dynobj*	dynloadgen(void*, long (*r)(void*,void*,long), vlong (*s)(void*,vlong,int), void (*e)(char*), Dynsym*, int, ulong);
+extern long	dynmagic(void);
+extern void	dynobjfree(Dynobj*);
+extern char*	dynreloc(uchar*, ulong, int, Dynsym**, int);
+extern int	dyntabsize(Dynsym*);
+
+extern Dynsym	_exporttab[];	/* created by linker -x (when desired) */
--- /dev/null
+++ b/include/fcall.h
@@ -1,0 +1,140 @@
+#pragma src "/usr/inferno/lib9"
+#pragma	lib	"libc.a"
+
+#define	VERSION9P	"9P2000"
+
+#define	MAXWELEM	16
+
+typedef
+struct	Fcall
+{
+	uchar	type;
+	u32int	fid;
+	ushort	tag;
+	/* union { */
+		/* struct { */
+			u32int	msize;		/* Tversion, Rversion */
+			char	*version;	/* Tversion, Rversion */
+		/* }; */
+		/* struct { */
+			ushort	oldtag;		/* Tflush */
+		/* }; */
+		/* struct { */
+			char	*ename;		/* Rerror */
+		/* }; */
+		/* struct { */
+			Qid	qid;		/* Rattach, Ropen, Rcreate */
+			u32int	iounit;		/* Ropen, Rcreate */
+		/* }; */
+		/* struct { */
+			Qid	aqid;		/* Rauth */
+		/* }; */
+		/* struct { */
+			u32int	afid;		/* Tauth, Tattach */
+			char	*uname;		/* Tauth, Tattach */
+			char	*aname;		/* Tauth, Tattach */
+		/* }; */
+		/* struct { */
+			u32int	perm;		/* Tcreate */ 
+			char	*name;		/* Tcreate */
+			uchar	mode;		/* Tcreate, Topen */
+		/* }; */
+		/* struct { */
+			u32int	newfid;		/* Twalk */
+			ushort	nwname;		/* Twalk */
+			char	*wname[MAXWELEM];	/* Twalk */
+		/* }; */
+		/* struct { */
+			ushort	nwqid;		/* Rwalk */
+			Qid	wqid[MAXWELEM];		/* Rwalk */
+		/* }; */
+		/* struct { */
+			vlong	offset;		/* Tread, Twrite */
+			u32int	count;		/* Tread, Twrite, Rread */
+			char	*data;		/* Twrite, Rread */
+		/* }; */
+		/* struct { */
+			ushort	nstat;		/* Twstat, Rstat */
+			uchar	*stat;		/* Twstat, Rstat */
+		/* }; */
+	/* }; */
+} Fcall;
+
+
+#define	GBIT8(p)	((p)[0])
+#define	GBIT16(p)	((p)[0]|((p)[1]<<8))
+#define	GBIT32(p)	((u32int)((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24)))
+#define	GBIT64(p)	((u32int)((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24)) |\
+				((vlong)((p)[4]|((p)[5]<<8)|((p)[6]<<16)|((p)[7]<<24)) << 32))
+
+#define	PBIT8(p,v)	(p)[0]=(v)
+#define	PBIT16(p,v)	(p)[0]=(v);(p)[1]=(v)>>8
+#define	PBIT32(p,v)	(p)[0]=(v);(p)[1]=(v)>>8;(p)[2]=(v)>>16;(p)[3]=(v)>>24
+#define	PBIT64(p,v)	(p)[0]=(v);(p)[1]=(v)>>8;(p)[2]=(v)>>16;(p)[3]=(v)>>24;\
+			(p)[4]=(v)>>32;(p)[5]=(v)>>40;(p)[6]=(v)>>48;(p)[7]=(v)>>56
+
+#define	BIT8SZ		1
+#define	BIT16SZ		2
+#define	BIT32SZ		4
+#define	BIT64SZ		8
+#define	QIDSZ	(BIT8SZ+BIT32SZ+BIT64SZ)
+
+/* STATFIXLEN includes leading 16-bit count */
+/* The count, however, excludes itself; total size is BIT16SZ+count */
+#define STATFIXLEN	(BIT16SZ+QIDSZ+5*BIT16SZ+4*BIT32SZ+1*BIT64SZ)	/* amount of fixed length data in a stat buffer */
+
+#define	NOTAG		(ushort)~0U	/* Dummy tag */
+#define	NOFID		(u32int)~0U	/* Dummy fid */
+#define	IOHDRSZ		24	/* ample room for Twrite/Rread header (iounit) */
+
+enum
+{
+	Tversion =	100,
+	Rversion,
+	Tauth =	102,
+	Rauth,
+	Tattach =	104,
+	Rattach,
+	Terror =	106,	/* illegal */
+	Rerror,
+	Tflush =	108,
+	Rflush,
+	Twalk =		110,
+	Rwalk,
+	Topen =		112,
+	Ropen,
+	Tcreate =	114,
+	Rcreate,
+	Tread =		116,
+	Rread,
+	Twrite =	118,
+	Rwrite,
+	Tclunk =	120,
+	Rclunk,
+	Tremove =	122,
+	Rremove,
+	Tstat =		124,
+	Rstat,
+	Twstat =	126,
+	Rwstat,
+	Tmax,
+};
+
+uint	convM2S(uchar*, uint, Fcall*);
+uint	convS2M(Fcall*, uchar*, uint);
+uint	sizeS2M(Fcall*);
+
+int	statcheck(uchar *abuf, uint nbuf);
+uint	convM2D(uchar*, uint, Dir*, char*);
+uint	convD2M(Dir*, uchar*, uint);
+uint	sizeD2M(Dir*);
+
+int	fcallfmt(Fmt*);
+int	dirfmt(Fmt*);
+int	dirmodefmt(Fmt*);
+
+int	read9pmsg(int, void*, uint);
+
+#pragma	varargck	type	"F"	Fcall*
+#pragma	varargck	type	"M"	ulong
+#pragma	varargck	type	"D"	Dir*
--- /dev/null
+++ b/include/flate.h
@@ -1,0 +1,36 @@
+/*
+ * errors from deflate, deflateinit, deflateblock,
+ * inflate, inflateinit, inflateblock.
+ * convertable to a string by flateerr
+ */
+enum
+{
+	FlateOk			= 0,
+	FlateNoMem		= -1,
+	FlateInputFail		= -2,
+	FlateOutputFail		= -3,
+	FlateCorrupted		= -4,
+	FlateInternal		= -5,
+};
+
+int	deflateinit(void);
+int	deflate(void *wr, int (*w)(void*, void*, int), void *rr, int (*r)(void*, void*, int), int level, int debug);
+
+int	inflateinit(void);
+int	inflate(void *wr, int (*w)(void*, void*, int), void *getr, int (*get)(void*));
+
+int	inflateblock(uchar *dst, int dsize, uchar *src, int ssize);
+int	deflateblock(uchar *dst, int dsize, uchar *src, int ssize, int level, int debug);
+
+int	deflatezlib(void *wr, int (*w)(void*, void*, int), void *rr, int (*r)(void*, void*, int), int level, int debug);
+int	inflatezlib(void *wr, int (*w)(void*, void*, int), void *getr, int (*get)(void*));
+
+int	inflatezlibblock(uchar *dst, int dsize, uchar *src, int ssize);
+int	deflatezlibblock(uchar *dst, int dsize, uchar *src, int ssize, int level, int debug);
+
+char	*flateerr(int err);
+
+ulong	*mkcrctab(ulong);
+ulong	blockcrc(ulong *tab, ulong crc, void *buf, int n);
+
+ulong	adler32(ulong adler, void *buf, int n);
--- /dev/null
+++ b/include/freetype.h
@@ -1,0 +1,55 @@
+/*
+ * interface to libfreetype without recourse to the real freetype headers
+ * which would otherwise require full-blown CPP
+ */
+
+typedef struct FTfaceinfo FTfaceinfo;
+struct FTfaceinfo {
+	int	nfaces;
+	int	index;
+	int	style;
+	int	height;
+	int	ascent;
+	char*	familyname;
+	char*	stylename;
+};
+
+typedef struct FTface FTface;
+struct FTface {
+	void*	ft_lib;
+	void*	ft_face;
+};
+
+typedef struct FTglyph FTglyph;
+struct FTglyph {
+	int	top;
+	int	left;
+	int	advx;
+	int	advy;
+	int	height;
+	int	width;
+	int	bpr;
+	uchar*	bitmap;
+};
+
+typedef struct FTmatrix FTmatrix;
+struct FTmatrix {
+	int	a;
+	int	b;
+	int	c;
+	int	d;
+};
+
+typedef struct FTvector FTvector;
+struct FTvector {
+	int	dx;
+	int	dy;
+};
+
+extern	char*	ftnewface(char *, int, FTface*, FTfaceinfo*);
+extern	char*	ftloadmemface(void*, int, int, FTface*, FTfaceinfo*);
+extern	char*	ftsetcharsize(FTface, int, int, int, FTfaceinfo*);
+extern	void		ftsettransform(FTface, FTmatrix*, FTvector*);
+extern	int		fthaschar(FTface,int);
+extern	char*	ftloadglyph(FTface, int, FTglyph*);
+extern	void		ftdoneface(FTface);
--- /dev/null
+++ b/include/freetype/cache/ftccache.h
@@ -1,0 +1,304 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftccache.h                                                             */
+/*                                                                         */
+/*    FreeType internal cache interface (specification).                   */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTCCACHE_H__
+#define __FTCCACHE_H__
+
+
+/* define to allow cache lookup inlining */
+#define  FTC_CACHE_USE_INLINE
+
+
+FT_BEGIN_HEADER
+
+  /* handle to cache object */
+  typedef struct FTC_CacheRec_*  FTC_Cache;
+
+  /* handle to cache class */
+  typedef const struct FTC_Cache_ClassRec_*  FTC_Cache_Class;
+
+  /* handle to cache node family */
+  typedef struct FTC_FamilyRec_*  FTC_Family;
+
+  /* handle to cache root query */
+  typedef struct FTC_QueryRec_*  FTC_Query;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                   CACHE NODE DEFINITIONS                      *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Each cache controls one or more cache nodes.  Each node is part of    */
+  /* the global_lru list of the manager.  Its `data' field however is used */
+  /* as a reference count for now.                                         */
+  /*                                                                       */
+  /* A node can be anything, depending on the type of information held by  */
+  /* the cache.  It can be an individual glyph image, a set of bitmaps     */
+  /* glyphs for a given size, some metrics, etc.                           */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /* structure size should be 20 bytes on 32-bits machines */
+  typedef struct  FTC_NodeRec_
+  {
+    FTC_Node   mru_next;     /* circular mru list pointer           */
+    FTC_Node   mru_prev;     /* circular mru list pointer           */
+    FTC_Node   link;         /* used for hashing                    */
+    FT_UInt32  hash;         /* used for hashing too                */
+    FT_UShort  fam_index;    /* index of family the node belongs to */
+    FT_Short   ref_count;    /* reference count for this node       */
+
+  } FTC_NodeRec;
+
+
+#define FTC_NODE( x )    ( (FTC_Node)(x) )
+#define FTC_NODE_P( x )  ( (FTC_Node*)(x) )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* These functions are exported so that they can be called from          */
+  /* user-provided cache classes; otherwise, they are really part of the   */
+  /* cache sub-system internals.                                           */
+  /*                                                                       */
+
+  /* can be used as a FTC_Node_DoneFunc */
+  FT_EXPORT( void )
+  ftc_node_done( FTC_Node   node,
+                 FTC_Cache  cache );
+
+  /* reserved for manager's use */
+  FT_EXPORT( void )
+  ftc_node_destroy( FTC_Node     node,
+                    FTC_Manager  manager );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                   CACHE QUERY DEFINITIONS                     *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* A structure modelling a cache node query.  The following fields must  */
+  /* all be set by the @FTC_Family_CompareFunc method of a cache's family  */
+  /* list.                                                                 */
+  /*                                                                       */
+  typedef struct  FTC_QueryRec_
+  {
+    FTC_Family  family;
+    FT_UFast    hash;
+
+  } FTC_QueryRec;
+
+
+#define FTC_QUERY( x )    ( (FTC_Query)(x) )
+#define FTC_QUERY_P( x )  ( (FTC_Query*)(x) )
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                   CACHE FAMILY DEFINITIONS                    *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef struct  FTC_FamilyRec_
+  {
+    FT_LruNodeRec  lru;
+    FTC_Cache      cache;
+    FT_UInt        num_nodes;
+    FT_UInt        fam_index;
+
+  } FTC_FamilyRec;
+
+
+#define FTC_FAMILY( x )    ( (FTC_Family)(x) )
+#define FTC_FAMILY_P( x )  ( (FTC_Family*)(x) )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* These functions are exported so that they can be called from          */
+  /* user-provided cache classes; otherwise, they are really part of the   */
+  /* cache sub-system internals.                                           */
+  /*                                                                       */
+
+  /* must be called by any FTC_Node_InitFunc routine */
+  FT_EXPORT( FT_Error )
+  ftc_family_init( FTC_Family  family,
+                   FTC_Query   query,
+                   FTC_Cache   cache );
+
+
+  /* can be used as a FTC_Family_DoneFunc; otherwise, must be called */
+  /* by any family finalizer function                                */
+  FT_EXPORT( void )
+  ftc_family_done( FTC_Family  family );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                       CACHE DEFINITIONS                       *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* each cache really implements a dynamic hash table to manage its nodes */
+  typedef struct  FTC_CacheRec_
+  {
+    FTC_Manager          manager;
+    FT_Memory            memory;
+    FTC_Cache_Class      clazz;
+
+    FT_UInt              cache_index;  /* in manager's table         */
+    FT_Pointer           cache_data;   /* used by cache node methods */
+
+    FT_UFast             p;
+    FT_UFast             mask;
+    FT_Long              slack;
+    FTC_Node*            buckets;
+
+    FT_LruList_ClassRec  family_class;
+    FT_LruList           families;
+
+  } FTC_CacheRec;
+
+
+#define FTC_CACHE( x )    ( (FTC_Cache)(x) )
+#define FTC_CACHE_P( x )  ( (FTC_Cache*)(x) )
+
+
+  /* initialize a given cache */
+  typedef FT_Error
+  (*FTC_Cache_InitFunc)( FTC_Cache  cache );
+
+  /* clear a cache */
+  typedef void
+  (*FTC_Cache_ClearFunc)( FTC_Cache  cache );
+
+  /* finalize a given cache */
+  typedef void
+  (*FTC_Cache_DoneFunc)( FTC_Cache  cache );
+
+
+  typedef FT_Error
+  (*FTC_Family_InitFunc)( FTC_Family  family,
+                          FTC_Query   query,
+                          FTC_Cache   cache );
+
+  typedef FT_Int
+  (*FTC_Family_CompareFunc)( FTC_Family  family,
+                             FTC_Query   query );
+
+  typedef void
+  (*FTC_Family_DoneFunc)( FTC_Family  family,
+                          FTC_Cache   cache );
+
+  /* initialize a new cache node */
+  typedef FT_Error
+  (*FTC_Node_InitFunc)( FTC_Node    node,
+                        FT_Pointer  type,
+                        FTC_Cache   cache );
+
+  /* compute the weight of a given cache node */
+  typedef FT_ULong
+  (*FTC_Node_WeightFunc)( FTC_Node   node,
+                          FTC_Cache  cache );
+
+  /* compare a node to a given key pair */
+  typedef FT_Bool
+  (*FTC_Node_CompareFunc)( FTC_Node    node,
+                           FT_Pointer  key,
+                           FTC_Cache   cache );
+
+  /* finalize a given cache node */
+  typedef void
+  (*FTC_Node_DoneFunc)( FTC_Node   node,
+                        FTC_Cache  cache );
+
+
+  typedef struct  FTC_Cache_ClassRec_
+  {
+    FT_UInt                 cache_size;
+    FTC_Cache_InitFunc      cache_init;
+    FTC_Cache_ClearFunc     cache_clear;
+    FTC_Cache_DoneFunc      cache_done;
+
+    FT_UInt                 family_size;
+    FTC_Family_InitFunc     family_init;
+    FTC_Family_CompareFunc  family_compare;
+    FTC_Family_DoneFunc     family_done;
+
+    FT_UInt                 node_size;
+    FTC_Node_InitFunc       node_init;
+    FTC_Node_WeightFunc     node_weight;
+    FTC_Node_CompareFunc    node_compare;
+    FTC_Node_DoneFunc       node_done;
+
+  } FTC_Cache_ClassRec;
+
+
+  /* */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* These functions are exported so that they can be called from          */
+  /* user-provided cache classes; otherwise, they are really part of the   */
+  /* cache sub-system internals.                                           */
+  /*                                                                       */
+
+  /* can be used directly as FTC_Cache_DoneFunc(), or called by custom */
+  /* cache finalizers                                                  */
+  FT_EXPORT( void )
+  ftc_cache_done( FTC_Cache  cache );
+
+  /* can be used directly as FTC_Cache_ClearFunc(), or called by custom */
+  /* cache clear routines                                               */
+  FT_EXPORT( void )
+  ftc_cache_clear( FTC_Cache  cache );
+
+  /* initalize the hash table within the cache */
+  FT_EXPORT( FT_Error )
+  ftc_cache_init( FTC_Cache  cache );
+
+  /* can be called when the key's hash value has been computed */
+  FT_EXPORT( FT_Error )
+  ftc_cache_lookup( FTC_Cache  cache,
+                    FTC_Query  query,
+                    FTC_Node  *anode );
+
+ /* */
+
+FT_END_HEADER
+
+
+#endif /* __FTCCACHE_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/cache/ftccmap.h
@@ -1,0 +1,216 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftccmap.h                                                              */
+/*                                                                         */
+/*    FreeType charmap cache (specification).                              */
+/*                                                                         */
+/*  Copyright 2000-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTCCMAP_H__
+#define __FTCCMAP_H__
+
+#include <ft2build.h>
+#include FT_CACHE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    cache_subsystem                                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @type:                                                                */
+  /*    FTC_CmapCache                                                      */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    An opaque handle used to manager a charmap cache.  This cache is   */
+  /*    to hold character codes -> glyph indices mappings.                 */
+  /*                                                                       */
+  typedef struct FTC_CMapCacheRec_*  FTC_CMapCache;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @type:                                                                */
+  /*    FTC_CMapDesc                                                       */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A handle to an @FTC_CMapDescRec structure used to describe a given */
+  /*    charmap in a charmap cache.                                        */
+  /*                                                                       */
+  /*    Each @FTC_CMapDesc describes which charmap (of which @FTC_Face) we */
+  /*    want to use in @FTC_CMapCache_Lookup.                              */
+  /*                                                                       */
+  typedef struct FTC_CMapDescRec_*  FTC_CMapDesc;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @enum:                                                                */
+  /*    FTC_CMapType                                                       */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    The list of valid @FTC_CMap types.  They indicate how we want to   */
+  /*    address a charmap within an @FTC_FaceID.                           */
+  /*                                                                       */
+  /* @values:                                                              */
+  /*    FTC_CMAP_BY_INDEX ::                                               */
+  /*      Address a charmap by its index in the corresponding @FT_Face.    */
+  /*                                                                       */
+  /*    FTC_CMAP_BY_ENCODING ::                                            */
+  /*      Use a @FT_Face charmap that corresponds to a given encoding.     */
+  /*                                                                       */
+  /*    FTC_CMAP_BY_ID ::                                                  */
+  /*      Use an @FT_Face charmap that corresponds to a given              */
+  /*      (platform,encoding) ID.  See @FTC_CMapIdRec.                     */
+  /*                                                                       */
+  typedef enum  FTC_CMapType_
+  {
+    FTC_CMAP_BY_INDEX    = 0,
+    FTC_CMAP_BY_ENCODING = 1,
+    FTC_CMAP_BY_ID       = 2
+
+  } FTC_CMapType;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @struct:                                                              */
+  /*    FTC_CMapIdRec                                                      */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A short structure to identify a charmap by a (platform,encoding)   */
+  /*    pair of values.                                                    */
+  /*                                                                       */
+  /* @fields:                                                              */
+  /*    platform :: The platform ID.                                       */
+  /*                                                                       */
+  /*    encoding :: The encoding ID.                                       */
+  /*                                                                       */
+  typedef struct  FTC_CMapIdRec_
+  {
+    FT_UInt  platform;
+    FT_UInt  encoding;
+
+  } FTC_CMapIdRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @struct:                                                              */
+  /*    FTC_CMapDescRec                                                    */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A structure to describe a given charmap to @FTC_CMapCache.         */
+  /*                                                                       */
+  /* @fields:                                                              */
+  /*    face_id    :: @FTC_FaceID of the face this charmap belongs to.     */
+  /*                                                                       */
+  /*    type       :: The type of charmap, see @FTC_CMapType.              */
+  /*                                                                       */
+  /*    u.index    :: For @FTC_CMAP_BY_INDEX types, this is the charmap    */
+  /*                  index (within a @FT_Face) we want to use.            */
+  /*                                                                       */
+  /*    u.encoding :: For @FTC_CMAP_BY_ENCODING types, this is the charmap */
+  /*                  encoding we want to use. see @FT_Encoding.           */
+  /*                                                                       */
+  /*    u.id       :: For @FTC_CMAP_BY_ID types, this is the               */
+  /*                  (platform,encoding) pair we want to use. see         */
+  /*                  @FTC_CMapIdRec and @FT_CharMapRec.                   */
+  /*                                                                       */
+  typedef struct  FTC_CMapDescRec_
+  {
+    FTC_FaceID    face_id;
+    FTC_CMapType  type;
+
+    union
+    {
+      FT_UInt        index;
+      FT_Encoding    encoding;
+      FTC_CMapIdRec  id;
+
+    } u;
+
+  } FTC_CMapDescRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @function:                                                            */
+  /*    FTC_CMapCache_New                                                  */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    Creates a new charmap cache.                                       */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    manager :: A handle to the cache manager.                          */
+  /*                                                                       */
+  /* @output:                                                              */
+  /*    acache  :: A new cache handle.  NULL in case of error.             */
+  /*                                                                       */
+  /* @return:                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    Like all other caches, this one will be destroyed with the cache   */
+  /*    manager.                                                           */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_CMapCache_New( FTC_Manager     manager,
+                     FTC_CMapCache  *acache );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @function:                                                            */
+  /*    FTC_CMapCache_Lookup                                               */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    Translates a character code into a glyph index, using the charmap  */
+  /*    cache.                                                             */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    cache     :: A charmap cache handle.                               */
+  /*                                                                       */
+  /*    cmap_desc :: A charmap descriptor handle.                          */
+  /*                                                                       */
+  /*    char_code :: The character code (in the corresponding charmap).    */
+  /*                                                                       */
+  /* @return:                                                              */
+  /*    Glyph index.  0 means "no glyph".                                  */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    This function doesn't return @FTC_Node handles, since there is no  */
+  /*    real use for them with typical uses of charmaps.                   */
+  /*                                                                       */
+  FT_EXPORT( FT_UInt )
+  FTC_CMapCache_Lookup( FTC_CMapCache  cache,
+                        FTC_CMapDesc   cmap_desc,
+                        FT_UInt32      char_code );
+
+  /* */
+
+
+FT_END_HEADER
+
+
+#endif /* __FTCCMAP_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/cache/ftcglyph.h
@@ -1,0 +1,193 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcglyph.h                                                             */
+/*                                                                         */
+/*    FreeType abstract glyph cache (specification).                       */
+/*                                                                         */
+/*  Copyright 2000-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Important: The functions defined in this file are only used to        */
+  /*            implement an abstract glyph cache class.  You need to      */
+  /*            provide additional logic to implement a complete cache.    */
+  /*            For example, see `ftcimage.h' and `ftcimage.c' which       */
+  /*            implement a FT_Glyph cache based on this code.             */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*********                                                       *********/
+  /*********             WARNING, THIS IS BETA CODE.               *********/
+  /*********                                                       *********/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+#ifndef __FTCGLYPH_H__
+#define __FTCGLYPH_H__
+
+
+#include <ft2build.h>
+#include FT_CACHE_H
+#include FT_CACHE_MANAGER_H
+
+#include <stddef.h>
+
+
+FT_BEGIN_HEADER
+
+
+  /* each glyph set is characterized by a "glyph set type" which must be */
+  /* defined by sub-classes                                              */
+  typedef struct FTC_GlyphFamilyRec_*  FTC_GlyphFamily;
+
+  /* handle to a glyph cache node */
+  typedef struct FTC_GlyphNodeRec_*  FTC_GlyphNode;
+
+
+  /* size should be 24 + chunk size on 32-bit machines;                 */
+  /* note that the node's hash is ((gfam->hash << 16) | glyph_index) -- */
+  /* this _must_ be set properly by the glyph node initializer          */
+  /*                                                                    */
+  typedef struct  FTC_GlyphNodeRec_
+  {
+    FTC_NodeRec   node;
+    FT_UShort     item_count;
+    FT_UShort     item_start;
+
+  } FTC_GlyphNodeRec;
+
+
+#define FTC_GLYPH_NODE( x )    ( (FTC_GlyphNode)(x) )
+#define FTC_GLYPH_NODE_P( x )  ( (FTC_GlyphNode*)(x) )
+
+
+  typedef struct  FTC_GlyphQueryRec_
+  {
+    FTC_QueryRec  query;
+    FT_UInt       gindex;
+
+  } FTC_GlyphQueryRec, *FTC_GlyphQuery;
+
+
+#define FTC_GLYPH_QUERY( x )  ( (FTC_GlyphQuery)(x) )
+
+
+  /* a glyph set is used to categorize glyphs of a given type */
+  typedef struct  FTC_GlyphFamilyRec_
+  {
+    FTC_FamilyRec  family;
+    FT_UInt32      hash;
+    FT_UInt        item_total;   /* total number of glyphs in family */
+    FT_UInt        item_count;   /* number of glyph items per node   */
+
+  } FTC_GlyphFamilyRec;
+
+
+#define FTC_GLYPH_FAMILY( x )         ( (FTC_GlyphFamily)(x) )
+#define FTC_GLYPH_FAMILY_P( x )       ( (FTC_GlyphFamily*)(x) )
+
+#define FTC_GLYPH_FAMILY_MEMORY( x )  FTC_FAMILY(x)->cache->memory
+
+
+  /* each glyph node contains a 'chunk' of glyph items; */
+  /* translate a glyph index into a chunk index         */
+#define FTC_GLYPH_FAMILY_CHUNK( gfam, gindex )                  \
+          ( ( gindex ) / FTC_GLYPH_FAMILY( gfam )->item_count )
+
+  /* find a glyph index's chunk, and return its start index */
+#define FTC_GLYPH_FAMILY_START( gfam, gindex )       \
+          ( FTC_GLYPH_FAMILY_CHUNK( gfam, gindex ) * \
+            FTC_GLYPH_FAMILY( gfam )->item_count )
+
+  /* compute a glyph request's hash value */
+#define FTC_GLYPH_FAMILY_HASH( gfam, gindex )                         \
+          ( (FT_UFast)(                                               \
+              ( FTC_GLYPH_FAMILY( gfam )->hash << 16 ) |              \
+              ( FTC_GLYPH_FAMILY_CHUNK( gfam, gindex ) & 0xFFFF ) ) )
+
+  /* must be called in an FTC_Family_CompareFunc to update the query */
+  /* whenever a glyph set is matched in the lookup, or when it       */
+  /* is created                                                      */
+#define FTC_GLYPH_FAMILY_FOUND( gfam, gquery )                            \
+          do                                                              \
+          {                                                               \
+            FTC_QUERY( gquery )->family = FTC_FAMILY( gfam );             \
+            FTC_QUERY( gquery )->hash =                                   \
+              FTC_GLYPH_FAMILY_HASH( gfam,                                \
+                                     FTC_GLYPH_QUERY( gquery )->gindex ); \
+          } while ( 0 )
+
+  /* retrieve glyph index of glyph node */
+#define FTC_GLYPH_NODE_GINDEX( x )                                 \
+          ( (FT_UInt)( FTC_GLYPH_NODE( x )->node.hash & 0xFFFF ) )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* These functions are exported so that they can be called from          */
+  /* user-provided cache classes; otherwise, they are really part of the   */
+  /* cache sub-system internals.                                           */
+  /*                                                                       */
+
+  /* must be called by derived FTC_Node_InitFunc routines */
+  FT_EXPORT( void )
+  ftc_glyph_node_init( FTC_GlyphNode    node,
+                       FT_UInt          gindex,  /* glyph index for node */
+                       FTC_GlyphFamily  gfam );
+
+  /* returns TRUE iff the query's glyph index correspond to the node;  */
+  /* this assumes that the "family" and "hash" fields of the query are */
+  /* already correctly set                                             */
+  FT_EXPORT( FT_Bool )
+  ftc_glyph_node_compare( FTC_GlyphNode   gnode,
+                          FTC_GlyphQuery  gquery );
+
+  /* must be called by derived FTC_Node_DoneFunc routines */
+  FT_EXPORT( void )
+  ftc_glyph_node_done( FTC_GlyphNode  node,
+                       FTC_Cache      cache );
+
+
+  /* must be called by derived FTC_Family_InitFunc; */
+  /* calls "ftc_family_init"                        */
+  FT_EXPORT( FT_Error )
+  ftc_glyph_family_init( FTC_GlyphFamily  gfam,
+                         FT_UInt32        hash,
+                         FT_UInt          item_count,
+                         FT_UInt          item_total,
+                         FTC_GlyphQuery   gquery,
+                         FTC_Cache        cache );
+
+  FT_EXPORT( void )
+  ftc_glyph_family_done( FTC_GlyphFamily  gfam );
+
+
+  /* */
+ 
+FT_END_HEADER
+
+
+#endif /* __FTCGLYPH_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/cache/ftcimage.h
@@ -1,0 +1,312 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcimage.h                                                             */
+/*                                                                         */
+/*    FreeType Image cache (specification).                                */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Each image cache really manages FT_Glyph objects.                     */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __FTCIMAGE_H__
+#define __FTCIMAGE_H__
+
+
+#include <ft2build.h>
+#include FT_CACHE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    cache_subsystem                                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                       IMAGE CACHE OBJECT                      *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+ /**************************************************************************
+  *
+  * @struct:
+  *   FTC_ImageTypeRec
+  *
+  * @description:
+  *   A simple structure used to describe the type of glyph image to be
+  *   loaded into the cache.
+  *
+  * @fields:
+  *   font  :: An @FTC_FontRec used to describe the glyph's face and size.
+  *
+  *   flags :: The load flags to be applied when loading the glyph; see
+  *            the @FT_LOAD_XXX constants for details.
+  *
+  * @note:
+  *   This type completely replaces the @FTC_Image_Desc structure which is
+  *   now obsolete.
+  */
+  typedef struct  FTC_ImageTypeRec_
+  {
+    FTC_FontRec  font;
+    FT_Int32     flags;
+
+  } FTC_ImageTypeRec;
+
+  typedef struct FTC_ImageTypeRec_*   FTC_ImageType;
+
+ /* */
+
+#define FTC_IMAGE_TYPE_COMPARE( d1, d2 )                    \
+          ( FTC_FONT_COMPARE( &(d1)->font, &(d2)->font ) && \
+            (d1)->flags == (d2)->flags                   )
+
+#define FTC_IMAGE_TYPE_HASH( d )                    \
+          (FT_UFast)( FTC_FONT_HASH( &(d)->font ) ^ \
+                      ( (d)->flags << 4 )         )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FTC_ImageCache                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to an glyph image cache object.  They are designed to     */
+  /*    hold many distinct glyph images while not exceeding a certain      */
+  /*    memory threshold.                                                  */
+  /*                                                                       */
+  typedef struct FTC_ImageCacheRec_*  FTC_ImageCache;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_ImageCache_New                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Creates a new glyph image cache.                                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    manager :: The parent manager for the image cache.                 */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    acache  :: A handle to the new glyph image cache object.           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_ImageCache_New( FTC_Manager      manager,
+                      FTC_ImageCache  *acache );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_ImageCache_Lookup                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieves a given glyph image from a glyph image cache.            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    cache  :: A handle to the source glyph image cache.                */
+  /*                                                                       */
+  /*    type   :: A pointer to a glyph image type descriptor.              */
+  /*                                                                       */
+  /*    gindex :: The glyph index to retrieve.                             */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aglyph :: The corresponding @FT_Glyph object.  0 in case of        */
+  /*              failure.                                                 */
+  /*                                                                       */
+  /*    anode  :: Used to return the address of of the corresponding cache */
+  /*              node after incrementing its reference count (see note    */
+  /*              below).                                                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The returned glyph is owned and managed by the glyph image cache.  */
+  /*    Never try to transform or discard it manually!  You can however    */
+  /*    create a copy with @FT_Glyph_Copy and modify the new one.          */
+  /*                                                                       */
+  /*    If "anode" is _not_ NULL, it receives the address of the cache     */
+  /*    node containing the glyph image, after increasing its reference    */
+  /*    count.  This ensures that the node (as well as the FT_Glyph) will  */
+  /*    always be kept in the cache until you call @FTC_Node_Unref to      */
+  /*    "release" it.                                                      */
+  /*                                                                       */
+  /*    If "anode" is NULL, the cache node is left unchanged, which means  */
+  /*    that the FT_Glyph could be flushed out of the cache on the next    */
+  /*    call to one of the caching sub-system APIs.  Don't assume that it  */
+  /*    is persistent!                                                     */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_ImageCache_Lookup( FTC_ImageCache  cache,
+                         FTC_ImageType   type,
+                         FT_UInt         gindex,
+                         FT_Glyph       *aglyph,
+                         FTC_Node       *anode );
+
+  /* */
+
+#define ftc_image_format( x )  ( (x) & 7 )
+
+
+#define ftc_image_format_bitmap    0x0000
+#define ftc_image_format_outline   0x0001
+
+#define ftc_image_format_mask      0x000F
+
+#define ftc_image_flag_monochrome  0x0010
+#define ftc_image_flag_unhinted    0x0020
+#define ftc_image_flag_autohinted  0x0040
+#define ftc_image_flag_unscaled    0x0080
+#define ftc_image_flag_no_sbits    0x0100
+
+  /* monochrome bitmap */
+#define ftc_image_mono             ftc_image_format_bitmap | \
+                                   ftc_image_flag_monochrome
+
+  /* anti-aliased bitmap */
+#define ftc_image_grays            ftc_image_format_bitmap
+
+  /* scaled outline */
+#define ftc_image_outline          ftc_image_format_outline
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FTC_Image_Desc                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    THIS TYPE IS DEPRECATED.  Use @FTC_ImageDesc instead.              */
+  /*                                                                       */
+  /*    A simple structure used to describe a given glyph image category.  */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    size       :: An @FTC_SizeRec used to describe the glyph's face    */
+  /*                  and size.                                            */
+  /*                                                                       */
+  /*    image_type :: The glyph image's type.                              */
+  /*                                                                       */
+  typedef struct  FTC_Image_Desc_
+  {
+    FTC_FontRec  font;
+    FT_UInt      image_type;
+
+  } FTC_Image_Desc;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FTC_Image_Cache                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    THIS TYPE IS DEPRECATED.  Use @FTC_ImageCache instead.             */
+  /*                                                                       */
+  typedef FTC_ImageCache  FTC_Image_Cache;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_Image_Cache_New                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    THIS FUNCTION IS DEPRECATED.  Use @FTC_ImageCache_New instead.     */
+  /*                                                                       */
+  /*    Creates a new glyph image cache.                                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    manager :: The parent manager for the image cache.                 */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    acache  :: A handle to the new glyph image cache object.           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_Image_Cache_New( FTC_Manager       manager,
+                       FTC_Image_Cache  *acache );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_Image_Cache_Lookup                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    THIS FUNCTION IS DEPRECATED.  Use @FTC_ImageCache_Lookup instead.  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    cache  :: A handle to the source glyph image cache.                */
+  /*                                                                       */
+  /*    desc   :: A pointer to a glyph image descriptor.                   */
+  /*                                                                       */
+  /*    gindex :: The glyph index to retrieve.                             */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aglyph :: The corresponding @FT_Glyph object.  0 in case of        */
+  /*              failure.                                                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The returned glyph is owned and managed by the glyph image cache.  */
+  /*    Never try to transform or discard it manually!  You can however    */
+  /*    create a copy with @FT_Glyph_Copy and modify the new one.          */
+  /*                                                                       */
+  /*    Because the glyph image cache limits the total amount of memory    */
+  /*    taken by the glyphs it holds, the returned glyph might disappear   */
+  /*    on a later invocation of this function!  It is a cache after       */
+  /*    all...                                                             */
+  /*                                                                       */
+  /*    Use this function to "lock" the glyph as long as it is needed.     */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_Image_Cache_Lookup( FTC_Image_Cache  cache,
+                          FTC_Image_Desc*  desc,
+                          FT_UInt          gindex,
+                          FT_Glyph        *aglyph );
+
+ /* */
+
+FT_END_HEADER
+
+
+#endif /* __FTCIMAGE_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/cache/ftcmanag.h
@@ -1,0 +1,244 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcmanag.h                                                             */
+/*                                                                         */
+/*    FreeType Cache Manager (specification).                              */
+/*                                                                         */
+/*  Copyright 2000-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* A cache manager is in charge of the following:                        */
+  /*                                                                       */
+  /*  - Maintain a mapping between generic FTC_FaceIDs and live FT_Face    */
+  /*    objects.  The mapping itself is performed through a user-provided  */
+  /*    callback.  However, the manager maintains a small cache of FT_Face */
+  /*    and FT_Size objects in order to speed up things considerably.      */
+  /*                                                                       */
+  /*  - Manage one or more cache objects.  Each cache is in charge of      */
+  /*    holding a varying number of `cache nodes'.  Each cache node        */
+  /*    represents a minimal amount of individually accessible cached      */
+  /*    data.  For example, a cache node can be an FT_Glyph image          */
+  /*    containing a vector outline, or some glyph metrics, or anything    */
+  /*    else.                                                              */
+  /*                                                                       */
+  /*    Each cache node has a certain size in bytes that is added to the   */
+  /*    total amount of `cache memory' within the manager.                 */
+  /*                                                                       */
+  /*    All cache nodes are located in a global LRU list, where the oldest */
+  /*    node is at the tail of the list.                                   */
+  /*                                                                       */
+  /*    Each node belongs to a single cache, and includes a reference      */
+  /*    count to avoid destroying it (due to caching).                     */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*********                                                       *********/
+  /*********             WARNING, THIS IS BETA CODE.               *********/
+  /*********                                                       *********/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+#ifndef __FTCMANAG_H__
+#define __FTCMANAG_H__
+
+
+#include <ft2build.h>
+#include FT_CACHE_H
+#include FT_CACHE_INTERNAL_LRU_H
+#include FT_CACHE_INTERNAL_CACHE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    cache_subsystem                                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#define FTC_MAX_FACES_DEFAULT  2
+#define FTC_MAX_SIZES_DEFAULT  4
+#define FTC_MAX_BYTES_DEFAULT  200000L  /* ~200kByte by default */
+
+  /* maximum number of caches registered in a single manager */
+#define FTC_MAX_CACHES         16
+
+
+  typedef struct  FTC_FamilyEntryRec_
+  {
+    FTC_Family  family;
+    FTC_Cache   cache;
+    FT_UInt     index;
+    FT_UInt     link;
+
+  } FTC_FamilyEntryRec, *FTC_FamilyEntry;
+
+
+#define FTC_FAMILY_ENTRY_NONE  ( (FT_UInt)-1 )
+
+
+  typedef struct  FTC_FamilyTableRec_
+  {
+    FT_UInt          count;
+    FT_UInt          size;
+    FTC_FamilyEntry  entries;
+    FT_UInt          free;
+  
+  } FTC_FamilyTableRec, *FTC_FamilyTable;
+
+
+  FT_EXPORT( FT_Error )
+  ftc_family_table_alloc( FTC_FamilyTable   table,
+                          FT_Memory         memory,
+                          FTC_FamilyEntry  *aentry );
+
+  FT_EXPORT( void )
+  ftc_family_table_free( FTC_FamilyTable  table,
+                         FT_UInt          idx );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FTC_ManagerRec                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The cache manager structure.                                       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    library      :: A handle to a FreeType library instance.           */
+  /*                                                                       */
+  /*    faces_list   :: The lru list of @FT_Face objects in the cache.     */
+  /*                                                                       */
+  /*    sizes_list   :: The lru list of @FT_Size objects in the cache.     */
+  /*                                                                       */
+  /*    max_weight   :: The maximum cache pool weight.                     */
+  /*                                                                       */
+  /*    cur_weight   :: The current cache pool weight.                     */
+  /*                                                                       */
+  /*    num_nodes    :: The current number of nodes in the manager.        */
+  /*                                                                       */
+  /*    nodes_list   :: The global lru list of all cache nodes.            */
+  /*                                                                       */
+  /*    caches       :: A table of installed/registered cache objects.     */
+  /*                                                                       */
+  /*    request_data :: User-provided data passed to the requester.        */
+  /*                                                                       */
+  /*    request_face :: User-provided function used to implement a mapping */
+  /*                    between abstract @FTC_FaceID values and real       */
+  /*                    @FT_Face objects.                                  */
+  /*                                                                       */
+  /*    families     :: Global table of families.                          */
+  /*                                                                       */
+  typedef struct  FTC_ManagerRec_
+  {
+    FT_Library          library;
+    FT_LruList          faces_list;
+    FT_LruList          sizes_list;
+
+    FT_ULong            max_weight;
+    FT_ULong            cur_weight;
+    
+    FT_UInt             num_nodes;
+    FTC_Node            nodes_list;
+    
+    FTC_Cache           caches[FTC_MAX_CACHES];
+
+    FT_Pointer          request_data;
+    FTC_Face_Requester  request_face;
+
+    FTC_FamilyTableRec  families;
+
+  } FTC_ManagerRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_Manager_Compress                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used to check the state of the cache manager if   */
+  /*    its `num_bytes' field is greater than its `max_bytes' field.  It   */
+  /*    will flush as many old cache nodes as possible (ignoring cache     */
+  /*    nodes with a non-zero reference count).                            */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    manager :: A handle to the cache manager.                          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Client applications should not call this function directly.  It is */
+  /*    normally invoked by specific cache implementations.                */
+  /*                                                                       */
+  /*    The reason this function is exported is to allow client-specific   */
+  /*    cache classes.                                                     */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FTC_Manager_Compress( FTC_Manager  manager );
+
+
+  /* this must be used internally for the moment */
+  FT_EXPORT( FT_Error )
+  FTC_Manager_Register_Cache( FTC_Manager      manager,
+                              FTC_Cache_Class  clazz,
+                              FTC_Cache       *acache );
+
+
+  /* can be called to increment a node's reference count */
+  FT_EXPORT( void )
+  FTC_Node_Ref( FTC_Node     node,
+                FTC_Manager  manager );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_Node_Unref                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Decrement a cache node's internal reference count.  When the count */
+  /*    reaches 0, it is not destroyed but becomes eligible for subsequent */
+  /*    cache flushes.                                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    node    :: The cache node handle.                                  */
+  /*                                                                       */
+  /*    manager :: The cache manager handle.                               */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FTC_Node_Unref( FTC_Node     node,
+                  FTC_Manager  manager );
+
+ /* */
+
+FT_END_HEADER
+
+
+#endif /* __FTCMANAG_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/cache/ftcsbits.h
@@ -1,0 +1,275 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcsbits.h                                                             */
+/*                                                                         */
+/*    A small-bitmap cache (specification).                                */
+/*                                                                         */
+/*  Copyright 2000-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTCSBITS_H__
+#define __FTCSBITS_H__
+
+
+#include <ft2build.h>
+#include FT_CACHE_H
+#include FT_CACHE_IMAGE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    cache_subsystem                                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FTC_SBit                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a small bitmap descriptor.  See the @FTC_SBitRec       */
+  /*    structure for details.                                             */
+  /*                                                                       */
+  typedef struct FTC_SBitRec_*  FTC_SBit;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FTC_SBitRec                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A very compact structure used to describe a small glyph bitmap.    */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    width     :: The bitmap width in pixels.                           */
+  /*                                                                       */
+  /*    height    :: The bitmap height in pixels.                          */
+  /*                                                                       */
+  /*    left      :: The horizontal distance from the pen position to the  */
+  /*                 left bitmap border (a.k.a. `left side bearing', or    */
+  /*                 `lsb').                                               */
+  /*                                                                       */
+  /*    top       :: The vertical distance from the pen position (on the   */
+  /*                 baseline) to the upper bitmap border (a.k.a. `top     */
+  /*                 side bearing').  The distance is positive for upwards */
+  /*                 Y coordinates.                                        */
+  /*                                                                       */
+  /*    format    :: The format of the glyph bitmap (monochrome or gray).  */
+  /*                                                                       */
+  /*    max_grays :: Maximum gray level value (in the range 1 to 255).     */
+  /*                                                                       */
+  /*    pitch     :: The number of bytes per bitmap line.  May be positive */
+  /*                 or negative.                                          */
+  /*                                                                       */
+  /*    xadvance  :: The horizontal advance width in pixels.               */
+  /*                                                                       */
+  /*    yadvance  :: The vertical advance height in pixels.                */
+  /*                                                                       */
+  /*    buffer   :: A pointer to the bitmap pixels.                        */
+  /*                                                                       */
+  typedef struct  FTC_SBitRec_
+  {
+    FT_Byte   width;
+    FT_Byte   height;
+    FT_Char   left;
+    FT_Char   top;
+
+    FT_Byte   format;
+    FT_Byte   max_grays;
+    FT_Short  pitch;
+    FT_Char   xadvance;
+    FT_Char   yadvance;
+
+    FT_Byte*  buffer;
+
+  } FTC_SBitRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FTC_SBitCache                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a small bitmap cache.  These are special cache objects */
+  /*    used to store small glyph bitmaps (and anti-aliased pixmaps) in a  */
+  /*    much more efficient way than the traditional glyph image cache     */
+  /*    implemented by @FTC_ImageCache.                                    */
+  /*                                                                       */
+  typedef struct FTC_SBitCacheRec_*  FTC_SBitCache;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FTC_SBit_Cache                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    DEPRECATED.  Use @FTC_SBitCache instead.                           */
+  /*                                                                       */
+  typedef FTC_SBitCache  FTC_SBit_Cache;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_SBitCache_New                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Creates a new cache to store small glyph bitmaps.                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    manager :: A handle to the source cache manager.                   */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    acache  :: A handle to the new sbit cache.  NULL in case of error. */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_SBitCache_New( FTC_Manager     manager,
+                     FTC_SBitCache  *acache );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_SBitCache_Lookup                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Looks up a given small glyph bitmap in a given sbit cache and      */
+  /*    "lock" it to prevent its flushing from the cache until needed      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    cache  :: A handle to the source sbit cache.                       */
+  /*                                                                       */
+  /*    type   :: A pointer to the glyph image type descriptor.            */
+  /*                                                                       */
+  /*    gindex :: The glyph index.                                         */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    sbit   :: A handle to a small bitmap descriptor.                   */
+  /*                                                                       */
+  /*    anode  :: Used to return the address of of the corresponding cache */
+  /*              node after incrementing its reference count (see note    */
+  /*              below).                                                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The small bitmap descriptor and its bit buffer are owned by the    */
+  /*    cache and should never be freed by the application.  They might    */
+  /*    as well disappear from memory on the next cache lookup, so don't   */
+  /*    treat them as persistent data.                                     */
+  /*                                                                       */
+  /*    The descriptor's `buffer' field is set to 0 to indicate a missing  */
+  /*    glyph bitmap.                                                      */
+  /*                                                                       */
+  /*    If "anode" is _not_ NULL, it receives the address of the cache     */
+  /*    node containing the bitmap, after increasing its reference count.  */
+  /*    This ensures that the node (as well as the image) will always be   */
+  /*    kept in the cache until you call @FTC_Node_Unref to "release" it.  */
+  /*                                                                       */
+  /*    If "anode" is NULL, the cache node is left unchanged, which means  */
+  /*    that the bitmap could be flushed out of the cache on the next      */
+  /*    call to one of the caching sub-system APIs.  Don't assume that it  */
+  /*    is persistent!                                                     */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_SBitCache_Lookup( FTC_SBitCache    cache,
+                        FTC_ImageType    type,
+                        FT_UInt          gindex,
+                        FTC_SBit        *sbit,
+                        FTC_Node        *anode );
+
+
+  /* */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_SBit_Cache_New                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    DEPRECATED.  Use @FTC_SBitCache_New instead.                       */
+  /*                                                                       */
+  /*    Creates a new cache to store small glyph bitmaps.                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    manager :: A handle to the source cache manager.                   */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    acache  :: A handle to the new sbit cache.  NULL in case of error. */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_SBit_Cache_New( FTC_Manager      manager,
+                      FTC_SBit_Cache  *acache );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_SBit_Cache_Lookup                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    DEPRECATED.  Use @FTC_SBitCache_Lookup instead.                    */
+  /*                                                                       */
+  /*    Looks up a given small glyph bitmap in a given sbit cache.         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    cache  :: A handle to the source sbit cache.                       */
+  /*                                                                       */
+  /*    desc   :: A pointer to the glyph image descriptor.                 */
+  /*                                                                       */
+  /*    gindex :: The glyph index.                                         */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    sbit   :: A handle to a small bitmap descriptor.                   */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The small bitmap descriptor and its bit buffer are owned by the    */
+  /*    cache and should never be freed by the application.  They might    */
+  /*    as well disappear from memory on the next cache lookup, so don't   */
+  /*    treat them as persistent data.                                     */
+  /*                                                                       */
+  /*    The descriptor's `buffer' field is set to 0 to indicate a missing  */
+  /*    glyph bitmap.                                                      */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_SBit_Cache_Lookup( FTC_SBit_Cache   cache,
+                         FTC_Image_Desc*  desc,
+                         FT_UInt          gindex,
+                         FTC_SBit        *sbit );
+
+
+FT_END_HEADER
+
+#endif /* __FTCSBITS_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/cache/ftlru.h
@@ -1,0 +1,202 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftlru.h                                                                */
+/*                                                                         */
+/*    Simple LRU list-cache (specification).                               */
+/*                                                                         */
+/*  Copyright 2000-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* An LRU is a list that cannot hold more than a certain number of       */
+  /* elements (`max_elements').  All elements in the list are sorted in    */
+  /* least-recently-used order, i.e., the `oldest' element is at the tail  */
+  /* of the list.                                                          */
+  /*                                                                       */
+  /* When doing a lookup (either through `Lookup()' or `Lookup_Node()'),   */
+  /* the list is searched for an element with the corresponding key.  If   */
+  /* it is found, the element is moved to the head of the list and is      */
+  /* returned.                                                             */
+  /*                                                                       */
+  /* If no corresponding element is found, the lookup routine will try to  */
+  /* obtain a new element with the relevant key.  If the list is already   */
+  /* full, the oldest element from the list is discarded and replaced by a */
+  /* new one; a new element is added to the list otherwise.                */
+  /*                                                                       */
+  /* Note that it is possible to pre-allocate the element list nodes.      */
+  /* This is handy if `max_elements' is sufficiently small, as it saves    */
+  /* allocations/releases during the lookup process.                       */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*********                                                       *********/
+  /*********             WARNING, THIS IS BETA CODE.               *********/
+  /*********                                                       *********/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+#ifndef __FTLRU_H__
+#define __FTLRU_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /* generic list key type */
+  typedef FT_Pointer  FT_LruKey;
+
+  /* a list list handle */
+  typedef struct FT_LruListRec_*  FT_LruList;
+
+  /* a list class handle */
+  typedef const struct FT_LruList_ClassRec_*  FT_LruList_Class;
+
+  /* a list node handle */
+  typedef struct FT_LruNodeRec_*  FT_LruNode;
+
+  /* the list node structure */
+  typedef struct  FT_LruNodeRec_
+  {
+    FT_LruNode  next;
+    FT_LruKey   key;
+
+  } FT_LruNodeRec;
+
+
+  /* the list structure */
+  typedef struct  FT_LruListRec_
+  {
+    FT_Memory         memory;
+    FT_LruList_Class  clazz;
+    FT_LruNode        nodes;
+    FT_UInt           max_nodes;
+    FT_UInt           num_nodes;
+    FT_Pointer        data;
+
+  } FT_LruListRec;
+
+
+  /* initialize a list list */
+  typedef FT_Error
+  (*FT_LruList_InitFunc)( FT_LruList  list );
+
+  /* finalize a list list */
+  typedef void
+  (*FT_LruList_DoneFunc)( FT_LruList  list );
+
+  /* this method is used to initialize a new list element node */
+  typedef FT_Error
+  (*FT_LruNode_InitFunc)( FT_LruNode  node,
+                          FT_LruKey   key,
+                          FT_Pointer  data );
+
+  /* this method is used to finalize a given list element node */
+  typedef void
+  (*FT_LruNode_DoneFunc)( FT_LruNode  node,
+                          FT_Pointer  data );
+
+  /* If defined, this method is called when the list if full        */
+  /* during the lookup process -- it is used to change the contents */
+  /* of a list element node instead of calling `done_element()',    */
+  /* then `init_element()'.  Set it to 0 for default behaviour.     */
+  typedef FT_Error
+  (*FT_LruNode_FlushFunc)( FT_LruNode  node,
+                           FT_LruKey   new_key,
+                           FT_Pointer  data );
+
+  /* If defined, this method is used to compare a list element node */
+  /* with a given key during a lookup.  If set to 0, the `key'      */
+  /* fields will be directly compared instead.                      */
+  typedef FT_Bool
+  (*FT_LruNode_CompareFunc)( FT_LruNode  node,
+                             FT_LruKey   key,
+                             FT_Pointer  data );
+
+  /* A selector is used to indicate whether a given list element node */
+  /* is part of a selection for FT_LruList_Remove_Selection().  The   */
+  /* functrion must return true (i.e., non-null) to indicate that the */
+  /* node is part of it.                                              */
+  typedef FT_Bool
+  (*FT_LruNode_SelectFunc)( FT_LruNode  node,
+                            FT_Pointer  data,
+                            FT_Pointer  list_data );
+
+  /* LRU class */
+  typedef struct  FT_LruList_ClassRec_
+  {
+    FT_UInt                 list_size;
+    FT_LruList_InitFunc     list_init;      /* optional */
+    FT_LruList_DoneFunc     list_done;      /* optional */
+
+    FT_UInt                 node_size;
+    FT_LruNode_InitFunc     node_init;     /* MANDATORY */
+    FT_LruNode_DoneFunc     node_done;     /* optional  */
+    FT_LruNode_FlushFunc    node_flush;    /* optional  */
+    FT_LruNode_CompareFunc  node_compare;  /* optional  */
+
+  } FT_LruList_ClassRec;
+
+
+  /* The following functions must be exported in the case where */
+  /* applications would want to write their own cache classes.  */
+
+  FT_EXPORT( FT_Error )
+  FT_LruList_New( FT_LruList_Class  clazz,
+                  FT_UInt           max_elements,
+                  FT_Pointer        user_data,
+                  FT_Memory         memory,
+                  FT_LruList       *alist );
+
+  FT_EXPORT( void )
+  FT_LruList_Reset( FT_LruList  list );
+
+  FT_EXPORT( void )
+  FT_LruList_Destroy ( FT_LruList  list );
+
+  FT_EXPORT( FT_Error )
+  FT_LruList_Lookup( FT_LruList  list,
+                     FT_LruKey   key,
+                     FT_LruNode *anode );
+
+  FT_EXPORT( void )
+  FT_LruList_Remove( FT_LruList  list,
+                     FT_LruNode  node );
+
+  FT_EXPORT( void )
+  FT_LruList_Remove_Selection( FT_LruList             list,
+                               FT_LruNode_SelectFunc  select_func,
+                               FT_Pointer             select_data );
+
+ /* */
+
+FT_END_HEADER
+
+
+#endif /* __FTLRU_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/config/ftconfig.h
@@ -1,0 +1,334 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftconfig.h                                                             */
+/*                                                                         */
+/*    ANSI-specific configuration file (specification only).               */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This header file contains a number of macro definitions that are used */
+  /* by the rest of the engine.  Most of the macros here are automatically */
+  /* determined at compile time, and you should not need to change it to   */
+  /* port FreeType, except to compile the library with a non-ANSI          */
+  /* compiler.                                                             */
+  /*                                                                       */
+  /* Note however that if some specific modifications are needed, we       */
+  /* advise you to place a modified copy in your build directory.          */
+  /*                                                                       */
+  /* The build directory is usually `freetype/builds/<system>', and        */
+  /* contains system-specific files that are always included first when    */
+  /* building the library.                                                 */
+  /*                                                                       */
+  /* This ANSI version should stay in `include/freetype/config'.           */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __FTCONFIG_H__
+#define __FTCONFIG_H__
+
+#include <ft2build.h>
+#include FT_CONFIG_OPTIONS_H
+#include FT_CONFIG_STANDARD_LIBRARY_H
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*               PLATFORM-SPECIFIC CONFIGURATION MACROS                  */
+  /*                                                                       */
+  /* These macros can be toggled to suit a specific system.  The current   */
+  /* ones are defaults used to compile FreeType in an ANSI C environment   */
+  /* (16bit compilers are also supported).  Copy this file to your own     */
+  /* `freetype/builds/<system>' directory, and edit it to port the engine. */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* The number of bytes in an `int' type.  */
+#if   FT_UINT_MAX == 0xFFFFFFFFUL
+#define FT_SIZEOF_INT  4
+#elif FT_UINT_MAX == 0xFFFFU
+#define FT_SIZEOF_INT  2
+#elif FT_UINT_MAX > 0xFFFFFFFFU && FT_UINT_MAX == 0xFFFFFFFFFFFFFFFFU
+#define FT_SIZEOF_INT  8
+#else
+#error "Unsupported number of bytes in `int' type!"
+#endif
+
+  /* The number of bytes in a `long' type.  */
+#if   FT_ULONG_MAX == 0xFFFFFFFFUL
+#define FT_SIZEOF_LONG  4
+#elif FT_ULONG_MAX > 0xFFFFFFFFU && FT_ULONG_MAX == 0xFFFFFFFFFFFFFFFFU
+#define FT_SIZEOF_LONG  8
+#else
+#error "Unsupported number of bytes in `long' type!"
+#endif
+
+
+  /* Preferred alignment of data */
+#define FT_ALIGNMENT  8
+
+
+  /* FT_UNUSED is a macro used to indicate that a given parameter is not  */
+  /* used -- this is only used to get rid of unpleasant compiler warnings */
+#ifndef FT_UNUSED
+#define FT_UNUSED( arg )  ( (arg) = (arg) )
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                     AUTOMATIC CONFIGURATION MACROS                    */
+  /*                                                                       */
+  /* These macros are computed from the ones defined above.  Don't touch   */
+  /* their definition, unless you know precisely what you are doing.  No   */
+  /* porter should need to mess with them.                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Mac support (not MacOS X)                                             */
+  /*                                                                       */
+  /*   This is the only necessary change, so it is defined here instead    */
+  /*   providing a new configuration file.                                 */
+  /*                                                                       */
+#if (defined( __APPLE__ ) || ( defined( __MWERKS__ ) && defined( macintosh ) )) && !defined(__MACH__)
+#define FT_MACINTOSH 1
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* IntN types                                                            */
+  /*                                                                       */
+  /*   Used to guarantee the size of some specific integers.               */
+  /*                                                                       */
+  typedef signed short    FT_Int16;
+  typedef unsigned short  FT_UInt16;
+
+#if FT_SIZEOF_INT == 4
+
+  typedef signed int      FT_Int32;
+  typedef unsigned int    FT_UInt32;
+
+#elif FT_SIZEOF_LONG == 4
+
+  typedef signed long     FT_Int32;
+  typedef unsigned long   FT_UInt32;
+
+#else
+#error "no 32bit type found -- please check your configuration files"
+#endif
+
+  /* now, lookup for an integer type that is at least 32 bits */
+#if FT_SIZEOF_INT >= 4
+
+  typedef int            FT_Fast;
+  typedef unsigned int   FT_UFast;
+
+#elif FT_SIZEOF_LONG >= 4
+
+  typedef long           FT_Fast;
+  typedef unsigned long  FT_UFast;
+
+#endif
+
+
+  /* determine whether we have a 64-bit int type for platforms without */
+  /* Autoconf                                                          */
+#if FT_SIZEOF_LONG == 8
+
+  /* FT_LONG64 must be defined if a 64-bit type is available */
+#define FT_LONG64
+#define FT_INT64  long
+
+#elif defined( _MSC_VER ) && _MSC_VER >= 900  /* Visual C++ (and Intel C++) */
+
+  /* this compiler provides the __int64 type */
+#define FT_LONG64
+#define FT_INT64  __int64
+
+#elif defined( __BORLANDC__ )  /* Borland C++ */
+
+  /* XXXX: We should probably check the value of __BORLANDC__ in order */
+  /*       to test the compiler version.                               */
+
+  /* this compiler provides the __int64 type */
+#define FT_LONG64
+#define FT_INT64  __int64
+
+#elif defined( __WATCOMC__ )   /* Watcom C++ */
+
+  /* Watcom doesn't provide 64-bit data types */
+
+#elif defined( __MWKS__ )      /* Metrowerks CodeWarrior */
+
+  /* I don't know if it provides 64-bit data types, any suggestion */
+  /* is welcome.                                                   */
+
+#elif defined( __GNUC__ )
+
+  /* GCC provides the "long long" type */
+#define FT_LONG64
+#define FT_INT64  long long int
+
+#endif /* FT_SIZEOF_LONG == 8 */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* A 64-bit data type will create compilation problems if you compile    */
+  /* in strict ANSI mode.  To avoid them, we disable their use if          */
+  /* __STDC__ is defined.  You can however ignore this rule by             */
+  /* defining the FT_CONFIG_OPTION_FORCE_INT64 configuration macro.        */
+  /*                                                                       */
+#if defined( FT_LONG64 ) && !defined( FT_CONFIG_OPTION_FORCE_INT64 )
+
+#ifdef __STDC__
+
+  /* undefine the 64-bit macros in strict ANSI compilation mode */
+#undef FT_LONG64
+#undef FT_INT64
+
+#endif /* __STDC__ */
+
+#endif /* FT_LONG64 && !FT_CONFIG_OPTION_FORCE_INT64 */
+
+
+#ifdef FT_MAKE_OPTION_SINGLE_OBJECT
+
+#define FT_LOCAL( x )      static  x
+#define FT_LOCAL_DEF( x )  static  x
+
+#else
+
+#ifdef __cplusplus
+#define FT_LOCAL( x )      extern "C"  x
+#define FT_LOCAL_DEF( x )  extern "C"  x
+#else
+#define FT_LOCAL( x )      extern  x
+#define FT_LOCAL_DEF( x )  x
+#endif
+
+#endif /* FT_MAKE_OPTION_SINGLE_OBJECT */
+
+
+#ifndef FT_BASE
+
+#ifdef __cplusplus
+#define FT_BASE( x )  extern "C"  x
+#else
+#define FT_BASE( x )  extern  x
+#endif
+
+#endif /* !FT_BASE */
+
+
+#ifndef FT_BASE_DEF
+
+#ifdef __cplusplus
+#define FT_BASE_DEF( x )  extern "C"  x
+#else
+#define FT_BASE_DEF( x )  extern  x
+#endif
+
+#endif /* !FT_BASE_DEF */
+
+
+#ifndef FT_EXPORT
+
+#ifdef __cplusplus
+#define FT_EXPORT( x )  extern "C"  x
+#else
+#define FT_EXPORT( x )  extern  x
+#endif
+
+#endif /* !FT_EXPORT */
+
+
+#ifndef FT_EXPORT_DEF
+
+#ifdef __cplusplus
+#define FT_EXPORT_DEF( x )  extern "C"  x
+#else
+#define FT_EXPORT_DEF( x )  extern  x
+#endif
+
+#endif /* !FT_EXPORT_DEF */
+
+
+#ifndef FT_EXPORT_VAR
+
+#ifdef __cplusplus
+#define FT_EXPORT_VAR( x )  extern "C"  x
+#else
+#define FT_EXPORT_VAR( x )  extern  x
+#endif
+
+#endif /* !FT_EXPORT_VAR */
+
+  /* The following macros are needed to compile the library with a   */
+  /* C++ compiler and with 16bit compilers.                          */
+  /*                                                                 */
+
+  /* This is special.  Within C++, you must specify `extern "C"' for */
+  /* functions which are used via function pointers, and you also    */
+  /* must do that for structures which contain function pointers to  */
+  /* assure C linkage -- it's not possible to have (local) anonymous */
+  /* functions which are accessed by (global) function pointers.     */
+  /*                                                                 */
+  /*                                                                 */
+  /* FT_CALLBACK_DEF is used to _define_ a callback function.        */
+  /*                                                                 */
+  /* FT_CALLBACK_TABLE is used to _declare_ a constant variable that */
+  /* contains pointers to callback functions.                        */
+  /*                                                                 */
+  /* FT_CALLBACK_TABLE_DEF is used to _define_ a constant variable   */
+  /* that contains pointers to callback functions.                   */
+  /*                                                                 */
+  /*                                                                 */
+  /* Some 16bit compilers have to redefine these macros to insert    */
+  /* the infamous `_cdecl' or `__fastcall' declarations.             */
+  /*                                                                 */
+#ifndef FT_CALLBACK_DEF
+#ifdef __cplusplus
+#define FT_CALLBACK_DEF( x )  extern "C"  x
+#else
+#define FT_CALLBACK_DEF( x )  static  x
+#endif
+#endif /* FT_CALLBACK_DEF */
+
+#ifndef FT_CALLBACK_TABLE
+#ifdef __cplusplus
+#define FT_CALLBACK_TABLE      extern "C"
+#define FT_CALLBACK_TABLE_DEF  extern "C"
+#else
+#define FT_CALLBACK_TABLE      extern
+#define FT_CALLBACK_TABLE_DEF  /* nothing */
+#endif
+#endif /* FT_CALLBACK_TABLE */
+
+
+FT_END_HEADER
+
+
+#endif /* __FTCONFIG_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/config/ftconfig.h.orig
@@ -1,0 +1,334 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftconfig.h                                                             */
+/*                                                                         */
+/*    ANSI-specific configuration file (specification only).               */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This header file contains a number of macro definitions that are used */
+  /* by the rest of the engine.  Most of the macros here are automatically */
+  /* determined at compile time, and you should not need to change it to   */
+  /* port FreeType, except to compile the library with a non-ANSI          */
+  /* compiler.                                                             */
+  /*                                                                       */
+  /* Note however that if some specific modifications are needed, we       */
+  /* advise you to place a modified copy in your build directory.          */
+  /*                                                                       */
+  /* The build directory is usually `freetype/builds/<system>', and        */
+  /* contains system-specific files that are always included first when    */
+  /* building the library.                                                 */
+  /*                                                                       */
+  /* This ANSI version should stay in `include/freetype/config'.           */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __FTCONFIG_H__
+#define __FTCONFIG_H__
+
+#include <ft2build.h>
+#include FT_CONFIG_OPTIONS_H
+#include FT_CONFIG_STANDARD_LIBRARY_H
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*               PLATFORM-SPECIFIC CONFIGURATION MACROS                  */
+  /*                                                                       */
+  /* These macros can be toggled to suit a specific system.  The current   */
+  /* ones are defaults used to compile FreeType in an ANSI C environment   */
+  /* (16bit compilers are also supported).  Copy this file to your own     */
+  /* `freetype/builds/<system>' directory, and edit it to port the engine. */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* The number of bytes in an `int' type.  */
+#if   FT_UINT_MAX == 0xFFFFFFFFUL
+#define FT_SIZEOF_INT  4
+#elif FT_UINT_MAX == 0xFFFFU
+#define FT_SIZEOF_INT  2
+#elif FT_UINT_MAX > 0xFFFFFFFFU && FT_UINT_MAX == 0xFFFFFFFFFFFFFFFFU
+#define FT_SIZEOF_INT  8
+#else
+#error "Unsupported number of bytes in `int' type!"
+#endif
+
+  /* The number of bytes in a `long' type.  */
+#if   FT_ULONG_MAX == 0xFFFFFFFFUL
+#define FT_SIZEOF_LONG  4
+#elif FT_ULONG_MAX > 0xFFFFFFFFU && FT_ULONG_MAX == 0xFFFFFFFFFFFFFFFFU
+#define FT_SIZEOF_LONG  8
+#else
+#error "Unsupported number of bytes in `long' type!"
+#endif
+
+
+  /* Preferred alignment of data */
+#define FT_ALIGNMENT  8
+
+
+  /* FT_UNUSED is a macro used to indicate that a given parameter is not  */
+  /* used -- this is only used to get rid of unpleasant compiler warnings */
+#ifndef FT_UNUSED
+#define FT_UNUSED( arg )  ( (arg) = (arg) )
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                     AUTOMATIC CONFIGURATION MACROS                    */
+  /*                                                                       */
+  /* These macros are computed from the ones defined above.  Don't touch   */
+  /* their definition, unless you know precisely what you are doing.  No   */
+  /* porter should need to mess with them.                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Mac support                                                           */
+  /*                                                                       */
+  /*   This is the only necessary change, so it is defined here instead    */
+  /*   providing a new configuration file.                                 */
+  /*                                                                       */
+#if defined( __APPLE__ ) || ( defined( __MWERKS__ ) && defined( macintosh ) )
+#define FT_MACINTOSH 1
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* IntN types                                                            */
+  /*                                                                       */
+  /*   Used to guarantee the size of some specific integers.               */
+  /*                                                                       */
+  typedef signed short    FT_Int16;
+  typedef unsigned short  FT_UInt16;
+
+#if FT_SIZEOF_INT == 4
+
+  typedef signed int      FT_Int32;
+  typedef unsigned int    FT_UInt32;
+
+#elif FT_SIZEOF_LONG == 4
+
+  typedef signed long     FT_Int32;
+  typedef unsigned long   FT_UInt32;
+
+#else
+#error "no 32bit type found -- please check your configuration files"
+#endif
+
+  /* now, lookup for an integer type that is at least 32 bits */
+#if FT_SIZEOF_INT >= 4
+
+  typedef int            FT_Fast;
+  typedef unsigned int   FT_UFast;
+
+#elif FT_SIZEOF_LONG >= 4
+
+  typedef long           FT_Fast;
+  typedef unsigned long  FT_UFast;
+
+#endif
+
+
+  /* determine whether we have a 64-bit int type for platforms without */
+  /* Autoconf                                                          */
+#if FT_SIZEOF_LONG == 8
+
+  /* FT_LONG64 must be defined if a 64-bit type is available */
+#define FT_LONG64
+#define FT_INT64  long
+
+#elif defined( _MSC_VER ) && _MSC_VER >= 900  /* Visual C++ (and Intel C++) */
+
+  /* this compiler provides the __int64 type */
+#define FT_LONG64
+#define FT_INT64  __int64
+
+#elif defined( __BORLANDC__ )  /* Borland C++ */
+
+  /* XXXX: We should probably check the value of __BORLANDC__ in order */
+  /*       to test the compiler version.                               */
+
+  /* this compiler provides the __int64 type */
+#define FT_LONG64
+#define FT_INT64  __int64
+
+#elif defined( __WATCOMC__ )   /* Watcom C++ */
+
+  /* Watcom doesn't provide 64-bit data types */
+
+#elif defined( __MWKS__ )      /* Metrowerks CodeWarrior */
+
+  /* I don't know if it provides 64-bit data types, any suggestion */
+  /* is welcome.                                                   */
+
+#elif defined( __GNUC__ )
+
+  /* GCC provides the "long long" type */
+#define FT_LONG64
+#define FT_INT64  long long int
+
+#endif /* FT_SIZEOF_LONG == 8 */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* A 64-bit data type will create compilation problems if you compile    */
+  /* in strict ANSI mode.  To avoid them, we disable their use if          */
+  /* __STDC__ is defined.  You can however ignore this rule by             */
+  /* defining the FT_CONFIG_OPTION_FORCE_INT64 configuration macro.        */
+  /*                                                                       */
+#if defined( FT_LONG64 ) && !defined( FT_CONFIG_OPTION_FORCE_INT64 )
+
+#ifdef __STDC__
+
+  /* undefine the 64-bit macros in strict ANSI compilation mode */
+#undef FT_LONG64
+#undef FT_INT64
+
+#endif /* __STDC__ */
+
+#endif /* FT_LONG64 && !FT_CONFIG_OPTION_FORCE_INT64 */
+
+
+#ifdef FT_MAKE_OPTION_SINGLE_OBJECT
+
+#define FT_LOCAL( x )      static  x
+#define FT_LOCAL_DEF( x )  static  x
+
+#else
+
+#ifdef __cplusplus
+#define FT_LOCAL( x )      extern "C"  x
+#define FT_LOCAL_DEF( x )  extern "C"  x
+#else
+#define FT_LOCAL( x )      extern  x
+#define FT_LOCAL_DEF( x )  x
+#endif
+
+#endif /* FT_MAKE_OPTION_SINGLE_OBJECT */
+
+
+#ifndef FT_BASE
+
+#ifdef __cplusplus
+#define FT_BASE( x )  extern "C"  x
+#else
+#define FT_BASE( x )  extern  x
+#endif
+
+#endif /* !FT_BASE */
+
+
+#ifndef FT_BASE_DEF
+
+#ifdef __cplusplus
+#define FT_BASE_DEF( x )  extern "C"  x
+#else
+#define FT_BASE_DEF( x )  extern  x
+#endif
+
+#endif /* !FT_BASE_DEF */
+
+
+#ifndef FT_EXPORT
+
+#ifdef __cplusplus
+#define FT_EXPORT( x )  extern "C"  x
+#else
+#define FT_EXPORT( x )  extern  x
+#endif
+
+#endif /* !FT_EXPORT */
+
+
+#ifndef FT_EXPORT_DEF
+
+#ifdef __cplusplus
+#define FT_EXPORT_DEF( x )  extern "C"  x
+#else
+#define FT_EXPORT_DEF( x )  extern  x
+#endif
+
+#endif /* !FT_EXPORT_DEF */
+
+
+#ifndef FT_EXPORT_VAR
+
+#ifdef __cplusplus
+#define FT_EXPORT_VAR( x )  extern "C"  x
+#else
+#define FT_EXPORT_VAR( x )  extern  x
+#endif
+
+#endif /* !FT_EXPORT_VAR */
+
+  /* The following macros are needed to compile the library with a   */
+  /* C++ compiler and with 16bit compilers.                          */
+  /*                                                                 */
+
+  /* This is special.  Within C++, you must specify `extern "C"' for */
+  /* functions which are used via function pointers, and you also    */
+  /* must do that for structures which contain function pointers to  */
+  /* assure C linkage -- it's not possible to have (local) anonymous */
+  /* functions which are accessed by (global) function pointers.     */
+  /*                                                                 */
+  /*                                                                 */
+  /* FT_CALLBACK_DEF is used to _define_ a callback function.        */
+  /*                                                                 */
+  /* FT_CALLBACK_TABLE is used to _declare_ a constant variable that */
+  /* contains pointers to callback functions.                        */
+  /*                                                                 */
+  /* FT_CALLBACK_TABLE_DEF is used to _define_ a constant variable   */
+  /* that contains pointers to callback functions.                   */
+  /*                                                                 */
+  /*                                                                 */
+  /* Some 16bit compilers have to redefine these macros to insert    */
+  /* the infamous `_cdecl' or `__fastcall' declarations.             */
+  /*                                                                 */
+#ifndef FT_CALLBACK_DEF
+#ifdef __cplusplus
+#define FT_CALLBACK_DEF( x )  extern "C"  x
+#else
+#define FT_CALLBACK_DEF( x )  static  x
+#endif
+#endif /* FT_CALLBACK_DEF */
+
+#ifndef FT_CALLBACK_TABLE
+#ifdef __cplusplus
+#define FT_CALLBACK_TABLE      extern "C"
+#define FT_CALLBACK_TABLE_DEF  extern "C"
+#else
+#define FT_CALLBACK_TABLE      extern
+#define FT_CALLBACK_TABLE_DEF  /* nothing */
+#endif
+#endif /* FT_CALLBACK_TABLE */
+
+
+FT_END_HEADER
+
+
+#endif /* __FTCONFIG_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/config/ftheader.h
@@ -1,0 +1,524 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftheader.h                                                             */
+/*                                                                         */
+/*    Build macros of the FreeType 2 library.                              */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+#ifndef __FT_HEADER_H__
+#define __FT_HEADER_H__
+
+  /*@***********************************************************************/
+  /*                                                                       */
+  /* <Macro>                                                               */
+  /*    FT_BEGIN_HEADER                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This macro is used in association with @FT_END_HEADER in header    */
+  /*    files to ensure that the declarations within are properly          */
+  /*    encapsulated in an `extern "C" { .. }' block when included from a  */
+  /*    C++ compiler.                                                      */
+  /*                                                                       */
+#ifdef __cplusplus
+#define FT_BEGIN_HEADER  extern "C" {
+#else
+#define FT_BEGIN_HEADER  /* nothing */
+#endif
+
+
+  /*@***********************************************************************/
+  /*                                                                       */
+  /* <Macro>                                                               */
+  /*    FT_END_HEADER                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This macro is used in association with @FT_BEGIN_HEADER in header  */
+  /*    files to ensure that the declarations within are properly          */
+  /*    encapsulated in an `extern "C" { .. }' block when included from a  */
+  /*    C++ compiler.                                                      */
+  /*                                                                       */
+#ifdef __cplusplus
+#define FT_END_HEADER  }
+#else
+#define FT_END_HEADER  /* nothing */
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Aliases for the FreeType 2 public and configuration files.            */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    header_file_macros                                                 */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Header File Macros                                                 */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Macro definitions used to #include specific header files.          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The following macros are defined to the name of specific           */
+  /*    FreeType 2 header files.  They can be used directly in #include    */
+  /*    statements as in:                                                  */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      #include FT_FREETYPE_H                                           */
+  /*      #include FT_MULTIPLE_MASTERS_H                                   */
+  /*      #include FT_GLYPH_H                                              */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    There are several reasons why we are now using macros to name      */
+  /*    public header files.  The first one is that such macros are not    */
+  /*    limited to the infamous 8.3 naming rule required by DOS (and       */
+  /*    `FT_MULTIPLE_MASTERS_H' is a lot more meaningful than `ftmm.h').   */
+  /*                                                                       */
+  /*    The second reason is that is allows for more flexibility in the    */
+  /*    way FreeType 2 is installed on a given system.                     */
+  /*                                                                       */
+  /*************************************************************************/
+
+  /* configuration files */
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_CONFIG_CONFIG_H                                                 */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    FreeType 2 configuration data.                                     */
+  /*                                                                       */
+#ifndef FT_CONFIG_CONFIG_H
+#define FT_CONFIG_CONFIG_H  <freetype/config/ftconfig.h>
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_CONFIG_STANDARD_LIBRARY_H                                       */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    FreeType 2 configuration data.                                     */
+  /*                                                                       */
+#ifndef FT_CONFIG_STANDARD_LIBRARY_H
+#define FT_CONFIG_STANDARD_LIBRARY_H  <freetype/config/ftstdlib.h>
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_CONFIG_OPTIONS_H                                                */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    FreeType 2 project-specific configuration options.                 */
+  /*                                                                       */
+#ifndef FT_CONFIG_OPTIONS_H
+#define FT_CONFIG_OPTIONS_H  <freetype/config/ftoption.h>
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_CONFIG_MODULES_H                                                */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the list of FreeType 2 modules that are statically linked to new   */
+  /*    library instances in @FT_Init_FreeType.                            */
+  /*                                                                       */
+#ifndef FT_CONFIG_MODULES_H
+#define FT_CONFIG_MODULES_H  <freetype/config/ftmodule.h>
+#endif
+
+  /* public headers */
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_FREETYPE_H                                                      */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the base FreeType 2 API.                                           */
+  /*                                                                       */
+#define FT_FREETYPE_H  <freetype/freetype.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_ERRORS_H                                                        */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the list of FreeType 2 error codes (and messages).                 */
+  /*                                                                       */
+  /*    It is included by @FT_FREETYPE_H.                                  */
+  /*                                                                       */
+#define FT_ERRORS_H  <freetype/fterrors.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_MODULE_ERRORS_H                                                 */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the list of FreeType 2 module error offsets (and messages).        */
+  /*                                                                       */
+#define FT_MODULE_ERRORS_H  <freetype/ftmoderr.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_SYSTEM_H                                                        */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the FreeType 2 interface to low-level operations (i.e. memory      */
+  /*    management and stream i/o).                                        */
+  /*                                                                       */
+  /*    It is included by @FT_FREETYPE_H.                                  */
+  /*                                                                       */
+#define FT_SYSTEM_H  <freetype/ftsystem.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_IMAGE_H                                                         */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    types definitions related to glyph images (i.e. bitmaps, outlines, */
+  /*    scan-converter parameters).                                        */
+  /*                                                                       */
+  /*    It is included by @FT_FREETYPE_H.                                  */
+  /*                                                                       */
+#define FT_IMAGE_H  <freetype/ftimage.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_TYPES_H                                                         */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the basic data types defined by FreeType 2.                        */
+  /*                                                                       */
+  /*    It is included by @FT_FREETYPE_H.                                  */
+  /*                                                                       */
+#define FT_TYPES_H  <freetype/fttypes.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_LIST_H                                                          */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the list management API of FreeType 2.                             */
+  /*                                                                       */
+  /*    (Most applications will never need to include this file.)          */
+  /*                                                                       */
+#define FT_LIST_H  <freetype/ftlist.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_OUTLINE_H                                                       */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the scalable outline management API of FreeType 2.                 */
+  /*                                                                       */
+#define FT_OUTLINE_H  <freetype/ftoutln.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_SIZES_H                                                         */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the API used to manage multiple @FT_Size objects per face.         */
+  /*                                                                       */
+#define FT_SIZES_H  <freetype/ftsizes.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_MODULE_H                                                        */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the module management API of FreeType 2.                           */
+  /*                                                                       */
+#define FT_MODULE_H  <freetype/ftmodule.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_RENDER_H                                                        */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the renderer module management API of FreeType 2.                  */
+  /*                                                                       */
+#define FT_RENDER_H  <freetype/ftrender.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_TYPE1_TABLES_H                                                  */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the types and API specific to the Type 1 format.                   */
+  /*                                                                       */
+#define FT_TYPE1_TABLES_H  <freetype/t1tables.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_TRUETYPE_IDS_H                                                  */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the enumeration values used to identify name strings, languages,   */
+  /*    encodings, etc.  This file really contains a _large_ set of        */
+  /*    constant macro definitions, taken from the TrueType and OpenType   */
+  /*    specifications.                                                    */
+  /*                                                                       */
+#define FT_TRUETYPE_IDS_H  <freetype/ttnameid.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_TRUETYPE_TABLES_H                                               */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the types and API specific to the TrueType (as well as OpenType)   */
+  /*    format.                                                            */
+  /*                                                                       */
+#define FT_TRUETYPE_TABLES_H  <freetype/tttables.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_TRUETYPE_TAGS_H                                                 */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the definitions of TrueType 4-byte `tags' used to identify blocks  */
+  /*    in SFNT-based font formats (i.e. TrueType and OpenType).           */
+  /*                                                                       */
+#define FT_TRUETYPE_TAGS_H  <freetype/tttags.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_BDF_H                                                           */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the definitions of an API to access BDF-specific strings from a    */
+  /*    face.                                                              */
+  /*                                                                       */
+#define FT_BDF_H  <freetype/ftbdf.h>
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_GZIP_H                                                          */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the definitions of an API to support for gzip-compressed files.    */
+  /*                                                                       */
+#define FT_GZIP_H  <freetype/ftgzip.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_GLYPH_H                                                         */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the API of the optional glyph management component.                */
+  /*                                                                       */
+#define FT_GLYPH_H  <freetype/ftglyph.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_BBOX_H                                                          */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the API of the optional exact bounding box computation routines.   */
+  /*                                                                       */
+#define FT_BBOX_H  <freetype/ftbbox.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_CACHE_H                                                         */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the API of the optional FreeType 2 cache sub-system.               */
+  /*                                                                       */
+#define FT_CACHE_H  <freetype/ftcache.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_CACHE_IMAGE_H                                                   */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the `glyph image' API of the FreeType 2 cache sub-system.          */
+  /*                                                                       */
+  /*    It is used to define a cache for @FT_Glyph elements.  You can also */
+  /*    see the API defined in @FT_CACHE_SMALL_BITMAPS_H if you only need  */
+  /*    to store small glyph bitmaps, as it will use less memory.          */
+  /*                                                                       */
+#define FT_CACHE_IMAGE_H  <freetype/cache/ftcimage.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_CACHE_SMALL_BITMAPS_H                                           */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the `small bitmaps' API of the FreeType 2 cache sub-system.        */
+  /*                                                                       */
+  /*    It is used to define a cache for small glyph bitmaps in a          */
+  /*    relatively memory-efficient way.  You can also use the API defined */
+  /*    in @FT_CACHE_IMAGE_H if you want to cache arbitrary glyph images,  */
+  /*    including scalable outlines.                                       */
+  /*                                                                       */
+#define FT_CACHE_SMALL_BITMAPS_H  <freetype/cache/ftcsbits.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_CACHE_CHARMAP_H                                                 */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the `charmap' API of the FreeType 2 cache sub-system.              */
+  /*                                                                       */
+#define FT_CACHE_CHARMAP_H  <freetype/cache/ftccmap.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_MAC_H                                                           */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the Macintosh-specific FreeType 2 API. The latter is used to       */
+  /*    access fonts embedded in resource forks.                           */
+  /*                                                                       */
+  /*    This header file must be explicitly included by client             */
+  /*    applications compiled on the Mac (note that the base API still     */
+  /*    works though).                                                     */
+  /*                                                                       */
+#define FT_MAC_H  <freetype/ftmac.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_MULTIPLE_MASTERS_H                                              */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the optional multiple-masters management API of FreeType 2.        */
+  /*                                                                       */
+#define FT_MULTIPLE_MASTERS_H  <freetype/ftmm.h>
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_SFNT_NAMES_H                                                    */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro used in #include statements to name the file containing    */
+  /*    the optional FreeType 2 API used to access embedded `name' strings */
+  /*    in SFNT-based font formats (i.e. TrueType and OpenType).           */
+  /*                                                                       */
+#define FT_SFNT_NAMES_H  <freetype/ftsnames.h>
+
+  /* */
+
+#define FT_TRIGONOMETRY_H          <freetype/fttrigon.h>
+#define FT_STROKER_H               <freetype/ftstroker.h>
+#define FT_SYNTHESIS_H             <freetype/ftsynth.h>
+#define FT_ERROR_DEFINITIONS_H     <freetype/fterrdef.h>
+
+#define FT_CACHE_MANAGER_H         <freetype/cache/ftcmanag.h>
+
+#define FT_CACHE_INTERNAL_LRU_H    <freetype/cache/ftlru.h>
+#define FT_CACHE_INTERNAL_GLYPH_H  <freetype/cache/ftcglyph.h>
+#define FT_CACHE_INTERNAL_CACHE_H  <freetype/cache/ftccache.h>
+
+#define FT_XFREE86_H               <freetype/ftxf86.h>
+
+#define FT_INCREMENTAL_H           <freetype/ftincrem.h>
+
+  /* now include internal headers definitions from <freetype/internal/...> */
+
+#define  FT_INTERNAL_INTERNAL_H    <freetype/internal/internal.h>
+#include FT_INTERNAL_INTERNAL_H
+
+
+#endif /* __FT2_BUILD_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/config/ftmodule.h
@@ -1,0 +1,19 @@
+FT_USE_MODULE(autohint_module_class)
+FT_USE_MODULE(cff_driver_class)
+/*FT_USE_MODULE(t1cid_driver_class)*/
+/*FT_USE_MODULE(pcf_driver_class)*/
+/*FT_USE_MODULE(bdf_driver_class)*/
+FT_USE_MODULE(psaux_module_class)
+FT_USE_MODULE(psnames_module_class)
+FT_USE_MODULE(pshinter_module_class)
+FT_USE_MODULE(ft_raster1_renderer_class)
+FT_USE_MODULE(sfnt_module_class)
+FT_USE_MODULE(ft_smooth_renderer_class)
+FT_USE_MODULE(ft_smooth_lcd_renderer_class)
+FT_USE_MODULE(ft_smooth_lcdv_renderer_class)
+FT_USE_MODULE(tt_driver_class)
+FT_USE_MODULE(t1_driver_class)
+FT_USE_MODULE(t42_driver_class)
+FT_USE_MODULE(pfr_driver_class)
+/*FT_USE_MODULE(winfnt_driver_class)*/
+
--- /dev/null
+++ b/include/freetype/config/ftmodule.h.orig
@@ -1,0 +1,19 @@
+FT_USE_MODULE(autohint_module_class)
+FT_USE_MODULE(cff_driver_class)
+FT_USE_MODULE(t1cid_driver_class)
+FT_USE_MODULE(pcf_driver_class)
+FT_USE_MODULE(bdf_driver_class)
+FT_USE_MODULE(psaux_module_class)
+FT_USE_MODULE(psnames_module_class)
+FT_USE_MODULE(pshinter_module_class)
+FT_USE_MODULE(ft_raster1_renderer_class)
+FT_USE_MODULE(sfnt_module_class)
+FT_USE_MODULE(ft_smooth_renderer_class)
+FT_USE_MODULE(ft_smooth_lcd_renderer_class)
+FT_USE_MODULE(ft_smooth_lcdv_renderer_class)
+FT_USE_MODULE(tt_driver_class)
+FT_USE_MODULE(t1_driver_class)
+FT_USE_MODULE(t42_driver_class)
+FT_USE_MODULE(pfr_driver_class)
+FT_USE_MODULE(winfnt_driver_class)
+
--- /dev/null
+++ b/include/freetype/config/ftoption.h
@@ -1,0 +1,478 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftoption.h                                                             */
+/*                                                                         */
+/*    User-selectable configuration macros (specification only).           */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTOPTION_H__
+#define __FTOPTION_H__
+
+
+#include <ft2build.h>
+
+
+FT_BEGIN_HEADER
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                 USER-SELECTABLE CONFIGURATION MACROS                  */
+  /*                                                                       */
+  /* This file contains the default configuration macro definitions for    */
+  /* a standard build of the FreeType library.  There are three ways to    */
+  /* use this file to build project-specific versions of the library:      */
+  /*                                                                       */
+  /*  - You can modify this file by hand, but this is not recommended in   */
+  /*    cases where you would like to build several versions of the        */
+  /*    library from a single source directory.                            */
+  /*                                                                       */
+  /*  - You can put a copy of this file in your build directory, more      */
+  /*    precisely in "$BUILD/freetype/config/ftoption.h", where "$BUILD"   */
+  /*    is the name of a directory that is included _before_ the FreeType  */
+  /*    include path during compilation.                                   */
+  /*                                                                       */
+  /*    The default FreeType Makefiles and Jamfiles use the build          */
+  /*    directory "builds/<system>" by default, but you can easily change  */
+  /*    that for your own projects.                                        */
+  /*                                                                       */
+  /*  - Copy the file <ft2build.h> to "$BUILD/ft2build.h" and modify it    */
+  /*    slightly to pre-define the macro FT_CONFIG_OPTIONS_H used to       */
+  /*    locate this file during the build.  For example,                   */
+  /*                                                                       */
+  /*      #define FT_CONFIG_OPTIONS_H  <myftoptions.h>                     */
+  /*      #include <freetype/config/ftheader.h>                            */
+  /*                                                                       */
+  /*    will use "$BUILD/myftoptions.h" instead of this file for macro     */
+  /*    definitions.                                                       */
+  /*                                                                       */
+  /*    Note also that you can similarly pre-define the macro              */
+  /*    FT_CONFIG_MODULES_H used to locate the file listing of the modules */
+  /*    that are statically linked to the library at compile time.  By     */
+  /*    default, this file is <freetype/config/ftmodule.h>.                */
+  /*                                                                       */
+  /*  We highly recommend using the third method whenever possible.        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /**** G E N E R A L   F R E E T Y P E   2   C O N F I G U R A T I O N ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Many compilers provide a non-ANSI 64-bit data type that can be used   */
+  /* by FreeType to speed up some computations.  However, this will create */
+  /* some problems when compiling the library in strict ANSI mode.         */
+  /*                                                                       */
+  /* For this reason, the use of 64-bit ints is normally disabled when     */
+  /* the __STDC__ macro is defined.  You can however disable this by       */
+  /* defining here the macro FT_CONFIG_OPTION_FORCE_INT64.                 */
+  /*                                                                       */
+  /* For most compilers, this will only create compilation warnings        */
+  /* when building the library.                                            */
+  /*                                                                       */
+  /* ObNote: The compiler-specific 64-bit integers are detected in the     */
+  /*         file "ftconfig.h" either statically, or through Autoconf      */
+  /*         on platforms that support it.                                 */
+  /*                                                                       */
+#undef  FT_CONFIG_OPTION_FORCE_INT64
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Gzip-compressed file support.                                         */
+  /*                                                                       */
+  /*   FreeType now handles font files that have been compressed with the  */
+  /*   'gzip' program. This is mostly used to parse many of the PCF files  */
+  /*   that come with XFree86. The implementation uses 'zlib' to           */
+  /*   partially uncompress the file on the fly (see src/base/ftgzip.c).   */
+  /*                                                                       */
+  /*   Define this macro if you want to enable this "feature". Note that   */
+  /*   this will however force you to link the zlib to any program that    */
+  /*   also uses FreeType.                                                 */
+  /*                                                                       */
+#define FT_CONFIG_OPTION_USE_ZLIB
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* ZLib library selection                                                */
+  /*                                                                       */
+  /*   This macro is only used when FT_CONFIG_OPTION_USE_ZLIB is defined.  */
+  /*   It allows FreeType's "ftgzip" component to link to the system's     */
+  /*   installation of the ZLib library. This is useful on systems like    */
+  /*   Unix or VMS where it generally is already available.                */
+  /*                                                                       */
+  /*   If you let it undefined, the component will use its own copy        */
+  /*   of the zlib sources instead. These have been modified to be         */
+  /*   included directly within the component and *not* export external    */
+  /*   function names. This allows you to link any program with FreeType   */
+  /*   _and_ ZLib without linking conflicts.                               */
+  /*                                                                       */
+  /*   do not #undef this macro here, since the build system might         */
+  /*   define for certain configurations                                   */
+  /*                                                                       */
+/* #define  FT_CONFIG_OPTION_SYSTEM_ZLIB */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* DLL export compilation                                                */
+  /*                                                                       */
+  /*   When compiling FreeType as a DLL, some systems/compilers need a     */
+  /*   special keyword in front OR after the return type of function       */
+  /*   declarations.                                                       */
+  /*                                                                       */
+  /*   Two macros are used within the FreeType source code to define       */
+  /*   exported library functions: FT_EXPORT and FT_EXPORT_DEF.            */
+  /*                                                                       */
+  /*     FT_EXPORT( return_type )                                          */
+  /*                                                                       */
+  /*       is used in a function declaration, as in                        */
+  /*                                                                       */
+  /*         FT_EXPORT( FT_Error )                                         */
+  /*         FT_Init_FreeType( FT_Library*  alibrary );                    */
+  /*                                                                       */
+  /*                                                                       */
+  /*     FT_EXPORT_DEF( return_type )                                      */
+  /*                                                                       */
+  /*       is used in a function definition, as in                         */
+  /*                                                                       */
+  /*         FT_EXPORT_DEF( FT_Error )                                     */
+  /*         FT_Init_FreeType( FT_Library*  alibrary )                     */
+  /*         {                                                             */
+  /*           ... some code ...                                           */
+  /*           return FT_Err_Ok;                                           */
+  /*         }                                                             */
+  /*                                                                       */
+  /*   You can provide your own implementation of FT_EXPORT and            */
+  /*   FT_EXPORT_DEF here if you want.  If you leave them undefined, they  */
+  /*   will be later automatically defined as `extern return_type' to      */
+  /*   allow normal compilation.                                           */
+  /*                                                                       */
+/* #define  FT_EXPORT(x)       extern x */
+/* #define  FT_EXPORT_DEF(x)   x */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Glyph Postscript Names handling                                       */
+  /*                                                                       */
+  /*   By default, FreeType 2 is compiled with the `PSNames' module.  This */
+  /*   module is in charge of converting a glyph name string into a        */
+  /*   Unicode value, or return a Macintosh standard glyph name for the    */
+  /*   use with the TrueType `post' table.                                 */
+  /*                                                                       */
+  /*   Undefine this macro if you do not want `PSNames' compiled in your   */
+  /*   build of FreeType.  This has the following effects:                 */
+  /*                                                                       */
+  /*   - The TrueType driver will provide its own set of glyph names,      */
+  /*     if you build it to support postscript names in the TrueType       */
+  /*     `post' table.                                                     */
+  /*                                                                       */
+  /*   - The Type 1 driver will not be able to synthetize a Unicode        */
+  /*     charmap out of the glyphs found in the fonts.                     */
+  /*                                                                       */
+  /*   You would normally undefine this configuration macro when building  */
+  /*   a version of FreeType that doesn't contain a Type 1 or CFF driver.  */
+  /*                                                                       */
+#define FT_CONFIG_OPTION_POSTSCRIPT_NAMES
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Postscript Names to Unicode Values support                            */
+  /*                                                                       */
+  /*   By default, FreeType 2 is built with the `PSNames' module compiled  */
+  /*   in.  Among other things, the module is used to convert a glyph name */
+  /*   into a Unicode value.  This is especially useful in order to        */
+  /*   synthetize on the fly a Unicode charmap from the CFF/Type 1 driver  */
+  /*   through a big table named the `Adobe Glyph List' (AGL).             */
+  /*                                                                       */
+  /*   Undefine this macro if you do not want the Adobe Glyph List         */
+  /*   compiled in your `PSNames' module.  The Type 1 driver will not be   */
+  /*   able to synthetize a Unicode charmap out of the glyphs found in the */
+  /*   fonts.                                                              */
+  /*                                                                       */
+#define FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Allow the use of FT_Incremental_Interface to load typefaces that      */
+  /* contain no glyph data, but supply it via a callback function.         */
+  /* This allows FreeType to be used with the PostScript language, using   */
+  /* the GhostScript interpreter.                                          */
+  /*                                                                       */
+/* #define  FT_CONFIG_OPTION_INCREMENTAL */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The size in bytes of the render pool used by the scan-line converter  */
+  /* to do all of its work.                                                */
+  /*                                                                       */
+  /* This must be greater than 4kByte.                                     */
+  /*                                                                       */
+#define FT_RENDER_POOL_SIZE  16384L
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* FT_MAX_MODULES                                                        */
+  /*                                                                       */
+  /*   The maximum number of modules that can be registered in a single    */
+  /*   FreeType library object.  32 is the default.                        */
+  /*                                                                       */
+#define FT_MAX_MODULES  32
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Debug level                                                           */
+  /*                                                                       */
+  /*   FreeType can be compiled in debug or trace mode.  In debug mode,    */
+  /*   errors are reported through the `ftdebug' component.  In trace      */
+  /*   mode, additional messages are sent to the standard output during    */
+  /*   execution.                                                          */
+  /*                                                                       */
+  /*   Define FT_DEBUG_LEVEL_ERROR to build the library in debug mode.     */
+  /*   Define FT_DEBUG_LEVEL_TRACE to build it in trace mode.              */
+  /*                                                                       */
+  /*   Don't define any of these macros to compile in `release' mode!      */
+  /*                                                                       */
+/* #define  FT_DEBUG_LEVEL_ERROR */
+/* #define  FT_DEBUG_LEVEL_TRACE */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Memory Debugging                                                      */
+  /*                                                                       */
+  /*   FreeType now comes with an integrated memory debugger that is       */
+  /*   capable of detecting simple errors like memory leaks or double      */
+  /*   deletes.  To compile it within your build of the library, you       */
+  /*   should define FT_DEBUG_MEMORY here.                                 */
+  /*                                                                       */
+  /*   Note that the memory debugger is only activated at runtime when     */
+  /*   when the _environment_ variable "FT_DEBUG_MEMORY" is also defined!  */
+  /*                                                                       */
+/* #define  FT_DEBUG_MEMORY */
+
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Module errors                                                         */
+  /*                                                                       */
+  /*   If this macro is set (which is _not_ the default), the higher byte  */
+  /*   of an error code gives the module in which the error has occurred,  */
+  /*   while the lower byte is the real error code.                        */
+  /*                                                                       */
+  /*   Setting this macro makes sense for debugging purposes only, since   */
+  /*   it would break source compatibility of certain programs that use    */
+  /*   FreeType 2.                                                         */
+  /*                                                                       */
+  /*   More details can be found in the files ftmoderr.h and fterrors.h.   */
+  /*                                                                       */
+#undef FT_CONFIG_OPTION_USE_MODULE_ERRORS
+
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****        S F N T   D R I V E R    C O N F I G U R A T I O N       ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define TT_CONFIG_OPTION_EMBEDDED_BITMAPS if you want to support       */
+  /* embedded bitmaps in all formats using the SFNT module (namely         */
+  /* TrueType & OpenType).                                                 */
+  /*                                                                       */
+#define TT_CONFIG_OPTION_EMBEDDED_BITMAPS
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define TT_CONFIG_OPTION_POSTSCRIPT_NAMES if you want to be able to    */
+  /* load and enumerate the glyph Postscript names in a TrueType or        */
+  /* OpenType file.                                                        */
+  /*                                                                       */
+  /* Note that when you do not compile the `PSNames' module by undefining  */
+  /* the above FT_CONFIG_OPTION_POSTSCRIPT_NAMES, the `sfnt' module will   */
+  /* contain additional code used to read the PS Names table from a font.  */
+  /*                                                                       */
+  /* (By default, the module uses `PSNames' to extract glyph names.)       */
+  /*                                                                       */
+#define TT_CONFIG_OPTION_POSTSCRIPT_NAMES
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define TT_CONFIG_OPTION_SFNT_NAMES if your applications need to       */
+  /* access the internal name table in a SFNT-based format like TrueType   */
+  /* or OpenType.  The name table contains various strings used to         */
+  /* describe the font, like family name, copyright, version, etc.  It     */
+  /* does not contain any glyph name though.                               */
+  /*                                                                       */
+  /* Accessing SFNT names is done through the functions declared in        */
+  /* `freetype/ftnames.h'.                                                 */
+  /*                                                                       */
+#define TT_CONFIG_OPTION_SFNT_NAMES
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* TrueType CMap support                                                 */
+  /*                                                                       */
+  /*   Here you can fine-tune which TrueType CMap table format shall be    */
+  /*   supported.                                                          */
+#define TT_CONFIG_CMAP_FORMAT_0
+#define TT_CONFIG_CMAP_FORMAT_2
+#define TT_CONFIG_CMAP_FORMAT_4
+#define TT_CONFIG_CMAP_FORMAT_6
+#define TT_CONFIG_CMAP_FORMAT_8
+#define TT_CONFIG_CMAP_FORMAT_10
+#define TT_CONFIG_CMAP_FORMAT_12
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****    T R U E T Y P E   D R I V E R    C O N F I G U R A T I O N   ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define TT_CONFIG_OPTION_BYTECODE_INTERPRETER if you want to compile   */
+  /* a bytecode interpreter in the TrueType driver.  Note that there are   */
+  /* important patent issues related to the use of the interpreter.        */
+  /*                                                                       */
+  /* By undefining this, you will only compile the code necessary to load  */
+  /* TrueType glyphs without hinting.                                      */
+  /*                                                                       */
+  /*   do not #undef this macro here, since the build system might         */
+  /*   define for certain configurations                                   */
+  /*                                                                       */
+/*#define  TT_CONFIG_OPTION_BYTECODE_INTERPRETER*/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define TT_CONFIG_OPTION_INTERPRETER_SWITCH to compile the TrueType    */
+  /* bytecode interpreter with a huge switch statement, rather than a call */
+  /* table.  This results in smaller and faster code for a number of       */
+  /* architectures.                                                        */
+  /*                                                                       */
+  /* Note however that on some compiler/processor combinations, undefining */
+  /* this macro will generate faster, though larger, code.                 */
+  /*                                                                       */
+#define TT_CONFIG_OPTION_INTERPRETER_SWITCH
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED to compile the        */
+  /* TrueType glyph loader to use Apple's definition of how to handle      */
+  /* component offsets in composite glyphs.                                */
+  /*                                                                       */
+  /* Apple and MS disagree on the default behavior of component offsets    */
+  /* in composites.  Apple says that they should be scaled by the scale    */
+  /* factors in the transformation matrix (roughly, it's more complex)     */
+  /* while MS says they should not.  OpenType defines two bits in the      */
+  /* composite flags array which can be used to disambiguate, but old      */
+  /* fonts will not have them.                                             */
+  /*                                                                       */
+  /*   http://partners.adobe.com/asn/developer/opentype/glyf.html          */
+  /*   http://fonts.apple.com/TTRefMan/RM06/Chap6glyf.html                 */
+  /*                                                                       */
+#undef TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****      T Y P E 1   D R I V E R    C O N F I G U R A T I O N       ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* T1_MAX_DICT_DEPTH is the maximal depth of nest dictionaries and       */
+  /* arrays in the Type 1 stream (see t1load.c).  A minimum of 4 is        */
+  /* required.                                                             */
+  /*                                                                       */
+#define T1_MAX_DICT_DEPTH  5
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* T1_MAX_SUBRS_CALLS details the maximum number of nested sub-routine   */
+  /* calls during glyph loading.                                           */
+  /*                                                                       */
+#define T1_MAX_SUBRS_CALLS  16
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* T1_MAX_CHARSTRING_OPERANDS is the charstring stack's capacity.  A     */
+  /* minimum of 16 is required.                                            */
+  /*                                                                       */
+  /* The Chinese font MingTiEG-Medium (CNS 11643 character set) needs 256. */
+  /*                                                                       */
+#define T1_MAX_CHARSTRINGS_OPERANDS  256
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define this configuration macro if you want to prevent the            */
+  /* compilation of `t1afm', which is in charge of reading Type 1 AFM      */
+  /* files into an existing face.  Note that if set, the T1 driver will be */
+  /* unable to produce kerning distances.                                  */
+  /*                                                                       */
+#undef T1_CONFIG_OPTION_NO_AFM
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define this configuration macro if you want to prevent the            */
+  /* compilation of the Multiple Masters font support in the Type 1        */
+  /* driver.                                                               */
+  /*                                                                       */
+#undef T1_CONFIG_OPTION_NO_MM_SUPPORT
+
+ /* */
+
+FT_END_HEADER
+
+
+#endif /* __FTOPTION_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/config/ftstdlib.h
@@ -1,0 +1,149 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftstdlib.h                                                             */
+/*                                                                         */
+/*    ANSI-specific library and header configuration file (specification   */
+/*    only).                                                               */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file is used to group all #includes to the ANSI C library that   */
+  /* FreeType normally requires.  It also defines macros to rename the     */
+  /* standard functions within the FreeType source code.                   */
+  /*                                                                       */
+  /* Load a file which defines __FTSTDLIB_H__ before this one to override  */
+  /* it.                                                                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __FTSTDLIB_H__
+#define __FTSTDLIB_H__
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                           integer limits                           */
+  /*                                                                    */
+  /* UINT_MAX and ULONG_MAX are used to automatically compute the size  */
+  /* of `int' and `long' in bytes at compile-time.  So far, this works  */
+  /* for all platforms the library has been tested on.                  */
+  /*                                                                    */
+  /* Note that on the extremely rare platforms that do not provide      */
+  /* integer types that are _exactly_ 16 and 32 bits wide (e.g. some    */
+  /* old Crays where `int' is 36 bits), we do not make any guarantee    */
+  /* about the correct behaviour of FT2 with all fonts.                 */
+  /*                                                                    */
+  /* In these case, "ftconfig.h" will refuse to compile anyway with a   */
+  /* message like "couldn't find 32-bit type" or something similar.     */
+  /*                                                                    */
+  /* IMPORTANT NOTE: We do not define aliases for heap management and   */
+  /*                 i/o routines (i.e. malloc/free/fopen/fread/...)    */
+  /*                 since these functions should all be encapsulated   */
+  /*                 by platform-specific implementations of            */
+  /*                 "ftsystem.c".                                      */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#include <lib9.h>
+#define UINT_MAX	0xffffffffU
+#define ULONG_MAX	0xffffffffUL
+/*#include <limits.h>*/
+
+#define FT_UINT_MAX   UINT_MAX
+#define FT_ULONG_MAX  ULONG_MAX
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                 character and string processing                    */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#include <ctype.h>
+
+#define ft_isalnum  isalnum
+#define ft_isupper  isupper
+#define ft_islower  islower
+#define ft_xdigit   isxdigit
+
+
+/*#include <string.h>*/
+
+#define ft_strlen   strlen
+#define ft_strcmp   strcmp
+#define ft_strncmp  strncmp
+#define ft_memcpy   memcpy
+#define ft_strcpy   strcpy
+#define ft_strncpy  strncpy
+#define ft_memset   memset
+#define ft_memmove  memmove
+#define ft_memcmp   memcmp
+
+#include <stdio.h>
+
+#define ft_sprintf  sprintf
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                             sorting                                */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+
+/*#include <stdlib.h>*/
+
+#define ft_qsort  qsort
+
+/*#define ft_exit   exit    /* only used to exit from unhandled exceptions */
+
+#define ft_exit(a)   exits("")    /* only used to exit from unhandled exceptions */
+
+#define ft_atoi   atoi
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                         execution control                          */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+/*#include <setjmp.h>*/
+
+#define ft_jmp_buf  jmp_buf   /* note: this cannot be a typedef since */
+                              /*       jmp_buf is defined as a macro  */
+                              /*       on certain platforms           */
+
+#define ft_setjmp   setjmp    /* same thing here */
+#define ft_longjmp  longjmp   /* "               */
+
+
+  /* the following is only used for debugging purposes, i.e. when */
+  /* FT_DEBUG_LEVEL_ERROR or FT_DEBUG_LEVEL_TRACE are defined     */
+  /*                                                              */
+/*
+#include <stdarg.h>
+*/
+
+
+#endif /* __FTSTDLIB_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/config/ftstdlib.h.orig
@@ -1,0 +1,140 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftstdlib.h                                                             */
+/*                                                                         */
+/*    ANSI-specific library and header configuration file (specification   */
+/*    only).                                                               */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file is used to group all #includes to the ANSI C library that   */
+  /* FreeType normally requires.  It also defines macros to rename the     */
+  /* standard functions within the FreeType source code.                   */
+  /*                                                                       */
+  /* Load a file which defines __FTSTDLIB_H__ before this one to override  */
+  /* it.                                                                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __FTSTDLIB_H__
+#define __FTSTDLIB_H__
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                           integer limits                           */
+  /*                                                                    */
+  /* UINT_MAX and ULONG_MAX are used to automatically compute the size  */
+  /* of `int' and `long' in bytes at compile-time.  So far, this works  */
+  /* for all platforms the library has been tested on.                  */
+  /*                                                                    */
+  /* Note that on the extremely rare platforms that do not provide      */
+  /* integer types that are _exactly_ 16 and 32 bits wide (e.g. some    */
+  /* old Crays where `int' is 36 bits), we do not make any guarantee    */
+  /* about the correct behaviour of FT2 with all fonts.                 */
+  /*                                                                    */
+  /* In these case, "ftconfig.h" will refuse to compile anyway with a   */
+  /* message like "couldn't find 32-bit type" or something similar.     */
+  /*                                                                    */
+  /* IMPORTANT NOTE: We do not define aliases for heap management and   */
+  /*                 i/o routines (i.e. malloc/free/fopen/fread/...)    */
+  /*                 since these functions should all be encapsulated   */
+  /*                 by platform-specific implementations of            */
+  /*                 "ftsystem.c".                                      */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#include <limits.h>
+
+#define FT_UINT_MAX   UINT_MAX
+#define FT_ULONG_MAX  ULONG_MAX
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                 character and string processing                    */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#include <ctype.h>
+
+#define ft_isalnum  isalnum
+#define ft_isupper  isupper
+#define ft_islower  islower
+#define ft_xdigit   isxdigit
+
+
+#include <string.h>
+
+#define ft_strlen   strlen
+#define ft_strcmp   strcmp
+#define ft_strncmp  strncmp
+#define ft_memcpy   memcpy
+#define ft_strcpy   strcpy
+#define ft_strncpy  strncpy
+#define ft_memset   memset
+#define ft_memmove  memmove
+#define ft_memcmp   memcmp
+
+#include <stdio.h>
+
+#define ft_sprintf  sprintf
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                             sorting                                */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#include <stdlib.h>
+
+#define ft_qsort  qsort
+#define ft_exit   exit    /* only used to exit from unhandled exceptions */
+
+#define ft_atoi   atoi
+
+
+  /**********************************************************************/
+  /*                                                                    */
+  /*                         execution control                          */
+  /*                                                                    */
+  /**********************************************************************/
+
+
+#include <setjmp.h>
+
+#define ft_jmp_buf  jmp_buf   /* note: this cannot be a typedef since */
+                              /*       jmp_buf is defined as a macro  */
+                              /*       on certain platforms           */
+
+#define ft_setjmp   setjmp    /* same thing here */
+#define ft_longjmp  longjmp   /* "               */
+
+
+  /* the following is only used for debugging purposes, i.e. when */
+  /* FT_DEBUG_LEVEL_ERROR or FT_DEBUG_LEVEL_TRACE are defined     */
+  /*                                                              */
+#include <stdarg.h>
+
+
+#endif /* __FTSTDLIB_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/freetype.h
@@ -1,0 +1,2860 @@
+/***************************************************************************/
+/*                                                                         */
+/*  freetype.h                                                             */
+/*                                                                         */
+/*    FreeType high-level API and common types (specification only).       */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FREETYPE_H__
+#define __FREETYPE_H__
+#pragma incomplete _off_	/* it's too hard */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The `raster' component duplicates some of the declarations in         */
+  /* freetype.h for stand-alone use if _FREETYPE_ isn't defined.           */
+  /*                                                                       */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The FREETYPE_MAJOR and FREETYPE_MINOR macros are used to version the  */
+  /* new FreeType design, which is able to host several kinds of font      */
+  /* drivers.  It starts at 2.0.                                           */
+  /*                                                                       */
+#define FREETYPE_MAJOR 2
+#define FREETYPE_MINOR 1
+#define FREETYPE_PATCH 3
+
+
+#include <ft2build.h>
+#include FT_CONFIG_CONFIG_H
+#include FT_ERRORS_H
+#include FT_TYPES_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*                                                                       */
+  /*                        B A S I C   T Y P E S                          */
+  /*                                                                       */
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    base_interface                                                     */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Base Interface                                                     */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    The FreeType 2 base font interface.                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section describes the public high-level API of FreeType 2.    */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    FT_Library                                                         */
+  /*    FT_Face                                                            */
+  /*    FT_Size                                                            */
+  /*    FT_GlyphSlot                                                       */
+  /*    FT_CharMap                                                         */
+  /*    FT_Encoding                                                        */
+  /*                                                                       */
+  /*    FT_FaceRec                                                         */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_SCALABLE                                              */
+  /*    FT_FACE_FLAG_FIXED_SIZES                                           */
+  /*    FT_FACE_FLAG_FIXED_WIDTH                                           */
+  /*    FT_FACE_FLAG_HORIZONTAL                                            */
+  /*    FT_FACE_FLAG_VERTICAL                                              */
+  /*    FT_FACE_FLAG_SFNT                                                  */
+  /*    FT_FACE_FLAG_KERNING                                               */
+  /*    FT_FACE_FLAG_MULTIPLE_MASTERS                                      */
+  /*    FT_FACE_FLAG_GLYPH_NAMES                                           */
+  /*    FT_FACE_FLAG_EXTERNAL_STREAM                                       */
+  /*    FT_FACE_FLAG_FAST_GLYPHS                                           */
+  /*                                                                       */
+  /*    FT_STYLE_FLAG_BOLD                                                 */
+  /*    FT_STYLE_FLAG_ITALIC                                               */
+  /*                                                                       */
+  /*    FT_SizeRec                                                         */
+  /*    FT_Size_Metrics                                                    */
+  /*                                                                       */
+  /*    FT_GlyphSlotRec                                                    */
+  /*    FT_Glyph_Metrics                                                   */
+  /*    FT_SubGlyph                                                        */
+  /*                                                                       */
+  /*    FT_Bitmap_Size                                                     */
+  /*                                                                       */
+  /*    FT_Init_FreeType                                                   */
+  /*    FT_Done_FreeType                                                   */
+  /*    FT_Library_Version                                                 */
+  /*                                                                       */
+  /*    FT_New_Face                                                        */
+  /*    FT_Done_Face                                                       */
+  /*    FT_New_Memory_Face                                                 */
+  /*    FT_Open_Face                                                       */
+  /*    FT_Open_Args                                                       */
+  /*    FT_Open_Flags                                                      */
+  /*    FT_Parameter                                                       */
+  /*    FT_Attach_File                                                     */
+  /*    FT_Attach_Stream                                                   */
+  /*                                                                       */
+  /*    FT_Set_Char_Size                                                   */
+  /*    FT_Set_Pixel_Sizes                                                 */
+  /*    FT_Set_Transform                                                   */
+  /*    FT_Load_Glyph                                                      */
+  /*    FT_Get_Char_Index                                                  */
+  /*    FT_Get_Name_Index                                                  */
+  /*    FT_Load_Char                                                       */
+  /*                                                                       */
+  /*    FT_LOAD_DEFAULT                                                    */
+  /*    FT_LOAD_RENDER                                                     */
+  /*    FT_LOAD_MONOCHROME                                                 */
+  /*    FT_LOAD_LINEAR_DESIGN                                              */
+  /*    FT_LOAD_NO_SCALE                                                   */
+  /*    FT_LOAD_NO_HINTING                                                 */
+  /*    FT_LOAD_NO_BITMAP                                                  */
+  /*    FT_LOAD_CROP_BITMAP                                                */
+  /*                                                                       */
+  /*    FT_LOAD_VERTICAL_LAYOUT                                            */
+  /*    FT_LOAD_IGNORE_TRANSFORM                                           */
+  /*    FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH                                */
+  /*    FT_LOAD_FORCE_AUTOHINT                                             */
+  /*    FT_LOAD_NO_RECURSE                                                 */
+  /*    FT_LOAD_PEDANTIC                                                   */
+  /*                                                                       */
+  /*    FT_Render_Glyph                                                    */
+  /*    FT_Render_Mode                                                     */
+  /*    FT_Get_Kerning                                                     */
+  /*    FT_Kerning_Mode                                                    */
+  /*    FT_Get_Glyph_Name                                                  */
+  /*    FT_Get_Postscript_Name                                             */
+  /*                                                                       */
+  /*    FT_CharMapRec                                                      */
+  /*    FT_Select_Charmap                                                  */
+  /*    FT_Set_Charmap                                                     */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Glyph_Metrics                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model the metrics of a single glyph.  Note     */
+  /*    that values are expressed in 26.6 fractional pixel format or in    */
+  /*    font units, depending on context.                                  */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    width        :: The glyph's width.                                 */
+  /*                                                                       */
+  /*    height       :: The glyph's height.                                */
+  /*                                                                       */
+  /*    horiBearingX :: Horizontal left side bearing.                      */
+  /*                                                                       */
+  /*    horiBearingY :: Horizontal top side bearing.                       */
+  /*                                                                       */
+  /*    horiAdvance  :: Horizontal advance width.                          */
+  /*                                                                       */
+  /*    vertBearingX :: Vertical left side bearing.                        */
+  /*                                                                       */
+  /*    vertBearingY :: Vertical top side bearing.                         */
+  /*                                                                       */
+  /*    vertAdvance  :: Vertical advance height.                           */
+  /*                                                                       */
+  typedef struct  FT_Glyph_Metrics_
+  {
+    FT_Pos  width;         /* glyph width  */
+    FT_Pos  height;        /* glyph height */
+
+    FT_Pos  horiBearingX;  /* left side bearing in horizontal layouts */
+    FT_Pos  horiBearingY;  /* top side bearing in horizontal layouts  */
+    FT_Pos  horiAdvance;   /* advance width for horizontal layout     */
+
+    FT_Pos  vertBearingX;  /* left side bearing in vertical layouts */
+    FT_Pos  vertBearingY;  /* top side bearing in vertical layouts  */
+    FT_Pos  vertAdvance;   /* advance height for vertical layout    */
+
+  } FT_Glyph_Metrics;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Bitmap_Size                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An extremely simple structure used to model the size of a bitmap   */
+  /*    strike (i.e., a bitmap instance of the font for a given            */
+  /*    resolution) in a fixed-size font face.  This is used for the       */
+  /*    `available_sizes' field of the FT_Face_Properties structure.       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    height :: The character height in pixels.                          */
+  /*                                                                       */
+  /*    width  :: The character width in pixels.                           */
+  /*                                                                       */
+  typedef struct  FT_Bitmap_Size_
+  {
+    FT_Short  height;
+    FT_Short  width;
+
+  } FT_Bitmap_Size;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*                                                                       */
+  /*                     O B J E C T   C L A S S E S                       */
+  /*                                                                       */
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Library                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a FreeType library instance.  Each `library' is        */
+  /*    completely independent from the others; it is the `root' of a set  */
+  /*    of objects like fonts, faces, sizes, etc.                          */
+  /*                                                                       */
+  /*    It also embeds a memory manager (see @FT_Memory), as well as a     */
+  /*    scan-line converter object (see @FT_Raster).                       */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Library objects are normally created by @FT_Init_FreeType, and     */
+  /*    destroyed with @FT_Done_FreeType.                                  */
+  /*                                                                       */
+  typedef struct FT_LibraryRec_  *FT_Library;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Module                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a given FreeType module object.  Each module can be a  */
+  /*    font driver, a renderer, or anything else that provides services   */
+  /*    to the formers.                                                    */
+  /*                                                                       */
+  typedef struct FT_ModuleRec_*  FT_Module;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Driver                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a given FreeType font driver object.  Each font driver */
+  /*    is a special module capable of creating faces from font files.     */
+  /*                                                                       */
+  typedef struct FT_DriverRec_*  FT_Driver;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Renderer                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a given FreeType renderer.  A renderer is a special    */
+  /*    module in charge of converting a glyph image to a bitmap, when     */
+  /*    necessary.  Each renderer supports a given glyph image format, and */
+  /*    one or more target surface depths.                                 */
+  /*                                                                       */
+  typedef struct FT_RendererRec_*  FT_Renderer;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Face                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a given typographic face object.  A face object models */
+  /*    a given typeface, in a given style.                                */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Each face object also owns a single @FT_GlyphSlot object, as well  */
+  /*    as one or more @FT_Size objects.                                   */
+  /*                                                                       */
+  /*    Use @FT_New_Face or @FT_Open_Face to create a new face object from */
+  /*    a given filepathname or a custom input stream.                     */
+  /*                                                                       */
+  /*    Use @FT_Done_Face to destroy it (along with its slot and sizes).   */
+  /*                                                                       */
+  /* <Also>                                                                */
+  /*    The @FT_FaceRec details the publicly accessible fields of a given  */
+  /*    face object.                                                       */
+  /*                                                                       */
+  typedef struct FT_FaceRec_*  FT_Face;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Size                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a given size object.  Such an object models the data   */
+  /*    that depends on the current _resolution_ and _character size_ in a */
+  /*    given @FT_Face.                                                    */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Each face object owns one or more sizes.  There is however a       */
+  /*    single _active_ size for the face at any time that will be used by */
+  /*    functions like @FT_Load_Glyph, @FT_Get_Kerning, etc.               */
+  /*                                                                       */
+  /*    You can use the @FT_Activate_Size API to change the current        */
+  /*    active size of any given face.                                     */
+  /*                                                                       */
+  /* <Also>                                                                */
+  /*    The @FT_SizeRec structure details the publicly accessible fields   */
+  /*    of a given face object.                                            */
+  /*                                                                       */
+  typedef struct FT_SizeRec_*  FT_Size;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_GlyphSlot                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a given `glyph slot'.  A slot is a container where it  */
+  /*    is possible to load any one of the glyphs contained in its parent  */
+  /*    face.                                                              */
+  /*                                                                       */
+  /*    In other words, each time you call @FT_Load_Glyph or               */
+  /*    @FT_Load_Char, the slot's content is erased by the new glyph data, */
+  /*    i.e. the glyph's metrics, its image (bitmap or outline), and       */
+  /*    other control information.                                         */
+  /*                                                                       */
+  /* <Also>                                                                */
+  /*    @FT_GlyphSlotRec details the publicly accessible glyph fields.     */
+  /*                                                                       */
+  typedef struct FT_GlyphSlotRec_*  FT_GlyphSlot;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_CharMap                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a given character map.  A charmap is used to translate */
+  /*    character codes in a given encoding into glyph indexes for its     */
+  /*    parent's face.  Some font formats may provide several charmaps per */
+  /*    font.                                                              */
+  /*                                                                       */
+  /*    Each face object owns zero or more charmaps, but only one of them  */
+  /*    can be "active" and used by @FT_Get_Char_Index or @FT_Load_Char.   */
+  /*                                                                       */
+  /*    The list of available charmaps in a face is available through the  */
+  /*    "face->num_charmaps" and "face->charmaps" fields of @FT_FaceRec.   */
+  /*                                                                       */
+  /*    The currently active charmap is available as "face->charmap".      */
+  /*    You should call @FT_Set_Charmap to change it.                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    When a new face is created (either through @FT_New_Face or         */
+  /*    @FT_Open_Face), the library looks for a Unicode charmap within     */
+  /*    the list and automatically activates it.                           */
+  /*                                                                       */
+  typedef struct FT_CharMapRec_*  FT_CharMap;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Macro>                                                               */
+  /*    FT_ENC_TAG                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This macro converts four letter tags into an unsigned long.  It is */
+  /*    used to define "encoding" identifiers (see @FT_Encoding).          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Since many 16bit compilers don't like 32bit enumerations, you      */
+  /*    should redefine this macro in case of problems to something like   */
+  /*    this:                                                              */
+  /*                                                                       */
+  /*      #define FT_ENC_TAG( value, a, b, c, d )  (value)                 */
+  /*                                                                       */
+  /*    to get a simple enumeration without assigning special numbers.     */
+  /*                                                                       */
+
+#ifndef FT_ENC_TAG
+#define FT_ENC_TAG( value, a, b, c, d )         \
+          value = ( ( (FT_UInt32)(a) << 24 ) |  \
+                    ( (FT_UInt32)(b) << 16 ) |  \
+                    ( (FT_UInt32)(c) <<  8 ) |  \
+                      (FT_UInt32)(d)         )
+
+#endif /* FT_ENC_TAG */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Encoding                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration used to specify encodings supported by charmaps.    */
+  /*    Used in the @FT_Select_Charmap API function.                       */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Because of 32-bit charcodes defined in Unicode (i.e., surrogates), */
+  /*    all character codes must be expressed as FT_Longs.                 */
+  /*                                                                       */
+  /*    The values of this type correspond to specific character           */
+  /*    repertories (i.e. charsets), and not to text encoding methods      */
+  /*    (like UTF-8, UTF-16, GB2312_EUC, etc.).                            */
+  /*                                                                       */
+  /*    Other encodings might be defined in the future.                    */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*   FT_ENCODING_NONE ::                                                 */
+  /*     The encoding value 0 is reserved.                                 */
+  /*                                                                       */
+  /*   FT_ENCODING_UNICODE ::                                              */
+  /*     Corresponds to the Unicode character set.  This value covers      */
+  /*     all versions of the Unicode repertoire, including ASCII and       */
+  /*     Latin-1.  Most fonts include a Unicode charmap, but not all       */
+  /*     of them.                                                          */
+  /*                                                                       */
+  /*   FT_ENCODING_MS_SYMBOL ::                                            */
+  /*     Corresponds to the Microsoft Symbol encoding, used to encode      */
+  /*     mathematical symbols in the 32..255 character code range.  For    */
+  /*     more information, see `http://www.ceviz.net/symbol.htm'.          */
+  /*                                                                       */
+  /*   FT_ENCODING_MS_SJIS ::                                              */
+  /*     Corresponds to Microsoft's Japanese SJIS encoding.  More info     */
+  /*     at `http://langsupport.japanreference.com/encoding.shtml'.        */
+  /*     See note on multi-byte encodings below.                           */
+  /*                                                                       */
+  /*   FT_ENCODING_MS_GB2312 ::                                            */
+  /*     Corresponds to the encoding system for Simplified Chinese, as     */
+  /*     used in China.  Only found in some TrueType fonts.                */
+  /*                                                                       */
+  /*   FT_ENCODING_MS_BIG5 ::                                              */
+  /*     Corresponds to the encoding system for Traditional Chinese, as    */
+  /*     used in Taiwan and Hong Kong.  Only found in some TrueType fonts. */
+  /*                                                                       */
+  /*   FT_ENCODING_MS_WANSUNG ::                                           */
+  /*     Corresponds to the Korean encoding system known as Wansung.       */
+  /*     This is a Microsoft encoding that is only found in some TrueType  */
+  /*     fonts.  For more information, see                                 */
+  /*     `http://www.microsoft.com/typography/unicode/949.txt'.            */
+  /*                                                                       */
+  /*   FT_ENCODING_MS_JOHAB ::                                             */
+  /*     The Korean standard character set (KS C-5601-1992), which         */
+  /*     corresponds to Windows code page 1361.  This character set        */
+  /*     includes all possible Hangeul character combinations.             */
+  /*     Only found on some rare TrueType fonts.                           */
+  /*                                                                       */
+  /*   FT_ENCODING_ADOBE_LATIN_1 ::                                        */
+  /*     Corresponds to a Latin-1 encoding as defined in a Type 1          */
+  /*     Postscript font.  It is limited to 256 character codes.           */
+  /*                                                                       */
+  /*   FT_ENCODING_ADOBE_STANDARD ::                                       */
+  /*     Corresponds to the Adobe Standard encoding, as found in Type 1,   */
+  /*     CFF, and OpenType/CFF fonts.  It is limited to 256character       */
+  /*     codes.                                                            */
+  /*                                                                       */
+  /*   FT_ENCODING_ADOBE_EXPERT ::                                         */
+  /*     Corresponds to the Adobe Expert encoding, as found in Type 1,     */
+  /*     CFF, and OpenType/CFF fonts.  It is limited to 256 character      */
+  /*     codes.                                                            */
+  /*                                                                       */
+  /*   FT_ENCODING_ADOBE_CUSTOM ::                                         */
+  /*     Corresponds to a custom encoding, as found in Type 1, CFF, and    */
+  /*     OpenType/CFF fonts.  It is limited to 256 character codes.        */
+  /*                                                                       */
+  /*   FT_ENCODING_APPLE_ROMAN ::                                          */
+  /*     Corresponds to the 8-bit Apple roman encoding.  Many TrueType and */
+  /*     OpenType fonts contain a charmap for this encoding, since older   */
+  /*     versions of Mac OS are able to use it.                            */
+  /*                                                                       */
+  /*   FT_ENCODING_OLD_LATIN_2 ::                                          */
+  /*     This value is deprecated and was never used nor reported by       */
+  /*     FreeType.  Don't use or test for it.                              */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*   By default, FreeType automatically synthetizes a Unicode charmap    */
+  /*   for Postscript fonts, using their glyph names dictionaries.         */
+  /*   However, it will also report the encodings defined explicitly in    */
+  /*   the font file, for the cases when they are needed, with the Adobe   */
+  /*   values as well.                                                     */
+  /*                                                                       */
+  typedef enum  FT_Encoding_
+  {
+    FT_ENC_TAG( FT_ENCODING_NONE, 0, 0, 0, 0 ),
+
+    FT_ENC_TAG( FT_ENCODING_MS_SYMBOL,  's', 'y', 'm', 'b' ),
+    FT_ENC_TAG( FT_ENCODING_UNICODE,    'u', 'n', 'i', 'c' ),
+
+    FT_ENC_TAG( FT_ENCODING_MS_SJIS,    's', 'j', 'i', 's' ),
+    FT_ENC_TAG( FT_ENCODING_MS_GB2312,  'g', 'b', ' ', ' ' ),
+    FT_ENC_TAG( FT_ENCODING_MS_BIG5,    'b', 'i', 'g', '5' ),
+    FT_ENC_TAG( FT_ENCODING_MS_WANSUNG, 'w', 'a', 'n', 's' ),
+    FT_ENC_TAG( FT_ENCODING_MS_JOHAB,   'j', 'o', 'h', 'a' ),
+
+    FT_ENC_TAG( FT_ENCODING_ADOBE_STANDARD, 'A', 'D', 'O', 'B' ),
+    FT_ENC_TAG( FT_ENCODING_ADOBE_EXPERT,   'A', 'D', 'B', 'E' ),
+    FT_ENC_TAG( FT_ENCODING_ADOBE_CUSTOM,   'A', 'D', 'B', 'C' ),
+    FT_ENC_TAG( FT_ENCODING_ADOBE_LATIN_1,  'l', 'a', 't', '1' ),
+
+    FT_ENC_TAG( FT_ENCODING_OLD_LATIN_2, 'l', 'a', 't', '2' ),
+
+    FT_ENC_TAG( FT_ENCODING_APPLE_ROMAN, 'a', 'r', 'm', 'n' )
+
+  } FT_Encoding;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    ft_encoding_xxx                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    These constants are deprecated; use the corresponding @FT_Encoding */
+  /*    values instead.                                                    */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*   ft_encoding_none    :: see @FT_ENCODING_NONE                        */
+  /*   ft_encoding_unicode :: see @FT_ENCODING_UNICODE                     */
+  /*   ft_encoding_latin_2 :: see @FT_ENCODING_OLD_LATIN_2                 */
+  /*   ft_encoding_symbol  :: see @FT_ENCODING_MS_SYMBOL                   */
+  /*   ft_encoding_sjis    :: see @FT_ENCODING_MS_SJIS                     */
+  /*   ft_encoding_gb2312  :: see @FT_ENCODING_MS_GB2312                   */
+  /*   ft_encoding_big5    :: see @FT_ENCODING_MS_BIG5                     */
+  /*   ft_encoding_wansung :: see @FT_ENCODING_MS_WANSUNG                  */
+  /*   ft_encoding_johab   :: see @FT_ENCODING_MS_JOHAB                    */
+  /*                                                                       */
+  /*   ft_encoding_adobe_standard :: see @FT_ENCODING_ADOBE_STANDARD       */
+  /*   ft_encoding_adobe_expert   :: see @FT_ENCODING_ADOBE_EXPERT         */
+  /*   ft_encoding_adobe_custom   :: see @FT_ENCODING_ADOBE_CUSTOM         */
+  /*   ft_encoding_latin_1        :: see @FT_ENCODING_ADOBE_LATIN_1        */
+  /*                                                                       */
+  /*   ft_encoding_apple_roman    :: see @FT_ENCODING_APPLE_ROMAN          */
+  /*                                                                       */
+#define  ft_encoding_none            FT_ENCODING_NONE
+#define  ft_encoding_unicode         FT_ENCODING_UNICODE
+#define  ft_encoding_symbol          FT_ENCODING_MS_SYMBOL
+#define  ft_encoding_latin_1         FT_ENCODING_ADOBE_LATIN_1
+#define  ft_encoding_latin_2         FT_ENCODING_OLD_LATIN_2
+#define  ft_encoding_sjis            FT_ENCODING_MS_SJIS
+#define  ft_encoding_gb2312          FT_ENCODING_MS_GB2312
+#define  ft_encoding_big5            FT_ENCODING_MS_BIG5
+#define  ft_encoding_wansung         FT_ENCODING_MS_WANSUNG
+#define  ft_encoding_johab           FT_ENCODING_MS_JOHAB
+
+#define  ft_encoding_adobe_standard  FT_ENCODING_ADOBE_STANDARD
+#define  ft_encoding_adobe_expert    FT_ENCODING_ADOBE_EXPERT
+#define  ft_encoding_adobe_custom    FT_ENCODING_ADOBE_CUSTOM
+#define  ft_encoding_apple_roman     FT_ENCODING_APPLE_ROMAN
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_CharMapRec                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The base charmap structure.                                        */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    face        :: A handle to the parent face object.                 */
+  /*                                                                       */
+  /*    encoding    :: An @FT_Encoding tag identifying the charmap.  Use   */
+  /*                   this with @FT_Select_Charmap.                       */
+  /*                                                                       */
+  /*    platform_id :: An ID number describing the platform for the        */
+  /*                   following encoding ID.  This comes directly from    */
+  /*                   the TrueType specification and should be emulated   */
+  /*                   for other formats.                                  */
+  /*                                                                       */
+  /*    encoding_id :: A platform specific encoding number.  This also     */
+  /*                   comes from the TrueType specification and should be */
+  /*                   emulated similarly.                                 */
+  /*                                                                       */
+  typedef struct  FT_CharMapRec_
+  {
+    FT_Face      face;
+    FT_Encoding  encoding;
+    FT_UShort    platform_id;
+    FT_UShort    encoding_id;
+
+  } FT_CharMapRec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*                                                                       */
+  /*                 B A S E   O B J E C T   C L A S S E S                 */
+  /*                                                                       */
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Face_Internal                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An opaque handle to an FT_Face_InternalRec structure, used to      */
+  /*    model private data of a given @FT_Face object.                     */
+  /*                                                                       */
+  /*    This structure might change between releases of FreeType 2 and is  */
+  /*    not generally available to client applications.                    */
+  /*                                                                       */
+  typedef struct FT_Face_InternalRec_*  FT_Face_Internal;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_FaceRec                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    FreeType root face class structure.  A face object models the      */
+  /*    resolution and point-size independent data found in a font file.   */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    num_faces           :: In the case where the face is located in a  */
+  /*                           collection (i.e., a file which embeds       */
+  /*                           several faces), this is the total number of */
+  /*                           faces found in the resource.  1 by default. */
+  /*                                                                       */
+  /*    face_index          :: The index of the face in its font file.     */
+  /*                           Usually, this is 0 for all normal font      */
+  /*                           formats.  It can be more in the case of     */
+  /*                           collections (which embed several fonts in a */
+  /*                           single resource/file).                      */
+  /*                                                                       */
+  /*    face_flags          :: A set of bit flags that give important      */
+  /*                           information about the face; see the         */
+  /*                           @FT_FACE_FLAG_XXX constants for details.    */
+  /*                                                                       */
+  /*    style_flags         :: A set of bit flags indicating the style of  */
+  /*                           the face (i.e., italic, bold, underline,    */
+  /*                           etc).  See the @FT_STYLE_FLAG_XXX           */
+  /*                           constants.                                  */
+  /*                                                                       */
+  /*    num_glyphs          :: The total number of glyphs in the face.     */
+  /*                                                                       */
+  /*    family_name         :: The face's family name.  This is an ASCII   */
+  /*                           string, usually in English, which describes */
+  /*                           the typeface's family (like `Times New      */
+  /*                           Roman', `Bodoni', `Garamond', etc).  This   */
+  /*                           is a least common denominator used to list  */
+  /*                           fonts.  Some formats (TrueType & OpenType)  */
+  /*                           provide localized and Unicode versions of   */
+  /*                           this string.  Applications should use the   */
+  /*                           format specific interface to access them.   */
+  /*                                                                       */
+  /*    style_name          :: The face's style name.  This is an ASCII    */
+  /*                           string, usually in English, which describes */
+  /*                           the typeface's style (like `Italic',        */
+  /*                           `Bold', `Condensed', etc).  Not all font    */
+  /*                           formats provide a style name, so this field */
+  /*                           is optional, and can be set to NULL.  As    */
+  /*                           for `family_name', some formats provide     */
+  /*                           localized/Unicode versions of this string.  */
+  /*                           Applications should use the format specific */
+  /*                           interface to access them.                   */
+  /*                                                                       */
+  /*    num_fixed_sizes     :: The number of fixed sizes available in this */
+  /*                           face.  This should be set to 0 for scalable */
+  /*                           fonts, unless its face includes a complete  */
+  /*                           set of glyphs (called a `strike') for the   */
+  /*                           specified sizes.                            */
+  /*                                                                       */
+  /*    available_sizes     :: An array of sizes specifying the available  */
+  /*                           bitmap/graymap sizes that are contained in  */
+  /*                           in the font face.  Should be set to NULL if */
+  /*                           the field `num_fixed_sizes' is set to 0.    */
+  /*                                                                       */
+  /*    num_charmaps        :: The total number of character maps in the   */
+  /*                           face.                                       */
+  /*                                                                       */
+  /*    charmaps            :: A table of pointers to the face's charmaps. */
+  /*                           Used to scan the list of available charmaps */
+  /*                           -- this table might change after a call to  */
+  /*                           @FT_Attach_File or @FT_Attach_Stream (e.g.  */
+  /*                           if used to hook an additional encoding or   */
+  /*                           CMap to the face object).                   */
+  /*                                                                       */
+  /*    generic             :: A field reserved for client uses.  See the  */
+  /*                           @FT_Generic type description.               */
+  /*                                                                       */
+  /*    bbox                :: The font bounding box.  Coordinates are     */
+  /*                           expressed in font units (see units_per_EM). */
+  /*                           The box is large enough to contain any      */
+  /*                           glyph from the font.  Thus, bbox.yMax can   */
+  /*                           be seen as the `maximal ascender',          */
+  /*                           bbox.yMin as the `minimal descender', and   */
+  /*                           the maximal glyph width is given by         */
+  /*                           `bbox.xMax-bbox.xMin' (not to be confused   */
+  /*                           with the maximal _advance_width_).  Only    */
+  /*                           relevant for scalable formats.              */
+  /*                                                                       */
+  /*    units_per_EM        :: The number of font units per EM square for  */
+  /*                           this face.  This is typically 2048 for      */
+  /*                           TrueType fonts, 1000 for Type1 fonts, and   */
+  /*                           should be set to the (unrealistic) value 1  */
+  /*                           for fixed-sizes fonts.  Only relevant for   */
+  /*                           scalable formats.                           */
+  /*                                                                       */
+  /*    ascender            :: The face's ascender is the vertical         */
+  /*                           distance from the baseline to the topmost   */
+  /*                           point of any glyph in the face.  This       */
+  /*                           field's value is positive, expressed in     */
+  /*                           font units.  Some font designs use a value  */
+  /*                           different from `bbox.yMax'.  Only relevant  */
+  /*                           for scalable formats.                       */
+  /*                                                                       */
+  /*    descender           :: The face's descender is the vertical        */
+  /*                           distance from the baseline to the           */
+  /*                           bottommost point of any glyph in the face.  */
+  /*                           This field's value is *negative*, expressed */
+  /*                           in font units.  Some font designs use a     */
+  /*                           value different from `bbox.yMin'.  Only     */
+  /*                           relevant for scalable formats.              */
+  /*                                                                       */
+  /*    height              :: The face's height is the vertical distance  */
+  /*                           from one baseline to the next when writing  */
+  /*                           several lines of text.  Its value is always */
+  /*                           positive, expressed in font units.  The     */
+  /*                           value can be computed as                    */
+  /*                           `ascender+descender+line_gap' where the     */
+  /*                           value of `line_gap' is also called          */
+  /*                           `external leading'.  Only relevant for      */
+  /*                           scalable formats.                           */
+  /*                                                                       */
+  /*    max_advance_width   :: The maximal advance width, in font units,   */
+  /*                           for all glyphs in this face.  This can be   */
+  /*                           used to make word wrapping computations     */
+  /*                           faster.  Only relevant for scalable         */
+  /*                           formats.                                    */
+  /*                                                                       */
+  /*    max_advance_height  :: The maximal advance height, in font units,  */
+  /*                           for all glyphs in this face.  This is only  */
+  /*                           relevant for vertical layouts, and should   */
+  /*                           be set to the `height' for fonts that do    */
+  /*                           not provide vertical metrics.  Only         */
+  /*                           relevant for scalable formats.              */
+  /*                                                                       */
+  /*    underline_position  :: The position, in font units, of the         */
+  /*                           underline line for this face.  It's the     */
+  /*                           center of the underlining stem.  Only       */
+  /*                           relevant for scalable formats.              */
+  /*                                                                       */
+  /*    underline_thickness :: The thickness, in font units, of the        */
+  /*                           underline for this face.  Only relevant for */
+  /*                           scalable formats.                           */
+  /*                                                                       */
+  /*    glyph               :: The face's associated glyph slot(s).  This  */
+  /*                           object is created automatically with a new  */
+  /*                           face object.  However, certain kinds of     */
+  /*                           applications (mainly tools like converters) */
+  /*                           can need more than one slot to ease their   */
+  /*                           task.                                       */
+  /*                                                                       */
+  /*    size                :: The current active size for this face.      */
+  /*                                                                       */
+  /*    charmap             :: The current active charmap for this face.   */
+  /*                                                                       */
+  typedef struct  FT_FaceRec_
+  {
+    FT_Long           num_faces;
+    FT_Long           face_index;
+
+    FT_Long           face_flags;
+    FT_Long           style_flags;
+
+    FT_Long           num_glyphs;
+
+    FT_String*        family_name;
+    FT_String*        style_name;
+
+    FT_Int            num_fixed_sizes;
+    FT_Bitmap_Size*   available_sizes;
+
+    FT_Int            num_charmaps;
+    FT_CharMap*       charmaps;
+
+    FT_Generic        generic;
+
+    /*# the following are only relevant to scalable outlines */
+    FT_BBox           bbox;
+
+    FT_UShort         units_per_EM;
+    FT_Short          ascender;
+    FT_Short          descender;
+    FT_Short          height;
+
+    FT_Short          max_advance_width;
+    FT_Short          max_advance_height;
+
+    FT_Short          underline_position;
+    FT_Short          underline_thickness;
+
+    FT_GlyphSlot      glyph;
+    FT_Size           size;
+    FT_CharMap        charmap;
+
+    /*@private begin */
+
+    FT_Driver         driver;
+    FT_Memory         memory;
+    FT_Stream         stream;
+
+    FT_ListRec        sizes_list;
+
+    FT_Generic        autohint;
+    void*             extensions;
+
+    FT_Face_Internal  internal;
+
+    /*@private end */
+
+  } FT_FaceRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_FACE_FLAG_XXX                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A list of bit flags used in the 'face_flags' field of the          */
+  /*    @FT_FaceRec structure.  They inform client applications of         */
+  /*    properties of the corresponding face.                              */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_FACE_FLAG_SCALABLE ::                                           */
+  /*      Indicates that the face provides vectorial outlines.  This       */
+  /*      doesn't prevent embedded bitmaps, i.e., a face can have both     */
+  /*      this bit and @FT_FACE_FLAG_FIXED_SIZES set                       */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_FIXED_SIZES ::                                        */
+  /*      Indicates that the face contains `fixed sizes', i.e., bitmap     */
+  /*      strikes for some given pixel sizes.  See the `num_fixed_sizes'   */
+  /*      and `available_sizes' fields of @FT_FaceRec.                     */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_FIXED_WIDTH ::                                        */
+  /*      Indicates that the face contains fixed-width characters (like    */
+  /*      Courier, Lucido, MonoType, etc.).                                */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_SFNT ::                                               */
+  /*      Indicates that the face uses the `sfnt' storage scheme.  For     */
+  /*      now, this means TrueType and OpenType.                           */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_HORIZONTAL ::                                         */
+  /*      Indicates that the face contains horizontal glyph metrics.  This */
+  /*      should be set for all common formats.                            */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_VERTICAL ::                                           */
+  /*      Indicates that the face contains vertical glyph metrics.  This   */
+  /*      is only available in some formats, not all of them.              */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_KERNING ::                                            */
+  /*      Indicates that the face contains kerning information.  If set,   */
+  /*      the kerning distance can be retrieved through the function       */
+  /*      @FT_Get_Kerning.  Note that if unset, this function will always  */
+  /*      return the vector (0,0).                                         */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_FAST_GLYPHS ::                                        */
+  /*      THIS FLAG IS DEPRECATED.  DO NOT USE OR TEST IT.                 */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_MULTIPLE_MASTERS ::                                   */
+  /*      Indicates that the font contains multiple masters and is capable */
+  /*      of interpolating between them.  See the multiple-masters         */
+  /*      specific API for details.                                        */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_GLYPH_NAMES ::                                        */
+  /*      Indicates that the font contains glyph names that can be         */
+  /*      retrieved through @FT_Get_Glyph_Names.  Note that some TrueType  */
+  /*      fonts contain broken glyph name tables.  Use the function        */
+  /*      @FT_Has_PS_Glyph_Name when needed.                               */
+  /*                                                                       */
+  /*    FT_FACE_FLAG_EXTERNAL_STREAM ::                                    */
+  /*      Used internally by FreeType to indicate that a face's stream was */
+  /*      provided by the client application and should not be destroyed   */
+  /*      when @FT_Done_Face is called.  Don't read or test this flag.     */
+  /*                                                                       */
+#define FT_FACE_FLAG_SCALABLE          ( 1L <<  0 )
+#define FT_FACE_FLAG_FIXED_SIZES       ( 1L <<  1 )
+#define FT_FACE_FLAG_FIXED_WIDTH       ( 1L <<  2 )
+#define FT_FACE_FLAG_SFNT              ( 1L <<  3 )
+#define FT_FACE_FLAG_HORIZONTAL        ( 1L <<  4 )
+#define FT_FACE_FLAG_VERTICAL          ( 1L <<  5 )
+#define FT_FACE_FLAG_KERNING           ( 1L <<  6 )
+#define FT_FACE_FLAG_FAST_GLYPHS       ( 1L <<  7 )
+#define FT_FACE_FLAG_MULTIPLE_MASTERS  ( 1L <<  8 )
+#define FT_FACE_FLAG_GLYPH_NAMES       ( 1L <<  9 )
+#define FT_FACE_FLAG_EXTERNAL_STREAM   ( 1L << 10 )
+
+  /* */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_HAS_HORIZONTAL( face )                                          */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro that returns true whenever a face object contains          */
+  /*    horizontal metrics (this is true for all font formats though).     */
+  /*                                                                       */
+  /* @also:                                                                */
+  /*    @FT_HAS_VERTICAL can be used to check for vertical metrics.        */
+  /*                                                                       */
+#define FT_HAS_HORIZONTAL( face ) \
+          ( face->face_flags & FT_FACE_FLAG_HORIZONTAL )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_HAS_VERTICAL( face )                                            */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro that returns true whenever a face object contains vertical */
+  /*    metrics.                                                           */
+  /*                                                                       */
+#define FT_HAS_VERTICAL( face ) \
+          ( face->face_flags & FT_FACE_FLAG_VERTICAL )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_HAS_KERNING( face )                                             */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro that returns true whenever a face object contains kerning  */
+  /*    data that can be accessed with @FT_Get_Kerning.                    */
+  /*                                                                       */
+#define FT_HAS_KERNING( face ) \
+          ( face->face_flags & FT_FACE_FLAG_KERNING )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_IS_SCALABLE( face )                                             */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro that returns true whenever a face object contains a        */
+  /*    scalable font face (true for TrueType, Type 1, CID, and            */
+  /*    OpenType/CFF font formats.                                         */
+  /*                                                                       */
+#define FT_IS_SCALABLE( face ) \
+          ( face->face_flags & FT_FACE_FLAG_SCALABLE )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_IS_SFNT( face )                                                 */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro that returns true whenever a face object contains a font   */
+  /*    whose format is based on the SFNT storage scheme.  This usually    */
+  /*    means: TrueType fonts, OpenType fonts, as well as SFNT-based       */
+  /*    embedded bitmap fonts.                                             */
+  /*                                                                       */
+  /*    If this macro is true, all functions defined in @FT_SFNT_NAMES_H   */
+  /*    and @FT_TRUETYPE_TABLES_H are available.                           */
+  /*                                                                       */
+#define FT_IS_SFNT( face ) \
+          ( face->face_flags & FT_FACE_FLAG_SFNT )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_IS_FIXED_WIDTH( face )                                          */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro that returns true whenever a face object contains a font   */
+  /*    face that contains fixed-width (or "monospace", "fixed-pitch",     */
+  /*    etc.) glyphs.                                                      */
+  /*                                                                       */
+#define FT_IS_FIXED_WIDTH( face ) \
+          ( face->face_flags & FT_FACE_FLAG_FIXED_WIDTH )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_IS_FIXED_SIZES( face )                                          */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro that returns true whenever a face object contains some     */
+  /*    embedded bitmaps.  See the `fixed_sizes' field of the @FT_FaceRec  */
+  /*    structure.                                                         */
+  /*                                                                       */
+#define FT_HAS_FIXED_SIZES( face ) \
+          ( face->face_flags & FT_FACE_FLAG_FIXED_SIZES )
+
+
+   /* */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_HAS_FAST_GLYPHS( face )                                         */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    Deprecated; indicates that the face contains so-called "fast"      */
+  /*    glyph bitmaps.                                                     */
+  /*                                                                       */
+#define FT_HAS_FAST_GLYPHS( face ) \
+          ( face->face_flags & FT_FACE_FLAG_FAST_GLYPHS )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_HAS_GLYPH_NAMES( face )                                         */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro that returns true whenever a face object contains some     */
+  /*    glyph names that can be accessed through @FT_Get_Glyph_Names.      */
+  /*                                                                       */
+#define FT_HAS_GLYPH_NAMES( face ) \
+          ( face->face_flags & FT_FACE_FLAG_GLYPH_NAMES )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_HAS_MULTIPLE_MASTERS( face )                                    */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A macro that returns true whenever a face object contains some     */
+  /*    multiple masters.  The functions provided by                       */
+  /*    @FT_MULTIPLE_MASTERS_H are then available to choose the exact      */
+  /*    design you want.                                                   */
+  /*                                                                       */
+#define FT_HAS_MULTIPLE_MASTERS( face ) \
+          ( face->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Constant>                                                            */
+  /*    FT_STYLE_FLAG_XXX                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A list of bit-flags used to indicate the style of a given face.    */
+  /*    These are used in the `style_flags' field of @FT_FaceRec.          */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_STYLE_FLAG_ITALIC ::                                            */
+  /*      Indicates that a given face is italicized.                       */
+  /*                                                                       */
+  /*    FT_STYLE_FLAG_BOLD ::                                              */
+  /*      Indicates that a given face is bold.                             */
+  /*                                                                       */
+#define FT_STYLE_FLAG_ITALIC  ( 1 << 0 )
+#define FT_STYLE_FLAG_BOLD    ( 1 << 1 )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Size_Internal                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An opaque handle to an FT_Size_InternalRec structure, used to      */
+  /*    model private data of a given FT_Size object.                      */
+  /*                                                                       */
+  typedef struct FT_Size_InternalRec_*  FT_Size_Internal;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                    FreeType base size metrics                         */
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Size_Metrics                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The size metrics structure returned scaled important distances for */
+  /*    a given size object.                                               */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    x_ppem       :: The character width, expressed in integer pixels.  */
+  /*                    This is the width of the EM square expressed in    */
+  /*                    pixels, hence the term `ppem' (pixels per EM).     */
+  /*                                                                       */
+  /*    y_ppem       :: The character height, expressed in integer pixels. */
+  /*                    This is the height of the EM square expressed in   */
+  /*                    pixels, hence the term `ppem' (pixels per EM).     */
+  /*                                                                       */
+  /*    x_scale      :: A simple 16.16 fixed point format coefficient used */
+  /*                    to scale horizontal distances expressed in font    */
+  /*                    units to fractional (26.6) pixel coordinates.      */
+  /*                                                                       */
+  /*    y_scale      :: A simple 16.16 fixed point format coefficient used */
+  /*                    to scale vertical distances expressed in font      */
+  /*                    units to fractional (26.6) pixel coordinates.      */
+  /*                                                                       */
+  /*    ascender     :: The ascender, expressed in 26.6 fixed point        */
+  /*                    pixels.  Always positive.                          */
+  /*                                                                       */
+  /*    descender    :: The descender, expressed in 26.6 fixed point       */
+  /*                    pixels.  Always positive.                          */
+  /*                                                                       */
+  /*    height       :: The text height, expressed in 26.6 fixed point     */
+  /*                    pixels.  Always positive.                          */
+  /*                                                                       */
+  /*    max_advance  :: Maximum horizontal advance, expressed in 26.6      */
+  /*                    fixed point pixels.  Always positive.              */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The values of `ascender', `descender', and `height' are only the   */
+  /*    scaled versions of `face->ascender', `face->descender', and        */
+  /*    `face->height'.                                                    */
+  /*                                                                       */
+  /*    Unfortunately, due to glyph hinting, these values might not be     */
+  /*    exact for certain fonts, they thus must be treated as unreliable   */
+  /*    with an error margin of at least one pixel!                        */
+  /*                                                                       */
+  /*    Indeed, the only way to get the exact pixel ascender and descender */
+  /*    is to render _all_ glyphs.  As this would be a definite            */
+  /*    performance hit, it is up to client applications to perform such   */
+  /*    computations.                                                      */
+  /*                                                                       */
+  typedef struct  FT_Size_Metrics_
+  {
+    FT_UShort  x_ppem;      /* horizontal pixels per EM               */
+    FT_UShort  y_ppem;      /* vertical pixels per EM                 */
+
+    FT_Fixed   x_scale;     /* two scales used to convert font units  */
+    FT_Fixed   y_scale;     /* to 26.6 frac. pixel coordinates..      */
+
+    FT_Pos     ascender;    /* ascender in 26.6 frac. pixels          */
+    FT_Pos     descender;   /* descender in 26.6 frac. pixels         */
+    FT_Pos     height;      /* text height in 26.6 frac. pixels       */
+    FT_Pos     max_advance; /* max horizontal advance, in 26.6 pixels */
+
+  } FT_Size_Metrics;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_SizeRec                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    FreeType root size class structure.  A size object models the      */
+  /*    resolution and pointsize dependent data of a given face.           */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    face    :: Handle to the parent face object.                       */
+  /*                                                                       */
+  /*    generic :: A typeless pointer, which is unused by the FreeType     */
+  /*               library or any of its drivers.  It can be used by       */
+  /*               client applications to link their own data to each size */
+  /*               object.                                                 */
+  /*                                                                       */
+  /*    metrics :: Metrics for this size object.  This field is read-only. */
+  /*                                                                       */
+  typedef struct  FT_SizeRec_
+  {
+    FT_Face           face;      /* parent face object              */
+    FT_Generic        generic;   /* generic pointer for client uses */
+    FT_Size_Metrics   metrics;   /* size metrics                    */
+    FT_Size_Internal  internal;
+
+  } FT_SizeRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_SubGlyph                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The subglyph structure is an internal object used to describe      */
+  /*    subglyphs (for example, in the case of composites).                */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The subglyph implementation is not part of the high-level API,     */
+  /*    hence the forward structure declaration.                           */
+  /*                                                                       */
+  typedef struct FT_SubGlyphRec_*  FT_SubGlyph;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Slot_Internal                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An opaque handle to an FT_Slot_InternalRec structure, used to      */
+  /*    model private data of a given FT_GlyphSlot object.                 */
+  /*                                                                       */
+  typedef struct FT_Slot_InternalRec_*  FT_Slot_Internal;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_GlyphSlotRec                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    FreeType root glyph slot class structure.  A glyph slot is a       */
+  /*    container where individual glyphs can be loaded, be they           */
+  /*    vectorial or bitmap/graymaps.                                      */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    library           :: A handle to the FreeType library instance     */
+  /*                         this slot belongs to.                         */
+  /*                                                                       */
+  /*    face              :: A handle to the parent face object.           */
+  /*                                                                       */
+  /*    next              :: In some cases (like some font tools), several */
+  /*                         glyph slots per face object can be a good     */
+  /*                         thing.  As this is rare, the glyph slots are  */
+  /*                         listed through a direct, single-linked list   */
+  /*                         using its `next' field.                       */
+  /*                                                                       */
+  /*    generic           :: A typeless pointer which is unused by the     */
+  /*                         FreeType library or any of its drivers.  It   */
+  /*                         can be used by client applications to link    */
+  /*                         their own data to each glyph slot object.     */
+  /*                                                                       */
+  /*    metrics           :: The metrics of the last loaded glyph in the   */
+  /*                         slot.  The returned values depend on the last */
+  /*                         load flags (see the @FT_Load_Glyph API        */
+  /*                         function) and can be expressed either in 26.6 */
+  /*                         fractional pixels or font units.              */
+  /*                                                                       */
+  /*                         Note that even when the glyph image is        */
+  /*                         transformed, the metrics are not.             */
+  /*                                                                       */
+  /*    linearHoriAdvance :: For scalable formats only, this field holds   */
+  /*                         the linearly scaled horizontal advance width  */
+  /*                         for the glyph (i.e. the scaled and unhinted   */
+  /*                         value of the hori advance).  This can be      */
+  /*                         important to perform correct WYSIWYG layout.  */
+  /*                                                                       */
+  /*                         Note that this value is expressed by default  */
+  /*                         in 16.16 pixels. However, when the glyph is   */
+  /*                         loaded with the FT_LOAD_LINEAR_DESIGN flag,   */
+  /*                         this field contains simply the value of the   */
+  /*                         advance in original font units.               */
+  /*                                                                       */
+  /*    linearVertAdvance :: For scalable formats only, this field holds   */
+  /*                         the linearly scaled vertical advance height   */
+  /*                         for the glyph.  See linearHoriAdvance for     */
+  /*                         comments.                                     */
+  /*                                                                       */
+  /*    advance           :: This is the transformed advance width for the */
+  /*                         glyph.                                        */
+  /*                                                                       */
+  /*    format            :: This field indicates the format of the image  */
+  /*                         contained in the glyph slot.  Typically       */
+  /*                         FT_GLYPH_FORMAT_BITMAP,                       */
+  /*                         FT_GLYPH_FORMAT_OUTLINE, and                  */
+  /*                         FT_GLYPH_FORMAT_COMPOSITE, but others are     */
+  /*                         possible.                                     */
+  /*                                                                       */
+  /*    bitmap            :: This field is used as a bitmap descriptor     */
+  /*                         when the slot format is                       */
+  /*                         FT_GLYPH_FORMAT_BITMAP.  Note that the        */
+  /*                         address and content of the bitmap buffer can  */
+  /*                         change between calls of @FT_Load_Glyph and a  */
+  /*                         few other functions.                          */
+  /*                                                                       */
+  /*    bitmap_left       :: This is the bitmap's left bearing expressed   */
+  /*                         in integer pixels.  Of course, this is only   */
+  /*                         valid if the format is                        */
+  /*                         FT_GLYPH_FORMAT_BITMAP.                       */
+  /*                                                                       */
+  /*    bitmap_top        :: This is the bitmap's top bearing expressed in */
+  /*                         integer pixels.  Remember that this is the    */
+  /*                         distance from the baseline to the top-most    */
+  /*                         glyph scanline, upwards y-coordinates being   */
+  /*                         *positive*.                                   */
+  /*                                                                       */
+  /*    outline           :: The outline descriptor for the current glyph  */
+  /*                         image if its format is                        */
+  /*                         ft_glyph_bitmap_outline.                      */
+  /*                                                                       */
+  /*    num_subglyphs     :: The number of subglyphs in a composite glyph. */
+  /*                         This format is only valid for the composite   */
+  /*                         glyph format, that should normally only be    */
+  /*                         loaded with the FT_LOAD_NO_RECURSE flag.      */
+  /*                                                                       */
+  /*    subglyphs         :: An array of subglyph descriptors for          */
+  /*                         composite glyphs.  There are `num_subglyphs'  */
+  /*                         elements in there.                            */
+  /*                                                                       */
+  /*    control_data      :: Certain font drivers can also return the      */
+  /*                         control data for a given glyph image (e.g.    */
+  /*                         TrueType bytecode, Type 1 charstrings, etc.). */
+  /*                         This field is a pointer to such data.         */
+  /*                                                                       */
+  /*    control_len       :: This is the length in bytes of the control    */
+  /*                         data.                                         */
+  /*                                                                       */
+  /*    other             :: Really wicked formats can use this pointer to */
+  /*                         present their own glyph image to client apps. */
+  /*                         Note that the app will need to know about the */
+  /*                         image format.                                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    If @FT_Load_Glyph is called with default flags (see                */
+  /*    @FT_LOAD_DEFAULT) the glyph image is loaded in the glyph slot in   */
+  /*    its native format (e.g. a vectorial outline for TrueType and       */
+  /*    Type 1 formats).                                                   */
+  /*                                                                       */
+  /*    This image can later be converted into a bitmap by calling         */
+  /*    @FT_Render_Glyph.  This function finds the current renderer for    */
+  /*    the native image's format then invokes it.                         */
+  /*                                                                       */
+  /*    The renderer is in charge of transforming the native image through */
+  /*    the slot's face transformation fields, then convert it into a      */
+  /*    bitmap that is returned in `slot->bitmap'.                         */
+  /*                                                                       */
+  /*    Note that `slot->bitmap_left' and `slot->bitmap_top' are also used */
+  /*    to specify the position of the bitmap relative to the current pen  */
+  /*    position (e.g. coordinates [0,0] on the baseline).  Of course,     */
+  /*    `slot->format' is also changed to `FT_GLYPH_FORMAT_BITMAP' .       */
+  /*                                                                       */
+  typedef struct  FT_GlyphSlotRec_
+  {
+    FT_Library        library;
+    FT_Face           face;
+    FT_GlyphSlot      next;
+    FT_UInt           flags;
+    FT_Generic        generic;
+
+    FT_Glyph_Metrics  metrics;
+    FT_Fixed          linearHoriAdvance;
+    FT_Fixed          linearVertAdvance;
+    FT_Vector         advance;
+
+    FT_Glyph_Format   format;
+
+    FT_Bitmap         bitmap;
+    FT_Int            bitmap_left;
+    FT_Int            bitmap_top;
+
+    FT_Outline        outline;
+
+    FT_UInt           num_subglyphs;
+    FT_SubGlyph       subglyphs;
+
+    void*             control_data;
+    long              control_len;
+
+    void*             other;
+
+    FT_Slot_Internal  internal;
+
+  } FT_GlyphSlotRec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*                                                                       */
+  /*                         F U N C T I O N S                             */
+  /*                                                                       */
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Init_FreeType                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Initializes a new FreeType library object.  The set of modules     */
+  /*    that are registered by this function is determined at build time.  */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    alibrary :: A handle to a new library object.                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Init_FreeType( FT_Library  *alibrary );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Library_Version                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return the version of the FreeType library being used.  This is    */
+  /*    useful when dynamically linking to the library, since one cannot   */
+  /*    use the macros FT_FREETYPE_MAJOR, FT_FREETYPE_MINOR, and           */
+  /*    FT_FREETYPE_PATCH.                                                 */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A source library handle.                                */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    amajor :: The major version number.                                */
+  /*                                                                       */
+  /*    aminor :: The minor version number.                                */
+  /*                                                                       */
+  /*    apatch :: The patch version number.                                */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The reason why this function takes a 'library' argument is because */
+  /*    certain programs implement library initialization in a custom way  */
+  /*    that doesn't use `FT_Init_FreeType'.                               */
+  /*                                                                       */
+  /*    In such cases, the library version might not be available before   */
+  /*    the library object has been created.                               */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Library_Version( FT_Library   library,
+                      FT_Int      *amajor,
+                      FT_Int      *aminor,
+                      FT_Int      *apatch );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Done_FreeType                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroys a given FreeType library object and all of its childs,    */
+  /*    including resources, drivers, faces, sizes, etc.                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A handle to the target library object.                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Done_FreeType( FT_Library  library );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Open_Flags                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration used to list the bit flags used within the          */
+  /*    `flags' field of the @FT_Open_Args structure.                      */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    FT_OPEN_MEMORY      :: This is a memory-based stream.              */
+  /*                                                                       */
+  /*    FT_OPEN_STREAM      :: Copy the stream from the `stream' field.    */
+  /*                                                                       */
+  /*    FT_OPEN_PATHNAME    :: Create a new input stream from a C          */
+  /*                           path name.                                  */
+  /*                                                                       */
+  /*    FT_OPEN_DRIVER      :: Use the `driver' field.                     */
+  /*                                                                       */
+  /*    FT_OPEN_PARAMS      :: Use the `num_params' & `params' field.      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The `FT_OPEN_MEMORY', `FT_OPEN_STREAM', and `FT_OPEN_PATHNAME'     */
+  /*    flags are mutually exclusive.                                      */
+  /*                                                                       */
+  typedef enum
+  {
+    FT_OPEN_MEMORY   = 1,
+    FT_OPEN_STREAM   = 2,
+    FT_OPEN_PATHNAME = 4,
+    FT_OPEN_DRIVER   = 8,
+    FT_OPEN_PARAMS   = 16
+
+  } FT_Open_Flags;
+
+#define  FT_OPEN_MEMORY    FT_OPEN_MEMORY
+#define  FT_OPEN_STREAM    FT_OPEN_STREAM
+#define  FT_OPEN_PATHNAME  FT_OPEN_PATHNAME
+#define  FT_OPEN_DRIVER    FT_OPEN_DRIVER
+#define  FT_OPEN_PARAMS    FT_OPEN_PARAMS
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Parameter                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple structure used to pass more or less generic parameters    */
+  /*    to @FT_Open_Face.                                                  */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    tag  :: A 4-byte identification tag.                               */
+  /*                                                                       */
+  /*    data :: A pointer to the parameter data.                           */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The id and function of parameters are driver-specific.             */
+  /*                                                                       */
+  typedef struct  FT_Parameter_
+  {
+    FT_ULong    tag;
+    FT_Pointer  data;
+
+  } FT_Parameter;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Open_Args                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to indicate how to open a new font file/stream.   */
+  /*    A pointer to such a structure can be used as a parameter for the   */
+  /*    functions @FT_Open_Face and @FT_Attach_Stream.                     */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    flags       :: A set of bit flags indicating how to use the        */
+  /*                   structure.                                          */
+  /*                                                                       */
+  /*    memory_base :: The first byte of the file in memory.               */
+  /*                                                                       */
+  /*    memory_size :: The size in bytes of the file in memory.            */
+  /*                                                                       */
+  /*    pathname    :: A pointer to an 8-bit file pathname.                */
+  /*                                                                       */
+  /*    stream      :: A handle to a source stream object.                 */
+  /*                                                                       */
+  /*    driver      :: This field is exclusively used by @FT_Open_Face;    */
+  /*                   it simply specifies the font driver to use to open  */
+  /*                   the face.  If set to 0, FreeType will try to load   */
+  /*                   the face with each one of the drivers in its list.  */
+  /*                                                                       */
+  /*    num_params  :: The number of extra parameters.                     */
+  /*                                                                       */
+  /*    params      :: Extra parameters passed to the font driver when     */
+  /*                   opening a new face.                                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The stream type is determined by the contents of `flags' which     */
+  /*    are tested in the following order by @FT_Open_Face:                */
+  /*                                                                       */
+  /*    If the `FT_OPEN_MEMORY' bit is set, assume that this is a          */
+  /*    memory file of `memory_size' bytes,located at `memory_address'.    */
+  /*                                                                       */
+  /*    Otherwise, if the `FT_OPEN_STREAM' bit is set, assume that a       */
+  /*    custom input stream `stream' is used.                              */
+  /*                                                                       */
+  /*    Otherwise, if the `FT_OPEN_PATHNAME' bit is set, assume that this  */
+  /*    is a normal file and use `pathname' to open it.                    */
+  /*                                                                       */
+  /*    If the `FT_OPEN_DRIVER' bit is set, @FT_Open_Face will only try to */
+  /*    open the file with the driver whose handler is in `driver'.        */
+  /*                                                                       */
+  /*    If the `FT_OPEN_PARAMS' bit is set, the parameters given by        */
+  /*    `num_params' and `params' will be used.  They are ignored          */
+  /*    otherwise.                                                         */
+  /*                                                                       */
+  typedef struct  FT_Open_Args_
+  {
+    FT_Open_Flags              flags;
+    const FT_Byte*             memory_base;
+    FT_Long                    memory_size;
+    FT_String*                 pathname;
+    FT_Stream                  stream;
+    FT_Module                  driver;
+    FT_Int                     num_params;
+    FT_Parameter*              params;
+
+  } FT_Open_Args;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Face                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Creates a new face object from a given resource and typeface index */
+  /*    using a pathname to the font file.                                 */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library    :: A handle to the library resource.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    pathname   :: A path to the font file.                             */
+  /*                                                                       */
+  /*    face_index :: The index of the face within the resource.  The      */
+  /*                  first face has index 0.                              */
+  /* <Output>                                                              */
+  /*    aface      :: A handle to a new face object.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Unlike FreeType 1.x, this function automatically creates a glyph   */
+  /*    slot for the face object which can be accessed directly through    */
+  /*    `face->glyph'.                                                     */
+  /*                                                                       */
+  /*    @FT_New_Face can be used to determine and/or check the font format */
+  /*    of a given font resource.  If the `face_index' field is negative,  */
+  /*    the function will _not_ return any face handle in `aface'.  Its    */
+  /*    return value should be 0 if the font format is recognized, or      */
+  /*    non-zero otherwise.                                                */
+  /*                                                                       */
+  /*    Each new face object created with this function also owns a        */
+  /*    default @FT_Size object, accessible as `face->size'.               */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_New_Face( FT_Library   library,
+               const char*  filepathname,
+               FT_Long      face_index,
+               FT_Face     *aface );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Memory_Face                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Creates a new face object from a given resource and typeface index */
+  /*    using a font file already loaded into memory.                      */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library    :: A handle to the library resource.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    file_base  :: A pointer to the beginning of the font data.         */
+  /*                                                                       */
+  /*    file_size  :: The size of the memory chunk used by the font data.  */
+  /*                                                                       */
+  /*    face_index :: The index of the face within the resource.  The      */
+  /*                  first face has index 0.                              */
+  /* <Output>                                                              */
+  /*    aface      :: A handle to a new face object.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The font data bytes are used _directly_ by the @FT_Face object.    */
+  /*    This means that they are not copied, and that the client is        */
+  /*    responsible for releasing/destroying them _after_ the              */
+  /*    corresponding call to @FT_Done_Face .                              */
+  /*                                                                       */
+  /*    Unlike FreeType 1.x, this function automatically creates a glyph   */
+  /*    slot for the face object which can be accessed directly through    */
+  /*    `face->glyph'.                                                     */
+  /*                                                                       */
+  /*    @FT_New_Memory_Face can be used to determine and/or check the font */
+  /*    format of a given font resource.  If the `face_index' field is     */
+  /*    negative, the function will _not_ return any face handle in        */
+  /*    `aface'.  Its return value should be 0 if the font format is       */
+  /*    recognized, or non-zero otherwise.                                 */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_New_Memory_Face( FT_Library      library,
+                      const FT_Byte*  file_base,
+                      FT_Long         file_size,
+                      FT_Long         face_index,
+                      FT_Face        *aface );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Open_Face                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Opens a face object from a given resource and typeface index using */
+  /*    an `FT_Open_Args' structure.  If the face object doesn't exist, it */
+  /*    will be created.                                                   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library    :: A handle to the library resource.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    args       :: A pointer to an `FT_Open_Args' structure which must  */
+  /*                  be filled by the caller.                             */
+  /*                                                                       */
+  /*    face_index :: The index of the face within the resource.  The      */
+  /*                  first face has index 0.                              */
+  /* <Output>                                                              */
+  /*    aface      :: A handle to a new face object.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Unlike FreeType 1.x, this function automatically creates a glyph   */
+  /*    slot for the face object which can be accessed directly through    */
+  /*    `face->glyph'.                                                     */
+  /*                                                                       */
+  /*    @FT_Open_Face can be used to determine and/or check the font      */
+  /*    format of a given font resource.  If the `face_index' field is     */
+  /*    negative, the function will _not_ return any face handle in        */
+  /*    `*face'.  Its return value should be 0 if the font format is       */
+  /*    recognized, or non-zero otherwise.                                 */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Open_Face( FT_Library           library,
+                const FT_Open_Args*  args,
+                FT_Long              face_index,
+                FT_Face             *aface );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Attach_File                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    `Attaches' a given font file to an existing face.  This is usually */
+  /*    to read additional information for a single face object.  For      */
+  /*    example, it is used to read the AFM files that come with Type 1    */
+  /*    fonts in order to add kerning data and other metrics.              */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face         :: The target face object.                            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    filepathname :: An 8-bit pathname naming the `metrics' file.       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    If your font file is in memory, or if you want to provide your     */
+  /*    own input stream object, use @FT_Attach_Stream.                    */
+  /*                                                                       */
+  /*    The meaning of the `attach' action (i.e., what really happens when */
+  /*    the new file is read) is not fixed by FreeType itself.  It really  */
+  /*    depends on the font format (and thus the font driver).             */
+  /*                                                                       */
+  /*    Client applications are expected to know what they are doing       */
+  /*    when invoking this function.  Most drivers simply do not implement */
+  /*    file attachments.                                                  */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Attach_File( FT_Face      face,
+                  const char*  filepathname );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Attach_Stream                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is similar to @FT_Attach_File with the exception     */
+  /*    that it reads the attachment from an arbitrary stream.             */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face       :: The target face object.                              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    parameters :: A pointer to an FT_Open_Args structure used to       */
+  /*                  describe the input stream to FreeType.               */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The meaning of the `attach' (i.e. what really happens when the     */
+  /*    new file is read) is not fixed by FreeType itself.  It really      */
+  /*    depends on the font format (and thus the font driver).             */
+  /*                                                                       */
+  /*    Client applications are expected to know what they are doing       */
+  /*    when invoking this function.  Most drivers simply do not implement */
+  /*    file attachments.                                                  */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Attach_Stream( FT_Face        face,
+                    FT_Open_Args*  parameters );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Done_Face                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Discards a given face object, as well as all of its child slots    */
+  /*    and sizes.                                                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to a target face object.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Done_Face( FT_Face  face );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_Char_Size                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Sets the character dimensions of a given face object.  The         */
+  /*    `char_width' and `char_height' values are used for the width and   */
+  /*    height, respectively, expressed in 26.6 fractional points.         */
+  /*                                                                       */
+  /*    If the horizontal or vertical resolution values are zero, a        */
+  /*    default value of 72dpi is used.  Similarly, if one of the          */
+  /*    character dimensions is zero, its value is set equal to the other. */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    size            :: A handle to a target size object.               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    char_width      :: The character width, in 26.6 fractional points. */
+  /*                                                                       */
+  /*    char_height     :: The character height, in 26.6 fractional        */
+  /*                       points.                                         */
+  /*                                                                       */
+  /*    horz_resolution :: The horizontal resolution.                      */
+  /*                                                                       */
+  /*    vert_resolution :: The vertical resolution.                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    When dealing with fixed-size faces (i.e., non-scalable formats),   */
+  /*    use the function @FT_Set_Pixel_Sizes.                              */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Set_Char_Size( FT_Face     face,
+                    FT_F26Dot6  char_width,
+                    FT_F26Dot6  char_height,
+                    FT_UInt     horz_resolution,
+                    FT_UInt     vert_resolution );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_Pixel_Sizes                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Sets the character dimensions of a given face object.  The width   */
+  /*    and height are expressed in integer pixels.                        */
+  /*                                                                       */
+  /*    If one of the character dimensions is zero, its value is set equal */
+  /*    to the other.                                                      */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face         :: A handle to the target face object.                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    pixel_width  :: The character width, in integer pixels.            */
+  /*                                                                       */
+  /*    pixel_height :: The character height, in integer pixels.           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The values of `pixel_width' and `pixel_height' correspond to the   */
+  /*    pixel values of the _typographic_ character size, which are NOT    */
+  /*    necessarily the same as the dimensions of the glyph `bitmap        */
+  /*    cells'.                                                            */
+  /*                                                                       */
+  /*    The `character size' is really the size of an abstract square      */
+  /*    called the `EM', used to design the font.  However, depending      */
+  /*    on the font design, glyphs will be smaller or greater than the     */
+  /*    EM.                                                                */
+  /*                                                                       */
+  /*    This means that setting the pixel size to, say, 8x8 doesn't        */
+  /*    guarantee in any way that you will get glyph bitmaps that all fit  */
+  /*    within an 8x8 cell (sometimes even far from it).                   */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Set_Pixel_Sizes( FT_Face  face,
+                      FT_UInt  pixel_width,
+                      FT_UInt  pixel_height );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Load_Glyph                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to load a single glyph within a given glyph slot,  */
+  /*    for a given size.                                                  */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face        :: A handle to the target face object where the glyph  */
+  /*                   will be loaded.                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    glyph_index :: The index of the glyph in the font file.            */
+  /*                                                                       */
+  /*    load_flags  :: A flag indicating what to load for this glyph.  The */
+  /*                   @FT_LOAD_XXX constants can be used to control the   */
+  /*                   glyph loading process (e.g., whether the outline    */
+  /*                   should be scaled, whether to load bitmaps or not,   */
+  /*                   whether to hint the outline, etc).                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    If the glyph image is not a bitmap, and if the bit flag            */
+  /*    FT_LOAD_IGNORE_TRANSFORM is unset, the glyph image will be         */
+  /*    transformed with the information passed to a previous call to      */
+  /*    @FT_Set_Transform.                                                 */
+  /*                                                                       */
+  /*    Note that this also transforms the `face.glyph.advance' field, but */
+  /*    *not* the values in `face.glyph.metrics'.                          */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Load_Glyph( FT_Face   face,
+                 FT_UInt   glyph_index,
+                 FT_Int32  load_flags );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Load_Char                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to load a single glyph within a given glyph slot,  */
+  /*    for a given size, according to its character code.                 */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face        :: A handle to a target face object where the glyph    */
+  /*                   will be loaded.                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    char_code   :: The glyph's character code, according to the        */
+  /*                   current charmap used in the face.                   */
+  /*                                                                       */
+  /*    load_flags  :: A flag indicating what to load for this glyph.  The */
+  /*                   @FT_LOAD_XXX constants can be used to control the   */
+  /*                   glyph loading process (e.g., whether the outline    */
+  /*                   should be scaled, whether to load bitmaps or not,   */
+  /*                   whether to hint the outline, etc).                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    If the face has no current charmap, or if the character code       */
+  /*    is not defined in the charmap, this function will return an        */
+  /*    error.                                                             */
+  /*                                                                       */
+  /*    If the glyph image is not a bitmap, and if the bit flag            */
+  /*    FT_LOAD_IGNORE_TRANSFORM is unset, the glyph image will be         */
+  /*    transformed with the information passed to a previous call to      */
+  /*    @FT_Set_Transform.                                                 */
+  /*                                                                       */
+  /*    Note that this also transforms the `face.glyph.advance' field, but */
+  /*    *not* the values in `face.glyph.metrics'.                          */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Load_Char( FT_Face   face,
+                FT_ULong  char_code,
+                FT_Int32  load_flags );
+
+
+ /****************************************************************************
+  *
+  * @enum:
+  *   FT_LOAD_XXX
+  *
+  * @description:
+  *   A list of bit-field constants, used with @FT_Load_Glyph to indicate
+  *   what kind of operations to perform during glyph loading.
+  *
+  * @values:
+  *   FT_LOAD_DEFAULT ::
+  *     Corresponding to 0, this value is used a default glyph load.  In this
+  *     case, the following will happen:
+  *
+  *     1. FreeType looks for a bitmap for the glyph corresponding to the
+  *        face's current size.  If one is found, the function returns.  The
+  *        bitmap data can be accessed from the glyph slot (see note below).
+  *
+  *     2. If no embedded bitmap is searched or found, FreeType looks for a
+  *        scalable outline.  If one is found, it is loaded from the font
+  *        file, scaled to device pixels, then "hinted" to the pixel grid in
+  *        order to optimize it.  The outline data can be accessed from the
+  *        glyph slot (see note below).
+  *
+  *     Note that by default, the glyph loader doesn't render outlines into
+  *     bitmaps.  The following flags are used to modify this default
+  *     behaviour to more specific and useful cases.
+  *
+  *   FT_LOAD_NO_SCALE ::
+  *     Don't scale the vector outline being loaded to 26.6 fractional
+  *     pixels, but kept in font units.  Note that this also disables
+  *     hinting and the loading of embedded bitmaps.  You should only use it
+  *     when you want to retrieve the original glyph outlines in font units.
+  *
+  *   FT_LOAD_NO_HINTING ::
+  *     Don't hint glyph outlines after their scaling to device pixels.
+  *     This generally generates "blurrier" glyphs in anti-aliased modes.
+  *
+  *     This flag is ignored if @FT_LOAD_NO_SCALE is set.
+  *
+  *   FT_LOAD_RENDER ::
+  *     Render the glyph outline immediately into a bitmap before the glyph
+  *     loader returns.  By default, the glyph is rendered for the
+  *     @FT_RENDER_MODE_NORMAL mode, which corresponds to 8-bit anti-aliased
+  *     bitmaps using 256 opacity levels.  You can use either
+  *     @FT_LOAD_TARGET_MONO or @FT_LOAD_MONOCHROME to render 1-bit
+  *     monochrome bitmaps.
+  *
+  *     This flag is ignored if @FT_LOAD_NO_SCALE is set.
+  *
+  *   FT_LOAD_NO_BITMAP ::
+  *     Don't look for bitmaps when loading the glyph.  Only scalable
+  *     outlines will be loaded when available, and scaled, hinted, or
+  *     rendered depending on other bit flags.
+  *
+  *     This does not prevent you from rendering outlines to bitmaps
+  *     with @FT_LOAD_RENDER, however.
+  *
+  *   FT_LOAD_VERTICAL_LAYOUT ::
+  *     Prepare the glyph image for vertical text layout.  This basically
+  *     means that `face.glyph.advance' will correspond to the vertical
+  *     advance height (instead of the default horizontal advance width),
+  *     and that the glyph image will be translated to match the vertical
+  *     bearings positions.
+  *
+  *   FT_LOAD_FORCE_AUTOHINT ::
+  *     Force the use of the FreeType auto-hinter when a glyph outline is
+  *     loaded.  You shouldn't need this in a typical application, since it
+  *     is mostly used to experiment with its algorithm.
+  *
+  *   FT_LOAD_CROP_BITMAP ::
+  *     Indicates that the glyph loader should try to crop the bitmap (i.e.,
+  *     remove all space around its black bits) when loading it.  This is
+  *     only useful when loading embedded bitmaps in certain fonts, since
+  *     bitmaps rendered with @FT_LOAD_RENDER are always cropped by default.
+  *
+  *   FT_LOAD_PEDANTIC ::
+  *     Indicates that the glyph loader should perform pedantic
+  *     verifications during glyph loading, rejecting invalid fonts.  This
+  *     is mostly used to detect broken glyphs in fonts.  By default,
+  *     FreeType tries to handle broken fonts also.
+  *
+  *   FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH ::
+  *     Indicates that the glyph loader should ignore the global advance
+  *     width defined in the font.  As far as we know, this is only used by
+  *     the X-TrueType font server, in order to deal correctly with the
+  *     incorrect metrics contained in DynaLab's TrueType CJK fonts.
+  *
+  *   FT_LOAD_NO_RECURSE ::
+  *     This flag is only used internally.  It merely indicates that the
+  *     glyph loader should not load composite glyphs recursively.  Instead,
+  *     it should set the `num_subglyph' and `subglyphs' values of the glyph
+  *     slot accordingly, and set "glyph->format" to
+  *     @FT_GLYPH_FORMAT_COMPOSITE.
+  *
+  *     The description of sub-glyphs is not available to client
+  *     applications for now.
+  *
+  *   FT_LOAD_IGNORE_TRANSFORM ::
+  *     Indicates that the glyph loader should not try to transform the
+  *     loaded glyph image.  This doesn't prevent scaling, hinting, or
+  *     rendering.
+  *
+  *   FT_LOAD_MONOCHROME ::
+  *     This flag is used with @FT_LOAD_RENDER to indicate that you want
+  *     to render a 1-bit monochrome glyph bitmap from a vectorial outline.
+  *
+  *     Note that this has no effect on the hinting algorithm used by the
+  *     glyph loader.  You should better use @FT_LOAD_TARGET_MONO if you
+  *     want to render monochrome-optimized glyph images instead.
+  *
+  *   FT_LOAD_LINEAR_DESIGN ::
+  *     Return the linearly scaled metrics expressed in original font units
+  *     instead of the default 16.16 pixel values.
+  *
+  *   FT_LOAD_NO_AUTOHINT ::
+  *     Indicates that the auto-hinter should never be used to hint glyph
+  *     outlines.  This doesn't prevent native format-specific hinters from
+  *     being used.  This can be important for certain fonts where unhinted
+  *     output is better than auto-hinted one.
+  */
+#define FT_LOAD_NO_SCALE                     0x1
+#define FT_LOAD_NO_HINTING                   0x2
+#define FT_LOAD_RENDER                       0x4
+#define FT_LOAD_NO_BITMAP                    0x8
+#define FT_LOAD_VERTICAL_LAYOUT              0x10
+#define FT_LOAD_FORCE_AUTOHINT               0x20
+#define FT_LOAD_CROP_BITMAP                  0x40
+#define FT_LOAD_PEDANTIC                     0x80
+#define FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH  0x200
+#define FT_LOAD_NO_RECURSE                   0x400
+#define FT_LOAD_IGNORE_TRANSFORM             0x800
+#define FT_LOAD_MONOCHROME                   0x1000
+#define FT_LOAD_LINEAR_DESIGN                0x2000
+
+  /* temporary hack! */
+#define FT_LOAD_SBITS_ONLY                   0x4000
+#define FT_LOAD_NO_AUTOHINT                  0x8000U
+
+  /* */
+
+#define FT_LOAD_TARGET_( x )      ( (FT_Int32)( (x) & 15 ) << 16 )
+#define FT_LOAD_TARGET_MODE( x )  ( (FT_Render_Mode)( ( (x) >> 16 ) & 15 ) )
+
+#define FT_LOAD_TARGET_NORMAL     FT_LOAD_TARGET_( FT_RENDER_MODE_NORMAL )
+#define FT_LOAD_TARGET_LIGHT      FT_LOAD_TARGET_( FT_RENDER_MODE_LIGHT  )
+#define FT_LOAD_TARGET_MONO       FT_LOAD_TARGET_( FT_RENDER_MODE_MONO   )
+#define FT_LOAD_TARGET_LCD        FT_LOAD_TARGET_( FT_RENDER_MODE_LCD    )
+#define FT_LOAD_TARGET_LCD_V      FT_LOAD_TARGET_( FT_RENDER_MODE_LCD_V  )
+
+#define FT_LOAD_DEFAULT           0x0
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_Transform                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to set the transformation that is applied to glyph */
+  /*    images just before they are converted to bitmaps in a glyph slot   */
+  /*    when @FT_Render_Glyph is called.                                   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face   :: A handle to the source face object.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    matrix :: A pointer to the transformation's 2x2 matrix.  Use 0 for */
+  /*              the identity matrix.                                     */
+  /*    delta  :: A pointer to the translation vector.  Use 0 for the null */
+  /*              vector.                                                  */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The transformation is only applied to scalable image formats after */
+  /*    the glyph has been loaded.  It means that hinting is unaltered by  */
+  /*    the transformation and is performed on the character size given in */
+  /*    the last call to @FT_Set_Char_Sizes or @FT_Set_Pixel_Sizes.        */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Set_Transform( FT_Face     face,
+                    FT_Matrix*  matrix,
+                    FT_Vector*  delta );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Render_Mode                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration type that lists the render modes supported by       */
+  /*    FreeType 2.  Each mode corresponds to a specific type of scanline  */
+  /*    conversion performed on the outline, as well as specific           */
+  /*    hinting optimizations.                                             */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_RENDER_MODE_NORMAL ::                                           */
+  /*      This is the default render mode; it corresponds to 8-bit         */
+  /*      anti-aliased bitmaps, using 256 levels of opacity.               */
+  /*                                                                       */
+  /*    FT_RENDER_MODE_LIGHT ::                                            */
+  /*      This is similar to @FT_RENDER_MODE_NORMAL, except that this      */
+  /*      changes the hinting to prevent stem width quantization. This     */
+  /*      results in glyph shapes that are more similar to the original,   */
+  /*      while being a bit more fuzzy ("better shapes", instead of        */
+  /*      "better contrast" if you want :-) THIS IS STILL EXPERIMENTAL,    */
+  /*      FOR NOW, THIS WILL PRODUCE RESULTS SIMILAR TO NORMAL MODE !!     */
+  /*                                                                       */
+  /*    FT_RENDER_MODE_MONO ::                                             */
+  /*      This mode corresponds to 1-bit bitmaps.                          */
+  /*                                                                       */
+  /*    FT_RENDER_MODE_LCD ::                                              */
+  /*      This mode corresponds to horizontal RGB/BGR sub-pixel displays,  */
+  /*      like LCD-screens.  It produces 8-bit bitmaps that are 3 times    */
+  /*      the width of the original glyph outline in pixels, and which use */
+  /*      the @FT_PIXEL_MODE_LCD mode. THIS IS STILL EXPERIMENTAL, DO NOT  */
+  /*      USE FOR NOW !!                                                   */
+  /*                                                                       */
+  /*    FT_RENDER_MODE_LCD_V ::                                            */
+  /*      This mode corresponds to vertical RGB/BGR sub-pixel displays     */
+  /*      (like PDA screens, rotated LCD displays, etc.).  It produces     */
+  /*      8-bit bitmaps that are 3 times the height of the original        */
+  /*      glyph outline in pixels and use the @FT_PIXEL_MODE_LCD_V mode.   */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*   The LCD-optimized glyph bitmaps produced by FT_Render_Glyph are     */
+  /*   _not filtered_ to reduce color-fringes.  It is up to the caller to  */
+  /*   perform this pass. THIS IS STILL EXPERIMENTAL, DO NOT USE FOR NOW   */
+  /*   !!                                                                  */
+  /*                                                                       */
+  typedef enum  FT_Render_Mode_
+  {
+    FT_RENDER_MODE_NORMAL = 0,
+    FT_RENDER_MODE_LIGHT,
+    FT_RENDER_MODE_MONO,
+    FT_RENDER_MODE_LCD,
+    FT_RENDER_MODE_LCD_V,
+
+    FT_RENDER_MODE_MAX
+
+  } FT_Render_Mode;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    ft_render_mode_xxx                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    These constats are deprecated.  Use the corresponding              */
+  /*    @FT_Render_Mode values instead.                                    */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*   ft_render_mode_normal :: see @FT_RENDER_MODE_NORMAL                 */
+  /*   ft_render_mode_mono   :: see @FT_RENDER_MODE_MONO                   */
+  /*                                                                       */
+#define ft_render_mode_normal  FT_RENDER_MODE_NORMAL
+#define ft_render_mode_mono    FT_RENDER_MODE_MONO
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Render_Glyph                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Converts a given glyph image to a bitmap.  It does so by           */
+  /*    inspecting the glyph image format, find the relevant renderer, and */
+  /*    invoke it.                                                         */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    slot        :: A handle to the glyph slot containing the image to  */
+  /*                   convert.                                            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    render_mode :: This is the render mode used to render the glyph    */
+  /*                   image into a bitmap.  See FT_Render_Mode for a list */
+  /*                   of possible values.                                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Render_Glyph( FT_GlyphSlot    slot,
+                   FT_Render_Mode  render_mode );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Kerning_Mode                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration used to specify which kerning values to return in   */
+  /*    @FT_Get_Kerning.                                                   */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_KERNING_DEFAULT  :: Return scaled and grid-fitted kerning       */
+  /*                           distances (value is 0).                     */
+  /*                                                                       */
+  /*    FT_KERNING_UNFITTED :: Return scaled but un-grid-fitted kerning    */
+  /*                           distances.                                  */
+  /*                                                                       */
+  /*    FT_KERNING_UNSCALED :: Return the kerning vector in original font  */
+  /*                           units.                                      */
+  /*                                                                       */
+  typedef enum  FT_Kerning_Mode_
+  {
+    FT_KERNING_DEFAULT  = 0,
+    FT_KERNING_UNFITTED,
+    FT_KERNING_UNSCALED
+
+  } FT_Kerning_Mode;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Const>                                                               */
+  /*    ft_kerning_default                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This constant is deprecated.  Please use @FT_KERNING_DEFAULT       */
+  /*    instead.                                                           */
+  /*                                                                       */
+#define ft_kerning_default   FT_KERNING_DEFAULT
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Const>                                                               */
+  /*    ft_kerning_unfitted                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This constant is deprecated.  Please use @FT_KERNING_UNFITTED      */
+  /*    instead.                                                           */
+  /*                                                                       */
+#define ft_kerning_unfitted  FT_KERNING_UNFITTED
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Const>                                                               */
+  /*    ft_kerning_unscaled                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This constant is deprecated.  Please use @FT_KERNING_UNSCALED      */
+  /*    instead.                                                           */
+  /*                                                                       */
+#define ft_kerning_unscaled  FT_KERNING_UNSCALED
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Kerning                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Returns the kerning vector between two glyphs of a same face.      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face        :: A handle to a source face object.                   */
+  /*                                                                       */
+  /*    left_glyph  :: The index of the left glyph in the kern pair.       */
+  /*                                                                       */
+  /*    right_glyph :: The index of the right glyph in the kern pair.      */
+  /*                                                                       */
+  /*    kern_mode   :: See @FT_Kerning_Mode for more information.          */
+  /*                   Determines the scale/dimension of the returned      */
+  /*                   kerning vector.                                     */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    akerning    :: The kerning vector.  This is in font units for      */
+  /*                   scalable formats, and in pixels for fixed-sizes     */
+  /*                   formats.                                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Only horizontal layouts (left-to-right & right-to-left) are        */
+  /*    supported by this method.  Other layouts, or more sophisticated    */
+  /*    kernings, are out of the scope of this API function -- they can be */
+  /*    implemented through format-specific interfaces.                    */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Kerning( FT_Face     face,
+                  FT_UInt     left_glyph,
+                  FT_UInt     right_glyph,
+                  FT_UInt     kern_mode,
+                  FT_Vector  *akerning );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Glyph_Name                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieves the ASCII name of a given glyph in a face.  This only    */
+  /*    works for those faces where FT_HAS_GLYPH_NAME(face) returns true.  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face        :: A handle to a source face object.                   */
+  /*                                                                       */
+  /*    glyph_index :: The glyph index.                                    */
+  /*                                                                       */
+  /*    buffer_max  :: The maximal number of bytes available in the        */
+  /*                   buffer.                                             */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    buffer      :: A pointer to a target buffer where the name will be */
+  /*                   copied to.                                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    An error is returned if the face doesn't provide glyph names or if */
+  /*    the glyph index is invalid.  In all cases of failure, the first    */
+  /*    byte of `buffer' will be set to 0 to indicate an empty name.       */
+  /*                                                                       */
+  /*    The glyph name is truncated to fit within the buffer if it is too  */
+  /*    long.  The returned string is always zero-terminated.              */
+  /*                                                                       */
+  /*    This function is not compiled within the library if the config     */
+  /*    macro FT_CONFIG_OPTION_NO_GLYPH_NAMES is defined in                */
+  /*    `include/freetype/config/ftoptions.h'                              */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Glyph_Name( FT_Face     face,
+                     FT_UInt     glyph_index,
+                     FT_Pointer  buffer,
+                     FT_UInt     buffer_max );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Postscript_Name                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieves the ASCII Postscript name of a given face, if available. */
+  /*    This should only work with Postscript and TrueType fonts.          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to the source face object.                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A pointer to the face's Postscript name.  NULL if un-available.    */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The returned pointer is owned by the face and will be destroyed    */
+  /*    with it.                                                           */
+  /*                                                                       */
+  FT_EXPORT( const char* )
+  FT_Get_Postscript_Name( FT_Face  face );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Select_Charmap                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Selects a given charmap by its encoding tag (as listed in          */
+  /*    `freetype.h').                                                     */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face     :: A handle to the source face object.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    encoding :: A handle to the selected charmap.                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function will return an error if no charmap in the face       */
+  /*    corresponds to the encoding queried here.                          */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Select_Charmap( FT_Face      face,
+                     FT_Encoding  encoding );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_Charmap                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Selects a given charmap for character code to glyph index          */
+  /*    decoding.                                                          */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face    :: A handle to the source face object.                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    charmap :: A handle to the selected charmap.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function will return an error if the charmap is not part of   */
+  /*    the face (i.e., if it is not listed in the face->charmaps[]        */
+  /*    table).                                                            */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Set_Charmap( FT_Face     face,
+                  FT_CharMap  charmap );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Char_Index                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Returns the glyph index of a given character code.  This function  */
+  /*    uses a charmap object to do the translation.                       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face     :: A handle to the source face object.                    */
+  /*                                                                       */
+  /*    charcode :: The character code.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The glyph index.  0 means `undefined character code'.              */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    FreeType computes its own glyph indices which are not necessarily  */
+  /*    the same as used in the font in case the font is based on glyph    */
+  /*    indices.  Reason for this behaviour is to assure that index 0 is   */
+  /*    never used, representing the missing glyph.                        */
+  /*                                                                       */
+  FT_EXPORT( FT_UInt )
+  FT_Get_Char_Index( FT_Face   face,
+                     FT_ULong  charcode );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_First_Char                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used to return the first character code in the    */
+  /*    current charmap of a given face.  It will also return the          */
+  /*    corresponding glyph index.                                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face    :: A handle to the source face object.                     */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    agindex :: Glyph index of first character code.  0 if charmap is   */
+  /*               empty.                                                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The charmap's first character code.                                */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You should use this function with @FT_Get_Next_Char to be able to  */
+  /*    parse all character codes available in a given charmap.  The code  */
+  /*    should look like this:                                             */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      FT_ULong  charcode;                                              */
+  /*      FT_UInt   gindex;                                                */
+  /*                                                                       */
+  /*                                                                       */
+  /*      charcode = FT_Get_First_Char( face, &gindex );                   */
+  /*      while ( gindex != 0 )                                            */
+  /*      {                                                                */
+  /*        ... do something with (charcode,gindex) pair ...               */
+  /*                                                                       */
+  /*        charcode = FT_Get_Next_Char( face, charcode, &gindex );        */
+  /*      }                                                                */
+  /*    }                                                                  */
+  /*                                                                       */
+  /*    Note that `*agindex' will be set to 0 if the charmap is empty.     */
+  /*    The result itself can be 0 in two cases: if the charmap is empty   */
+  /*    or when the value 0 is the first valid character code.             */
+  /*                                                                       */
+  FT_EXPORT( FT_ULong )
+  FT_Get_First_Char( FT_Face   face,
+                     FT_UInt  *agindex );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Next_Char                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used to return the next character code in the     */
+  /*    current charmap of a given face following the value 'char_code',   */
+  /*    as well as the corresponding glyph index.                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face      :: A handle to the source face object.                   */
+  /*    char_code :: The starting character code.                          */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    agindex   :: Glyph index of first character code.  0 if charmap    */
+  /*                 is empty.                                             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The charmap's next character code.                                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You should use this function with @FT_Get_First_Char to walk       */
+  /*    through all character codes available in a given charmap.  See     */
+  /*    the note for this function for a simple code example.              */
+  /*                                                                       */
+  /*    Note that `*agindex' will be set to 0 when there are no more codes */
+  /*    in the charmap.                                                    */
+  /*                                                                       */
+  FT_EXPORT( FT_ULong )
+  FT_Get_Next_Char( FT_Face    face,
+                    FT_ULong   char_code,
+                    FT_UInt   *agindex );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Name_Index                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Returns the glyph index of a given glyph name.  This function uses */
+  /*    driver specific objects to do the translation.                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face       :: A handle to the source face object.                  */
+  /*                                                                       */
+  /*    glyph_name :: The glyph name.                                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The glyph index.  0 means `undefined character code'.              */
+  /*                                                                       */
+  FT_EXPORT( FT_UInt )
+  FT_Get_Name_Index( FT_Face     face,
+                     FT_String*  glyph_name );
+
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    computations                                                       */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Computations                                                       */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Crunching fixed numbers and vectors                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains various functions used to perform            */
+  /*    computations on 16.16 fixed-float numbers or 2d vectors.           */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    FT_MulDiv                                                          */
+  /*    FT_MulFix                                                          */
+  /*    FT_DivFix                                                          */
+  /*    FT_RoundFix                                                        */
+  /*    FT_CeilFix                                                         */
+  /*    FT_FloorFix                                                        */
+  /*    FT_Vector_Transform                                                */
+  /*    FT_Matrix_Multiply                                                 */
+  /*    FT_Matrix_Invert                                                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_MulDiv                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A very simple function used to perform the computation `(a*b)/c'   */
+  /*    with maximal accuracy (it uses a 64-bit intermediate integer       */
+  /*    whenever necessary).                                               */
+  /*                                                                       */
+  /*    This function isn't necessarily as fast as some processor specific */
+  /*    operations, but is at least completely portable.                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    a :: The first multiplier.                                         */
+  /*    b :: The second multiplier.                                        */
+  /*    c :: The divisor.                                                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The result of `(a*b)/c'.  This function never traps when trying to */
+  /*    divide by zero; it simply returns `MaxInt' or `MinInt' depending   */
+  /*    on the signs of `a' and `b'.                                       */
+  /*                                                                       */
+  FT_EXPORT( FT_Long )
+  FT_MulDiv( FT_Long  a,
+             FT_Long  b,
+             FT_Long  c );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_MulFix                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A very simple function used to perform the computation             */
+  /*    `(a*b)/0x10000' with maximal accuracy.  Most of the time this is   */
+  /*    used to multiply a given value by a 16.16 fixed float factor.      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    a :: The first multiplier.                                         */
+  /*    b :: The second multiplier.  Use a 16.16 factor here whenever      */
+  /*         possible (see note below).                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The result of `(a*b)/0x10000'.                                     */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function has been optimized for the case where the absolute   */
+  /*    value of `a' is less than 2048, and `b' is a 16.16 scaling factor. */
+  /*    As this happens mainly when scaling from notional units to         */
+  /*    fractional pixels in FreeType, it resulted in noticeable speed     */
+  /*    improvements between versions 2.x and 1.x.                         */
+  /*                                                                       */
+  /*    As a conclusion, always try to place a 16.16 factor as the         */
+  /*    _second_ argument of this function; this can make a great          */
+  /*    difference.                                                        */
+  /*                                                                       */
+  FT_EXPORT( FT_Long )
+  FT_MulFix( FT_Long  a,
+             FT_Long  b );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_DivFix                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A very simple function used to perform the computation             */
+  /*    `(a*0x10000)/b' with maximal accuracy.  Most of the time, this is  */
+  /*    used to divide a given value by a 16.16 fixed float factor.        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    a :: The first multiplier.                                         */
+  /*    b :: The second multiplier.  Use a 16.16 factor here whenever      */
+  /*         possible (see note below).                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The result of `(a*0x10000)/b'.                                     */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The optimization for FT_DivFix() is simple: If (a << 16) fits in   */
+  /*    32 bits, then the division is computed directly.  Otherwise, we    */
+  /*    use a specialized version of the old @FT_MulDiv64.                 */
+  /*                                                                       */
+  FT_EXPORT( FT_Long )
+  FT_DivFix( FT_Long  a,
+             FT_Long  b );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_RoundFix                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A very simple function used to round a 16.16 fixed number.         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    a :: The number to be rounded.                                     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The result of `(a + 0x8000) & -0x10000'.                           */
+  /*                                                                       */
+  FT_EXPORT( FT_Fixed )
+  FT_RoundFix( FT_Fixed  a );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_CeilFix                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A very simple function used to compute the ceiling function of a   */
+  /*    16.16 fixed number.                                                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    a :: The number for which the ceiling function is to be computed.  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The result of `(a + 0x10000 - 1) & -0x10000'.                      */
+  /*                                                                       */
+  FT_EXPORT( FT_Fixed )
+  FT_CeilFix( FT_Fixed  a );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_FloorFix                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A very simple function used to compute the floor function of a     */
+  /*    16.16 fixed number.                                                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    a :: The number for which the floor function is to be computed.    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The result of `a & -0x10000'.                                      */
+  /*                                                                       */
+  FT_EXPORT( FT_Fixed )
+  FT_FloorFix( FT_Fixed  a );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Vector_Transform                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Transforms a single vector through a 2x2 matrix.                   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    vector :: The target vector to transform.                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    matrix :: A pointer to the source 2x2 matrix.                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The result is undefined if either `vector' or `matrix' is invalid. */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Vector_Transform( FT_Vector*  vec,
+                       FT_Matrix*  matrix );
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* __FREETYPE_H__ */
+
+
+/* END */
+
--- /dev/null
+++ b/include/freetype/ft2build.h
@@ -1,0 +1,40 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ft2build.h                                                             */
+/*                                                                         */
+/*    FreeType 2 build and setup macros.                                   */
+/*    (Generic version)                                                    */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file corresponds to the default "ft2build.h" file for            */
+  /* FreeType 2.  It uses the "freetype" include root.                     */
+  /*                                                                       */
+  /* Note that specific platforms might use a different configuration.     */
+  /* See builds/unix/ft2unix.h for an example.                             */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __FT2_BUILD_GENERIC_H__
+#define __FT2_BUILD_GENERIC_H__
+
+#pragma incomplete _off_	/* it's too hard */
+
+#include <freetype/config/ftheader.h>
+#endif /* __FT2_BUILD_GENERIC_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftbbox.h
@@ -1,0 +1,83 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftbbox.h                                                               */
+/*                                                                         */
+/*    FreeType exact bbox computation (specification).                     */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This component has a _single_ role: to compute exact outline bounding */
+  /* boxes.                                                                */
+  /*                                                                       */
+  /* It is separated from the rest of the engine for various technical     */
+  /* reasons.  It may well be integrated in `ftoutln' later.               */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __FTBBOX_H__
+#define __FTBBOX_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    outline_processing                                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Get_BBox                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Computes the exact bounding box of an outline.  This is slower     */
+  /*    than computing the control box.  However, it uses an advanced      */
+  /*    algorithm which returns _very_ quickly when the two boxes          */
+  /*    coincide.  Otherwise, the outline Bezier arcs are walked over to   */
+  /*    extract their extrema.                                             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    outline :: A pointer to the source outline.                        */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    abbox   :: The outline's exact bounding box.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_Get_BBox( FT_Outline*  outline,
+                       FT_BBox     *abbox );
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* __FTBBOX_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftbdf.h
@@ -1,0 +1,84 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftbdf.h                                                                */
+/*                                                                         */
+/*    FreeType API for accessing BDF-specific strings (specification).     */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTBDF_H__
+#define __FTBDF_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    bdf_fonts                                                          */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    BDF Fonts                                                          */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    BDF-specific APIs                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the declaration of BDF-specific functions.   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_Get_BDF_Charset_ID
+  *
+  * @description:
+  *    Retrieves a BDF font character set identity, according to
+  *    the BDF specification.
+  *
+  * @input:
+  *    face ::
+  *       handle to input face
+  *
+  * @output:
+  *    acharset_encoding ::
+  *       Charset encoding, as a C string, owned by the face.
+  *
+  *    acharset_registry ::
+  *       Charset registry, as a C string, owned by the face.
+  *
+  * @return:
+  *   FreeType rror code.  0 means success.
+  *
+  * @note:
+  *   This function only works with BDF faces, returning an error otherwise.
+  */
+  FT_EXPORT( FT_Error )
+  FT_Get_BDF_Charset_ID( FT_Face       face,
+                         const char*  *acharset_encoding,
+                         const char*  *acharset_registry );
+
+ /* */
+
+FT_END_HEADER
+
+#endif /* __FTBDF_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftcache.h
@@ -1,0 +1,415 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcache.h                                                              */
+/*                                                                         */
+/*    FreeType Cache subsystem (specification).                            */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*********                                                       *********/
+  /*********             WARNING, THIS IS BETA CODE.               *********/
+  /*********                                                       *********/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+#ifndef __FTCACHE_H__
+#define __FTCACHE_H__
+
+
+#include <ft2build.h>
+#include FT_GLYPH_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    cache_subsystem                                                    */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Cache Sub-System                                                   */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    How to cache face, size, and glyph data with FreeType 2.           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   This section describes the FreeType 2 cache sub-system which is     */
+  /*   stile in beta.                                                      */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*   FTC_Manager                                                         */
+  /*   FTC_FaceID                                                          */
+  /*   FTC_Face_Requester                                                  */
+  /*                                                                       */
+  /*   FTC_Manager_New                                                     */
+  /*   FTC_Manager_Lookup_Face                                             */
+  /*   FTC_Manager_Lookup_Size                                             */
+  /*                                                                       */
+  /*   FTC_Node                                                            */
+  /*   FTC_Node_Ref                                                        */
+  /*   FTC_Node_Unref                                                      */
+  /*                                                                       */
+  /*   FTC_Font                                                            */
+  /*   FTC_ImageDesc                                                       */
+  /*   FTC_ImageCache                                                      */
+  /*   FTC_ImageCache_New                                                  */
+  /*   FTC_ImageCache_Lookup                                               */
+  /*                                                                       */
+  /*   FTC_SBit                                                            */
+  /*   FTC_SBitCache                                                       */
+  /*   FTC_SBitCache_New                                                   */
+  /*   FTC_SBitCache_Lookup                                                */
+  /*                                                                       */
+  /*                                                                       */
+  /*   FTC_Image_Desc                                                      */
+  /*   FTC_Image_Cache                                                     */
+  /*   FTC_Image_Cache_Lookup                                              */
+  /*                                                                       */
+  /*   FTC_SBit_Cache                                                      */
+  /*   FTC_SBit_Cache_Lookup                                               */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                    BASIC TYPE DEFINITIONS                     *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FTC_FaceID                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A generic pointer type that is used to identity face objects.  The */
+  /*    contents of such objects is application-dependent.                 */
+  /*                                                                       */
+  typedef FT_Pointer  FTC_FaceID;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FTC_Face_Requester                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A callback function provided by client applications.  It is used   */
+  /*    to translate a given @FTC_FaceID into a new valid @FT_Face object. */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face_id :: The face ID to resolve.                                 */
+  /*                                                                       */
+  /*    library :: A handle to a FreeType library object.                  */
+  /*                                                                       */
+  /*    data    :: Application-provided request data.                      */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aface   :: A new @FT_Face handle.                                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The face requester should not perform funny things on the returned */
+  /*    face object, like creating a new @FT_Size for it, or setting a     */
+  /*    transformation through @FT_Set_Transform!                          */
+  /*                                                                       */
+  typedef FT_Error
+  (*FTC_Face_Requester)( FTC_FaceID  face_id,
+                         FT_Library  library,
+                         FT_Pointer  request_data,
+                         FT_Face*    aface );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FTC_FontRec                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple structure used to describe a given `font' to the cache    */
+  /*    manager.  Note that a `font' is the combination of a given face    */
+  /*    with a given character size.                                       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    face_id    :: The ID of the face to use.                           */
+  /*                                                                       */
+  /*    pix_width  :: The character width in integer pixels.               */
+  /*                                                                       */
+  /*    pix_height :: The character height in integer pixels.              */
+  /*                                                                       */
+  typedef struct  FTC_FontRec_
+  {
+    FTC_FaceID  face_id;
+    FT_UShort   pix_width;
+    FT_UShort   pix_height;
+
+  } FTC_FontRec;
+
+
+  /* */
+
+
+#define FTC_FONT_COMPARE( f1, f2 )                  \
+          ( (f1)->face_id    == (f2)->face_id    && \
+            (f1)->pix_width  == (f2)->pix_width  && \
+            (f1)->pix_height == (f2)->pix_height )
+
+#define FT_POINTER_TO_ULONG( p )  ((FT_ULong)(FT_Pointer)(p))
+
+#define FTC_FACE_ID_HASH( i )                              \
+          ((FT_UInt32)(( FT_POINTER_TO_ULONG( i ) >> 3 ) ^ \
+                       ( FT_POINTER_TO_ULONG( i ) << 7 ) ) )
+
+#define FTC_FONT_HASH( f )                              \
+          (FT_UInt32)( FTC_FACE_ID_HASH((f)->face_id) ^ \
+                       ((f)->pix_width << 8)          ^ \
+                       ((f)->pix_height)              )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FTC_Font                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple handle to an @FTC_FontRec structure.                      */
+  /*                                                                       */
+  typedef FTC_FontRec*  FTC_Font;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                      CACHE MANAGER OBJECT                     *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FTC_Manager                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This object is used to cache one or more @FT_Face objects, along   */
+  /*    with corresponding @FT_Size objects.                               */
+  /*                                                                       */
+  typedef struct FTC_ManagerRec_*  FTC_Manager;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FTC_Node                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An opaque handle to a cache node object.  Each cache node is       */
+  /*    reference-counted.  A node with a count of 0 might be flushed      */
+  /*    out of a full cache whenever a lookup request is performed.        */
+  /*                                                                       */
+  /*    If you lookup nodes, you have the ability to "acquire" them, i.e., */
+  /*    to increment their reference count.  This will prevent the node    */
+  /*    from being flushed out of the cache until you explicitly "release" */
+  /*    it (see @FTC_Node_Release).                                        */
+  /*                                                                       */
+  /*    See also @FTC_BitsetCache_Lookup and @FTC_ImageCache_Lookup.       */
+  /*                                                                       */
+  typedef struct FTC_NodeRec_*  FTC_Node;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_Manager_New                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Creates a new cache manager.                                       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library   :: The parent FreeType library handle to use.            */
+  /*                                                                       */
+  /*    max_faces :: Maximum number of faces to keep alive in manager.     */
+  /*                 Use 0 for defaults.                                   */
+  /*                                                                       */
+  /*    max_sizes :: Maximum number of sizes to keep alive in manager.     */
+  /*                 Use 0 for defaults.                                   */
+  /*                                                                       */
+  /*    max_bytes :: Maximum number of bytes to use for cached data.       */
+  /*                 Use 0 for defaults.                                   */
+  /*                                                                       */
+  /*    requester :: An application-provided callback used to translate    */
+  /*                 face IDs into real @FT_Face objects.                  */
+  /*                                                                       */
+  /*    req_data  :: A generic pointer that is passed to the requester     */
+  /*                 each time it is called (see @FTC_Face_Requester).     */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    amanager  :: A handle to a new manager object.  0 in case of       */
+  /*                 failure.                                              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_Manager_New( FT_Library          library,
+                   FT_UInt             max_faces,
+                   FT_UInt             max_sizes,
+                   FT_ULong            max_bytes,
+                   FTC_Face_Requester  requester,
+                   FT_Pointer          req_data,
+                   FTC_Manager        *amanager );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_Manager_Reset                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Empties a given cache manager.  This simply gets rid of all the    */
+  /*    currently cached @FT_Face and @FT_Size objects within the manager. */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    manager :: A handle to the manager.                                */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FTC_Manager_Reset( FTC_Manager  manager );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_Manager_Done                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroys a given manager after emptying it.                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    manager :: A handle to the target cache manager object.            */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FTC_Manager_Done( FTC_Manager  manager );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_Manager_Lookup_Face                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieves the @FT_Face object that corresponds to a given face ID  */
+  /*    through a cache manager.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    manager :: A handle to the cache manager.                          */
+  /*                                                                       */
+  /*    face_id :: The ID of the face object.                              */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aface   :: A handle to the face object.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The returned @FT_Face object is always owned by the manager.  You  */
+  /*    should never try to discard it yourself.                           */
+  /*                                                                       */
+  /*    The @FT_Face object doesn't necessarily have a current size object */
+  /*    (i.e., face->size can be 0).  If you need a specific `font size',  */
+  /*    use @FTC_Manager_Lookup_Size instead.                              */
+  /*                                                                       */
+  /*    Never change the face's transformation matrix (i.e., never call    */
+  /*    the @FT_Set_Transform function) on a returned face!  If you need   */
+  /*    to transform glyphs, do it yourself after glyph loading.           */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_Manager_Lookup_Face( FTC_Manager  manager,
+                           FTC_FaceID   face_id,
+                           FT_Face     *aface );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FTC_Manager_Lookup_Size                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieves the @FT_Face and @FT_Size objects that correspond to a   */
+  /*    given @FTC_SizeID.                                                 */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    manager :: A handle to the cache manager.                          */
+  /*                                                                       */
+  /*    size_id :: The ID of the `font size' to use.                       */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aface   :: A pointer to the handle of the face object.  Set it to  */
+  /*               zero if you don't need it.                              */
+  /*                                                                       */
+  /*    asize   :: A pointer to the handle of the size object.  Set it to  */
+  /*               zero if you don't need it.                              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The returned @FT_Face object is always owned by the manager.  You  */
+  /*    should never try to discard it yourself.                           */
+  /*                                                                       */
+  /*    Never change the face's transformation matrix (i.e., never call    */
+  /*    the @FT_Set_Transform function) on a returned face!  If you need   */
+  /*    to transform glyphs, do it yourself after glyph loading.           */
+  /*                                                                       */
+  /*    Similarly, the returned @FT_Size object is always owned by the     */
+  /*    manager.  You should never try to discard it, and never change its */
+  /*    settings with @FT_Set_Pixel_Sizes or @FT_Set_Char_Size!            */
+  /*                                                                       */
+  /*    The returned size object is the face's current size, which means   */
+  /*    that you can call @FT_Load_Glyph with the face if you need to.     */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FTC_Manager_Lookup_Size( FTC_Manager  manager,
+                           FTC_Font     font,
+                           FT_Face     *aface,
+                           FT_Size     *asize );
+
+
+FT_END_HEADER
+
+#endif /* __FTCACHE_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftchapters.h
@@ -1,0 +1,69 @@
+/***************************************************************************/
+/*                                                                         */
+/* <Chapter>                                                               */
+/*    core_api                                                             */
+/*                                                                         */
+/* <Title>                                                                 */
+/*    Core API                                                             */
+/*                                                                         */
+/* <Sections>                                                              */
+/*    basic_types                                                          */
+/*    base_interface                                                       */
+/*    glyph_management                                                     */
+/*    mac_specific                                                         */
+/*    sizes_management                                                     */
+/*    header_file_macros                                                   */
+/*                                                                         */
+/***************************************************************************/
+
+/***************************************************************************/
+/*                                                                         */
+/* <Chapter>                                                               */
+/*    format_specific                                                      */
+/*                                                                         */
+/* <Title>                                                                 */
+/*    Format-Specific API                                                  */
+/*                                                                         */
+/* <Sections>                                                              */
+/*    multiple_masters                                                     */
+/*    truetype_tables                                                      */
+/*    type1_tables                                                         */
+/*    sfnt_names                                                           */
+/*    bdf_fonts                                                            */
+/*    pfr_fonts                                                            */
+/*                                                                         */
+/***************************************************************************/
+
+
+/***************************************************************************/
+/*                                                                         */
+/* <Chapter>                                                               */
+/*    cache_subsystem                                                      */
+/*                                                                         */
+/* <Title>                                                                 */
+/*    Cache Sub-System                                                     */
+/*                                                                         */
+/* <Sections>                                                              */
+/*    cache_subsystem                                                      */
+/*                                                                         */
+/***************************************************************************/
+
+
+/***************************************************************************/
+/*                                                                         */
+/* <Chapter>                                                               */
+/*    support_api                                                          */
+/*                                                                         */
+/* <Title>                                                                 */
+/*    Support API                                                          */
+/*                                                                         */
+/* <Sections>                                                              */
+/*    computations                                                         */
+/*    list_processing                                                      */
+/*    outline_processing                                                   */
+/*    raster                                                               */
+/*    system_interface                                                     */
+/*    module_management                                                    */
+/*                                                                         */
+/***************************************************************************/
+
--- /dev/null
+++ b/include/freetype/fterrdef.h
@@ -1,0 +1,229 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fterrdef.h                                                             */
+/*                                                                         */
+/*    FreeType error codes (specification).                                */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*******************************************************************/
+  /*******************************************************************/
+  /*****                                                         *****/
+  /*****                LIST OF ERROR CODES/MESSAGES             *****/
+  /*****                                                         *****/
+  /*******************************************************************/
+  /*******************************************************************/
+
+
+  /* You need to define both FT_ERRORDEF_ and FT_NOERRORDEF_ before */
+  /* including this file.                                           */
+
+
+  /* generic errors */
+
+  FT_NOERRORDEF_( Ok,                                        0x00, \
+                  "no error" )
+
+  FT_ERRORDEF_( Cannot_Open_Resource,                        0x01, \
+                "cannot open resource" )
+  FT_ERRORDEF_( Unknown_File_Format,                         0x02, \
+                "unknown file format" )
+  FT_ERRORDEF_( Invalid_File_Format,                         0x03, \
+                "broken file" )
+  FT_ERRORDEF_( Invalid_Version,                             0x04, \
+                "invalid FreeType version" )
+  FT_ERRORDEF_( Lower_Module_Version,                        0x05, \
+                "module version is too low" )
+  FT_ERRORDEF_( Invalid_Argument,                            0x06, \
+                "invalid argument" )
+  FT_ERRORDEF_( Unimplemented_Feature,                       0x07, \
+                "unimplemented feature" )
+  FT_ERRORDEF_( Invalid_Table,                               0x08, \
+                "broken table" )
+  FT_ERRORDEF_( Invalid_Offset,                              0x09, \
+                "broken offset within table" )
+
+  /* glyph/character errors */
+
+  FT_ERRORDEF_( Invalid_Glyph_Index,                         0x10, \
+                "invalid glyph index" )
+  FT_ERRORDEF_( Invalid_Character_Code,                      0x11, \
+                "invalid character code" )
+  FT_ERRORDEF_( Invalid_Glyph_Format,                        0x12, \
+                "unsupported glyph image format" )
+  FT_ERRORDEF_( Cannot_Render_Glyph,                         0x13, \
+                "cannot render this glyph format" )
+  FT_ERRORDEF_( Invalid_Outline,                             0x14, \
+                "invalid outline" )
+  FT_ERRORDEF_( Invalid_Composite,                           0x15, \
+                "invalid composite glyph" )
+  FT_ERRORDEF_( Too_Many_Hints,                              0x16, \
+                "too many hints" )
+  FT_ERRORDEF_( Invalid_Pixel_Size,                          0x17, \
+                "invalid pixel size" )
+
+  /* handle errors */
+
+  FT_ERRORDEF_( Invalid_Handle,                              0x20, \
+                "invalid object handle" )
+  FT_ERRORDEF_( Invalid_Library_Handle,                      0x21, \
+                "invalid library handle" )
+  FT_ERRORDEF_( Invalid_Driver_Handle,                       0x22, \
+                "invalid module handle" )
+  FT_ERRORDEF_( Invalid_Face_Handle,                         0x23, \
+                "invalid face handle" )
+  FT_ERRORDEF_( Invalid_Size_Handle,                         0x24, \
+                "invalid size handle" )
+  FT_ERRORDEF_( Invalid_Slot_Handle,                         0x25, \
+                "invalid glyph slot handle" )
+  FT_ERRORDEF_( Invalid_CharMap_Handle,                      0x26, \
+                "invalid charmap handle" )
+  FT_ERRORDEF_( Invalid_Cache_Handle,                        0x27, \
+                "invalid cache manager handle" )
+  FT_ERRORDEF_( Invalid_Stream_Handle,                       0x28, \
+                "invalid stream handle" )
+
+  /* driver errors */
+
+  FT_ERRORDEF_( Too_Many_Drivers,                            0x30, \
+                "too many modules" )
+  FT_ERRORDEF_( Too_Many_Extensions,                         0x31, \
+                "too many extensions" )
+
+  /* memory errors */
+
+  FT_ERRORDEF_( Out_Of_Memory,                               0x40, \
+                "out of memory" )
+  FT_ERRORDEF_( Unlisted_Object,                             0x41, \
+                "unlisted object" )
+
+  /* stream errors */
+
+  FT_ERRORDEF_( Cannot_Open_Stream,                          0x51, \
+                "cannot open stream" )
+  FT_ERRORDEF_( Invalid_Stream_Seek,                         0x52, \
+                "invalid stream seek" )
+  FT_ERRORDEF_( Invalid_Stream_Skip,                         0x53, \
+                "invalid stream skip" )
+  FT_ERRORDEF_( Invalid_Stream_Read,                         0x54, \
+                "invalid stream read" )
+  FT_ERRORDEF_( Invalid_Stream_Operation,                    0x55, \
+                "invalid stream operation" )
+  FT_ERRORDEF_( Invalid_Frame_Operation,                     0x56, \
+                "invalid frame operation" )
+  FT_ERRORDEF_( Nested_Frame_Access,                         0x57, \
+                "nested frame access" )
+  FT_ERRORDEF_( Invalid_Frame_Read,                          0x58, \
+                "invalid frame read" )
+
+  /* raster errors */
+
+  FT_ERRORDEF_( Raster_Uninitialized,                        0x60, \
+                "raster uninitialized" )
+  FT_ERRORDEF_( Raster_Corrupted,                            0x61, \
+                "raster corrupted" )
+  FT_ERRORDEF_( Raster_Overflow,                             0x62, \
+                "raster overflow" )
+  FT_ERRORDEF_( Raster_Negative_Height,                      0x63, \
+                "negative height while rastering" )
+
+  /* cache errors */
+
+  FT_ERRORDEF_( Too_Many_Caches,                             0x70, \
+                "too many registered caches" )
+
+  /* TrueType and SFNT errors */
+
+  FT_ERRORDEF_( Invalid_Opcode,                              0x80, \
+                "invalid opcode" )
+  FT_ERRORDEF_( Too_Few_Arguments,                           0x81, \
+                "too few arguments" )
+  FT_ERRORDEF_( Stack_Overflow,                              0x82, \
+                "stack overflow" )
+  FT_ERRORDEF_( Code_Overflow,                               0x83, \
+                "code overflow" )
+  FT_ERRORDEF_( Bad_Argument,                                0x84, \
+                "bad argument" )
+  FT_ERRORDEF_( Divide_By_Zero,                              0x85, \
+                "division by zero" )
+  FT_ERRORDEF_( Invalid_Reference,                           0x86, \
+                "invalid reference" )
+  FT_ERRORDEF_( Debug_OpCode,                                0x87, \
+                "found debug opcode" )
+  FT_ERRORDEF_( ENDF_In_Exec_Stream,                         0x88, \
+                "found ENDF opcode in execution stream" )
+  FT_ERRORDEF_( Nested_DEFS,                                 0x89, \
+                "nested DEFS" )
+  FT_ERRORDEF_( Invalid_CodeRange,                           0x8A, \
+                "invalid code range" )
+  FT_ERRORDEF_( Execution_Too_Long,                          0x8B, \
+                "execution context too long" )
+  FT_ERRORDEF_( Too_Many_Function_Defs,                      0x8C, \
+                "too many function definitions" )
+  FT_ERRORDEF_( Too_Many_Instruction_Defs,                   0x8D, \
+                "too many instruction definitions" )
+  FT_ERRORDEF_( Table_Missing,                               0x8E, \
+                "SFNT font table missing" )
+  FT_ERRORDEF_( Horiz_Header_Missing,                        0x8F, \
+                "horizontal header (hhea) table missing" )
+  FT_ERRORDEF_( Locations_Missing,                           0x90, \
+                "locations (loca) table missing" )
+  FT_ERRORDEF_( Name_Table_Missing,                          0x91, \
+                "name table missing" )
+  FT_ERRORDEF_( CMap_Table_Missing,                          0x92, \
+                "character map (cmap) table missing" )
+  FT_ERRORDEF_( Hmtx_Table_Missing,                          0x93, \
+                "horizontal metrics (hmtx) table missing" )
+  FT_ERRORDEF_( Post_Table_Missing,                          0x94, \
+                "PostScript (post) table missing" )
+  FT_ERRORDEF_( Invalid_Horiz_Metrics,                       0x95, \
+                "invalid horizontal metrics" )
+  FT_ERRORDEF_( Invalid_CharMap_Format,                      0x96, \
+                "invalid character map (cmap) format" )
+  FT_ERRORDEF_( Invalid_PPem,                                0x97, \
+                "invalid ppem value" )
+  FT_ERRORDEF_( Invalid_Vert_Metrics,                        0x98, \
+                "invalid vertical metrics" )
+  FT_ERRORDEF_( Could_Not_Find_Context,                      0x99, \
+                "could not find context" )
+  FT_ERRORDEF_( Invalid_Post_Table_Format,                   0x9A, \
+                "invalid PostScript (post) table format" )
+  FT_ERRORDEF_( Invalid_Post_Table,                          0x9B, \
+                "invalid PostScript (post) table" )
+
+  /* CFF, CID, and Type 1 errors */
+
+  FT_ERRORDEF_( Syntax_Error,                                0xA0, \
+                "opcode syntax error" )
+  FT_ERRORDEF_( Stack_Underflow,                             0xA1, \
+                "argument stack underflow" )
+
+  /* BDF errors */
+
+  FT_ERRORDEF_( Missing_Startfont_Field,                     0xB0, \
+                "`STARTFONT' field missing" )
+  FT_ERRORDEF_( Missing_Font_Field,                          0xB1, \
+                "`FONT' field missing" )
+  FT_ERRORDEF_( Missing_Size_Field,                          0xB2, \
+                "`SIZE' field missing" )
+  FT_ERRORDEF_( Missing_Chars_Field,                         0xB3, \
+                "`CHARS' field missing" )
+  FT_ERRORDEF_( Missing_Startchar_Field,                     0xB4, \
+                "`STARTCHAR' field missing" )
+  FT_ERRORDEF_( Missing_Encoding_Field,                      0xB5, \
+                "`ENCODING' field missing" )
+  FT_ERRORDEF_( Missing_Bbx_Field,                           0xB6, \
+                "`BBX' field missing" )
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/fterrors.h
@@ -1,0 +1,207 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fterrors.h                                                             */
+/*                                                                         */
+/*    FreeType error code handling (specification).                        */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This special header file is used to define the handling of FT2        */
+  /* enumeration constants.  It can also be used to generate error message */
+  /* strings with a small macro trick explained below.                     */
+  /*                                                                       */
+  /* I - Error Formats                                                     */
+  /* -----------------                                                     */
+  /*                                                                       */
+  /*   Since release 2.1, the error constants have changed.  The lower     */
+  /*   byte of the error value gives the "generic" error code, while the   */
+  /*   higher byte indicates in which module the error occurred.           */
+  /*                                                                       */
+  /*   You can use the macro FT_ERROR_BASE(x) macro to extract the generic */
+  /*   error code from an FT_Error value.                                  */
+  /*                                                                       */
+  /*   The configuration macro FT_CONFIG_OPTION_USE_MODULE_ERRORS can be   */
+  /*   undefined in ftoption.h in order to make the higher byte always     */
+  /*   zero, in case you need to be compatible with previous versions of   */
+  /*   FreeType 2.                                                         */
+  /*                                                                       */
+  /*                                                                       */
+  /* II - Error Message strings                                            */
+  /* --------------------------                                            */
+  /*                                                                       */
+  /*   The error definitions below are made through special macros that    */
+  /*   allow client applications to build a table of error message strings */
+  /*   if they need it.  The strings are not included in a normal build of */
+  /*   FreeType 2 to save space (most client applications do not use       */
+  /*   them).                                                              */
+  /*                                                                       */
+  /*   To do so, you have to define the following macros before including  */
+  /*   this file:                                                          */
+  /*                                                                       */
+  /*   FT_ERROR_START_LIST ::                                              */
+  /*     This macro is called before anything else to define the start of  */
+  /*     the error list.  It is followed by several FT_ERROR_DEF calls     */
+  /*     (see below).                                                      */
+  /*                                                                       */
+  /*   FT_ERROR_DEF( e, v, s ) ::                                          */
+  /*     This macro is called to define one single error.                  */
+  /*     `e' is the error code identifier (e.g. FT_Err_Invalid_Argument).  */
+  /*     `v' is the error numerical value.                                 */
+  /*     `s' is the corresponding error string.                            */
+  /*                                                                       */
+  /*   FT_ERROR_END_LIST ::                                                */
+  /*     This macro ends the list.                                         */
+  /*                                                                       */
+  /*   Additionally, you have to undefine __FTERRORS_H__ before #including */
+  /*   this file.                                                          */
+  /*                                                                       */
+  /*   Here is a simple example:                                           */
+  /*                                                                       */
+  /*     {                                                                 */
+  /*       #undef __FTERRORS_H__                                           */
+  /*       #define FT_ERRORDEF( e, v, s )  { e, s },                       */
+  /*       #define FT_ERROR_START_LIST     {                               */
+  /*       #define FT_ERROR_END_LIST       { 0, 0 } };                     */
+  /*                                                                       */
+  /*       const struct                                                    */
+  /*       {                                                               */
+  /*         int          err_code;                                        */
+  /*         const char*  err_msg                                          */
+  /*       } ft_errors[] =                                                 */
+  /*                                                                       */
+  /*       #include FT_ERRORS_H                                            */
+  /*     }                                                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __FTERRORS_H__
+#define __FTERRORS_H__
+
+
+  /* include module base error codes */
+#include FT_MODULE_ERRORS_H
+
+
+  /*******************************************************************/
+  /*******************************************************************/
+  /*****                                                         *****/
+  /*****                       SETUP MACROS                      *****/
+  /*****                                                         *****/
+  /*******************************************************************/
+  /*******************************************************************/
+
+
+#undef  FT_NEED_EXTERN_C
+
+#undef  FT_ERR_XCAT
+#undef  FT_ERR_CAT
+
+#define FT_ERR_XCAT( x, y )  x ## y
+#define FT_ERR_CAT( x, y )   FT_ERR_XCAT( x, y )
+
+
+  /* FT_ERR_PREFIX is used as a prefix for error identifiers. */
+  /* By default, we use `FT_Err_'.                            */
+  /*                                                          */
+#ifndef FT_ERR_PREFIX
+#define FT_ERR_PREFIX  FT_Err_
+#endif
+
+
+  /* FT_ERR_BASE is used as the base for module-specific errors. */
+  /*                                                             */
+#ifdef FT_CONFIG_OPTION_USE_MODULE_ERRORS
+
+#ifndef FT_ERR_BASE
+#define FT_ERR_BASE  FT_Mod_Err_Base
+#endif
+
+#else
+
+#undef FT_ERR_BASE
+#define FT_ERR_BASE  0
+
+#endif /* FT_CONFIG_OPTION_USE_MODULE_ERRORS */
+
+
+  /* If FT_ERRORDEF is not defined, we need to define a simple */
+  /* enumeration type.                                         */
+  /*                                                           */
+#ifndef FT_ERRORDEF
+
+#define FT_ERRORDEF( e, v, s )  e = v,
+#define FT_ERROR_START_LIST     enum {
+#define FT_ERROR_END_LIST       FT_ERR_CAT( FT_ERR_PREFIX, Max ) };
+
+#ifdef __cplusplus
+#define FT_NEED_EXTERN_C
+  extern "C" {
+#endif
+
+#endif /* !FT_ERRORDEF */
+
+
+  /* this macro is used to define an error */
+#define FT_ERRORDEF_( e, v, s )   \
+          FT_ERRORDEF( FT_ERR_CAT( FT_ERR_PREFIX, e ), v + FT_ERR_BASE, s )
+
+  /* this is only used for FT_Err_Ok, which must be 0! */
+#define FT_NOERRORDEF_( e, v, s ) \
+          FT_ERRORDEF( FT_ERR_CAT( FT_ERR_PREFIX, e ), v, s )
+
+
+#ifdef FT_ERROR_START_LIST
+  FT_ERROR_START_LIST
+#endif
+
+
+  /* no include the error codes */
+#include FT_ERROR_DEFINITIONS_H
+
+
+#ifdef FT_ERROR_END_LIST
+  FT_ERROR_END_LIST
+#endif
+
+
+  /*******************************************************************/
+  /*******************************************************************/
+  /*****                                                         *****/
+  /*****                      SIMPLE CLEANUP                     *****/
+  /*****                                                         *****/
+  /*******************************************************************/
+  /*******************************************************************/
+
+#ifdef FT_NEED_EXTERN_C
+  }
+#endif
+
+#undef FT_ERROR_START_LIST
+#undef FT_ERROR_END_LIST
+
+#undef FT_ERRORDEF
+#undef FT_ERRORDEF_
+#undef FT_NOERRORDEF_
+
+#undef FT_NEED_EXTERN_C
+#undef FT_ERR_PREFIX
+#undef FT_ERR_BASE
+#undef FT_ERR_CONCAT
+
+#endif /* __FTERRORS_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftglyph.h
@@ -1,0 +1,517 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftglyph.h                                                              */
+/*                                                                         */
+/*    FreeType convenience functions to handle glyphs (specification).     */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file contains the definition of several convenience functions    */
+  /* that can be used by client applications to easily retrieve glyph      */
+  /* bitmaps and outlines from a given face.                               */
+  /*                                                                       */
+  /* These functions should be optional if you are writing a font server   */
+  /* or text layout engine on top of FreeType.  However, they are pretty   */
+  /* handy for many other simple uses of the library.                      */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __FTGLYPH_H__
+#define __FTGLYPH_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    glyph_management                                                   */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Glyph Management                                                   */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Generic interface to manage individual glyph data.                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains definitions used to manage glyph data        */
+  /*    through generic FT_Glyph objects.  Each of them can contain a      */
+  /*    bitmap, a vector outline, or even images in other formats.         */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* forward declaration to a private type */
+  typedef struct FT_Glyph_Class_  FT_Glyph_Class;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Glyph                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Handle to an object used to model generic glyph images.  It is a   */
+  /*    pointer to the @FT_GlyphRec structure and can contain a glyph      */
+  /*    bitmap or pointer.                                                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Glyph objects are not owned by the library.  You must thus release */
+  /*    them manually (through @FT_Done_Glyph) _before_ calling            */
+  /*    @FT_Done_FreeType.                                                 */
+  /*                                                                       */
+  typedef struct FT_GlyphRec_*  FT_Glyph;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_GlyphRec                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The root glyph structure contains a given glyph image plus its     */
+  /*    advance width in 16.16 fixed float format.                         */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    library :: A handle to the FreeType library object.                */
+  /*                                                                       */
+  /*    clazz   :: A pointer to the glyph's class.  Private.               */
+  /*                                                                       */
+  /*    format  :: The format of the glyph's image.                        */
+  /*                                                                       */
+  /*    advance :: A 16.16 vector that gives the glyph's advance width.    */
+  /*                                                                       */
+  typedef struct  FT_GlyphRec_
+  {
+    FT_Library             library;
+    const FT_Glyph_Class*  clazz;
+    FT_Glyph_Format        format;
+    FT_Vector              advance;
+
+  } FT_GlyphRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_BitmapGlyph                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to an object used to model a bitmap glyph image.  This is */
+  /*    a sub-class of @FT_Glyph, and a pointer to @FT_BitmapGlyphRec.     */
+  /*                                                                       */
+  typedef struct FT_BitmapGlyphRec_*  FT_BitmapGlyph;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_BitmapGlyphRec                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used for bitmap glyph images.  This really is a        */
+  /*    `sub-class' of `FT_GlyphRec'.                                      */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    root   :: The root FT_Glyph fields.                                */
+  /*                                                                       */
+  /*    left   :: The left-side bearing, i.e., the horizontal distance     */
+  /*              from the current pen position to the left border of the  */
+  /*              glyph bitmap.                                            */
+  /*                                                                       */
+  /*    top    :: The top-side bearing, i.e., the vertical distance from   */
+  /*              the current pen position to the top border of the glyph  */
+  /*              bitmap.  This distance is positive for upwards-y!        */
+  /*                                                                       */
+  /*    bitmap :: A descriptor for the bitmap.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You can typecast FT_Glyph to FT_BitmapGlyph if you have            */
+  /*    glyph->format == FT_GLYPH_FORMAT_BITMAP.  This lets you access     */
+  /*    the bitmap's contents easily.                                      */
+  /*                                                                       */
+  /*    The corresponding pixel buffer is always owned by the BitmapGlyph  */
+  /*    and is thus created and destroyed with it.                         */
+  /*                                                                       */
+  typedef struct  FT_BitmapGlyphRec_
+  {
+    FT_GlyphRec  root;
+    FT_Int       left;
+    FT_Int       top;
+    FT_Bitmap    bitmap;
+
+  } FT_BitmapGlyphRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_OutlineGlyph                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to an object used to model an outline glyph image.  This  */
+  /*    is a sub-class of @FT_Glyph, and a pointer to @FT_OutlineGlyphRec. */
+  /*                                                                       */
+  typedef struct FT_OutlineGlyphRec_*  FT_OutlineGlyph;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_OutlineGlyphRec                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used for outline (vectorial) glyph images.  This       */
+  /*    really is a `sub-class' of `FT_GlyphRec'.                          */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    root    :: The root FT_Glyph fields.                               */
+  /*                                                                       */
+  /*    outline :: A descriptor for the outline.                           */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You can typecast FT_Glyph to FT_OutlineGlyph if you have           */
+  /*    glyph->format == FT_GLYPH_FORMAT_OUTLINE.  This lets you access    */
+  /*    the outline's content easily.                                      */
+  /*                                                                       */
+  /*    As the outline is extracted from a glyph slot, its coordinates are */
+  /*    expressed normally in 26.6 pixels, unless the flag                 */
+  /*    FT_LOAD_NO_SCALE was used in FT_Load_Glyph() or FT_Load_Char().    */
+  /*                                                                       */
+  /*    The outline's tables are always owned by the object and are        */
+  /*    destroyed with it.                                                 */
+  /*                                                                       */
+  typedef struct  FT_OutlineGlyphRec_
+  {
+    FT_GlyphRec  root;
+    FT_Outline   outline;
+
+  } FT_OutlineGlyphRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Glyph                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to extract a glyph image from a slot.              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    slot   :: A handle to the source glyph slot.                       */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aglyph :: A handle to the glyph object.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Glyph( FT_GlyphSlot  slot,
+                FT_Glyph     *aglyph );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Glyph_Copy                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to copy a glyph image.                             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    source :: A handle to the source glyph object.                     */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    target :: A handle to the target glyph object.  0 in case of       */
+  /*              error.                                                   */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Glyph_Copy( FT_Glyph   source,
+                 FT_Glyph  *target );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Glyph_Transform                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Transforms a glyph image if its format is scalable.                */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    glyph  :: A handle to the target glyph object.                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    matrix :: A pointer to a 2x2 matrix to apply.                      */
+  /*                                                                       */
+  /*    delta  :: A pointer to a 2d vector to apply.  Coordinates are      */
+  /*              expressed in 1/64th of a pixel.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code (the glyph format is not scalable if it is     */
+  /*    not zero).                                                         */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The 2x2 transformation matrix is also applied to the glyph's       */
+  /*    advance vector.                                                    */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Glyph_Transform( FT_Glyph    glyph,
+                      FT_Matrix*  matrix,
+                      FT_Vector*  delta );
+
+  /* */
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Glyph_Get_CBox                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Returns a glyph's `control box'.  The control box encloses all the */
+  /*    outline's points, including Bezier control points.  Though it      */
+  /*    coincides with the exact bounding box for most glyphs, it can be   */
+  /*    slightly larger in some situations (like when rotating an outline  */
+  /*    which contains Bezier outside arcs).                               */
+  /*                                                                       */
+  /*    Computing the control box is very fast, while getting the bounding */
+  /*    box can take much more time as it needs to walk over all segments  */
+  /*    and arcs in the outline.  To get the latter, you can use the       */
+  /*    `ftbbox' component which is dedicated to this single task.         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    glyph :: A handle to the source glyph object.                      */
+  /*                                                                       */
+  /*    mode  :: The mode which indicates how to interpret the returned    */
+  /*             bounding box values.                                      */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    acbox :: The glyph coordinate bounding box.  Coordinates are       */
+  /*             expressed in 1/64th of pixels if it is grid-fitted.       */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Coordinates are relative to the glyph origin, using the Y-upwards  */
+  /*    convention.                                                        */
+  /*                                                                       */
+  /*    If the glyph has been loaded with FT_LOAD_NO_SCALE, `bbox_mode'    */
+  /*    must be set to `ft_glyph_bbox_unscaled' to get unscaled font       */
+  /*    units.                                                             */
+  /*                                                                       */
+  /*    If `bbox_mode' is set to `ft_glyph_bbox_subpixels' the bbox        */
+  /*    coordinates are returned in 26.6 pixels (i.e. 1/64th of pixels).   */
+  /*                                                                       */
+  /*    Note that the maximum coordinates are exclusive, which means that  */
+  /*    one can compute the width and height of the glyph image (be it in  */
+  /*    integer or 26.6 pixels) as:                                        */
+  /*                                                                       */
+  /*      width  = bbox.xMax - bbox.xMin;                                  */
+  /*      height = bbox.yMax - bbox.yMin;                                  */
+  /*                                                                       */
+  /*    Note also that for 26.6 coordinates, if `bbox_mode' is set to      */
+  /*    `ft_glyph_bbox_gridfit', the coordinates will also be grid-fitted, */
+  /*    which corresponds to:                                              */
+  /*                                                                       */
+  /*      bbox.xMin = FLOOR(bbox.xMin);                                    */
+  /*      bbox.yMin = FLOOR(bbox.yMin);                                    */
+  /*      bbox.xMax = CEILING(bbox.xMax);                                  */
+  /*      bbox.yMax = CEILING(bbox.yMax);                                  */
+  /*                                                                       */
+  /*    To get the bbox in pixel coordinates, set `bbox_mode' to           */
+  /*    `ft_glyph_bbox_truncate'.                                          */
+  /*                                                                       */
+  /*    To get the bbox in grid-fitted pixel coordinates, set `bbox_mode'  */
+  /*    to `ft_glyph_bbox_pixels'.                                         */
+  /*                                                                       */
+  /*    The default value for `bbox_mode' is `ft_glyph_bbox_pixels'.       */
+  /*                                                                       */
+  enum
+  {
+    ft_glyph_bbox_unscaled  = 0, /* return unscaled font units           */
+    ft_glyph_bbox_subpixels = 0, /* return unfitted 26.6 coordinates     */
+    ft_glyph_bbox_gridfit   = 1, /* return grid-fitted 26.6 coordinates  */
+    ft_glyph_bbox_truncate  = 2, /* return coordinates in integer pixels */
+    ft_glyph_bbox_pixels    = 3  /* return grid-fitted pixel coordinates */
+  };
+
+
+  FT_EXPORT( void )
+  FT_Glyph_Get_CBox( FT_Glyph  glyph,
+                     FT_UInt   bbox_mode,
+                     FT_BBox  *acbox );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Glyph_To_Bitmap                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Converts a given glyph object to a bitmap glyph object.            */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    the_glyph   :: A pointer to a handle to the target glyph.          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    render_mode :: An enumeration that describe how the data is        */
+  /*                   rendered.                                           */
+  /*                                                                       */
+  /*    origin      :: A pointer to a vector used to translate the glyph   */
+  /*                   image before rendering.  Can be 0 (if no            */
+  /*                   translation).  The origin is expressed in           */
+  /*                   26.6 pixels.                                        */
+  /*                                                                       */
+  /*    destroy     :: A boolean that indicates that the original glyph    */
+  /*                   image should be destroyed by this function.  It is  */
+  /*                   never destroyed in case of error.                   */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The glyph image is translated with the `origin' vector before      */
+  /*    rendering.  In case of error, it it translated back to its         */
+  /*    original position and the glyph is left untouched.                 */
+  /*                                                                       */
+  /*    The first parameter is a pointer to a FT_Glyph handle, that will   */
+  /*    be replaced by this function.  Typically, you would use (omitting  */
+  /*    error handling):                                                   */
+  /*                                                                       */
+  /*                                                                       */
+  /*      {                                                                */
+  /*        FT_Glyph        glyph;                                         */
+  /*        FT_BitmapGlyph  glyph_bitmap;                                  */
+  /*                                                                       */
+  /*                                                                       */
+  /*        // load glyph                                                  */
+  /*        error = FT_Load_Char( face, glyph_index, FT_LOAD_DEFAUT );     */
+  /*                                                                       */
+  /*        // extract glyph image                                         */
+  /*        error = FT_Get_Glyph( face->glyph, &glyph );                   */
+  /*                                                                       */
+  /*        // convert to a bitmap (default render mode + destroy old)     */
+  /*        if ( glyph->format != FT_GLYPH_FORMAT_BITMAP )                 */
+  /*        {                                                              */
+  /*          error = FT_Glyph_To_Bitmap( &glyph, ft_render_mode_default,  */
+  /*                                      0, 1 );                          */
+  /*          if ( error ) // glyph unchanged                              */
+  /*            ...                                                        */
+  /*        }                                                              */
+  /*                                                                       */
+  /*        // access bitmap content by typecasting                        */
+  /*        glyph_bitmap = (FT_BitmapGlyph)glyph;                          */
+  /*                                                                       */
+  /*        // do funny stuff with it, like blitting/drawing               */
+  /*        ...                                                            */
+  /*                                                                       */
+  /*        // discard glyph image (bitmap or not)                         */
+  /*        FT_Done_Glyph( glyph );                                        */
+  /*      }                                                                */
+  /*                                                                       */
+  /*                                                                       */
+  /*    This function will always fail if the glyph's format isn't         */
+  /*    scalable.                                                          */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Glyph_To_Bitmap( FT_Glyph*       the_glyph,
+                      FT_Render_Mode  render_mode,
+                      FT_Vector*      origin,
+                      FT_Bool         destroy );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Done_Glyph                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroys a given glyph.                                            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    glyph :: A handle to the target glyph object.                      */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Done_Glyph( FT_Glyph  glyph );
+
+
+  /* other helpful functions */
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    computations                                                       */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Matrix_Multiply                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Performs the matrix operation `b = a*b'.                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    a :: A pointer to matrix `a'.                                      */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    b :: A pointer to matrix `b'.                                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The result is undefined if either `a' or `b' is zero.              */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Matrix_Multiply( FT_Matrix*  a,
+                      FT_Matrix*  b );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Matrix_Invert                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Inverts a 2x2 matrix.  Returns an error if it can't be inverted.   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    matrix :: A pointer to the target matrix.  Remains untouched in    */
+  /*              case of error.                                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Matrix_Invert( FT_Matrix*  matrix );
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* __FTGLYPH_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftgzip.h
@@ -1,0 +1,86 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftgzip.h                                                               */
+/*                                                                         */
+/*    Gzip-compressed stream support.                                      */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTXF86_H__
+#define __FTXF86_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+FT_BEGIN_HEADER
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    gzip                                                               */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    GZIP Streams                                                       */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Using gzip-compressed font files                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the declaration of Gzip-specific functions.  */
+  /*                                                                       */
+  /*************************************************************************/
+
+ /************************************************************************
+  *
+  * @type: FT_Stream_OpenGzip
+  *
+  * @description:
+  *   open a new stream to parse gzip-compressed font files. This is
+  *   mainly used to support the compressed *.pcf.gz fonts that come
+  *   with XFree86
+  *
+  * @input:
+  *   stream :: target embedding stream
+  *   source :: source stream, used to
+  *
+  * @return:
+  *   error code. 0 means success
+  *
+  * @note:
+  *   the source stream must be opened _before_ calling this function.
+  *
+  *   calling @FT_Stream_Close on the new stream will *not* call
+  *   @FT_Stream_Close on the source stream. None of the stream objects
+  *   will be released to the heap.
+  *
+  *   the stream implementation is very basic, and resets the decompression
+  *   process each time seeking backwards is needed within the stream
+  *
+  *   in certain builds of the library, gzip compression recognition is
+  *   automatic when calling @FT_New_Face or @FT_Open_Face. This means that
+  *   if no font driver is capable of handling the raw compressed file,
+  *   the library will try to open a gzip stream from it and re-open
+  *   the face with it.
+  *
+  *   this function may return "FT_Err_Unimplemented" if your build of
+  *   FreeType was not compiled with zlib support.
+  */
+  FT_EXPORT( FT_Error )
+  FT_Stream_OpenGzip( FT_Stream    stream,
+                      FT_Stream    source );
+
+ /* */
+
+FT_END_HEADER
+
+#endif /* __FTXF86_H__ */
--- /dev/null
+++ b/include/freetype/ftimage.h
@@ -1,0 +1,1241 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftimage.h                                                              */
+/*                                                                         */
+/*    FreeType glyph image formats and default raster interface            */
+/*    (specification).                                                     */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Note: A `raster' is simply a scan-line converter, used to render      */
+  /*       FT_Outlines into FT_Bitmaps.                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __FTIMAGE_H__
+#define __FTIMAGE_H__
+
+
+/* _STANDALONE_ is from ftgrays.c */
+#ifndef _STANDALONE_
+#include <ft2build.h>
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    basic_types                                                        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Pos                                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The type FT_Pos is a 32-bit integer used to store vectorial        */
+  /*    coordinates.  Depending on the context, these can represent        */
+  /*    distances in integer font units, or 26.6 fixed float pixel         */
+  /*    coordinates.                                                       */
+  /*                                                                       */
+  typedef signed long  FT_Pos;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Vector                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple structure used to store a 2D vector; coordinates are of   */
+  /*    the FT_Pos type.                                                   */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    x :: The horizontal coordinate.                                    */
+  /*    y :: The vertical coordinate.                                      */
+  /*                                                                       */
+  typedef struct  FT_Vector_
+  {
+    FT_Pos  x;
+    FT_Pos  y;
+
+  } FT_Vector;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_BBox                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to hold an outline's bounding box, i.e., the      */
+  /*    coordinates of its extrema in the horizontal and vertical          */
+  /*    directions.                                                        */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    xMin :: The horizontal minimum (left-most).                        */
+  /*                                                                       */
+  /*    yMin :: The vertical minimum (bottom-most).                        */
+  /*                                                                       */
+  /*    xMax :: The horizontal maximum (right-most).                       */
+  /*                                                                       */
+  /*    yMax :: The vertical maximum (top-most).                           */
+  /*                                                                       */
+  typedef struct  FT_BBox_
+  {
+    FT_Pos  xMin, yMin;
+    FT_Pos  xMax, yMax;
+
+  } FT_BBox;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Pixel_Mode                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration type used to describe the format of pixels in a     */
+  /*    given bitmap.  Note that additional formats may be added in the    */
+  /*    future.                                                            */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_PIXEL_MODE_NONE ::                                              */
+  /*      Value 0 is reserved.                                             */
+  /*                                                                       */
+  /*    FT_PIXEL_MODE_MONO ::                                              */
+  /*      A monochrome bitmap, using 1 bit per pixel.  Note that pixels    */
+  /*      are stored in most-significant order (MSB), which means that     */
+  /*      the left-most pixel in a byte has value 128.                     */
+  /*                                                                       */
+  /*    FT_PIXEL_MODE_GRAY ::                                              */
+  /*      An 8-bit bitmap, generally used to represent anti-aliased glyph  */
+  /*      images.  Each pixel is stored in one byte.  Note that the number */
+  /*      of value "gray" levels is stored in the `num_bytes' field of     */
+  /*      the @FT_Bitmap structure (it generally is 256).                  */
+  /*                                                                       */
+  /*    FT_PIXEL_MODE_GRAY2 ::                                             */
+  /*      A 2-bit/pixel bitmap, used to represent embedded anti-aliased    */
+  /*      bitmaps in font files according to the OpenType specification.   */
+  /*      We haven't found a single font using this format, however.       */
+  /*                                                                       */
+  /*    FT_PIXEL_MODE_GRAY4 ::                                             */
+  /*      A 4-bit/pixel bitmap, used to represent embedded anti-aliased    */
+  /*      bitmaps in font files according to the OpenType specification.   */
+  /*      We haven't found a single font using this format, however.       */
+  /*                                                                       */
+  /*    FT_PIXEL_MODE_LCD ::                                               */
+  /*      An 8-bit bitmap, used to represent RGB or BGR decimated glyph    */
+  /*      images used for display on LCD displays; the bitmap's width is   */
+  /*      three times wider than the original glyph image.  See also       */
+  /*      @FT_RENDER_MODE_LCD.                                             */
+  /*                                                                       */
+  /*    FT_PIXEL_MODE_LCD_V ::                                             */
+  /*      An 8-bit bitmap, used to represent RGB or BGR decimated glyph    */
+  /*      images used for display on rotated LCD displays; the bitmap's    */
+  /*      height is three times taller than the original glyph image.      */
+  /*      See also @FT_RENDER_MODE_LCD_V.                                  */
+  /*                                                                       */
+  typedef enum  FT_Pixel_Mode_
+  {
+    FT_PIXEL_MODE_NONE = 0,
+    FT_PIXEL_MODE_MONO,
+    FT_PIXEL_MODE_GRAY,
+    FT_PIXEL_MODE_GRAY2,
+    FT_PIXEL_MODE_GRAY4,
+    FT_PIXEL_MODE_LCD,
+    FT_PIXEL_MODE_LCD_V,
+
+    FT_PIXEL_MODE_MAX      /* do not remove */
+
+  } FT_Pixel_Mode;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    ft_pixel_mode_xxx                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A list of deprecated constants.  Use the corresponding             */
+  /*    @FT_Pixel_Mode values instead.                                     */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    ft_pixel_mode_none  :: see @FT_PIXEL_MODE_NONE                     */
+  /*    ft_pixel_mode_mono  :: see @FT_PIXEL_MODE_MONO                     */
+  /*    ft_pixel_mode_grays :: see @FT_PIXEL_MODE_GRAY                     */
+  /*    ft_pixel_mode_pal2  :: see @FT_PIXEL_MODE_GRAY2                    */
+  /*    ft_pixel_mode_pal4  :: see @FT_PIXEL_MODE_GRAY4                    */
+  /*                                                                       */
+#define ft_pixel_mode_none   FT_PIXEL_MODE_NONE
+#define ft_pixel_mode_mono   FT_PIXEL_MODE_MONO
+#define ft_pixel_mode_grays  FT_PIXEL_MODE_GRAY
+#define ft_pixel_mode_pal2   FT_PIXEL_MODE_GRAY2
+#define ft_pixel_mode_pal4   FT_PIXEL_MODE_GRAY4
+
+ /* */
+
+#if 0
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Palette_Mode                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    THIS TYPE IS DEPRECATED.  DO NOT USE IT!                           */
+  /*                                                                       */
+  /*    An enumeration type used to describe the format of a bitmap        */
+  /*    palette, used with ft_pixel_mode_pal4 and ft_pixel_mode_pal8.      */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    ft_palette_mode_rgb  :: The palette is an array of 3-bytes RGB     */
+  /*                            records.                                   */
+  /*                                                                       */
+  /*    ft_palette_mode_rgba :: The palette is an array of 4-bytes RGBA    */
+  /*                            records.                                   */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    As ft_pixel_mode_pal2, pal4 and pal8 are currently unused by       */
+  /*    FreeType, these types are not handled by the library itself.       */
+  /*                                                                       */
+  typedef enum  FT_Palette_Mode_
+  {
+    ft_palette_mode_rgb = 0,
+    ft_palette_mode_rgba,
+
+    ft_palettte_mode_max   /* do not remove */
+
+  } FT_Palette_Mode;
+
+  /* */
+
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Bitmap                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to describe a bitmap or pixmap to the raster.     */
+  /*    Note that we now manage pixmaps of various depths through the      */
+  /*    `pixel_mode' field.                                                */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    rows         :: The number of bitmap rows.                         */
+  /*                                                                       */
+  /*    width        :: The number of pixels in bitmap row.                */
+  /*                                                                       */
+  /*    pitch        :: The pitch's absolute value is the number of bytes  */
+  /*                    taken by one bitmap row, including padding.        */
+  /*                    However, the pitch is positive when the bitmap has */
+  /*                    a `down' flow, and negative when it has an `up'    */
+  /*                    flow.  In all cases, the pitch is an offset to add */
+  /*                    to a bitmap pointer in order to go down one row.   */
+  /*                                                                       */
+  /*    buffer       :: A typeless pointer to the bitmap buffer.  This     */
+  /*                    value should be aligned on 32-bit boundaries in    */
+  /*                    most cases.                                        */
+  /*                                                                       */
+  /*    num_grays    :: This field is only used with                       */
+  /*                    `FT_PIXEL_MODE_GRAY'; it gives the number of gray  */
+  /*                    levels used in the bitmap.                         */
+  /*                                                                       */
+  /*    pixel_mode   :: The pixel_mode, i.e., how pixel bits are stored.   */
+  /*                                                                       */
+  /*    palette_mode :: This field is only used with paletted pixel modes; */
+  /*                    it indicates how the palette is stored.            */
+  /*                                                                       */
+  /*    palette      :: A typeless pointer to the bitmap palette; only     */
+  /*                    used for paletted pixel modes.                     */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*   For now, the only pixel mode supported by FreeType are mono and     */
+  /*   grays.  However, drivers might be added in the future to support    */
+  /*   more `colorful' options.                                            */
+  /*                                                                       */
+  /*   When using pixel modes pal2, pal4 and pal8 with a void `palette'    */
+  /*   field, a gray pixmap with respectively 4, 16, and 256 levels of     */
+  /*   gray is assumed.  This, in order to be compatible with some         */
+  /*   embedded bitmap formats defined in the TrueType specification.      */
+  /*                                                                       */
+  /*   Note that no font was found presenting such embedded bitmaps, so    */
+  /*   this is currently completely unhandled by the library.              */
+  /*                                                                       */
+  typedef struct  FT_Bitmap_
+  {
+    int             rows;
+    int             width;
+    int             pitch;
+    unsigned char*  buffer;
+    short           num_grays;
+    char            pixel_mode;
+    char            palette_mode;
+    void*           palette;
+
+  } FT_Bitmap;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    outline_processing                                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Outline                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This structure is used to describe an outline to the scan-line     */
+  /*    converter.                                                         */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    n_contours :: The number of contours in the outline.               */
+  /*                                                                       */
+  /*    n_points   :: The number of points in the outline.                 */
+  /*                                                                       */
+  /*    points     :: A pointer to an array of `n_points' FT_Vector        */
+  /*                  elements, giving the outline's point coordinates.    */
+  /*                                                                       */
+  /*    tags       :: A pointer to an array of `n_points' chars, giving    */
+  /*                  each outline point's type.  If bit 0 is unset, the   */
+  /*                  point is `off' the curve, i.e. a Bezier control      */
+  /*                  point, while it is `on' when set.                    */
+  /*                                                                       */
+  /*                  Bit 1 is meaningful for `off' points only.  If set,  */
+  /*                  it indicates a third-order Bezier arc control point; */
+  /*                  and a second-order control point if unset.           */
+  /*                                                                       */
+  /*    contours   :: An array of `n_contours' shorts, giving the end      */
+  /*                  point of each contour within the outline.  For       */
+  /*                  example, the first contour is defined by the points  */
+  /*                  `0' to `contours[0]', the second one is defined by   */
+  /*                  the points `contours[0]+1' to `contours[1]', etc.    */
+  /*                                                                       */
+  /*    flags      :: A set of bit flags used to characterize the outline  */
+  /*                  and give hints to the scan-converter and hinter on   */
+  /*                  how to convert/grid-fit it.  See FT_Outline_Flags.   */
+  /*                                                                       */
+  typedef struct  FT_Outline_
+  {
+    short       n_contours;      /* number of contours in glyph        */
+    short       n_points;        /* number of points in the glyph      */
+
+    FT_Vector*  points;          /* the outline's points               */
+    char*       tags;            /* the points flags                   */
+    short*      contours;        /* the contour end points             */
+
+    int         flags;           /* outline masks                      */
+
+  } FT_Outline;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*   FT_Outline_Flags                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple type used to enumerates the flags in an outline's         */
+  /*    `outline_flags' field.                                             */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_OUTLINE_NONE           :: Value 0 is reserved.                  */
+  /*                                                                       */
+  /*    FT_OUTLINE_OWNER          :: If set, this flag indicates that the  */
+  /*                                 outline's field arrays (i.e.          */
+  /*                                 `points', `flags' & `contours') are   */
+  /*                                 `owned' by the outline object, and    */
+  /*                                 should thus be freed when it is       */
+  /*                                 destroyed.                            */
+  /*                                                                       */
+  /*   FT_OUTLINE_EVEN_ODD_FILL   :: By default, outlines are filled using */
+  /*                                 the non-zero winding rule.  If set to */
+  /*                                 1, the outline will be filled using   */
+  /*                                 the even-odd fill rule (only works    */
+  /*                                 with the smooth raster).              */
+  /*                                                                       */
+  /*   FT_OUTLINE_REVERSE_FILL    :: By default, outside contours of an    */
+  /*                                 outline are oriented in clock-wise    */
+  /*                                 direction, as defined in the TrueType */
+  /*                                 specification.  This flag is set if   */
+  /*                                 the outline uses the opposite         */
+  /*                                 direction (typically for Type 1       */
+  /*                                 fonts).  This flag is ignored by the  */
+  /*                                 scan-converter.  However, it is very  */
+  /*                                 important for the auto-hinter.        */
+  /*                                                                       */
+  /*   FT_OUTLINE_IGNORE_DROPOUTS :: By default, the scan converter will   */
+  /*                                 try to detect drop-outs in an outline */
+  /*                                 and correct the glyph bitmap to       */
+  /*                                 ensure consistent shape continuity.   */
+  /*                                 If set, this flag hints the scan-line */
+  /*                                 converter to ignore such cases.       */
+  /*                                                                       */
+  /*   FT_OUTLINE_HIGH_PRECISION  :: This flag indicates that the          */
+  /*                                 scan-line converter should try to     */
+  /*                                 convert this outline to bitmaps with  */
+  /*                                 the highest possible quality.  It is  */
+  /*                                 typically set for small character     */
+  /*                                 sizes.  Note that this is only a      */
+  /*                                 hint, that might be completely        */
+  /*                                 ignored by a given scan-converter.    */
+  /*                                                                       */
+  /*   FT_OUTLINE_SINGLE_PASS     :: This flag is set to force a given     */
+  /*                                 scan-converter to only use a single   */
+  /*                                 pass over the outline to render a     */
+  /*                                 bitmap glyph image.  Normally, it is  */
+  /*                                 set for very large character sizes.   */
+  /*                                 It is only a hint, that might be      */
+  /*                                 completely ignored by a given         */
+  /*                                 scan-converter.                       */
+  /*                                                                       */
+  typedef enum  FT_Outline_Flags_
+  {
+    FT_OUTLINE_NONE            = 0,
+    FT_OUTLINE_OWNER           = 1,
+    FT_OUTLINE_EVEN_ODD_FILL   = 2,
+    FT_OUTLINE_REVERSE_FILL    = 4,
+    FT_OUTLINE_IGNORE_DROPOUTS = 8,
+    FT_OUTLINE_HIGH_PRECISION  = 256,
+    FT_OUTLINE_SINGLE_PASS     = 512
+
+  } FT_Outline_Flags;
+
+
+ /*************************************************************************
+  *
+  * @enum:
+  *   ft_outline_xxx
+  *
+  * @description:
+  *   These constants are deprecated.  Please use the corresponding
+  *   @FT_OUTLINE_XXX values.
+  *
+  * @values:
+  *   ft_outline_none            :: See @FT_OUTLINE_NONE.
+  *   ft_outline_owner           :: See @FT_OUTLINE_OWNER.
+  *   ft_outline_even_odd_fill   :: See @FT_OUTLINE_EVEN_ODD_FILL.
+  *   ft_outline_reverse_fill    :: See @FT_OUTLINE_REVERSE_FILL.
+  *   ft_outline_ignore_dropouts :: See @FT_OUTLINE_IGNORE_DROPOUTS.
+  *   ft_outline_high_precision  :: See @FT_OUTLINE_HIGH_PRECISION.
+  *   ft_outline_single_pass     :: See @FT_OUTLINE_SINGLE_PASS.
+  */
+#define ft_outline_none             FT_OUTLINE_NONE
+#define ft_outline_owner            FT_OUTLINE_OWNER
+#define ft_outline_even_odd_fill    FT_OUTLINE_EVEN_ODD_FILL
+#define ft_outline_reverse_fill     FT_OUTLINE_REVERSE_FILL
+#define ft_outline_ignore_dropouts  FT_OUTLINE_IGNORE_DROPOUTS
+#define ft_outline_high_precision   FT_OUTLINE_HIGH_PRECISION
+#define ft_outline_single_pass      FT_OUTLINE_SINGLE_PASS
+
+  /* */
+
+#define FT_CURVE_TAG( flag )  ( flag & 3 )
+
+#define FT_CURVE_TAG_ON           1
+#define FT_CURVE_TAG_CONIC        0
+#define FT_CURVE_TAG_CUBIC        2
+
+#define FT_CURVE_TAG_TOUCH_X      8  /* reserved for the TrueType hinter */
+#define FT_CURVE_TAG_TOUCH_Y     16  /* reserved for the TrueType hinter */
+
+#define FT_CURVE_TAG_TOUCH_BOTH  ( FT_CURVE_TAG_TOUCH_X | \
+                                   FT_CURVE_TAG_TOUCH_Y )
+
+#define  FT_Curve_Tag_On       FT_CURVE_TAG_ON
+#define  FT_Curve_Tag_Conic    FT_CURVE_TAG_CONIC
+#define  FT_Curve_Tag_Cubic    FT_CURVE_TAG_CUBIC
+#define  FT_Curve_Tag_Touch_X  FT_CURVE_TAG_TOUCH_X
+#define  FT_Curve_Tag_Touch_Y  FT_CURVE_TAG_TOUCH_Y
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Outline_MoveToFunc                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function pointer type used to describe the signature of a `move  */
+  /*    to' function during outline walking/decomposition.                 */
+  /*                                                                       */
+  /*    A `move to' is emitted to start a new contour in an outline.       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    to   :: A pointer to the target point of the `move to'.            */
+  /*                                                                       */
+  /*    user :: A typeless pointer which is passed from the caller of the  */
+  /*            decomposition function.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0 means success.                                      */
+  /*                                                                       */
+  typedef int
+  (*FT_Outline_MoveToFunc)( FT_Vector*  to,
+                            void*       user );
+
+#define FT_Outline_MoveTo_Func  FT_Outline_MoveToFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Outline_LineToFunc                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function pointer type used to describe the signature of a `line  */
+  /*    to' function during outline walking/decomposition.                 */
+  /*                                                                       */
+  /*    A `line to' is emitted to indicate a segment in the outline.       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    to   :: A pointer to the target point of the `line to'.            */
+  /*                                                                       */
+  /*    user :: A typeless pointer which is passed from the caller of the  */
+  /*            decomposition function.                                    */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0 means success.                                      */
+  /*                                                                       */
+  typedef int
+  (*FT_Outline_LineToFunc)( FT_Vector*  to,
+                            void*       user );
+
+#define  FT_Outline_LineTo_Func  FT_Outline_LineToFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Outline_ConicToFunc                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function pointer type use to describe the signature of a `conic  */
+  /*    to' function during outline walking/decomposition.                 */
+  /*                                                                       */
+  /*    A `conic to' is emitted to indicate a second-order Bezier arc in   */
+  /*    the outline.                                                       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    control :: An intermediate control point between the last position */
+  /*               and the new target in `to'.                             */
+  /*                                                                       */
+  /*    to      :: A pointer to the target end point of the conic arc.     */
+  /*                                                                       */
+  /*    user    :: A typeless pointer which is passed from the caller of   */
+  /*               the decomposition function.                             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0 means success.                                      */
+  /*                                                                       */
+  typedef int
+  (*FT_Outline_ConicToFunc)( FT_Vector*  control,
+                             FT_Vector*  to,
+                             void*       user );
+
+#define  FT_Outline_ConicTo_Func  FT_Outline_ConicToFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Outline_CubicToFunc                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function pointer type used to describe the signature of a `cubic */
+  /*    to' function during outline walking/decomposition.                 */
+  /*                                                                       */
+  /*    A `cubic to' is emitted to indicate a third-order Bezier arc.      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    control1 :: A pointer to the first Bezier control point.           */
+  /*                                                                       */
+  /*    control2 :: A pointer to the second Bezier control point.          */
+  /*                                                                       */
+  /*    to       :: A pointer to the target end point.                     */
+  /*                                                                       */
+  /*    user     :: A typeless pointer which is passed from the caller of  */
+  /*                the decomposition function.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0 means success.                                      */
+  /*                                                                       */
+  typedef int
+  (*FT_Outline_CubicToFunc)( FT_Vector*  control1,
+                             FT_Vector*  control2,
+                             FT_Vector*  to,
+                             void*       user );
+
+#define  FT_Outline_CubicTo_Func  FT_Outline_CubicToFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Outline_Funcs                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to hold various function pointers used during outline  */
+  /*    decomposition in order to emit segments, conic, and cubic Beziers, */
+  /*    as well as `move to' and `close to' operations.                    */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    move_to  :: The `move to' emitter.                                 */
+  /*                                                                       */
+  /*    line_to  :: The segment emitter.                                   */
+  /*                                                                       */
+  /*    conic_to :: The second-order Bezier arc emitter.                   */
+  /*                                                                       */
+  /*    cubic_to :: The third-order Bezier arc emitter.                    */
+  /*                                                                       */
+  /*    shift    :: The shift that is applied to coordinates before they   */
+  /*                are sent to the emitter.                               */
+  /*                                                                       */
+  /*    delta    :: The delta that is applied to coordinates before they   */
+  /*                are sent to the emitter, but after the shift.          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The point coordinates sent to the emitters are the transformed     */
+  /*    version of the original coordinates (this is important for high    */
+  /*    accuracy during scan-conversion).  The transformation is simple:   */
+  /*                                                                       */
+  /*      x' = (x << shift) - delta                                        */
+  /*      y' = (x << shift) - delta                                        */
+  /*                                                                       */
+  /*    Set the value of `shift' and `delta' to 0 to get the original      */
+  /*    point coordinates.                                                 */
+  /*                                                                       */
+  typedef struct  FT_Outline_Funcs_
+  {
+    FT_Outline_MoveToFunc   move_to;
+    FT_Outline_LineToFunc   line_to;
+    FT_Outline_ConicToFunc  conic_to;
+    FT_Outline_CubicToFunc  cubic_to;
+
+    int                     shift;
+    FT_Pos                  delta;
+
+  } FT_Outline_Funcs;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    basic_types                                                        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Macro>                                                               */
+  /*    FT_IMAGE_TAG                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This macro converts four letter tags into an unsigned long.        */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Since many 16bit compilers don't like 32bit enumerations, you      */
+  /*    should redefine this macro in case of problems to something like   */
+  /*    this:                                                              */
+  /*                                                                       */
+  /*      #define FT_IMAGE_TAG( value, _x1, _x2, _x3, _x4 )  (value)       */
+  /*                                                                       */
+  /*    to get a simple enumeration without assigning special numbers.     */
+  /*                                                                       */
+#ifndef FT_IMAGE_TAG
+#define FT_IMAGE_TAG( value, _x1, _x2, _x3, _x4 )  \
+          value = ( ( (unsigned long)_x1 << 24 ) | \
+                    ( (unsigned long)_x2 << 16 ) | \
+                    ( (unsigned long)_x3 << 8  ) | \
+                      (unsigned long)_x4         )
+#endif /* FT_IMAGE_TAG */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Glyph_Format                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration type used to describe the format of a given glyph   */
+  /*    image.  Note that this version of FreeType only supports two image */
+  /*    formats, even though future font drivers will be able to register  */
+  /*    their own format.                                                  */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_GLYPH_FORMAT_NONE ::                                            */
+  /*      The value 0 is reserved and does describe a glyph format.        */
+  /*                                                                       */
+  /*    FT_GLYPH_FORMAT_COMPOSITE ::                                       */
+  /*      The glyph image is a composite of several other images.  This    */
+  /*      format is _only_ used with @FT_LOAD_FLAG_NO_RECURSE, and is      */
+  /*      used to report compound glyphs (like accented characters).       */
+  /*                                                                       */
+  /*    FT_GLYPH_FORMAT_BITMAP ::                                          */
+  /*      The glyph image is a bitmap, and can be described as an          */
+  /*      @FT_Bitmap.  You generally need to access the `bitmap' field of  */
+  /*      the @FT_GlyphSlotRec structure to read it.                       */
+  /*                                                                       */
+  /*    FT_GLYPH_FORMAT_OUTLINE ::                                         */
+  /*      The glyph image is a vertorial outline made of line segments     */
+  /*      and Bezier arcs; it can be described as an @FT_Outline; you      */
+  /*      generally want to access the `outline' field of the              */
+  /*      @FT_GlyphSlotRec structure to read it.                           */
+  /*                                                                       */
+  /*    FT_GLYPH_FORMAT_PLOTTER ::                                         */
+  /*      The glyph image is a vectorial path with no inside/outside       */
+  /*      contours.  Some Type 1 fonts, like those in the Hershey family,  */
+  /*      contain glyphs in this format.  These are described as           */
+  /*      @FT_Outline, but FreeType isn't currently capable of rendering   */
+  /*      them correctly.                                                  */
+  /*                                                                       */
+  typedef enum  FT_Glyph_Format_
+  {
+    FT_IMAGE_TAG( FT_GLYPH_FORMAT_NONE, 0, 0, 0, 0 ),
+
+    FT_IMAGE_TAG( FT_GLYPH_FORMAT_COMPOSITE, 'c', 'o', 'm', 'p' ),
+    FT_IMAGE_TAG( FT_GLYPH_FORMAT_BITMAP,    'b', 'i', 't', 's' ),
+    FT_IMAGE_TAG( FT_GLYPH_FORMAT_OUTLINE,   'o', 'u', 't', 'l' ),
+    FT_IMAGE_TAG( FT_GLYPH_FORMAT_PLOTTER,   'p', 'l', 'o', 't' )
+
+  } FT_Glyph_Format;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    ft_glyph_format_xxx                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A list of decprecated constants.  Use the corresponding            */
+  /*    @FT_Glyph_Format values instead.                                   */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    ft_glyph_format_none      :: see @FT_GLYPH_FORMAT_NONE             */
+  /*    ft_glyph_format_composite :: see @FT_GLYPH_FORMAT_COMPOSITE        */
+  /*    ft_glyph_format_bitmap    :: see @FT_GLYPH_FORMAT_BITMAP           */
+  /*    ft_glyph_format_outline   :: see @FT_GLYPH_FORMAT_OUTLINE          */
+  /*    ft_glyph_format_plotter   :: see @FT_GLYPH_FORMAT_PLOTTER          */
+  /*                                                                       */
+#define ft_glyph_format_none       FT_GLYPH_FORMAT_NONE
+#define ft_glyph_format_composite  FT_GLYPH_FORMAT_COMPOSITE
+#define ft_glyph_format_bitmap     FT_GLYPH_FORMAT_BITMAP
+#define ft_glyph_format_outline    FT_GLYPH_FORMAT_OUTLINE
+#define ft_glyph_format_plotter    FT_GLYPH_FORMAT_PLOTTER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****            R A S T E R   D E F I N I T I O N S                *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* A raster is a scan converter, in charge of rendering an outline into  */
+  /* a a bitmap.  This section contains the public API for rasters.        */
+  /*                                                                       */
+  /* Note that in FreeType 2, all rasters are now encapsulated within      */
+  /* specific modules called `renderers'.  See `freetype/ftrender.h' for   */
+  /* more details on renderers.                                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    raster                                                             */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Scanline converter                                                 */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    How vectorial outlines are converted into bitmaps and pixmaps.     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains technical definitions.                       */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Raster                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle (pointer) to a raster object.  Each object can be used    */
+  /*    independently to convert an outline into a bitmap or pixmap.       */
+  /*                                                                       */
+  typedef struct FT_RasterRec_*  FT_Raster;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Span                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a single span of gray (or black) pixels  */
+  /*    when rendering a monochrome or anti-aliased bitmap.                */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    x        :: The span's horizontal start position.                  */
+  /*                                                                       */
+  /*    len      :: The span's length in pixels.                           */
+  /*                                                                       */
+  /*    coverage :: The span color/coverage, ranging from 0 (background)   */
+  /*                to 255 (foreground).  Only used for anti-aliased       */
+  /*                rendering.                                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This structure is used by the span drawing callback type named     */
+  /*    FT_SpanFunc which takes the y-coordinate of the span as a          */
+  /*    a parameter.                                                       */
+  /*                                                                       */
+  /*    The coverage value is always between 0 and 255, even if the number */
+  /*    of gray levels have been set through FT_Set_Gray_Levels().         */
+  /*                                                                       */
+  typedef struct  FT_Span_
+  {
+    short           x;
+    unsigned short  len;
+    unsigned char   coverage;
+
+  } FT_Span;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_SpanFunc                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used as a call-back by the anti-aliased renderer in     */
+  /*    order to let client applications draw themselves the gray pixel    */
+  /*    spans on each scan line.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    y     :: The scanline's y-coordinate.                              */
+  /*                                                                       */
+  /*    count :: The number of spans to draw on this scanline.             */
+  /*                                                                       */
+  /*    spans :: A table of `count' spans to draw on the scanline.         */
+  /*                                                                       */
+  /*    user  :: User-supplied data that is passed to the callback.        */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This callback allows client applications to directly render the    */
+  /*    gray spans of the anti-aliased bitmap to any kind of surfaces.     */
+  /*                                                                       */
+  /*    This can be used to write anti-aliased outlines directly to a      */
+  /*    given background bitmap, and even perform translucency.            */
+  /*                                                                       */
+  /*    Note that the `count' field cannot be greater than a fixed value   */
+  /*    defined by the FT_MAX_GRAY_SPANS configuration macro in            */
+  /*    ftoption.h.  By default, this value is set to 32, which means that */
+  /*    if there are more than 32 spans on a given scanline, the callback  */
+  /*    will be called several times with the same `y' parameter in order  */
+  /*    to draw all callbacks.                                             */
+  /*                                                                       */
+  /*    Otherwise, the callback is only called once per scan-line, and     */
+  /*    only for those scanlines that do have `gray' pixels on them.       */
+  /*                                                                       */
+  typedef void
+  (*FT_SpanFunc)( int       y,
+                  int       count,
+                  FT_Span*  spans,
+                  void*     user );
+
+#define FT_Raster_Span_Func   FT_SpanFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Raster_BitTest_Func                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    THIS TYPE IS DEPRECATED.  DO NOT USE IT.                           */
+  /*                                                                       */
+  /*    A function used as a call-back by the monochrome scan-converter    */
+  /*    to test whether a given target pixel is already set to the drawing */
+  /*    `color'.  These tests are crucial to implement drop-out control    */
+  /*    per-se the TrueType spec.                                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    y     :: The pixel's y-coordinate.                                 */
+  /*                                                                       */
+  /*    x     :: The pixel's x-coordinate.                                 */
+  /*                                                                       */
+  /*    user  :: User-supplied data that is passed to the callback.        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*   1 if the pixel is `set', 0 otherwise.                               */
+  /*                                                                       */
+  typedef int
+  (*FT_Raster_BitTest_Func)( int    y,
+                             int    x,
+                             void*  user );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Raster_BitSet_Func                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    THIS TYPE IS DEPRECATED.  DO NOT USE IT.                           */
+  /*                                                                       */
+  /*    A function used as a call-back by the monochrome scan-converter    */
+  /*    to set an individual target pixel.  This is crucial to implement   */
+  /*    drop-out control according to the TrueType specification.          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    y     :: The pixel's y-coordinate.                                 */
+  /*                                                                       */
+  /*    x     :: The pixel's x-coordinate.                                 */
+  /*                                                                       */
+  /*    user  :: User-supplied data that is passed to the callback.        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    1 if the pixel is `set', 0 otherwise.                              */
+  /*                                                                       */
+  typedef void
+  (*FT_Raster_BitSet_Func)( int    y,
+                            int    x,
+                            void*  user );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    FT_Raster_Flag                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An enumeration to list the bit flags as used in the `flags' field  */
+  /*    of a FT_Raster_Params structure.                                   */
+  /*                                                                       */
+  /* <Values>                                                              */
+  /*    FT_RASTER_FLAG_DEFAULT :: This value is 0.                         */
+  /*                                                                       */
+  /*    FT_RASTER_FLAG_AA      :: This flag is set to indicate that an     */
+  /*                              anti-aliased glyph image should be       */
+  /*                              generated.  Otherwise, it will be        */
+  /*                              monochrome (1-bit)                       */
+  /*                                                                       */
+  /*    FT_RASTER_FLAG_DIRECT  :: This flag is set to indicate direct      */
+  /*                              rendering.  In this mode, client         */
+  /*                              applications must provide their own span */
+  /*                              callback.  This lets them directly       */
+  /*                              draw or compose over an existing bitmap. */
+  /*                              If this bit is not set, the target       */
+  /*                              pixmap's buffer _must_ be zeroed before  */
+  /*                              rendering.                               */
+  /*                                                                       */
+  /*                              Note that for now, direct rendering is   */
+  /*                              only possible with anti-aliased glyphs.  */
+  /*                                                                       */
+  /*    FT_RASTER_FLAG_CLIP    :: This flag is only used in direct         */
+  /*                              rendering mode.  If set, the output will */
+  /*                              be clipped to a box specified in the     */
+  /*                              "clip_box" field of the FT_Raster_Params */
+  /*                              structure.                               */
+  /*                                                                       */
+  /*                              Note that by default, the glyph bitmap   */
+  /*                              is clipped to the target pixmap, except  */
+  /*                              in direct rendering mode where all spans */
+  /*                              are generated if no clipping box is set. */
+  /*                                                                       */
+  typedef  enum
+  {
+    FT_RASTER_FLAG_DEFAULT = 0,
+    FT_RASTER_FLAG_AA      = 1,
+    FT_RASTER_FLAG_DIRECT  = 2,
+    FT_RASTER_FLAG_CLIP    = 4
+
+  } FT_Raster_Flag;
+
+#define ft_raster_flag_default  FT_RASTER_FLAG_DEFAULT
+#define ft_raster_flag_aa       FT_RASTER_FLAG_AA
+#define ft_raster_flag_direct   FT_RASTER_FLAG_DIRECT
+#define ft_raster_flag_clip     FT_RASTER_FLAG_CLIP
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Raster_Params                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure to hold the arguments used by a raster's render        */
+  /*    function.                                                          */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    target      :: The target bitmap.                                  */
+  /*                                                                       */
+  /*    source      :: A pointer to the source glyph image (e.g. an        */
+  /*                   FT_Outline).                                        */
+  /*                                                                       */
+  /*    flags       :: The rendering flags.                                */
+  /*                                                                       */
+  /*    gray_spans  :: The gray span drawing callback.                     */
+  /*                                                                       */
+  /*    black_spans :: The black span drawing callback.                    */
+  /*                                                                       */
+  /*    bit_test    :: The bit test callback.  UNIMPLEMENTED!              */
+  /*                                                                       */
+  /*    bit_set     :: The bit set callback.  UNIMPLEMENTED!               */
+  /*                                                                       */
+  /*    user        :: User-supplied data that is passed to each drawing   */
+  /*                   callback.                                           */
+  /*                                                                       */
+  /*    clip_box    :: An optional clipping box.  It is only used in       */
+  /*                   direct rendering mode.  Note that coordinates here  */
+  /*                   should be expressed in _integer_ pixels (and not in */
+  /*                   26.6 fixed-point units).                            */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    An anti-aliased glyph bitmap is drawn if the FT_RASTER_FLAG_AA bit */
+  /*    flag is set in the `flags' field, otherwise a monochrome bitmap    */
+  /*    will be generated.                                                 */
+  /*                                                                       */
+  /*    If the FT_RASTER_FLAG_DIRECT bit flag is set in `flags', the       */
+  /*    raster will call the `gray_spans' callback to draw gray pixel      */
+  /*    spans, in the case of an aa glyph bitmap, it will call             */
+  /*    `black_spans', and `bit_test' and `bit_set' in the case of a       */
+  /*    monochrome bitmap.  This allows direct composition over a          */
+  /*    pre-existing bitmap through user-provided callbacks to perform the */
+  /*    span drawing/composition.                                          */
+  /*                                                                       */
+  /*    Note that the `bit_test' and `bit_set' callbacks are required when */
+  /*    rendering a monochrome bitmap, as they are crucial to implement    */
+  /*    correct drop-out control as defined in the TrueType specification. */
+  /*                                                                       */
+  typedef struct  FT_Raster_Params_
+  {
+    FT_Bitmap*              target;
+    void*                   source;
+    int                     flags;
+    FT_SpanFunc             gray_spans;
+    FT_SpanFunc             black_spans;
+    FT_Raster_BitTest_Func  bit_test;     /* doesn't work! */
+    FT_Raster_BitSet_Func   bit_set;      /* doesn't work! */
+    void*                   user;
+    FT_BBox                 clip_box;
+
+  } FT_Raster_Params;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Raster_NewFunc                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to create a new raster object.                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    memory :: A handle to the memory allocator.                        */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    raster :: A handle to the new raster object.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0 means success.                                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The `memory' parameter is a typeless pointer in order to avoid     */
+  /*    un-wanted dependencies on the rest of the FreeType code.  In       */
+  /*    practice, it is a FT_Memory, i.e., a handle to the standard        */
+  /*    FreeType memory allocator.  However, this field can be completely  */
+  /*    ignored by a given raster implementation.                          */
+  /*                                                                       */
+  typedef int
+  (*FT_Raster_NewFunc)( void*       memory,
+                        FT_Raster*  raster );
+
+#define  FT_Raster_New_Func    FT_Raster_NewFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Raster_DoneFunc                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to destroy a given raster object.                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    raster :: A handle to the raster object.                           */
+  /*                                                                       */
+  typedef void
+  (*FT_Raster_DoneFunc)( FT_Raster  raster );
+
+#define  FT_Raster_Done_Func   FT_Raster_DoneFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Raster_ResetFunc                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    FreeType provides an area of memory called the `render pool',      */
+  /*    available to all registered rasters.  This pool can be freely used */
+  /*    during a given scan-conversion but is shared by all rasters.  Its  */
+  /*    content is thus transient.                                         */
+  /*                                                                       */
+  /*    This function is called each time the render pool changes, or just */
+  /*    after a new raster object is created.                              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    raster    :: A handle to the new raster object.                    */
+  /*                                                                       */
+  /*    pool_base :: The address in memory of the render pool.             */
+  /*                                                                       */
+  /*    pool_size :: The size in bytes of the render pool.                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Rasters can ignore the render pool and rely on dynamic memory      */
+  /*    allocation if they want to (a handle to the memory allocator is    */
+  /*    passed to the raster constructor).  However, this is not           */
+  /*    recommended for efficiency purposes.                               */
+  /*                                                                       */
+  typedef void
+  (*FT_Raster_ResetFunc)( FT_Raster       raster,
+                          unsigned char*  pool_base,
+                          unsigned long   pool_size );
+
+#define  FT_Raster_Reset_Func   FT_Raster_ResetFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Raster_SetModeFunc                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is a generic facility to change modes or attributes  */
+  /*    in a given raster.  This can be used for debugging purposes, or    */
+  /*    simply to allow implementation-specific `features' in a given      */
+  /*    raster module.                                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    raster :: A handle to the new raster object.                       */
+  /*                                                                       */
+  /*    mode   :: A 4-byte tag used to name the mode or property.          */
+  /*                                                                       */
+  /*    args   :: A pointer to the new mode/property to use.               */
+  /*                                                                       */
+  typedef int
+  (*FT_Raster_SetModeFunc)( FT_Raster      raster,
+                            unsigned long  mode,
+                            void*          args );
+
+#define  FT_Raster_Set_Mode_Func  FT_Raster_SetModeFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Raster_RenderFunc                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   Invokes a given raster to scan-convert a given glyph image into a   */
+  /*   target bitmap.                                                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    raster :: A handle to the raster object.                           */
+  /*                                                                       */
+  /*    params :: A pointer to a FT_Raster_Params structure used to store  */
+  /*              the rendering parameters.                                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Error code.  0 means success.                                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The exact format of the source image depends on the raster's glyph */
+  /*    format defined in its FT_Raster_Funcs structure.  It can be an     */
+  /*    FT_Outline or anything else in order to support a large array of   */
+  /*    glyph formats.                                                     */
+  /*                                                                       */
+  /*    Note also that the render function can fail and return a           */
+  /*    FT_Err_Unimplemented_Feature error code if the raster used does    */
+  /*    not support direct composition.                                    */
+  /*                                                                       */
+  /*    XXX: For now, the standard raster doesn't support direct           */
+  /*         composition but this should change for the final release (see */
+  /*         the files demos/src/ftgrays.c and demos/src/ftgrays2.c for    */
+  /*         examples of distinct implementations which support direct     */
+  /*         composition).                                                 */
+  /*                                                                       */
+  typedef int
+  (*FT_Raster_RenderFunc)( FT_Raster          raster,
+                           FT_Raster_Params*  params );
+
+#define  FT_Raster_Render_Func    FT_Raster_RenderFunc
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Raster_Funcs                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   A structure used to describe a given raster class to the library.   */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    glyph_format  :: The supported glyph format for this raster.       */
+  /*                                                                       */
+  /*    raster_new    :: The raster constructor.                           */
+  /*                                                                       */
+  /*    raster_reset  :: Used to reset the render pool within the raster.  */
+  /*                                                                       */
+  /*    raster_render :: A function to render a glyph into a given bitmap. */
+  /*                                                                       */
+  /*    raster_done   :: The raster destructor.                            */
+  /*                                                                       */
+  typedef struct  FT_Raster_Funcs_
+  {
+    FT_Glyph_Format         glyph_format;
+    FT_Raster_NewFunc       raster_new;
+    FT_Raster_ResetFunc     raster_reset;
+    FT_Raster_SetModeFunc   raster_set_mode;
+    FT_Raster_RenderFunc    raster_render;
+    FT_Raster_DoneFunc      raster_done;
+
+  } FT_Raster_Funcs;
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* __FTIMAGE_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftincrem.h
@@ -1,0 +1,286 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftincrem.h                                                             */
+/*                                                                         */
+/*    FreeType incremental loading (specification).                        */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTINCREM_H__
+#define __FTINCREM_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+ /***************************************************************************
+  *
+  * @type:
+  *   FT_Incremental
+  *
+  * @description:
+  *   An opaque type describing a user-provided object used to implement
+  *   "incremental" glyph loading within FreeType.  This is used to support
+  *   embedded fonts in certain environments (e.g. Postscript interpreters),
+  *   where the glyph data isn't in the font file, or must be overridden by
+  *   different values.
+  *
+  * @note:
+  *   It is up to client applications to create and implement @FT_Incremental
+  *   objects, as long as they provide implementations for the methods
+  *   @FT_Incremental_GetGlyphDataFunc, @FT_Incremental_FreeGlyphDataFunc
+  *   and @FT_Incremental_GetGlyphMetricsFunc.
+  *
+  *   See the description of @FT_Incremental_InterfaceRec to understand how
+  *   to use incremental objects with FreeType.
+  */
+  typedef struct FT_IncrementalRec_*  FT_Incremental;
+
+
+ /***************************************************************************
+  *
+  * @struct:
+  *   FT_Incremental_Metrics
+  *
+  * @description:
+  *   A small structure used to contain the basic glyph metrics returned
+  *   by the @FT_Incremental_GetGlyphMetricsFunc method.
+  *
+  * @fields:
+  *   bearing_x ::
+  *     Left bearing, in font units.
+  *
+  *   bearing_y ::
+  *     Top bearing, in font units.
+  *
+  *   advance ::
+  *     Glyph advance, in font units.
+  *
+  * @note:
+  *   These correspond to horizontal or vertical metrics depending on the
+  *   value of the 'vertical' argument to the function
+  *   @FT_Incremental_GetGlyphMetricsFunc.
+  */
+  typedef struct  FT_Incremental_MetricsRec_
+  {
+    FT_Long  bearing_x;
+    FT_Long  bearing_y;
+    FT_Long  advance;
+
+  } FT_Incremental_MetricsRec, *FT_Incremental_Metrics;
+
+
+ /***************************************************************************
+  *
+  * @type:
+  *   FT_Incremental_GetGlyphDataFunc
+  *
+  * @description:
+  *   A function called by FreeType to access a given glyph's data bytes
+  *   during @FT_Load_Glyph or @FT_Load_Char if incremental loading is
+  *   enabled.
+  *
+  *   Note that the format of the glyph's data bytes depends on the font
+  *   file format.  For TrueType, it must correspond to the raw bytes within
+  *   the 'glyf' table.  For Postscript formats, it must correspond to the
+  *   *unencrypted* charstring bytes, without any 'lenIV' header.  It is
+  *   undefined for any other format.
+  *
+  * @input:
+  *   incremental ::
+  *     Handle to an opaque @FT_Incremental handle provided by the client
+  *     application.
+  *
+  *   glyph_index ::
+  *     Index of relevant glyph.
+  *
+  * @output:
+  *   adata ::
+  *     A structure describing the returned glyph data bytes (which will be
+  *     accessed as a read-only byte block).
+  *
+  * @return:
+  *   FreeType error code.  0 means success.
+  *
+  * @note:
+  *   If this function returns succesfully the method
+  *   @FT_Incremental_FreeGlyphDataFunc will be called later to release
+  *   the data bytes.
+  *
+  *   Nested calls to @FT_Incremental_GetGlyphDataFunc can happen for
+  *   compound glyphs.
+  */
+  typedef FT_Error
+  (*FT_Incremental_GetGlyphDataFunc)( FT_Incremental  incremental,
+                                      FT_UInt         glyph_index,
+                                      FT_Data*        adata );
+
+
+ /***************************************************************************
+  *
+  * @type:
+  *   FT_Incremental_FreeGlyphDataFunc
+  *
+  * @description:
+  *   A function used to release the glyph data bytes returned by a
+  *   successful call to @FT_Incremental_GetGlyphDataFunc.
+  *
+  * @input:
+  *   incremental ::
+  *     A handle to an opaque @FT_Incremental handle provided by the client
+  *     application.
+  *
+  *   data ::
+  *     A structure describing the glyph data bytes (which will be accessed
+  *     as a read-only byte block).
+  */
+  typedef void
+  (*FT_Incremental_FreeGlyphDataFunc)( FT_Incremental  incremental,
+                                       FT_Data*        data );
+
+
+ /***************************************************************************
+  *
+  * @type:
+  *   FT_Incremental_GetGlyphMetricsFunc
+  *
+  * @description:
+  *   A function used to retrieve the basic metrics of a given glyph index
+  *   before accessing its data.  This is necessary because, in certain
+  *   formats like TrueType, the metrics are stored in a different place from
+  *   the glyph images proper.
+  *
+  * @input:
+  *   incremental ::
+  *     A handle to an opaque @FT_Incremental handle provided by the client
+  *     application.
+  *
+  *   glyph_index ::
+  *     Index of relevant glyph.
+  *
+  *   vertical ::
+  *     If true, return vertical metrics.
+  *
+  * @output:
+  *   ametrics ::
+  *     The glyph metrics in font units.
+  *
+  *   afound ::
+  *     True if there are metrics at all.
+  *
+  */
+  typedef FT_Error
+  (*FT_Incremental_GetGlyphMetricsFunc)
+                      ( FT_Incremental              incremental,
+                        FT_UInt                     glyph_index,
+                        FT_Bool                     vertical,
+                        FT_Incremental_MetricsRec  *ametrics,
+                        FT_Bool                    *afound );
+
+
+  /**************************************************************************
+   *
+   * @struct:
+   *   FT_Incremental_FuncsRec
+   * 
+   * @description:
+   *   A table of functions for accessing fonts that load data
+   *   incrementally.  Used in @FT_Incremental_Interface.
+   * 
+   * @fields:
+   *   get_glyph_data ::
+   *     The function to get glyph data.  Must not be null.
+   *
+   *   free_glyph_data ::
+   *     The function to release glyph data.  Must not be null.
+   *
+   *   get_glyph_metrics ::
+   *     The function to get glyph metrics.  May be null if the font does
+   *     not provide overriding glyph metrics. 
+   */
+  typedef struct  FT_Incremental_FuncsRec_
+  {
+    FT_Incremental_GetGlyphDataFunc     get_glyph_data;
+    FT_Incremental_FreeGlyphDataFunc    free_glyph_data;
+    FT_Incremental_GetGlyphMetricsFunc  get_glyph_metrics;
+
+  } FT_Incremental_FuncsRec;
+
+
+ /***************************************************************************
+  *
+  * @struct:
+  *   FT_Incremental_InterfaceRec
+  *
+  * @description:
+  *   A structure to be used with @FT_Open_Face to indicate that the user
+  *   wants to support incremental glyph loading.  You should use it with
+  *   @FT_PARAM_TAG_INCREMENTAL as in the following example:
+  *
+  *     {
+  *       FT_Incremental_InterfaceRec  inc_int;
+  *       FT_Parameter                 parameter;
+  *       FT_Open_Args                 open_args;
+  *
+  *
+  *       // set up incremental descriptor
+  *       inc_int.funcs  = my_funcs;
+  *       inc_int.object = my_object;
+  *
+  *       // set up optional parameter
+  *       parameter.tag  = FT_PARAM_TAG_INCREMENTAL;
+  *       parameter.data = &inc_int;
+  *
+  *       // set up FT_Open_Args structure
+  *       open_args.flags      = (FT_Open_Flags)( FT_OPEN_PATHNAME |
+  *                                               FT_OPEN_PARAMS   );
+  *       open_args.pathname   = my_font_pathname;
+  *       open_args.num_params = 1;
+  *       open_args.params     = &parameter; // we use one optional argument
+  *
+  *       // open the font
+  *       error = FT_Open_Face( library, &open_args, index, &face );
+  *       ...
+  *     }
+  */
+  typedef struct  FT_Incremental_InterfaceRec_
+  {
+    const FT_Incremental_FuncsRec*  funcs;
+    FT_Incremental                  object;
+  
+  } FT_Incremental_InterfaceRec;
+
+
+ /***************************************************************************
+  *
+  * @constant:
+  *   FT_PARAM_TAG_INCREMENTAL
+  *
+  * @description:
+  *   A constant used as the tag of @FT_Parameter structures to indicate
+  *   an incremental loading object to be used by FreeType.
+  *
+  */
+#define FT_PARAM_TAG_INCREMENTAL  FT_MAKE_TAG( 'i', 'n', 'c', 'r' )
+
+ /* */  
+
+FT_END_HEADER
+
+#endif /* __FTINCREM_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftlist.h
@@ -1,0 +1,268 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftlist.h                                                               */
+/*                                                                         */
+/*    Generic list support for FreeType (specification).                   */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  This file implements functions relative to list processing.  Its     */
+  /*  data structures are defined in `freetype.h'.                         */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __FTLIST_H__
+#define __FTLIST_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    list_processing                                                    */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    List Processing                                                    */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Simple management of lists.                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains various definitions related to list          */
+  /*    processing using doubly-linked nodes.                              */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    FT_List                                                            */
+  /*    FT_ListNode                                                        */
+  /*    FT_ListRec                                                         */
+  /*    FT_ListNodeRec                                                     */
+  /*                                                                       */
+  /*    FT_List_Add                                                        */
+  /*    FT_List_Insert                                                     */
+  /*    FT_List_Find                                                       */
+  /*    FT_List_Remove                                                     */
+  /*    FT_List_Up                                                         */
+  /*    FT_List_Iterate                                                    */
+  /*    FT_List_Iterator                                                   */
+  /*    FT_List_Finalize                                                   */
+  /*    FT_List_Destructor                                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_List_Find                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finds the list node for a given listed object.                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    list :: A pointer to the parent list.                              */
+  /*    data :: The address of the listed object.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    List node.  NULL if it wasn't found.                               */
+  /*                                                                       */
+  FT_EXPORT( FT_ListNode )
+  FT_List_Find( FT_List  list,
+                void*    data );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_List_Add                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Appends an element to the end of a list.                           */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    list :: A pointer to the parent list.                              */
+  /*    node :: The node to append.                                        */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_List_Add( FT_List      list,
+               FT_ListNode  node );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_List_Insert                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Inserts an element at the head of a list.                          */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    list :: A pointer to parent list.                                  */
+  /*    node :: The node to insert.                                        */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_List_Insert( FT_List      list,
+                  FT_ListNode  node );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_List_Remove                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Removes a node from a list.  This function doesn't check whether   */
+  /*    the node is in the list!                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    node :: The node to remove.                                        */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    list :: A pointer to the parent list.                              */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_List_Remove( FT_List      list,
+                  FT_ListNode  node );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_List_Up                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Moves a node to the head/top of a list.  Used to maintain LRU      */
+  /*    lists.                                                             */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    list :: A pointer to the parent list.                              */
+  /*    node :: The node to move.                                          */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_List_Up( FT_List      list,
+              FT_ListNode  node );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_List_Iterator                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An FT_List iterator function which is called during a list parse   */
+  /*    by FT_List_Iterate().                                              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    node :: The current iteration list node.                           */
+  /*                                                                       */
+  /*    user :: A typeless pointer passed to FT_List_Iterate().            */
+  /*            Can be used to point to the iteration's state.             */
+  /*                                                                       */
+  typedef FT_Error
+  (*FT_List_Iterator)( FT_ListNode  node,
+                       void*        user );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_List_Iterate                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Parses a list and calls a given iterator function on each element. */
+  /*    Note that parsing is stopped as soon as one of the iterator calls  */
+  /*    returns a non-zero value.                                          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    list     :: A handle to the list.                                  */
+  /*    iterator :: An interator function, called on each node of the      */
+  /*                list.                                                  */
+  /*    user     :: A user-supplied field which is passed as the second    */
+  /*                argument to the iterator.                              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The result (a FreeType error code) of the last iterator call.      */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_List_Iterate( FT_List           list,
+                   FT_List_Iterator  iterator,
+                   void*             user );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_List_Destructor                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An FT_List iterator function which is called during a list         */
+  /*    finalization by FT_List_Finalize() to destroy all elements in a    */
+  /*    given list.                                                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    system :: The current system object.                               */
+  /*                                                                       */
+  /*    data   :: The current object to destroy.                           */
+  /*                                                                       */
+  /*    user   :: A typeless pointer passed to FT_List_Iterate().  It can  */
+  /*              be used to point to the iteration's state.               */
+  /*                                                                       */
+  typedef void
+  (*FT_List_Destructor)( FT_Memory  memory,
+                         void*      data,
+                         void*      user );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_List_Finalize                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroys all elements in the list as well as the list itself.      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    list    :: A handle to the list.                                   */
+  /*                                                                       */
+  /*    destroy :: A list destructor that will be applied to each element  */
+  /*               of the list.                                            */
+  /*                                                                       */
+  /*    memory  :: The current memory object which handles deallocation.   */
+  /*                                                                       */
+  /*    user    :: A user-supplied field which is passed as the last       */
+  /*               argument to the destructor.                             */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_List_Finalize( FT_List             list,
+                    FT_List_Destructor  destroy,
+                    FT_Memory           memory,
+                    void*               user );
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* __FTLIST_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftmac.h
@@ -1,0 +1,128 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftmac.h                                                                */
+/*                                                                         */
+/*    Additional Mac-specific API.                                         */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  Just van Rossum, David Turner, Robert Wilhelm, and Werner Lemberg.     */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+/***************************************************************************/
+/*                                                                         */
+/* NOTE: Include this file after <freetype/freetype.h> and after the       */
+/*       Mac-specific <Types.h> header (or any other Mac header that       */
+/*       includes <Types.h>); we use Handle type.                          */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTMAC_H__
+#define __FTMAC_H__
+
+
+#include <ft2build.h>
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    mac_specific                                                       */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Mac-Specific Interface                                             */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Only available on the Macintosh.                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The following definitions are only available if FreeType is        */
+  /*    compiled on a Macintosh.                                           */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Face_From_FOND                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Creates a new face object from an FOND resource.                   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library    :: A handle to the library resource.                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    fond       :: An FOND resource.                                    */
+  /*                                                                       */
+  /*    face_index :: Only supported for the -1 `sanity check' special     */
+  /*                  case.                                                */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aface      :: A handle to a new face object.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Notes>                                                               */
+  /*    This function can be used to create FT_Face abjects from fonts     */
+  /*    that are installed in the system like so:                          */
+  /*                                                                       */
+  /*    {                                                                  */
+  /*      fond = GetResource( 'FOND', fontName );                          */
+  /*      error = FT_New_Face_From_FOND( library, fond, 0, &face );        */
+  /*    }                                                                  */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_New_Face_From_FOND( FT_Library  library,
+                         Handle      fond,
+                         FT_Long     face_index,
+                         FT_Face    *aface );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_GetFile_From_Mac_Name                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Returns an FSSpec for the disk file containing the named font.     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    fontName   :: Mac OS name of the font (eg. Times New Roman Bold).  */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    pathSpec   :: FSSpec to the file.  For passing to @FT_New_Face.    */
+  /*                                                                       */
+  /*    face_index :: Index of the face.  For passing to @FT_New_Face.     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT_DEF( FT_Error )
+  FT_GetFile_From_Mac_Name( char*     fontName, 
+                            FSSpec*   pathSpec,
+                            FT_Long*  face_index );
+
+  /* */
+
+
+FT_END_HEADER
+
+
+#endif /* __FTMAC_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftmm.h
@@ -1,0 +1,203 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftmm.h                                                                 */
+/*                                                                         */
+/*    FreeType Multiple Master font interface (specification).             */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTMM_H__
+#define __FTMM_H__
+
+
+#include <ft2build.h>
+#include FT_TYPE1_TABLES_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    multiple_masters                                                   */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Multiple Masters                                                   */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    How to manage Multiple Masters fonts.                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The following types and functions are used to manage Multiple      */
+  /*    Master fonts, i.e. the selection of specific design instances by   */
+  /*    setting design axis coordinates.                                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_MM_Axis                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple structure used to model a given axis in design space for  */
+  /*    Multiple Masters fonts.                                            */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    name    :: The axis's name.                                        */
+  /*                                                                       */
+  /*    minimum :: The axis's minimum design coordinate.                   */
+  /*                                                                       */
+  /*    maximum :: The axis's maximum design coordinate.                   */
+  /*                                                                       */
+  typedef struct  FT_MM_Axis_
+  {
+    FT_String*  name;
+    FT_Long     minimum;
+    FT_Long     maximum;
+
+  } FT_MM_Axis;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Multi_Master                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model the axes and space of a Multiple Masters */
+  /*    font.                                                              */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    num_axis    :: Number of axes.  Cannot exceed 4.                   */
+  /*                                                                       */
+  /*    num_designs :: Number of designs; should ne normally 2^num_axis    */
+  /*                   even though the Type 1 specification strangely      */
+  /*                   allows for intermediate designs to be present. This */
+  /*                   number cannot exceed 16.                            */
+  /*                                                                       */
+  /*    axis        :: A table of axis descriptors.                        */
+  /*                                                                       */
+  typedef struct  FT_Multi_Master_
+  {
+    FT_UInt     num_axis;
+    FT_UInt     num_designs;
+    FT_MM_Axis  axis[T1_MAX_MM_AXIS];
+
+  } FT_Multi_Master;
+
+  /* */
+
+  typedef FT_Error
+  (*FT_Get_MM_Func)( FT_Face           face,
+                     FT_Multi_Master*  master );
+
+  typedef FT_Error
+  (*FT_Set_MM_Design_Func)( FT_Face   face,
+                            FT_UInt   num_coords,
+                            FT_Long*  coords );
+
+  typedef FT_Error
+  (*FT_Set_MM_Blend_Func)( FT_Face   face,
+                           FT_UInt   num_coords,
+                           FT_Long*  coords );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Multi_Master                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieves the Multiple Master descriptor of a given font.          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face    :: A handle to the source face.                            */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    amaster :: The Multiple Masters descriptor.                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Multi_Master( FT_Face           face,
+                       FT_Multi_Master  *amaster );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_MM_Design_Coordinates                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    For Multiple Masters fonts, choose an interpolated font design     */
+  /*    through design coordinates.                                        */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face       :: A handle to the source face.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    num_coords :: The number of design coordinates (must be equal to   */
+  /*                  the number of axes in the font).                     */
+  /*                                                                       */
+  /*    coords     :: An array of design coordinates.                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Set_MM_Design_Coordinates( FT_Face   face,
+                                FT_UInt   num_coords,
+                                FT_Long*  coords );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_MM_Blend_Coordinates                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    For Multiple Masters fonts, choose an interpolated font design     */
+  /*    through normalized blend coordinates.                              */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    face       :: A handle to the source face.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    num_coords :: The number of design coordinates (must be equal to   */
+  /*                  the number of axes in the font).                     */
+  /*                                                                       */
+  /*    coords     :: The design coordinates array (each element must be   */
+  /*                  between 0 and 1.0).                                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Set_MM_Blend_Coordinates( FT_Face    face,
+                               FT_UInt    num_coords,
+                               FT_Fixed*  coords );
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* __FTMM_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftmoderr.h
@@ -1,0 +1,149 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftmoderr.h                                                             */
+/*                                                                         */
+/*    FreeType module error offsets (specification).                       */
+/*                                                                         */
+/*  Copyright 2001, 2002 by                                                */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file is used to define the FreeType module error offsets.        */
+  /*                                                                       */
+  /* The lower byte gives the error code, the higher byte gives the        */
+  /* module.  The base module has error offset 0.  For example, the error  */
+  /* `FT_Err_Invalid_File_Format' has value 0x003, the error               */
+  /* `TT_Err_Invalid_File_Format' has value 0xB03, the error               */
+  /* `T1_Err_Invalid_File_Format' has value 0xC03, etc.                    */
+  /*                                                                       */
+  /* Undefine the macro FT_CONFIG_OPTION_USE_MODULE_ERRORS in ftoption.h   */
+  /* to make the higher byte always zero (disabling the module error       */
+  /* mechanism).                                                           */
+  /*                                                                       */
+  /* It can also be used to create a module error message table easily     */
+  /* with something like                                                   */
+  /*                                                                       */
+  /*   {                                                                   */
+  /*     #undef __FTMODERR_H__                                             */
+  /*     #define FT_MODERRDEF( e, v, s )  { FT_Mod_Err_ ## e, s },         */
+  /*     #define FT_MODERR_START_LIST     {                                */
+  /*     #define FT_MODERR_END_LIST       { 0, 0 } };                      */
+  /*                                                                       */
+  /*     const struct                                                      */
+  /*     {                                                                 */
+  /*       int          mod_err_offset;                                    */
+  /*       const char*  mod_err_msg                                        */
+  /*     } ft_mod_errors[] =                                               */
+  /*                                                                       */
+  /*     #include FT_MODULE_ERRORS_H                                       */
+  /*   }                                                                   */
+  /*                                                                       */
+  /* To use such a table, all errors must be ANDed with 0xFF00 to remove   */
+  /* the error code.                                                       */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __FTMODERR_H__
+#define __FTMODERR_H__
+
+
+  /*******************************************************************/
+  /*******************************************************************/
+  /*****                                                         *****/
+  /*****                       SETUP MACROS                      *****/
+  /*****                                                         *****/
+  /*******************************************************************/
+  /*******************************************************************/
+
+
+#undef  FT_NEED_EXTERN_C
+
+#ifndef FT_MODERRDEF
+
+#ifdef FT_CONFIG_OPTION_USE_MODULE_ERRORS
+#define FT_MODERRDEF( e, v, s )  FT_Mod_Err_ ## e = v,
+#else
+#define FT_MODERRDEF( e, v, s )  FT_Mod_Err_ ## e = 0,
+#endif
+
+#define FT_MODERR_START_LIST  enum {
+#define FT_MODERR_END_LIST    FT_Mod_Err_Max };
+
+#ifdef __cplusplus
+#define FT_NEED_EXTERN_C
+  extern "C" {
+#endif
+
+#endif /* !FT_MODERRDEF */
+
+
+  /*******************************************************************/
+  /*******************************************************************/
+  /*****                                                         *****/
+  /*****               LIST MODULE ERROR BASES                   *****/
+  /*****                                                         *****/
+  /*******************************************************************/
+  /*******************************************************************/
+
+
+#ifdef FT_MODERR_START_LIST
+  FT_MODERR_START_LIST
+#endif
+
+
+  FT_MODERRDEF( Base,     0x000, "base module" )
+  FT_MODERRDEF( Autohint, 0x100, "autohinter module" )
+  FT_MODERRDEF( Cache,    0x200, "cache module" )
+  FT_MODERRDEF( CFF,      0x300, "CFF module" )
+  FT_MODERRDEF( CID,      0x400, "CID module" )
+  FT_MODERRDEF( PCF,      0x500, "PCF module" )
+  FT_MODERRDEF( PSaux,    0x600, "PS auxiliary module" )
+  FT_MODERRDEF( PSnames,  0x700, "PS names module" )
+  FT_MODERRDEF( Raster,   0x800, "raster module" )
+  FT_MODERRDEF( SFNT,     0x900, "SFNT module" )
+  FT_MODERRDEF( Smooth,   0xA00, "smooth raster module" )
+  FT_MODERRDEF( TrueType, 0xB00, "TrueType module" )
+  FT_MODERRDEF( Type1,    0xC00, "Type 1 module" )
+  FT_MODERRDEF( Winfonts, 0xD00, "Windows FON/FNT module" )
+  FT_MODERRDEF( PFR,      0xE00, "PFR module" )
+
+
+#ifdef FT_MODERR_END_LIST
+  FT_MODERR_END_LIST
+#endif
+
+
+  /*******************************************************************/
+  /*******************************************************************/
+  /*****                                                         *****/
+  /*****                      CLEANUP                            *****/
+  /*****                                                         *****/
+  /*******************************************************************/
+  /*******************************************************************/
+
+
+#ifdef FT_NEED_EXTERN_C
+  }
+#endif
+
+#undef FT_MODERR_START_LIST
+#undef FT_MODERR_END_LIST
+#undef FT_MODERRDEF
+#undef FT_NEED_EXTERN_C
+
+
+#endif /* __FTMODERR_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftmodule.h
@@ -1,0 +1,307 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftmodule.h                                                             */
+/*                                                                         */
+/*    FreeType modules public interface (specification).                   */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTMODULE_H__
+#define __FTMODULE_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    module_management                                                  */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Module Management                                                  */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    How to add, upgrade, and remove modules from FreeType.             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The definitions below are used to manage modules within FreeType.  */
+  /*    Modules can be added, upgraded, and removed at runtime.            */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* module bit flags */
+  typedef enum  FT_Module_Flags_
+  {
+    ft_module_font_driver         = 1,     /* this module is a font driver  */
+    ft_module_renderer            = 2,     /* this module is a renderer     */
+    ft_module_hinter              = 4,     /* this module is a glyph hinter */
+    ft_module_styler              = 8,     /* this module is a styler       */
+
+    ft_module_driver_scalable     = 0x100, /* the driver supports scalable  */
+                                           /* fonts                         */
+    ft_module_driver_no_outlines  = 0x200, /* the driver does not support   */
+                                           /* vector outlines               */
+    ft_module_driver_has_hinter   = 0x400  /* the driver provides its own   */
+                                           /* hinter                        */
+
+  } FT_Module_Flags;
+
+
+  typedef void
+  (*FT_Module_Interface)( void );
+
+  typedef FT_Error
+  (*FT_Module_Constructor)( FT_Module  module );
+
+  typedef void
+  (*FT_Module_Destructor)( FT_Module  module );
+
+  typedef FT_Module_Interface
+  (*FT_Module_Requester)( FT_Module    module,
+                          const char*  name );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Module_Class                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The module class descriptor.                                       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    module_flags      :: Bit flags describing the module.              */
+  /*                                                                       */
+  /*    module_size       :: The size of one module object/instance in     */
+  /*                         bytes.                                        */
+  /*                                                                       */
+  /*    module_name       :: The name of the module.                       */
+  /*                                                                       */
+  /*    module_version    :: The version, as a 16.16 fixed number          */
+  /*                         (major.minor).                                */
+  /*                                                                       */
+  /*    module_requires   :: The version of FreeType this module requires  */
+  /*                         (starts at version 2.0, i.e 0x20000)          */
+  /*                                                                       */
+  /*    module_init       :: A function used to initialize (not create) a  */
+  /*                         new module object.                            */
+  /*                                                                       */
+  /*    module_done       :: A function used to finalize (not destroy) a   */
+  /*                         given module object                           */
+  /*                                                                       */
+  /*    get_interface     :: Queries a given module for a specific         */
+  /*                         interface by name.                            */
+  /*                                                                       */
+  typedef struct  FT_Module_Class_
+  {
+    FT_ULong               module_flags;
+    FT_Long                module_size;
+    const FT_String*       module_name;
+    FT_Fixed               module_version;
+    FT_Fixed               module_requires;
+
+    const void*            module_interface;
+
+    FT_Module_Constructor  module_init;
+    FT_Module_Destructor   module_done;
+    FT_Module_Requester    get_interface;
+
+  } FT_Module_Class;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Add_Module                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Adds a new module to a given library instance.                     */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library :: A handle to the library object.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    clazz   :: A pointer to class descriptor for the module.           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    An error will be returned if a module already exists by that name, */
+  /*    or if the module requires a version of FreeType that is too great. */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Add_Module( FT_Library              library,
+                 const FT_Module_Class*  clazz );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Module                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finds a module by its name.                                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library     :: A handle to the library object.                     */
+  /*                                                                       */
+  /*    module_name :: The module's name (as an ASCII string).             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A module handle.  0 if none was found.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You should better be familiar with FreeType internals to know      */
+  /*    which module to look for :-)                                       */
+  /*                                                                       */
+  FT_EXPORT( FT_Module )
+  FT_Get_Module( FT_Library   library,
+                 const char*  module_name );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Remove_Module                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Removes a given module from a library instance.                    */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library :: A handle to a library object.                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    module  :: A handle to a module object.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The module object is destroyed by the function in case of success. */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Remove_Module( FT_Library  library,
+                    FT_Module   module );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Library                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used to create a new FreeType library instance    */
+  /*    from a given memory object.  It is thus possible to use libraries  */
+  /*    with distinct memory allocators within the same program.           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    memory   :: A handle to the original memory object.                */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    alibrary :: A pointer to handle of a new library object.           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_New_Library( FT_Memory    memory,
+                  FT_Library  *alibrary );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Done_Library                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Discards a given library object.  This closes all drivers and      */
+  /*    discards all resource objects.                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A handle to the target library.                         */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Done_Library( FT_Library  library );
+
+
+
+  typedef void
+  (*FT_DebugHook_Func)( void*  arg );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_Debug_Hook                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Sets a debug hook function for debugging the interpreter of a font */
+  /*    format.                                                            */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library    :: A handle to the library object.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    hook_index :: The index of the debug hook.  You should use the     */
+  /*                  values defined in ftobjs.h, e.g.                     */
+  /*                  FT_DEBUG_HOOK_TRUETYPE.                              */
+  /*                                                                       */
+  /*    debug_hook :: The function used to debug the interpreter.          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Currently, four debug hook slots are available, but only two (for  */
+  /*    the TrueType and the Type 1 interpreter) are defined.              */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Set_Debug_Hook( FT_Library         library,
+                     FT_UInt            hook_index,
+                     FT_DebugHook_Func  debug_hook );
+
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Add_Default_Modules                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Adds the set of default drivers to a given library object.         */
+  /*    This is only useful when you create a library object with          */
+  /*    FT_New_Library() (usually to plug a custom memory manager).        */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library :: A handle to a new library object.                       */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Add_Default_Modules( FT_Library  library );
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* __FTMODULE_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftoutln.h
@@ -1,0 +1,400 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftoutln.h                                                              */
+/*                                                                         */
+/*    Support for the FT_Outline type used to store glyph shapes of        */
+/*    most scalable font formats (specification).                          */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTOUTLN_H__
+#define __FTOUTLN_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    outline_processing                                                 */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Outline Processing                                                 */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Functions to create, transform, and render vectorial glyph images. */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains routines used to create and destroy scalable */
+  /*    glyph images known as `outlines'.  These can also be measured,     */
+  /*    transformed, and converted into bitmaps and pixmaps.               */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    FT_Outline                                                         */
+  /*    FT_Outline_Flags                                                   */
+  /*    FT_Outline_New                                                     */
+  /*    FT_Outline_Done                                                    */
+  /*    FT_Outline_Copy                                                    */
+  /*    FT_Outline_Translate                                               */
+  /*    FT_Outline_Transform                                               */
+  /*    FT_Outline_Reverse                                                 */
+  /*    FT_Outline_Check                                                   */
+  /*                                                                       */
+  /*    FT_Outline_Get_CBox                                                */
+  /*    FT_Outline_Get_BBox                                                */
+  /*                                                                       */
+  /*    FT_Outline_Get_Bitmap                                              */
+  /*    FT_Outline_Render                                                  */
+  /*                                                                       */
+  /*    FT_Outline_Decompose                                               */
+  /*    FT_Outline_Funcs                                                   */
+  /*    FT_Outline_MoveTo_Func                                             */
+  /*    FT_Outline_LineTo_Func                                             */
+  /*    FT_Outline_ConicTo_Func                                            */
+  /*    FT_Outline_CubicTo_Func                                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Decompose                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Walks over an outline's structure to decompose it into individual  */
+  /*    segments and Bezier arcs.  This function is also able to emit      */
+  /*    `move to' and `close to' operations to indicate the start and end  */
+  /*    of new contours in the outline.                                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    outline        :: A pointer to the source target.                  */
+  /*                                                                       */
+  /*    func_interface :: A table of `emitters', i.e,. function pointers   */
+  /*                      called during decomposition to indicate path     */
+  /*                      operations.                                      */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    user           :: A typeless pointer which is passed to each       */
+  /*                      emitter during the decomposition.  It can be     */
+  /*                      used to store the state during the               */
+  /*                      decomposition.                                   */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means sucess.                              */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_Decompose( FT_Outline*              outline,
+                        const FT_Outline_Funcs*  func_interface,
+                        void*                    user );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_New                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Creates a new outline of a given size.                             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library     :: A handle to the library object from where the       */
+  /*                   outline is allocated.  Note however that the new    */
+  /*                   outline will NOT necessarily be FREED, when         */
+  /*                   destroying the library, by FT_Done_FreeType().      */
+  /*                                                                       */
+  /*    numPoints   :: The maximal number of points within the outline.    */
+  /*                                                                       */
+  /*    numContours :: The maximal number of contours within the outline.  */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    anoutline   :: A handle to the new outline.  NULL in case of       */
+  /*                   error.                                              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The reason why this function takes a `library' parameter is simply */
+  /*    to use the library's memory allocator.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_New( FT_Library   library,
+                  FT_UInt      numPoints,
+                  FT_Int       numContours,
+                  FT_Outline  *anoutline );
+
+
+  FT_EXPORT( FT_Error )
+  FT_Outline_New_Internal( FT_Memory    memory,
+                           FT_UInt      numPoints,
+                           FT_Int       numContours,
+                           FT_Outline  *anoutline );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Done                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroys an outline created with FT_Outline_New().                 */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A handle of the library object used to allocate the     */
+  /*               outline.                                                */
+  /*                                                                       */
+  /*    outline :: A pointer to the outline object to be discarded.        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    If the outline's `owner' field is not set, only the outline        */
+  /*    descriptor will be released.                                       */
+  /*                                                                       */
+  /*    The reason why this function takes an `library' parameter is       */
+  /*    simply to use FT_Free().                                           */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_Done( FT_Library   library,
+                   FT_Outline*  outline );
+
+
+  FT_EXPORT( FT_Error )
+  FT_Outline_Done_Internal( FT_Memory    memory,
+                            FT_Outline*  outline );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Check                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Check the contents of an outline descriptor.                       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    outline :: A handle to a source outline.                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_Check( FT_Outline*  outline );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Get_CBox                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Returns an outline's `control box'.  The control box encloses all  */
+  /*    the outline's points, including Bezier control points.  Though it  */
+  /*    coincides with the exact bounding box for most glyphs, it can be   */
+  /*    slightly larger in some situations (like when rotating an outline  */
+  /*    which contains Bezier outside arcs).                               */
+  /*                                                                       */
+  /*    Computing the control box is very fast, while getting the bounding */
+  /*    box can take much more time as it needs to walk over all segments  */
+  /*    and arcs in the outline.  To get the latter, you can use the       */
+  /*    `ftbbox' component which is dedicated to this single task.         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    outline :: A pointer to the source outline descriptor.             */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    acbox   :: The outline's control box.                              */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Outline_Get_CBox( FT_Outline*  outline,
+                       FT_BBox     *acbox );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Translate                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Applies a simple translation to the points of an outline.          */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    outline :: A pointer to the target outline descriptor.             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    xOffset :: The horizontal offset.                                  */
+  /*                                                                       */
+  /*    yOffset :: The vertical offset.                                    */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Outline_Translate( FT_Outline*  outline,
+                        FT_Pos       xOffset,
+                        FT_Pos       yOffset );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Copy                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Copies an outline into another one.  Both objects must have the    */
+  /*    same sizes (number of points & number of contours) when this       */
+  /*    function is called.                                                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    source :: A handle to the source outline.                          */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    target :: A handle to the target outline.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_Copy( FT_Outline*  source,
+                   FT_Outline  *target );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Transform                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Applies a simple 2x2 matrix to all of an outline's points.  Useful */
+  /*    for applying rotations, slanting, flipping, etc.                   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    outline :: A pointer to the target outline descriptor.             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    matrix  :: A pointer to the transformation matrix.                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You can use FT_Outline_Translate() if you need to translate the    */
+  /*    outline's points.                                                  */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Outline_Transform( FT_Outline*  outline,
+                        FT_Matrix*   matrix );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Reverse                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Reverses the drawing direction of an outline.  This is used to     */
+  /*    ensure consistent fill conventions for mirrored glyphs.            */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    outline :: A pointer to the target outline descriptor.             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This functions toggles the bit flag `FT_OUTLINE_REVERSE_FILL' in   */
+  /*    the outline's `flags' field.                                       */
+  /*                                                                       */
+  /*    It shouldn't be used by a normal client application, unless it     */
+  /*    knows what it is doing.                                            */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Outline_Reverse( FT_Outline*  outline );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Get_Bitmap                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Renders an outline within a bitmap.  The outline's image is simply */
+  /*    OR-ed to the target bitmap.                                        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A handle to a FreeType library object.                  */
+  /*                                                                       */
+  /*    outline :: A pointer to the source outline descriptor.             */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    abitmap :: A pointer to the target bitmap descriptor.              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function does NOT CREATE the bitmap, it only renders an       */
+  /*    outline image within the one you pass to it!                       */
+  /*                                                                       */
+  /*    It will use the raster correponding to the default glyph format.   */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_Get_Bitmap( FT_Library   library,
+                         FT_Outline*  outline,
+                         FT_Bitmap   *abitmap );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Outline_Render                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Renders an outline within a bitmap using the current scan-convert. */
+  /*    This functions uses an FT_Raster_Params structure as an argument,  */
+  /*    allowing advanced features like direct composition, translucency,  */
+  /*    etc.                                                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A handle to a FreeType library object.                  */
+  /*                                                                       */
+  /*    outline :: A pointer to the source outline descriptor.             */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    params  :: A pointer to a FT_Raster_Params structure used to       */
+  /*               describe the rendering operation.                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You should know what you are doing and how FT_Raster_Params works  */
+  /*    to use this function.                                              */
+  /*                                                                       */
+  /*    The field `params.source' will be set to `outline' before the scan */
+  /*    converter is called, which means that the value you give to it is  */
+  /*    actually ignored.                                                  */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Outline_Render( FT_Library         library,
+                     FT_Outline*        outline,
+                     FT_Raster_Params*  params );
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* __FTOUTLN_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftpfr.h
@@ -1,0 +1,156 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftpfr.h                                                                */
+/*                                                                         */
+/*    FreeType API for accessing PFR-specific data                         */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTPFR_H__
+#define __FTPFR_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    pfr_fonts                                                          */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    PFR Fonts                                                          */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    PFR/TrueDoc specific APIs                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the declaration of PFR-specific functions.   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_Get_PFR_Metrics
+  *
+  * @description:
+  *    returns the outline and metrics resolutions of a given PFR
+  *    face.
+  *
+  * @input:
+  *    face :: handle to input face. It can be a non-PFR face.
+  *
+  * @output:
+  *    aoutline_resolution ::
+  *      outline resolution. This is equivalent to "face->units_per_EM".
+  *      optional (parameter can be NULL)
+  *
+  *    ametrics_resolution ::
+  *      metrics_resolution. This is equivalent to "outline_resolution"
+  *      for non-PFR fonts. can be NULL
+  *      optional (parameter can be NULL)
+  *
+  *    ametrics_x_scale ::
+  *      a 16.16 fixed-point number used to scale distance expressed
+  *      in metrics units to device sub-pixels. This is equivalent to
+  *      'face->size->x_scale', but for metrics only.
+  *      optional (parameter can be NULL)
+  *
+  *    ametrics_y_scale ::
+  *      same as 'ametrics_x_scale', but for the vertical direction.
+  *      optional (parameter can be NULL)
+  *
+  * @note:
+  *   if the input face is not a PFR, this function will return an error.
+  *   However, in all cases, it will return valid values.
+  */
+  FT_EXPORT( FT_Error )
+  FT_Get_PFR_Metrics( FT_Face     face,
+                      FT_UInt    *aoutline_resolution,
+                      FT_UInt    *ametrics_resolution,
+                      FT_Fixed   *ametrics_x_scale,
+                      FT_Fixed   *ametrics_y_scale );
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_Get_PFR_Kerning
+  *
+  * @description:
+  *    returns the kerning pair corresponding to two glyphs in
+  *    a PFR face. The distance is expressed in metrics units, unlike
+  *    the result of @FT_Get_Kerning.
+  *
+  * @input:
+  *    face :: handle to input face.
+  *    left  :: left glyph index
+  *    right :: right glyph index
+  *
+  * @output:
+  *    avector :: kerning vector
+  *
+  * @note:
+  *    this function always return distances in original PFR metrics
+  *    units. This is unlike @FT_Get_Kerning with the @FT_KERNING_UNSCALED
+  *    mode, which always return distances converted to outline units.
+  *
+  *    you can use the value of the 'x_scale' and 'y_scale' parameters
+  *    returned by @FT_Get_PFR_Metrics to scale these to device sub-pixels
+  */
+  FT_EXPORT( FT_Error )
+  FT_Get_PFR_Kerning( FT_Face     face,
+                      FT_UInt     left,
+                      FT_UInt     right,
+                      FT_Vector  *avector );
+
+ /**********************************************************************
+  *
+  * @function:
+  *    FT_Get_PFR_Advance
+  *
+  * @description:
+  *    returns a given glyph advance, expressed in original metrics units,
+  *    from a PFR font.
+  *
+  * @input:
+  *    face   :: handle to input face.
+  *    gindex :: glyph index
+  *
+  * @output:
+  *    aadvance :: glyph advance in metrics units
+  *
+  * @return:
+  *    error code. 0 means success
+  *
+  * @note:
+  *    you can use the 'x_scale' or 'y_scale' results of @FT_Get_PFR_Metrics
+  *    to convert the advance to device sub-pixels (i.e. 1/64th of pixels)
+  */
+  FT_EXPORT( FT_Error )
+  FT_Get_PFR_Advance( FT_Face    face,
+                      FT_UInt    gindex,
+                      FT_Pos    *aadvance );
+
+ /* */
+
+FT_END_HEADER
+
+#endif /* __FTBDF_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftrender.h
@@ -1,0 +1,229 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftrender.h                                                             */
+/*                                                                         */
+/*    FreeType renderer modules public interface (specification).          */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTRENDER_H__
+#define __FTRENDER_H__
+
+
+#include <ft2build.h>
+#include FT_MODULE_H
+#include FT_GLYPH_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    module_management                                                  */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* create a new glyph object */
+  typedef FT_Error
+  (*FT_Glyph_InitFunc)( FT_Glyph      glyph,
+                        FT_GlyphSlot  slot );
+
+  /* destroys a given glyph object */
+  typedef void
+  (*FT_Glyph_DoneFunc)( FT_Glyph  glyph );
+
+  typedef void
+  (*FT_Glyph_TransformFunc)( FT_Glyph    glyph,
+                             FT_Matrix*  matrix,
+                             FT_Vector*  delta );
+
+  typedef void
+  (*FT_Glyph_GetBBoxFunc)( FT_Glyph  glyph,
+                           FT_BBox*  abbox );
+
+  typedef FT_Error
+  (*FT_Glyph_CopyFunc)( FT_Glyph   source,
+                        FT_Glyph   target );
+
+  typedef FT_Error
+  (*FT_Glyph_PrepareFunc)( FT_Glyph      glyph,
+                           FT_GlyphSlot  slot );
+
+/* deprecated */
+#define FT_Glyph_Init_Func       FT_Glyph_InitFunc
+#define FT_Glyph_Done_Func       FT_Glyph_DoneFunc
+#define FT_Glyph_Transform_Func  FT_Glyph_TransformFunc
+#define FT_Glyph_BBox_Func       FT_Glyph_GetBBoxFunc
+#define FT_Glyph_Copy_Func       FT_Glyph_CopyFunc
+#define FT_Glyph_Prepare_Func    FT_Glyph_PrepareFunc
+
+
+  struct  FT_Glyph_Class_
+  {
+    FT_Long                 glyph_size;
+    FT_Glyph_Format         glyph_format;
+    FT_Glyph_InitFunc       glyph_init;
+    FT_Glyph_DoneFunc       glyph_done;
+    FT_Glyph_CopyFunc       glyph_copy;
+    FT_Glyph_TransformFunc  glyph_transform;
+    FT_Glyph_GetBBoxFunc    glyph_bbox;
+    FT_Glyph_PrepareFunc    glyph_prepare;
+  };
+
+
+  typedef FT_Error
+  (*FT_Renderer_RenderFunc)( FT_Renderer   renderer,
+                             FT_GlyphSlot  slot,
+                             FT_UInt       mode,
+                             FT_Vector*    origin );
+
+  typedef FT_Error
+  (*FT_Renderer_TransformFunc)( FT_Renderer   renderer,
+                                FT_GlyphSlot  slot,
+                                FT_Matrix*    matrix,
+                                FT_Vector*    delta );
+
+
+  typedef void
+  (*FT_Renderer_GetCBoxFunc)( FT_Renderer   renderer,
+                              FT_GlyphSlot  slot,
+                              FT_BBox*      cbox );
+
+
+  typedef FT_Error
+  (*FT_Renderer_SetModeFunc)( FT_Renderer  renderer,
+                              FT_ULong     mode_tag,
+                              FT_Pointer   mode_ptr );
+
+/* deprecated identifiers */
+#define FTRenderer_render  FT_Renderer_RenderFunc
+#define FTRenderer_transform  FT_Renderer_TransformFunc
+#define FTRenderer_getCBox  FT_Renderer_GetCBoxFunc
+#define FTRenderer_setMode  FT_Renderer_SetModeFunc
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Renderer_Class                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The renderer module class descriptor.                              */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    root         :: The root FT_Module_Class fields.                   */
+  /*                                                                       */
+  /*    glyph_format :: The glyph image format this renderer handles.      */
+  /*                                                                       */
+  /*    render_glyph :: A method used to render the image that is in a     */
+  /*                    given glyph slot into a bitmap.                    */
+  /*                                                                       */
+  /*    set_mode     :: A method used to pass additional parameters.       */
+  /*                                                                       */
+  /*    raster_class :: For `FT_GLYPH_FORMAT_OUTLINE' renderers only, this */
+  /*                    is a pointer to its raster's class.                */
+  /*                                                                       */
+  /*    raster       :: For `FT_GLYPH_FORMAT_OUTLINE' renderers only. this */
+  /*                    is a pointer to the corresponding raster object,   */
+  /*                    if any.                                            */
+  /*                                                                       */
+  typedef struct  FT_Renderer_Class_
+  {
+    FT_Module_Class       root;
+
+    FT_Glyph_Format       glyph_format;
+
+    FT_Renderer_RenderFunc     render_glyph;
+    FT_Renderer_TransformFunc  transform_glyph;
+    FT_Renderer_GetCBoxFunc    get_glyph_cbox;
+    FT_Renderer_SetModeFunc    set_mode;
+
+    FT_Raster_Funcs*           raster_class;
+
+  } FT_Renderer_Class;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Renderer                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieves the current renderer for a given glyph format.           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library :: A handle to the library object.                         */
+  /*                                                                       */
+  /*    format  :: The glyph format.                                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A renderer handle.  0 if none found.                               */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    An error will be returned if a module already exists by that name, */
+  /*    or if the module requires a version of FreeType that is too great. */
+  /*                                                                       */
+  /*    To add a new renderer, simply use FT_Add_Module().  To retrieve a  */
+  /*    renderer by its name, use FT_Get_Module().                         */
+  /*                                                                       */
+  FT_EXPORT( FT_Renderer )
+  FT_Get_Renderer( FT_Library       library,
+                   FT_Glyph_Format  format );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Set_Renderer                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Sets the current renderer to use, and set additional mode.         */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    library    :: A handle to the library object.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    renderer   :: A handle to the renderer object.                     */
+  /*                                                                       */
+  /*    num_params :: The number of additional parameters.                 */
+  /*                                                                       */
+  /*    parameters :: Additional parameters.                               */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    In case of success, the renderer will be used to convert glyph     */
+  /*    images in the renderer's known format into bitmaps.                */
+  /*                                                                       */
+  /*    This doesn't change the current renderer for other formats.        */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Set_Renderer( FT_Library     library,
+                   FT_Renderer    renderer,
+                   FT_UInt        num_params,
+                   FT_Parameter*  parameters );
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* __FTRENDER_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftsizes.h
@@ -1,0 +1,151 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftsizes.h                                                              */
+/*                                                                         */
+/*    FreeType size objects management (specification).                    */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Typical application would normally not need to use these functions.   */
+  /* However, they have been placed in a public API for the rare cases     */
+  /* where they are needed.                                                */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __FTSIZES_H__
+#define __FTSIZES_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    sizes_management                                                   */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Size management                                                    */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Managing multiple sizes per face                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    When creating a new face object (e.g. with @FT_New_Face), an       */
+  /*    @FT_Size object is automatically created and used to store all     */
+  /*    pixel-size dependent information, available in the "face->size"    */
+  /*    field.                                                             */
+  /*                                                                       */
+  /*    It is however possible to create more sizes for a given face,      */
+  /*    mostly in order to manage several character pixel sizes of the     */
+  /*    same font family and style.  See @FT_New_Size and @FT_Done_Size.   */
+  /*                                                                       */
+  /*    Note that @FT_Set_Pixel_Sizes and @FT_Set_Char_Size only           */
+  /*    modify the contents of the current "active" size; you thus need    */
+  /*    to use @FT_Activate_Size to change it.                             */
+  /*                                                                       */
+  /*    99% of applications won't need the functions provided here,        */
+  /*    especially if they use the caching sub-system, so be cautious      */
+  /*    when using these.                                                  */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Size                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Creates a new size object from a given face object.                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to a parent face object.                          */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    asize :: A handle to a new size object.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You need to call @FT_Activate_Size in order to select the new size */
+  /*    for upcoming calls to @FT_Set_Pixel_Sizes, @FT_Set_Char_Size,      */
+  /*    @FT_Load_Glyph, @FT_Load_Char, etc.                                */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_New_Size( FT_Face   face,
+               FT_Size*  size );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Done_Size                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Discards a given size object.                                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    size :: A handle to a target size object.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Done_Size( FT_Size  size );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Activate_Size                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Even though it is possible to create several size objects for a    */
+  /*    given face (see @FT_New_Size for details), functions like          */
+  /*    @FT_Load_Glyph or @FT_Load_Char only use the last-created one to   */
+  /*    determine the "current character pixel size".                      */
+  /*                                                                       */
+  /*    This function can be used to "activate" a previously created size  */
+  /*    object.                                                            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    size :: A handle to a target size object.                          */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    If "face" is the size's parent face object, this function changes  */
+  /*    the value of "face->size" to the input size handle.                */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Activate_Size( FT_Size  size );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* __FTSIZES_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftsnames.h
@@ -1,0 +1,161 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftsnames.h                                                             */
+/*                                                                         */
+/*    Simple interface to access SFNT name tables (which are used          */
+/*    to hold font names, copyright info, notices, etc.) (specification).  */
+/*                                                                         */
+/*    This is _not_ used to retrieve glyph names!                          */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FT_SFNT_NAMES_H__
+#define __FT_SFNT_NAMES_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    sfnt_names                                                         */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    SFNT Names                                                         */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Access the names embedded in TrueType and OpenType files.          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The TrueType and OpenType specification allow the inclusion of     */
+  /*    a special `names table' in font files.  This table contains        */
+  /*    textual (and internationalized) information regarding the font,    */
+  /*    like family name, copyright, version, etc.                         */
+  /*                                                                       */
+  /*    The definitions below are used to access them if available.        */
+  /*                                                                       */
+  /*    Note that this has nothing to do with glyph names!                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_SfntName                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model an SFNT `name' table entry.              */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    platform_id :: The platform ID for `string'.                       */
+  /*                                                                       */
+  /*    encoding_id :: The encoding ID for `string'.                       */
+  /*                                                                       */
+  /*    language_id :: The language ID for `string'.                       */
+  /*                                                                       */
+  /*    name_id     :: An identifier for `string'.                         */
+  /*                                                                       */
+  /*    string      :: The `name' string.  Note that its format differs    */
+  /*                   depending on the (platform,encoding) pair. It can   */
+  /*                   be a Pascal String, a UTF-16 one, etc..             */
+  /*                                                                       */
+  /*                   Generally speaking, the string is not               */
+  /*                   zero-terminated. Please refer to the TrueType       */
+  /*                   specification for details..                         */
+  /*                                                                       */
+  /*    string_len  :: The length of `string' in bytes.                    */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Possible values for `platform_id', `encoding_id', `language_id',   */
+  /*    and `name_id' are given in the file `ttnameid.h'.  For details     */
+  /*    please refer to the TrueType or OpenType specification.            */
+  /*                                                                       */
+  typedef struct  FT_SfntName_
+  {
+    FT_UShort  platform_id;
+    FT_UShort  encoding_id;
+    FT_UShort  language_id;
+    FT_UShort  name_id;
+
+    FT_Byte*   string;      /* this string is *not* null-terminated! */
+    FT_UInt    string_len;  /* in bytes */
+
+  } FT_SfntName;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Sfnt_Name_Count                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieves the number of name strings in the SFNT `name' table.     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to the source face.                               */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The number of strings in the `name' table.                         */
+  /*                                                                       */
+  FT_EXPORT( FT_UInt )
+  FT_Get_Sfnt_Name_Count( FT_Face  face );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Sfnt_Name                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieves a string of the SFNT `name' table for a given index.     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face  :: A handle to the source face.                              */
+  /*                                                                       */
+  /*    idx   :: The index of the `name' string.                           */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aname :: The indexed FT_SfntName structure.                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The `string' array returned in the `aname' structure is not        */
+  /*    null-terminated.                                                   */
+  /*                                                                       */
+  /*    Use FT_Get_Sfnt_Name_Count() to get the total number of available  */
+  /*    `name' table entries, then do a loop until you get the right       */
+  /*    platform, encoding, and name ID.                                   */
+  /*                                                                       */
+  FT_EXPORT( FT_Error )
+  FT_Get_Sfnt_Name( FT_Face       face,
+                    FT_UInt       idx,
+                    FT_SfntName  *aname );
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* __FT_SFNT_NAMES_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftstroker.h
@@ -1,0 +1,139 @@
+#ifndef __FT_STROKER_H__
+#define __FT_STROKER_H__
+
+#include <ft2build.h>
+#include FT_OUTLINE_H
+
+FT_BEGIN_HEADER
+
+/*@*************************************************************
+ *
+ * @type: FT_Stroker
+ *
+ * @description:
+ *    opaque handler to a path stroker object
+ */
+  typedef struct FT_StrokerRec_*    FT_Stroker;
+
+
+/*@*************************************************************
+ *
+ * @enum: FT_Stroker_LineJoin
+ *
+ * @description:
+ *    these values determine how two joining lines are rendered
+ *    in a stroker.
+ *
+ * @values:
+ *    FT_STROKER_LINEJOIN_ROUND ::
+ *      used to render rounded line joins. circular arcs are used
+ *      to join two lines smoothly
+ *
+ *    FT_STROKER_LINEJOIN_BEVEL ::
+ *      used to render beveled line joins; i.e. the two joining lines
+ *      are extended until they intersect
+ *
+ *    FT_STROKER_LINEJOIN_MITER ::
+ *      same as beveled rendering, except that an additional line
+ *      break is added if the angle between the two joining lines
+ *      is too closed (this is useful to avoid unpleasant spikes
+ *      in beveled rendering).
+ */
+  typedef enum
+  {
+    FT_STROKER_LINEJOIN_ROUND = 0,
+    FT_STROKER_LINEJOIN_BEVEL,
+    FT_STROKER_LINEJOIN_MITER
+
+  } FT_Stroker_LineJoin;
+
+
+/*@*************************************************************
+ *
+ * @enum: FT_Stroker_LineCap
+ *
+ * @description:
+ *    these values determine how the end of opened sub-paths are
+ *    rendered in a stroke
+ *
+ * @values:
+ *    FT_STROKER_LINECAP_BUTT ::
+ *      the end of lines is rendered as a full stop on the last
+ *      point itself
+ *
+ *    FT_STROKER_LINECAP_ROUND ::
+ *      the end of lines is rendered as a half-circle around the
+ *      last point
+ *
+ *    FT_STROKER_LINECAP_SQUARE ::
+ *      the end of lines is rendered as a square around the
+ *      last point
+ */
+  typedef enum
+  {
+    FT_STROKER_LINECAP_BUTT = 0,
+    FT_STROKER_LINECAP_ROUND,
+    FT_STROKER_LINECAP_SQUARE
+
+  } FT_Stroker_LineCap;
+
+ /* */
+
+  FT_EXPORT( FT_Error )
+  FT_Stroker_New( FT_Memory    memory,
+                  FT_Stroker  *astroker );
+
+  FT_EXPORT( void )
+  FT_Stroker_Set( FT_Stroker           stroker,
+                  FT_Fixed             radius,
+                  FT_Stroker_LineCap   line_cap,
+                  FT_Stroker_LineJoin  line_join,
+                  FT_Fixed             miter_limit );
+
+
+  FT_EXPORT( FT_Error )
+  FT_Stroker_ParseOutline( FT_Stroker   stroker,
+                           FT_Outline*  outline,
+                           FT_Bool      opened );
+
+  FT_EXPORT( FT_Error )
+  FT_Stroker_BeginSubPath( FT_Stroker  stroker,
+                           FT_Vector*  to,
+                           FT_Bool     open );
+
+  FT_EXPORT( FT_Error )
+  FT_Stroker_EndSubPath( FT_Stroker  stroker );
+
+
+  FT_EXPORT( FT_Error )
+  FT_Stroker_LineTo( FT_Stroker  stroker,
+                     FT_Vector*  to );
+
+  FT_EXPORT( FT_Error )
+  FT_Stroker_ConicTo( FT_Stroker  stroker,
+                      FT_Vector*  control,
+                      FT_Vector*  to );
+
+  FT_EXPORT( FT_Error )
+  FT_Stroker_CubicTo( FT_Stroker  stroker,
+                      FT_Vector*  control1,
+                      FT_Vector*  control2,
+                      FT_Vector*  to );
+
+
+  FT_EXPORT( FT_Error )
+  FT_Stroker_GetCounts( FT_Stroker  stroker,
+                        FT_UInt    *anum_points,
+                        FT_UInt    *anum_contours );
+
+  FT_EXPORT( void )
+  FT_Stroker_Export( FT_Stroker   stroker,
+                     FT_Outline*  outline );
+
+  FT_EXPORT( void )
+  FT_Stroker_Done( FT_Stroker  stroker );
+
+
+FT_END_HEADER
+
+#endif /* __FT_STROKER_H__ */
--- /dev/null
+++ b/include/freetype/ftsynth.h
@@ -1,0 +1,65 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftsynth.h                                                              */
+/*                                                                         */
+/*    FreeType synthesizing code for emboldening and slanting              */
+/*    (specification).                                                     */
+/*                                                                         */
+/*  Copyright 2000-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*********                                                       *********/
+  /*********        WARNING, THIS IS ALPHA CODE, THIS API          *********/
+  /*********    IS DUE TO CHANGE UNTIL STRICTLY NOTIFIED BY THE    *********/
+  /*********            FREETYPE DEVELOPMENT TEAM                  *********/
+  /*********                                                       *********/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+#ifndef __FTSYNTH_H__
+#define __FTSYNTH_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /* This code is completely experimental -- use with care! */
+  /* It will probably be completely rewritten in the future */
+  /* or even integrated into the library.                   */
+  FT_EXPORT( void )
+  FT_GlyphSlot_Embolden( FT_GlyphSlot  slot );
+
+
+  FT_EXPORT( void )
+  FT_GlyphSlot_Oblique( FT_GlyphSlot  slot );
+
+ /* */
+
+FT_END_HEADER
+
+#endif /* __FTSYNTH_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftsysio.h
@@ -1,0 +1,195 @@
+#ifndef __FT_SYSTEM_IO_H__
+#define __FT_SYSTEM_IO_H__
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****    NOTE: THE CONTENT OF THIS FILE IS NOT CURRENTLY USED      *****/
+ /*****          IN NORMAL BUILDS.  CONSIDER IT EXPERIMENTAL.        *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+
+ /********************************************************************
+  *
+  *  designing custom streams is a bit different now
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  *
+  */
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECT_H
+
+FT_BEGIN_HEADER
+
+ /*@*******************************************************************
+  *
+  * @type: FT_Stream
+  *
+  * @description:
+  *   handle to an input stream object. These are also @FT_Object handles
+  */
+  typedef struct FT_StreamRec_*    FT_Stream;
+
+
+ /*@*******************************************************************
+  *
+  * @type: FT_Stream_Class
+  *
+  * @description:
+  *   opaque handle to a @FT_Stream_ClassRec class structure describing
+  *   the methods of input streams
+  */
+  typedef const struct FT_Stream_ClassRec_*   FT_Stream_Class;
+
+
+ /*@*******************************************************************
+  *
+  * @functype: FT_Stream_ReadFunc
+  *
+  * @description:
+  *   a method used to read bytes from an input stream into memory
+  *
+  * @input:
+  *   stream  :: target stream handle
+  *   buffer  :: target buffer address
+  *   size    :: number of bytes to read
+  *
+  * @return:
+  *   number of bytes effectively read. Must be <= 'size'.
+  */
+  typedef FT_ULong  (*FT_Stream_ReadFunc)( FT_Stream   stream,
+                                           FT_Byte*    buffer,
+                                           FT_ULong    size );
+
+
+ /*@*******************************************************************
+  *
+  * @functype: FT_Stream_SeekFunc
+  *
+  * @description:
+  *   a method used to seek to a new position within a stream
+  *
+  * @input:
+  *   stream  :: target stream handle
+  *   pos     :: new read position, from start of stream
+  *
+  * @return:
+  *   error code. 0 means success
+  */
+  typedef FT_Error  (*FT_Stream_SeekFunc)( FT_Stream   stream,
+                                           FT_ULong    pos );
+
+
+ /*@*******************************************************************
+  *
+  * @struct: FT_Stream_ClassRec
+  *
+  * @description:
+  *   a structure used to describe an input stream class
+  *
+  * @input:
+  *   clazz       :: root @FT_ClassRec fields
+  *   stream_read :: stream byte read method
+  *   stream_seek :: stream seek method
+  */
+  typedef struct FT_Stream_ClassRec_
+  {
+    FT_ClassRec          clazz;
+    FT_Stream_ReadFunc   stream_read;
+    FT_Stream_SeekFunc   stream_seek;
+
+  } FT_Stream_ClassRec;
+
+ /* */
+
+#define  FT_STREAM_CLASS(x)        ((FT_Stream_Class)(x))
+#define  FT_STREAM_CLASS__READ(x)  FT_STREAM_CLASS(x)->stream_read
+#define  FT_STREAM_CLASS__SEEK(x)  FT_STREAM_CLASS(x)->stream_seek;
+
+ /*@*******************************************************************
+  *
+  * @struct: FT_StreamRec
+  *
+  * @description:
+  *   the input stream object structure. See @FT_Stream_ClassRec for
+  *   its class descriptor
+  *
+  * @fields:
+  *   object      :: root @FT_ObjectRec fields
+  *   size        :: size of stream in bytes (0 if unknown)
+  *   pos         :: current position within stream
+  *   base        :: for memory-based streams, the address of the stream's
+  *                  first data byte in memory. NULL otherwise
+  *
+  *   cursor      :: the current cursor position within an input stream
+  *                  frame. Only valid within a FT_FRAME_ENTER .. FT_FRAME_EXIT
+  *                  block; NULL otherwise
+  *
+  *   limit       :: the current frame limit within a FT_FRAME_ENTER ..
+  *                  FT_FRAME_EXIT block. NULL otherwise
+  */
+  typedef struct FT_StreamRec_
+  {
+    FT_ObjectRec        object;
+    FT_ULong            size;
+    FT_ULong            pos;
+    const FT_Byte*      base;
+    const FT_Byte*      cursor;
+    const FT_Byte*      limit;
+
+  } FT_StreamRec;
+
+ /* some useful macros */
+#define  FT_STREAM(x)    ((FT_Stream)(x))
+#define  FT_STREAM_P(x)  ((FT_Stream*)(x))
+
+#define  FT_STREAM__READ(x)  FT_STREAM_CLASS__READ(FT_OBJECT__CLASS(x))
+#define  FT_STREAM__SEEK(x)  FT_STREAM_CLASS__SEEK(FT_OBJECT__CLASS(x))
+
+#define  FT_STREAM_IS_BASED(x)  ( FT_STREAM(x)->base != NULL )
+
+ /* */
+
+ /* create new memory-based stream */
+  FT_BASE( FT_Error )   ft_stream_new_memory( const FT_Byte*  stream_base,
+                                              FT_ULong        stream_size,
+                                              FT_Memory       memory,
+                                              FT_Stream      *astream );
+
+  FT_BASE( FT_Error )   ft_stream_new_iso( const char*  pathanme,
+                                           FT_Memory    memory,
+                                           FT_Stream   *astream );
+
+
+ /* handle to default stream class implementation for a given build */
+ /* this is used by "FT_New_Face"                                   */
+ /*                                                                 */
+  FT_APIVAR( FT_Type )   ft_stream_default_type;
+
+FT_END_HEADER
+
+#endif /* __FT_SYSTEM_STREAM_H__ */
--- /dev/null
+++ b/include/freetype/ftsysmem.h
@@ -1,0 +1,202 @@
+#ifndef __FT_SYSTEM_MEMORY_H__
+#define __FT_SYSTEM_MEMORY_H__
+
+#include <ft2build.h>
+
+FT_BEGIN_HEADER
+
+ /************************************************************************/
+ /************************************************************************/
+ /*****                                                              *****/
+ /*****    NOTE: THE CONTENT OF THIS FILE IS NOT CURRENTLY USED      *****/
+ /*****          IN NORMAL BUILDS.  CONSIDER IT EXPERIMENTAL.        *****/
+ /*****                                                              *****/
+ /************************************************************************/
+ /************************************************************************/
+
+
+ /*@**********************************************************************
+  *
+  * @type: FT_Memory
+  *
+  * @description:
+  *   opaque handle to a memory manager handle. Note that since FreeType
+  *   2.2, the memory manager structure FT_MemoryRec is hidden to client
+  *   applications.
+  *
+  *   however, you can still define custom allocators easily using the
+  *   @ft_memory_new API
+  */
+  typedef struct FT_MemoryRec_*   FT_Memory;
+
+
+ /*@**********************************************************************
+  *
+  * @functype: FT_Memory_AllocFunc
+  *
+  * @description:
+  *   a function used to allocate a block of memory.
+  *
+  * @input:
+  *   size     :: size of blocks in bytes. Always > 0 !!
+  *   mem_data :: memory-manager specific optional argument
+  *               (see @ft_memory_new)
+  *
+  * @return:
+  *   address of new block. NULL in case of memory exhaustion
+  */
+  typedef FT_Pointer  (*FT_Memory_AllocFunc)( FT_ULong   size,
+                                              FT_Pointer mem_data );
+
+
+ /*@**********************************************************************
+  *
+  * @functype: FT_Memory_FreeFunc
+  *
+  * @description:
+  *   a function used to release a block of memory created through
+  *   @FT_Memory_AllocFunc or @FT_Memory_ReallocFunc
+  *
+  * @input:
+  *   block    :: address of target memory block. cannot be NULL !!
+  *   mem_data :: memory-manager specific optional argument
+  *               (see @ft_memory_new)
+  */
+  typedef void        (*FT_Memory_FreeFunc) ( FT_Pointer  block,
+                                              FT_Pointer  mem_data );
+
+
+ /*@**********************************************************************
+  *
+  * @functype: FT_Memory_ReallocFunc
+  *
+  * @description:
+  *   a function used to reallocate a memory block.
+  *
+  * @input:
+  *   block    :: address of target memory block. cannot be NULL !!
+  *   new_size :: new requested size in bytes
+  *   cur_size :: current block size in bytes
+  *   mem_data :: memory-manager specific optional argument
+  *               (see @ft_memory_new)
+  */
+  typedef FT_Pointer  (*FT_Memory_ReallocFunc)( FT_Pointer   block,
+                                                FT_ULong     new_size,
+                                                FT_ULong     cur_size,
+                                                FT_Pointer   mem_data );
+
+
+ /*@**********************************************************************
+  *
+  * @functype: FT_Memory_CreateFunc
+  *
+  * @description:
+  *   a function used to create a @FT_Memory object to model a
+  *   memory manager
+  *
+  * @input:
+  *   size      :: size of memory manager structure in bytes
+  *   init_data :: optional initialisation argument
+  *
+  * @output:
+  *   amem_data :: memory-manager specific argument to block management
+  *                routines.
+  *
+  * @return:
+  *   handle to new memory manager object. NULL in case of failure
+  */
+  typedef FT_Pointer  (*FT_Memory_CreateFunc)( FT_UInt     size,
+                                               FT_Pointer  init_data,
+                                               FT_Pointer *amem_data );
+
+
+ /*@**********************************************************************
+  *
+  * @functype: FT_Memory_DestroyFunc
+  *
+  * @description:
+  *   a function used to destroy a given @FT_Memory manager
+  *
+  * @input:
+  *   memory   :: target memory manager handle
+  *   mem_data :: option manager-specific argument
+  */
+  typedef void        (*FT_Memory_DestroyFunc)( FT_Memory  memory,
+                                                FT_Pointer mem_data );
+
+
+ /*@**********************************************************************
+  *
+  * @struct: FT_Memory_FuncsRec
+  *
+  * @description:
+  *   a function used to hold all methods of a given memory manager
+  *   implementation.
+  *
+  * @fields:
+  *   mem_alloc   :: block allocation routine
+  *   mem_free    :: block release routine
+  *   mem_realloc :: block re-allocation routine
+  *   mem_create  :: manager creation routine
+  *   mem_destroy :: manager destruction routine
+  */
+  typedef struct FT_Memory_FuncsRec_
+  {
+    FT_Memory_AllocFunc     mem_alloc;
+    FT_Memory_FreeFunc      mem_free;
+    FT_Memory_ReallocFunc   mem_realloc;
+    FT_Memory_CreateFunc    mem_create;
+    FT_Memory_DestroyFunc   mem_destroy;
+
+  } FT_Memory_FuncsRec, *FT_Memory_Funcs;
+
+
+ /*@**********************************************************************
+  *
+  * @type: FT_Memory_Funcs
+  *
+  * @description:
+  *   a pointer to a constant @FT_Memory_FuncsRec structure used to
+  *   describe a given memory manager implementation.
+  */
+  typedef const FT_Memory_FuncsRec*  FT_Memory_Funcs;
+
+
+ /*@**********************************************************************
+  *
+  * @function: ft_memory_new
+  *
+  * @description:
+  *   create a new memory manager, given a set of memory methods
+  *
+  * @input:
+  *   mem_funcs     :: handle to memory manager implementation descriptor
+  *   mem_init_data :: optional initialisation argument, passed to
+  *                    @FT_Memory_CreateFunc
+  *
+  * @return:
+  *   new memory manager handle. NULL in case of failure
+  */
+  FT_BASE( FT_Memory )
+  ft_memory_new( FT_Memory_Funcs  mem_funcs,
+                 FT_Pointer       mem_init_data );
+
+
+ /*@**********************************************************************
+  *
+  * @function: ft_memory_destroy
+  *
+  * @description:
+  *   destroy a given memory manager
+  *
+  * @input:
+  *   memory :: handle to target memory manager
+  */
+  FT_BASE( void )
+  ft_memory_destroy( FT_Memory  memory );
+
+/* */
+
+FT_END_HEADER
+
+#endif /* __FT_SYSTEM_MEMORY_H__ */
--- /dev/null
+++ b/include/freetype/ftsystem.h
@@ -1,0 +1,309 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftsystem.h                                                             */
+/*                                                                         */
+/*    FreeType low-level system interface definition (specification).      */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTSYSTEM_H__
+#define __FTSYSTEM_H__
+
+
+#include <ft2build.h>
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    system_interface                                                   */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    System Interface                                                   */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    How FreeType manages memory and i/o.                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains various definitions related to memory        */
+  /*    management and i/o access.  You need to understand this            */
+  /*    information if you want to use a custom memory manager or you own  */
+  /*    input i/o streams.                                                 */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                  M E M O R Y   M A N A G E M E N T                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @type:                                                                */
+  /*    FT_Memory                                                          */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A handle to a given memory manager object, defined with a          */
+  /*    @FT_MemoryRec structure.                                           */
+  /*                                                                       */
+  typedef struct FT_MemoryRec_*  FT_Memory;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    FT_Alloc_Func                                                      */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A function used to allocate `size' bytes from `memory'.            */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    memory :: A handle to the source memory manager.                   */
+  /*                                                                       */
+  /*    size   :: The size in bytes to allocate.                           */
+  /*                                                                       */
+  /* @return:                                                              */
+  /*    Address of new memory block.  0 in case of failure.                */
+  /*                                                                       */
+  typedef void*
+  (*FT_Alloc_Func)( FT_Memory  memory,
+                    long       size );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    FT_Free_Func                                                       */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A function used to release a given block of memory.                */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    memory :: A handle to the source memory manager.                   */
+  /*                                                                       */
+  /*    block  :: The address of the target memory block.                  */
+  /*                                                                       */
+  typedef void
+  (*FT_Free_Func)( FT_Memory  memory,
+                   void*      block );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    FT_Realloc_Func                                                    */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    a function used to re-allocate a given block of memory.            */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    memory   :: A handle to the source memory manager.                 */
+  /*                                                                       */
+  /*    cur_size :: The block's current size in bytes.                     */
+  /*                                                                       */
+  /*    new_size :: The block's requested new size.                        */
+  /*                                                                       */
+  /*    block    :: The block's current address.                           */
+  /*                                                                       */
+  /* @return:                                                              */
+  /*    New block address.  0 in case of memory shortage.                  */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*   In case of error, the old block must still be available.            */
+  /*                                                                       */
+  typedef void*
+  (*FT_Realloc_Func)( FT_Memory  memory,
+                      long       cur_size,
+                      long       new_size,
+                      void*      block );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @struct:                                                              */
+  /*    FT_MemoryRec                                                       */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A structure used to describe a given memory manager to FreeType 2. */
+  /*                                                                       */
+  /* @fields:                                                              */
+  /*    user    :: A generic typeless pointer for user data.               */
+  /*                                                                       */
+  /*    alloc   :: A pointer type to an allocation function.               */
+  /*                                                                       */
+  /*    free    :: A pointer type to an memory freeing function.           */
+  /*                                                                       */
+  /*    realloc :: A pointer type to a reallocation function.              */
+  /*                                                                       */
+  struct  FT_MemoryRec_
+  {
+    void*            user;
+    FT_Alloc_Func    alloc;
+    FT_Free_Func     free;
+    FT_Realloc_Func  realloc;
+  };
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                       I / O   M A N A G E M E N T                     */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @type:                                                                */
+  /*    FT_Stream                                                          */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A handle to an input stream.                                       */
+  /*                                                                       */
+  typedef struct FT_StreamRec_*  FT_Stream;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @struct:                                                              */
+  /*    FT_StreamDesc                                                      */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A union type used to store either a long or a pointer.  This is    */
+  /*    used to store a file descriptor or a FILE* in an input stream.     */
+  /*                                                                       */
+  typedef union  FT_StreamDesc_
+  {
+    long   value;
+    void*  pointer;
+
+  } FT_StreamDesc;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    FT_Stream_IoFunc                                                   */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A function used to seek and read data from a given input stream.   */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    stream :: A handle to the source stream.                           */
+  /*                                                                       */
+  /*    offset :: The offset of read in stream (always from start).        */
+  /*                                                                       */
+  /*    buffer :: The address of the read buffer.                          */
+  /*                                                                       */
+  /*    count  :: The number of bytes to read from the stream.             */
+  /*                                                                       */
+  /* @return:                                                              */
+  /*    The number of bytes effectively read by the stream.                */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    This function might be called to perform a seek or skip operation  */
+  /*    with a `count' of 0.                                               */
+  /*                                                                       */
+  typedef unsigned long
+  (*FT_Stream_IoFunc)( FT_Stream       stream,
+                       unsigned long   offset,
+                       unsigned char*  buffer,
+                       unsigned long   count );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    FT_Stream_CloseFunc                                                */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A function used to close a given input stream.                     */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*   stream :: A handle to the target stream.                            */
+  /*                                                                       */
+  typedef void
+  (*FT_Stream_CloseFunc)( FT_Stream  stream );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @struct:                                                              */
+  /*    FT_StreamRec                                                       */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*   A structure used to describe an input stream.                       */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*   base       :: For memory-based streams, this is the address of the  */
+  /*                 first stream byte in memory.  This field should       */
+  /*                 always be set to NULL for disk-based streams.         */
+  /*                                                                       */
+  /*   size       :: The stream size in bytes.                             */
+  /*                                                                       */
+  /*   pos        :: The current position within the stream.               */
+  /*                                                                       */
+  /*   descriptor :: This field is a union that can hold an integer or a   */
+  /*                 pointer.  It is used by stream implementations to     */
+  /*                 store file descriptors or FILE* pointers.             */
+  /*                                                                       */
+  /*   pathname   :: This field is completely ignored by FreeType.         */
+  /*                 However, it is often useful during debugging to use   */
+  /*                 it to store the stream's filename (where available).  */
+  /*                                                                       */
+  /*   read       :: The stream's input function.                          */
+  /*                                                                       */
+  /*   close      :: The stream;s close function.                          */
+  /*                                                                       */
+  /*   memory     :: The memory manager to use to preload frames.  This is */
+  /*                 set internally by FreeType and shouldn't be touched   */
+  /*                 by stream implementations.                            */
+  /*                                                                       */
+  /*   cursor     :: This field is set and used internally by FreeType     */
+  /*                 when parsing frames.                                  */
+  /*                                                                       */
+  /*   limit      :: This field is set and used internally by FreeType     */
+  /*                 when parsing frames.                                  */
+  /*                                                                       */
+  typedef struct  FT_StreamRec_
+  {
+    unsigned char*       base;
+    unsigned long        size;
+    unsigned long        pos;
+
+    FT_StreamDesc        descriptor;
+    FT_StreamDesc        pathname;
+    FT_Stream_IoFunc     read;
+    FT_Stream_CloseFunc  close;
+
+    FT_Memory            memory;
+    unsigned char*       cursor;
+    unsigned char*       limit;
+
+  } FT_StreamRec;
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* __FTSYSTEM_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/fttrigon.h
@@ -1,0 +1,325 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fttrigon.h                                                             */
+/*                                                                         */
+/*    FreeType trigonometric functions (specification).                    */
+/*                                                                         */
+/*  Copyright 2001 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTTRIGON_H__
+#define __FTTRIGON_H__
+
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @section:                                                             */
+  /*   computations                                                        */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @type:                                                                */
+  /*    FT_Angle                                                           */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    This type is used to model angle values in FreeType.  Note that    */
+  /*    the angle is a 16.16 fixed float value expressed in degrees.       */
+  /*                                                                       */
+  typedef FT_Fixed  FT_Angle;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_ANGLE_PI                                                        */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*   The angle pi expressed in @FT_Angle units.                          */
+  /*                                                                       */
+#define FT_ANGLE_PI  ( 180L << 16 )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_ANGLE_2PI                                                       */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    The angle 2*pi expressed in @FT_Angle units.                       */
+  /*                                                                       */
+#define FT_ANGLE_2PI  ( FT_ANGLE_PI * 2 )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_ANGLE_PI2                                                       */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    The angle pi/2 expressed in @FT_Angle units.                       */
+  /*                                                                       */
+#define FT_ANGLE_PI2  ( FT_ANGLE_PI / 2 )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @macro:                                                               */
+  /*    FT_ANGLE_PI4                                                       */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    The angle pi/4 expressed in @FT_Angle units.                       */
+  /*                                                                       */
+#define FT_ANGLE_PI4  ( FT_ANGLE_PI / 4 )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @function:                                                            */
+  /*    FT_Sin                                                             */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    Return the sinus of a given angle in fixed point format.           */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    angle :: The input angle.                                          */
+  /*                                                                       */
+  /* @return:                                                              */
+  /*    The sinus value.                                                   */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    If you need both the sinus and cosinus for a given angle, use the  */
+  /*    function @FT_Vector_Unit.                                          */
+  /*                                                                       */
+  FT_EXPORT( FT_Fixed )
+  FT_Sin( FT_Angle  angle );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @function:                                                            */
+  /*    FT_Cos                                                             */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    Return the cosinus of a given angle in fixed point format.         */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    angle :: The input angle.                                          */
+  /*                                                                       */
+  /* @return:                                                              */
+  /*    The cosinus value.                                                 */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    If you need both the sinus and cosinus for a given angle, use the  */
+  /*    function @FT_Vector_Unit.                                          */
+  /*                                                                       */
+  FT_EXPORT( FT_Fixed )
+  FT_Cos( FT_Angle  angle );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @function:                                                            */
+  /*    FT_Tan                                                             */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    Return the tangent of a given angle in fixed point format.         */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    angle :: The input angle.                                          */
+  /*                                                                       */
+  /* @return:                                                              */
+  /*    The tangent value.                                                 */
+  /*                                                                       */
+  FT_EXPORT( FT_Fixed )
+  FT_Tan( FT_Angle  angle );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @function:                                                            */
+  /*    FT_Atan2                                                           */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    Return the arc-tangent corresponding to a given vector (x,y) in    */
+  /*    the 2d plane.                                                      */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    x :: The horizontal vector coordinate.                             */
+  /*                                                                       */
+  /*    y :: The vertical vector coordinate.                               */
+  /*                                                                       */
+  /* @return:                                                              */
+  /*    The arc-tangent value (i.e. angle).                                */
+  /*                                                                       */
+  FT_EXPORT( FT_Angle )
+  FT_Atan2( FT_Fixed  x,
+            FT_Fixed  y );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @function:                                                            */
+  /*    FT_Angle_Diff                                                      */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    Return the difference between two angles.  The result is always    */
+  /*    constrained to the ]-PI..PI] interval.                             */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    angle1 :: First angle.                                             */
+  /*                                                                       */
+  /*    angle2 :: Second angle.                                            */
+  /*                                                                       */
+  /* @return:                                                              */
+  /*    Contrainted value of `value2-value1'.                              */
+  /*                                                                       */
+  FT_EXPORT( FT_Angle )
+  FT_Angle_Diff( FT_Angle  angle1,
+                 FT_Angle  angle2 );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @function:                                                            */
+  /*    FT_Vector_Unit                                                     */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    Return the unit vector corresponding to a given angle.  After the  */
+  /*    call, the value of `vec.x' will be `sin(angle)', and the value of  */
+  /*    `vec.y' will be `cos(angle)'.                                      */
+  /*                                                                       */
+  /*    This function is useful to retrieve both the sinus and cosinus of  */
+  /*    a given angle quickly.                                             */
+  /*                                                                       */
+  /* @output:                                                              */
+  /*    vec   :: The address of target vector.                             */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    angle :: The address of angle.                                     */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Vector_Unit( FT_Vector*  vec,
+                  FT_Angle    angle );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @function:                                                            */
+  /*    FT_Vector_Rotate                                                   */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    Rotate a vector by a given angle.                                  */
+  /*                                                                       */
+  /* @inout:                                                               */
+  /*    vec   :: The address of target vector.                             */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    angle :: The address of angle.                                     */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Vector_Rotate( FT_Vector*  vec,
+                    FT_Angle    angle );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @function:                                                            */
+  /*   FT_Vector_Length                                                    */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*   Return the length of a given vector.                                */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*   vec :: The address of target vector.                                */
+  /*                                                                       */
+  /* @return:                                                              */
+  /*   The vector length, expressed in the same units that the original    */
+  /*   vector coordinates.                                                 */
+  /*                                                                       */
+  FT_EXPORT( FT_Fixed )
+  FT_Vector_Length( FT_Vector*  vec );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @function:                                                            */
+  /*    FT_Vector_Normalize                                                */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    Normalize a given vector (i.e. compute the equivalent unit         */
+  /*    vector).                                                           */
+  /*                                                                       */
+  /* @inout:                                                               */
+  /*    vec :: The address of target vector.                               */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Vector_Normalize( FT_Vector*  vec );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @function:                                                            */
+  /*    FT_Vector_Polarize                                                 */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    Compute both the length and angle of a given vector.               */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    vec    :: The address of source vector.                            */
+  /*                                                                       */
+  /* @output:                                                              */
+  /*    length :: The vector length.                                       */
+  /*    angle  :: The vector angle.                                        */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Vector_Polarize( FT_Vector*  vec,
+                      FT_Fixed   *length,
+                      FT_Angle   *angle );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @function:                                                            */
+  /*    FT_Vector_From_Polar                                               */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    Compute vector coordinates from a length and angle.                */
+  /*                                                                       */
+  /* @output:                                                              */
+  /*    vec    :: The address of source vector.                            */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    length :: The vector length.                                       */
+  /*    angle  :: The vector angle.                                        */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Vector_From_Polar( FT_Vector*  vec,
+                        FT_Fixed    length,
+                        FT_Angle    angle );
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* __FTTRIGON_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/fttypes.h
@@ -1,0 +1,558 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fttypes.h                                                              */
+/*                                                                         */
+/*    FreeType simple types definitions (specification only).              */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTTYPES_H__
+#define __FTTYPES_H__
+
+
+#include <ft2build.h>
+#include FT_CONFIG_CONFIG_H
+#include FT_SYSTEM_H
+#include FT_IMAGE_H
+
+#include <stddef.h>
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    basic_types                                                        */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Basic Data Types                                                   */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    The basic data types defined by the library.                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the basic data types defined by FreeType 2,  */
+  /*    ranging from simple scalar types to bitmap descriptors.  More      */
+  /*    font-specific structures are defined in a different section.       */
+  /*                                                                       */
+  /* <Order>                                                               */
+  /*    FT_Byte                                                            */
+  /*    FT_Char                                                            */
+  /*    FT_Int                                                             */
+  /*    FT_UInt                                                            */
+  /*    FT_Short                                                           */
+  /*    FT_UShort                                                          */
+  /*    FT_Long                                                            */
+  /*    FT_ULong                                                           */
+  /*    FT_Bool                                                            */
+  /*    FT_Offset                                                          */
+  /*    FT_PtrDist                                                         */
+  /*    FT_String                                                          */
+  /*    FT_Error                                                           */
+  /*    FT_Fixed                                                           */
+  /*    FT_Pointer                                                         */
+  /*    FT_Pos                                                             */
+  /*    FT_Vector                                                          */
+  /*    FT_BBox                                                            */
+  /*    FT_Matrix                                                          */
+  /*    FT_FWord                                                           */
+  /*    FT_UFWord                                                          */
+  /*    FT_F2Dot14                                                         */
+  /*    FT_UnitVector                                                      */
+  /*    FT_F26Dot6                                                         */
+  /*                                                                       */
+  /*                                                                       */
+  /*    FT_Generic                                                         */
+  /*    FT_Generic_Finalizer                                               */
+  /*                                                                       */
+  /*    FT_Bitmap                                                          */
+  /*    FT_Pixel_Mode                                                      */
+  /*    FT_Palette_Mode                                                    */
+  /*    FT_Glyph_Format                                                    */
+  /*    FT_IMAGE_TAG                                                       */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Bool                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef of unsigned char, used for simple booleans.              */
+  /*                                                                       */
+  typedef unsigned char  FT_Bool;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_FWord                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A signed 16-bit integer used to store a distance in original font  */
+  /*    units.                                                             */
+  /*                                                                       */
+  typedef signed short  FT_FWord;   /* distance in FUnits */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_UFWord                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    An unsigned 16-bit integer used to store a distance in original    */
+  /*    font units.                                                        */
+  /*                                                                       */
+  typedef unsigned short  FT_UFWord;  /* unsigned distance */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Char                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple typedef for the _signed_ char type.                       */
+  /*                                                                       */
+  typedef signed char  FT_Char;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Byte                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple typedef for the _unsigned_ char type.                     */
+  /*                                                                       */
+  typedef unsigned char  FT_Byte;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_String                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple typedef for the char type, usually used for strings.      */
+  /*                                                                       */
+  typedef char  FT_String;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Short                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for signed short.                                        */
+  /*                                                                       */
+  typedef signed short  FT_Short;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_UShort                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for unsigned short.                                      */
+  /*                                                                       */
+  typedef unsigned short  FT_UShort;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Int                                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for the int type.                                        */
+  /*                                                                       */
+  typedef int  FT_Int;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_UInt                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for the unsigned int type.                               */
+  /*                                                                       */
+  typedef unsigned int  FT_UInt;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Long                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for signed long.                                         */
+  /*                                                                       */
+  typedef signed long  FT_Long;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_ULong                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A typedef for unsigned long.                                       */
+  /*                                                                       */
+  typedef unsigned long  FT_ULong;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_F2Dot14                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A signed 2.14 fixed float type used for unit vectors.              */
+  /*                                                                       */
+  typedef signed short  FT_F2Dot14;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_F26Dot6                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A signed 26.6 fixed float type used for vectorial pixel            */
+  /*    coordinates.                                                       */
+  /*                                                                       */
+  typedef signed long  FT_F26Dot6;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Fixed                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This type is used to store 16.16 fixed float values, like scales   */
+  /*    or matrix coefficients.                                            */
+  /*                                                                       */
+  typedef signed long  FT_Fixed;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Error                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The FreeType error code type.  A value of 0 is always interpreted  */
+  /*    as a successful operation.                                         */
+  /*                                                                       */
+  typedef int  FT_Error;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Pointer                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple typedef for a typeless pointer.                           */
+  /*                                                                       */
+  typedef void*  FT_Pointer;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_Offset                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This is equivalent to the ANSI C `size_t' type, i.e. the largest   */
+  /*    _unsigned_ integer type used to express a file size or position,   */
+  /*    or a memory block size.                                            */
+  /*                                                                       */
+  typedef size_t  FT_Offset;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_PtrDist                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This is equivalent to the ANSI C `ptrdiff_t' type, i.e. the        */
+  /*    largest _signed_ integer type used to express the distance         */
+  /*    between two pointers.                                              */
+  /*                                                                       */
+  typedef size_t  FT_PtrDist;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_UnitVector                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple structure used to store a 2D vector unit vector.  Uses    */
+  /*    FT_F2Dot14 types.                                                  */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    x :: Horizontal coordinate.                                        */
+  /*                                                                       */
+  /*    y :: Vertical coordinate.                                          */
+  /*                                                                       */
+  typedef struct  FT_UnitVector_
+  {
+    FT_F2Dot14  x;
+    FT_F2Dot14  y;
+
+  } FT_UnitVector;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Matrix                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple structure used to store a 2x2 matrix.  Coefficients are   */
+  /*    in 16.16 fixed float format.  The computation performed is:        */
+  /*                                                                       */
+  /*       {                                                               */
+  /*          x' = x*xx + y*xy                                             */
+  /*          y' = x*yx + y*yy                                             */
+  /*       }                                                               */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    xx :: Matrix coefficient.                                          */
+  /*                                                                       */
+  /*    xy :: Matrix coefficient.                                          */
+  /*                                                                       */
+  /*    yx :: Matrix coefficient.                                          */
+  /*                                                                       */
+  /*    yy :: Matrix coefficient.                                          */
+  /*                                                                       */
+  typedef struct  FT_Matrix_
+  {
+    FT_Fixed  xx, xy;
+    FT_Fixed  yx, yy;
+
+  } FT_Matrix;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Data	                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Read-only binary data represented as a pointer and a length.       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    pointer :: The data.                                               */
+  /*                                                                       */
+  /*    length  :: The length of the data in bytes.                        */
+  /*                                                                       */
+  typedef struct  FT_Data_
+  {
+    const FT_Byte*  pointer;
+    FT_Int          length;
+
+  } FT_Data;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_Generic_Finalizer                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Describes a function used to destroy the `client' data of any      */
+  /*    FreeType object.  See the description of the FT_Generic type for   */
+  /*    details of usage.                                                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    The address of the FreeType object which is under finalization.    */
+  /*    Its client data is accessed through its `generic' field.           */
+  /*                                                                       */
+  typedef void  (*FT_Generic_Finalizer)(void*  object);
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Generic                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Client applications often need to associate their own data to a    */
+  /*    variety of FreeType core objects.  For example, a text layout API  */
+  /*    might want to associate a glyph cache to a given size object.      */
+  /*                                                                       */
+  /*    Most FreeType object contains a `generic' field, of type           */
+  /*    FT_Generic, which usage is left to client applications and font    */
+  /*    servers.                                                           */
+  /*                                                                       */
+  /*    It can be used to store a pointer to client-specific data, as well */
+  /*    as the address of a `finalizer' function, which will be called by  */
+  /*    FreeType when the object is destroyed (for example, the previous   */
+  /*    client example would put the address of the glyph cache destructor */
+  /*    in the `finalizer' field).                                         */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    data      :: A typeless pointer to any client-specified data. This */
+  /*                 field is completely ignored by the FreeType library.  */
+  /*                                                                       */
+  /*    finalizer :: A pointer to a `generic finalizer' function, which    */
+  /*                 will be called when the object is destroyed.  If this */
+  /*                 field is set to NULL, no code will be called.         */
+  /*                                                                       */
+  typedef struct  FT_Generic_
+  {
+    void*                 data;
+    FT_Generic_Finalizer  finalizer;
+
+  } FT_Generic;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Macro>                                                               */
+  /*    FT_MAKE_TAG                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This macro converts four letter tags which are used to label       */
+  /*    TrueType tables into an unsigned long to be used within FreeType.  */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The produced values *must* be 32bit integers.  Don't redefine this */
+  /*    macro.                                                             */
+  /*                                                                       */
+#define FT_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
+          ( ( (FT_ULong)_x1 << 24 ) |     \
+            ( (FT_ULong)_x2 << 16 ) |     \
+            ( (FT_ULong)_x3 <<  8 ) |     \
+              (FT_ULong)_x4         )
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*                                                                       */
+  /*                    L I S T   M A N A G E M E N T                      */
+  /*                                                                       */
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    list_processing                                                    */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_ListNode                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*     Many elements and objects in FreeType are listed through a        */
+  /*     FT_List record (see FT_ListRec).  As its name suggests, a         */
+  /*     FT_ListNode is a handle to a single list element.                 */
+  /*                                                                       */
+  typedef struct FT_ListNodeRec_*  FT_ListNode;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    FT_List                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a list record (see FT_ListRec).                        */
+  /*                                                                       */
+  typedef struct FT_ListRec_*  FT_List;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_ListNodeRec                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to hold a single list element.                    */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    prev :: The previous element in the list.  NULL if first.          */
+  /*                                                                       */
+  /*    next :: The next element in the list.  NULL if last.               */
+  /*                                                                       */
+  /*    data :: A typeless pointer to the listed object.                   */
+  /*                                                                       */
+  typedef struct  FT_ListNodeRec_
+  {
+    FT_ListNode  prev;
+    FT_ListNode  next;
+    void*        data;
+
+  } FT_ListNodeRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_ListRec                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to hold a simple doubly-linked list.  These are   */
+  /*    used in many parts of FreeType.                                    */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    head :: The head (first element) of doubly-linked list.            */
+  /*                                                                       */
+  /*    tail :: The tail (last element) of doubly-linked list.             */
+  /*                                                                       */
+  typedef struct  FT_ListRec_
+  {
+    FT_ListNode  head;
+    FT_ListNode  tail;
+
+  } FT_ListRec;
+
+
+  /* */
+
+#define FT_IS_EMPTY( list )  ( (list).head == 0 )
+
+  /* return base error code (without module-specific prefix) */
+#define FT_ERROR_BASE( x )    ( (x) & 0xFF )
+
+  /* return module error code */
+#define FT_ERROR_MODULE( x )  ( (x) & 0xFF00U )
+
+#define FT_BOOL( x )  ( (FT_Bool)( x ) )
+
+FT_END_HEADER
+
+#endif /* __FTTYPES_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ftxf86.h
@@ -1,0 +1,53 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftxf86.h                                                               */
+/*                                                                         */
+/*    Support functions for X11.                                           */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTXF86_H__
+#define __FTXF86_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+FT_BEGIN_HEADER
+
+  /* this comment is intentionally disabled for now, to prevent this       */
+  /* function from appearing in the API Reference.                         */
+
+  /*@***********************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_X11_Font_Format                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Return a string describing the format of a given face as an X11    */
+  /*    FONT_PROPERTY.  It should only be used by the FreeType 2 font      */
+  /*    backend of the XFree86 font server.                                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: Input face handle.                                         */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    Font format string.  NULL in case of error.                        */
+  /*                                                                       */
+  FT_EXPORT_DEF( const char* )
+  FT_Get_X11_Font_Format( FT_Face  face );
+
+ /* */
+
+FT_END_HEADER
+
+#endif /* __FTXF86_H__ */
--- /dev/null
+++ b/include/freetype/internal/autohint.h
@@ -1,0 +1,205 @@
+/***************************************************************************/
+/*                                                                         */
+/*  autohint.h                                                             */
+/*                                                                         */
+/*    High-level `autohint' module-specific interface (specification).     */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The auto-hinter is used to load and automatically hint glyphs if a    */
+  /* format-specific hinter isn't available.                               */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __AUTOHINT_H__
+#define __AUTOHINT_H__
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* A small technical note regarding automatic hinting in order to        */
+  /* clarify this module interface.                                        */
+  /*                                                                       */
+  /* An automatic hinter might compute two kinds of data for a given face: */
+  /*                                                                       */
+  /* - global hints: Usually some metrics that describe global properties  */
+  /*                 of the face.  It is computed by scanning more or less */
+  /*                 agressively the glyphs in the face, and thus can be   */
+  /*                 very slow to compute (even if the size of global      */
+  /*                 hints is really small).                               */
+  /*                                                                       */
+  /* - glyph hints:  These describe some important features of the glyph   */
+  /*                 outline, as well as how to align them.  They are      */
+  /*                 generally much faster to compute than global hints.   */
+  /*                                                                       */
+  /* The current FreeType auto-hinter does a pretty good job while         */
+  /* performing fast computations for both global and glyph hints.         */
+  /* However, we might be interested in introducing more complex and       */
+  /* powerful algorithms in the future, like the one described in the John */
+  /* D. Hobby paper, which unfortunately requires a lot more horsepower.   */
+  /*                                                                       */
+  /* Because a sufficiently sophisticated font management system would     */
+  /* typically implement an LRU cache of opened face objects to reduce     */
+  /* memory usage, it is a good idea to be able to avoid recomputing       */
+  /* global hints every time the same face is re-opened.                   */
+  /*                                                                       */
+  /* We thus provide the ability to cache global hints outside of the face */
+  /* object, in order to speed up font re-opening time.  Of course, this   */
+  /* feature is purely optional, so most client programs won't even notice */
+  /* it.                                                                   */
+  /*                                                                       */
+  /* I initially thought that it would be a good idea to cache the glyph   */
+  /* hints too.  However, my general idea now is that if you really need   */
+  /* to cache these too, you are simply in need of a new font format,      */
+  /* where all this information could be stored within the font file and   */
+  /* decoded on the fly.                                                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct FT_AutoHinterRec_  *FT_AutoHinter;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_AutoHinter_GlobalGetFunc                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Retrieves the global hints computed for a given face object the    */
+  /*    resulting data is dissociated from the face and will survive a     */
+  /*    call to FT_Done_Face().  It must be discarded through the API      */
+  /*    FT_AutoHinter_GlobalDoneFunc().                                    */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    hinter        :: A handle to the source auto-hinter.               */
+  /*                                                                       */
+  /*    face          :: A handle to the source face object.               */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    global_hints  :: A typeless pointer to the global hints.           */
+  /*                                                                       */
+  /*    global_len    :: The size in bytes of the global hints.            */
+  /*                                                                       */
+  typedef void
+  (*FT_AutoHinter_GlobalGetFunc)( FT_AutoHinter  hinter,
+                                  FT_Face        face,
+                                  void**         global_hints,
+                                  long*          global_len );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_AutoHinter_GlobalDoneFunc                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Discards the global hints retrieved through                        */
+  /*    FT_AutoHinter_GlobalGetFunc().  This is the only way these hints   */
+  /*    are freed from memory.                                             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    hinter :: A handle to the auto-hinter module.                      */
+  /*                                                                       */
+  /*    global :: A pointer to retrieved global hints to discard.          */
+  /*                                                                       */
+  typedef void
+  (*FT_AutoHinter_GlobalDoneFunc)( FT_AutoHinter  hinter,
+                                   void*          global );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_AutoHinter_GlobalResetFunc                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used to recompute the global metrics in a given   */
+  /*    font.  This is useful when global font data changes (e.g. Multiple */
+  /*    Masters fonts where blend coordinates change).                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    hinter :: A handle to the source auto-hinter.                      */
+  /*                                                                       */
+  /*    face   :: A handle to the face.                                    */
+  /*                                                                       */
+  typedef void
+  (*FT_AutoHinter_GlobalResetFunc)( FT_AutoHinter  hinter,
+                                    FT_Face        face );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    FT_AutoHinter_GlyphLoadFunc                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This function is used to load, scale, and automatically hint a     */
+  /*    glyph from a given face.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face        :: A handle to the face.                               */
+  /*                                                                       */
+  /*    glyph_index :: The glyph index.                                    */
+  /*                                                                       */
+  /*    load_flags  :: The load flags.                                     */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function is capable of loading composite glyphs by hinting    */
+  /*    each sub-glyph independently (which improves quality).             */
+  /*                                                                       */
+  /*    It will call the font driver with FT_Load_Glyph(), with            */
+  /*    FT_LOAD_NO_SCALE set.                                              */
+  /*                                                                       */
+  typedef FT_Error
+  (*FT_AutoHinter_GlyphLoadFunc)( FT_AutoHinter  hinter,
+                                  FT_GlyphSlot   slot,
+                                  FT_Size        size,
+                                  FT_UInt        glyph_index,
+                                  FT_Int32       load_flags );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_AutoHinter_ServiceRec                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The auto-hinter module's interface.                                */
+  /*                                                                       */
+  typedef struct  FT_AutoHinter_ServiceRec_
+  {
+    FT_AutoHinter_GlobalResetFunc  reset_face;
+    FT_AutoHinter_GlobalGetFunc    get_global_hints;
+    FT_AutoHinter_GlobalDoneFunc   done_global_hints;
+    FT_AutoHinter_GlyphLoadFunc    load_glyph;
+
+  } FT_AutoHinter_ServiceRec, *FT_AutoHinter_Service;
+
+
+FT_END_HEADER
+
+#endif /* __AUTOHINT_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/bdftypes.h
@@ -1,0 +1,53 @@
+/*  bdftypes.h
+
+  FreeType font driver for bdf fonts
+
+  Copyright (C) 2001, 2002 by
+  Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef __BDFTYPES_H__
+#define __BDFTYPES_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  BDF_Public_FaceRec_
+  {
+    FT_FaceRec  root;
+
+    char*       charset_encoding;
+    char*       charset_registry;
+
+  } BDF_Public_FaceRec, *BDF_Public_Face;
+
+
+FT_END_HEADER
+
+
+#endif  /* __BDFTYPES_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/cfftypes.h
@@ -1,0 +1,256 @@
+/***************************************************************************/
+/*                                                                         */
+/*  cfftypes.h                                                             */
+/*                                                                         */
+/*    Basic OpenType/CFF type definitions and interface (specification     */
+/*    only).                                                               */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __CFFTYPES_H__
+#define __CFFTYPES_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    CFF_IndexRec                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a CFF Index table.                       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    stream      :: The source input stream.                            */
+  /*                                                                       */
+  /*    count       :: The number of elements in the index.                */
+  /*                                                                       */
+  /*    off_size    :: The size in bytes of object offsets in index.       */
+  /*                                                                       */
+  /*    data_offset :: The position of first data byte in the index's      */
+  /*                   bytes.                                              */
+  /*                                                                       */
+  /*    offsets     :: A table of element offsets in the index.            */
+  /*                                                                       */
+  /*    bytes       :: If the index is loaded in memory, its bytes.        */
+  /*                                                                       */
+  typedef struct  CFF_IndexRec_
+  {
+    FT_Stream  stream;
+    FT_UInt    count;
+    FT_Byte    off_size;
+    FT_ULong   data_offset;
+
+    FT_ULong*  offsets;
+    FT_Byte*   bytes;
+
+  } CFF_IndexRec, *CFF_Index;
+
+
+  typedef struct  CFF_EncodingRec_
+  {
+    FT_UInt     format;
+    FT_ULong    offset;
+
+    FT_UInt     count;
+    FT_UShort   sids [256];  /* avoid dynamic allocations */
+    FT_UShort   codes[256];
+
+  } CFF_EncodingRec, *CFF_Encoding;
+
+
+  typedef struct  CFF_CharsetRec_
+  {
+
+    FT_UInt     format;
+    FT_ULong    offset;
+
+    FT_UShort*  sids;
+
+  } CFF_CharsetRec, *CFF_Charset;
+
+
+  typedef struct  CFF_FontRecDictRec_
+  {
+    FT_UInt    version;
+    FT_UInt    notice;
+    FT_UInt    copyright;
+    FT_UInt    full_name;
+    FT_UInt    family_name;
+    FT_UInt    weight;
+    FT_Bool    is_fixed_pitch;
+    FT_Fixed   italic_angle;
+    FT_Pos     underline_position;
+    FT_Pos     underline_thickness;
+    FT_Int     paint_type;
+    FT_Int     charstring_type;
+    FT_Matrix  font_matrix;
+    FT_UShort  units_per_em;
+    FT_Vector  font_offset;
+    FT_ULong   unique_id;
+    FT_BBox    font_bbox;
+    FT_Pos     stroke_width;
+    FT_ULong   charset_offset;
+    FT_ULong   encoding_offset;
+    FT_ULong   charstrings_offset;
+    FT_ULong   private_offset;
+    FT_ULong   private_size;
+    FT_Long    synthetic_base;
+    FT_UInt    embedded_postscript;
+    FT_UInt    base_font_name;
+    FT_UInt    postscript;
+
+    /* these should only be used for the top-level font dictionary */
+    FT_UInt    cid_registry;
+    FT_UInt    cid_ordering;
+    FT_ULong   cid_supplement;
+
+    FT_Long    cid_font_version;
+    FT_Long    cid_font_revision;
+    FT_Long    cid_font_type;
+    FT_Long    cid_count;
+    FT_ULong   cid_uid_base;
+    FT_ULong   cid_fd_array_offset;
+    FT_ULong   cid_fd_select_offset;
+    FT_UInt    cid_font_name;
+
+  } CFF_FontRecDictRec, *CFF_FontRecDict;
+
+
+  typedef struct  CFF_PrivateRec_
+  {
+    FT_Byte   num_blue_values;
+    FT_Byte   num_other_blues;
+    FT_Byte   num_family_blues;
+    FT_Byte   num_family_other_blues;
+
+    FT_Pos    blue_values[14];
+    FT_Pos    other_blues[10];
+    FT_Pos    family_blues[14];
+    FT_Pos    family_other_blues[10];
+
+    FT_Fixed  blue_scale;
+    FT_Pos    blue_shift;
+    FT_Pos    blue_fuzz;
+    FT_Pos    standard_width;
+    FT_Pos    standard_height;
+
+    FT_Byte   num_snap_widths;
+    FT_Byte   num_snap_heights;
+    FT_Pos    snap_widths[13];
+    FT_Pos    snap_heights[13];
+    FT_Bool   force_bold;
+    FT_Fixed  force_bold_threshold;
+    FT_Int    lenIV;
+    FT_Int    language_group;
+    FT_Fixed  expansion_factor;
+    FT_Long   initial_random_seed;
+    FT_ULong  local_subrs_offset;
+    FT_Pos    default_width;
+    FT_Pos    nominal_width;
+
+  } CFF_PrivateRec, *CFF_Private;
+
+
+  typedef struct  CFF_FDSelectRec_
+  {
+    FT_Byte   format;
+    FT_UInt   range_count;
+
+    /* that's the table, taken from the file `as is' */
+    FT_Byte*  data;
+    FT_UInt   data_size;
+
+    /* small cache for format 3 only */
+    FT_UInt   cache_first;
+    FT_UInt   cache_count;
+    FT_Byte   cache_fd;
+
+  } CFF_FDSelectRec, *CFF_FDSelect;
+
+
+  /* A SubFont packs a font dict and a private dict together.  They are */
+  /* needed to support CID-keyed CFF fonts.                             */
+  typedef struct  CFF_SubFontRec_
+  {
+    CFF_FontRecDictRec  font_dict;
+    CFF_PrivateRec      private_dict;
+
+    CFF_IndexRec        local_subrs_index;
+    FT_UInt             num_local_subrs;
+    FT_Byte**           local_subrs;
+
+  } CFF_SubFontRec, *CFF_SubFont;
+
+
+  /* maximum number of sub-fonts in a CID-keyed file */
+#define CFF_MAX_CID_FONTS  16
+
+
+  typedef struct  CFF_FontRec_
+  {
+    FT_Stream        stream;
+    FT_Memory        memory;
+    FT_UInt          num_faces;
+    FT_UInt          num_glyphs;
+
+    FT_Byte          version_major;
+    FT_Byte          version_minor;
+    FT_Byte          header_size;
+    FT_Byte          absolute_offsize;
+
+
+    CFF_IndexRec     name_index;
+    CFF_IndexRec     top_dict_index;
+    CFF_IndexRec     string_index;
+    CFF_IndexRec     global_subrs_index;
+
+    CFF_EncodingRec  encoding;
+    CFF_CharsetRec   charset;
+
+    CFF_IndexRec     charstrings_index;
+    CFF_IndexRec     font_dict_index;
+    CFF_IndexRec     private_index;
+    CFF_IndexRec     local_subrs_index;
+
+    FT_String*       font_name;
+    FT_UInt          num_global_subrs;
+    FT_Byte**        global_subrs;
+
+    CFF_SubFontRec   top_font;
+    FT_UInt          num_subfonts;
+    CFF_SubFont      subfonts[CFF_MAX_CID_FONTS];
+
+    CFF_FDSelectRec  fd_select;
+
+    /* interface to PostScript hinter */
+    void*            pshinter;
+
+    /* interface to Postscript Names service */
+    void*            psnames;
+
+  } CFF_FontRec, *CFF_Font;
+
+
+FT_END_HEADER
+
+#endif /* __CFFTYPES_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/fnttypes.h
@@ -1,0 +1,155 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fnttypes.h                                                             */
+/*                                                                         */
+/*    Basic Windows FNT/FON type definitions and interface (specification  */
+/*    only).                                                               */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FNTTYPES_H__
+#define __FNTTYPES_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  WinMZ_HeaderRec_
+  {
+    FT_UShort  magic;
+    /* skipped content */
+    FT_UShort  lfanew;
+
+  } WinMZ_HeaderRec;
+
+
+  typedef struct  WinNE_HeaderRec_
+  {
+    FT_UShort  magic;
+    /* skipped content */
+    FT_UShort  resource_tab_offset;
+    FT_UShort  rname_tab_offset;
+
+  } WinNE_HeaderRec;
+
+
+  typedef struct  WinNameInfoRec_
+  {
+    FT_UShort  offset;
+    FT_UShort  length;
+    FT_UShort  flags;
+    FT_UShort  id;
+    FT_UShort  handle;
+    FT_UShort  usage;
+
+  } WinNameInfoRec;
+
+
+  typedef struct  WinResourceInfoRec_
+  {
+    FT_UShort  type_id;
+    FT_UShort  count;
+
+  } WinResourceInfoRec;
+
+
+#define WINFNT_MZ_MAGIC  0x5A4D
+#define WINFNT_NE_MAGIC  0x454E
+
+
+  typedef struct  WinFNT_HeaderRec_
+  {
+    FT_UShort  version;
+    FT_ULong   file_size;
+    FT_Byte    copyright[60];
+    FT_UShort  file_type;
+    FT_UShort  nominal_point_size;
+    FT_UShort  vertical_resolution;
+    FT_UShort  horizontal_resolution;
+    FT_UShort  ascent;
+    FT_UShort  internal_leading;
+    FT_UShort  external_leading;
+    FT_Byte    italic;
+    FT_Byte    underline;
+    FT_Byte    strike_out;
+    FT_UShort  weight;
+    FT_Byte    charset;
+    FT_UShort  pixel_width;
+    FT_UShort  pixel_height;
+    FT_Byte    pitch_and_family;
+    FT_UShort  avg_width;
+    FT_UShort  max_width;
+    FT_Byte    first_char;
+    FT_Byte    last_char;
+    FT_Byte    default_char;
+    FT_Byte    break_char;
+    FT_UShort  bytes_per_row;
+    FT_ULong   device_offset;
+    FT_ULong   face_name_offset;
+    FT_ULong   bits_pointer;
+    FT_ULong   bits_offset;
+    FT_Byte    reserved;
+    FT_ULong   flags;
+    FT_UShort  A_space;
+    FT_UShort  B_space;
+    FT_UShort  C_space;
+    FT_UShort  color_table_offset;
+    FT_Byte    reserved2[4];
+
+  } WinFNT_HeaderRec, *WinFNT_Header;
+
+
+  typedef struct  FNT_FontRec_
+  {
+    FT_ULong          offset;
+    FT_Int            size_shift;
+
+    WinFNT_HeaderRec  header;
+
+    FT_Byte*          fnt_frame;
+    FT_ULong          fnt_size;
+
+  } FNT_FontRec, *FNT_Font;
+
+
+  typedef struct  FNT_SizeRec_
+  {
+    FT_SizeRec  root;
+    FNT_Font    font;
+
+  } FNT_SizeRec, *FNT_Size;
+
+
+  typedef struct  FNT_FaceRec_
+  {
+    FT_FaceRec     root;
+
+    FT_UInt        num_fonts;
+    FNT_Font       fonts;
+
+    FT_CharMap     charmap_handle;
+    FT_CharMapRec  charmap;  /* a single charmap per face */
+
+  } FNT_FaceRec, *FNT_Face;
+
+
+FT_END_HEADER
+
+#endif /* __FNTTYPES_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/ftcalc.h
@@ -1,0 +1,77 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftcalc.h                                                               */
+/*                                                                         */
+/*    Arithmetic computations (specification).                             */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTCALC_H__
+#define __FTCALC_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  FT_EXPORT( FT_Int32 )  FT_SqrtFixed( FT_Int32  x );
+
+
+#define SQRT_32( x )  FT_Sqrt32( x )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Sqrt32                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Computes the square root of an Int32 integer (which will be        */
+  /*    handled as an unsigned long value).                                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    x :: The value to compute the root for.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The result of `sqrt(x)'.                                           */
+  /*                                                                       */
+  FT_EXPORT( FT_Int32 )
+  FT_Sqrt32( FT_Int32  x );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* FT_MulDiv() and FT_MulFix() are declared in freetype.h.               */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#define INT_TO_F26DOT6( x )    ( (FT_Long)(x) << 6  )
+#define INT_TO_F2DOT14( x )    ( (FT_Long)(x) << 14 )
+#define INT_TO_FIXED( x )      ( (FT_Long)(x) << 16 )
+#define F2DOT14_TO_FIXED( x )  ( (FT_Long)(x) << 2  )
+#define FLOAT_TO_FIXED( x )    ( (FT_Long)( x * 65536.0 ) )
+
+#define ROUND_F26DOT6( x )     ( x >= 0 ? (    ( (x) + 32 ) & -64 )     \
+                                        : ( -( ( 32 - (x) ) & -64 ) ) )
+
+
+FT_END_HEADER
+
+#endif /* __FTCALC_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/ftcore.h
@@ -1,0 +1,185 @@
+#ifndef __FT_CORE_H__
+#define __FT_CORE_H__
+
+#include <ft2build.h>
+#include FT_TYPES_H
+#include FT_SYSTEM_MEMORY_H
+
+FT_BEGIN_HEADER
+
+ /**************************************************************************/
+ /**************************************************************************/
+ /*****                                                                *****/
+ /*****                  C L E A N U P   S T A C K                     *****/
+ /*****                                                                *****/
+ /**************************************************************************/
+ /**************************************************************************/
+
+
+ /************************************************************************
+  *
+  * @functype: FT_CleanupFunc
+  *
+  * @description:
+  *   a function used to cleanup a given item on the cleanup stack
+  *
+  * @input:
+  *   item      :: target item pointer
+  *   item_data :: optional argument to cleanup routine
+  */
+  typedef void  (*FT_CleanupFunc)( FT_Pointer  item,
+                                   FT_Pointer  item_data );
+
+
+
+ /************************************************************************
+  *
+  * @type: FT_XHandler
+  *
+  * @description:
+  *   handle to an exception-handler structure for the FreeType
+  *   exception sub-system
+  *
+  * @note:
+  *   exception handlers are allocated on the stack within a
+  *   @FT_XTRY macro. Do not try to access them directly.
+  */
+  typedef struct FT_XHandlerRec_*  FT_XHandler;
+
+
+/* the size of a cleanup chunk in bytes is FT_CLEANUP_CHUNK_SIZE*12 + 4 */
+/* this must be a small power of 2 whenever possible..                  */
+/*                                                                      */
+/* with a value of 5, we have a byte size of 64 bytes per chunk..       */
+/*                                                                      */
+#define  FT_CLEANUP_CHUNK_SIZE   5
+
+
+
+  typedef struct FT_CleanupItemRec_
+  {
+    FT_Pointer      item;
+    FT_CleanupFunc  item_func;
+    FT_Pointer      item_data;
+
+  } FT_CleanupItemRec;
+
+
+  typedef struct FT_CleanupChunkRec_*   FT_CleanupChunk;
+
+  typedef struct FT_CleanupChunkRec_
+  {
+    FT_CleanupChunk    link;
+    FT_CleanupItemRec  items[ FT_CLEANUP_CHUNK_SIZE ];
+
+  } FT_CleanupChunkRec;
+
+
+  typedef struct FT_CleanupStackRec_
+  {
+    FT_CleanupItem     top;
+    FT_CleanupItem     limit;
+    FT_CleanupChunk    chunk;
+    FT_CleanupChunkRec chunk_0;  /* avoids stupid dynamic allocation */
+    FT_Memory          memory;
+
+  } FT_CleanupStackRec, *FT_CleanupStack;
+
+
+  FT_BASE( void )
+  ft_cleanup_stack_push( FT_CleanupStack  stack,
+                         FT_Pointer       item,
+                         FT_CleanupFunc   item_func,
+                         FT_Pointer       item_data );
+
+  FT_BASE( void )
+  ft_cleanup_stack_pop( FT_CleanupStack   stack,
+                        FT_Int            destroy );
+
+  FT_BASE( FT_CleanupItem )
+  ft_cleanup_stack_peek( FT_CleanupStack  stack );
+
+  FT_BASE( void )
+  ft_cleanup_throw( FT_CleanupStack  stack,
+                    FT_Error         error );
+
+
+
+ /**************************************************************************/
+ /**************************************************************************/
+ /*****                                                                *****/
+ /*****                 M E M O R Y   M A N A G E R                    *****/
+ /*****                                                                *****/
+ /**************************************************************************/
+ /**************************************************************************/
+
+  typedef struct FT_MemoryRec_
+  {
+    FT_Memory_AllocFunc     mem_alloc;   /* shortcut to funcs->mem_alloc */
+    FT_Memory_FreeFunc      mem_free;    /* shortcut to funcs->mem_free  */
+    FT_Pointer              mem_data;
+    const FT_Memory_Funcs   mem_funcs;
+
+    FT_CleanupStackRec      cleanup_stack;
+    FT_Pointer              meta_class;
+
+  } FT_MemoryRec;
+
+
+#define  FT_MEMORY(x)  ((FT_Memory)(x))
+#define  FT_MEMORY__ALLOC(x)       FT_MEMORY(x)->mem_alloc
+#define  FT_MEMORY__FREE(x)        FT_MEMORY(x)->mem_free
+#define  FT_MEMORY__REALLOC(x)     FT_MEMORY(x)->mem_funcs->mem_realloc
+#define  FT_MEMORY__CLEANUP(x)     (&FT_MEMORY(x)->cleanup_stack)
+#define  FT_MEMORY__META_CLASS(x)  ((FT_MetaClass)(FT_MEMORY(x)->meta_class))
+
+
+ /**************************************************************************/
+ /**************************************************************************/
+ /*****                                                                *****/
+ /*****             E X C E P T I O N   H A N D L I N G                *****/
+ /*****                                                                *****/
+ /**************************************************************************/
+ /**************************************************************************/
+
+
+ /************************************************************************
+  *
+  * @struct: FT_XHandlerRec
+  *
+  * @description:
+  *   exception handler structure
+  *
+  * @fields:
+  *   previous   :: previous handler in chain.
+  *   jum_buffer :: processor state used by setjmp/longjmp to implement
+  *                 exception control transfer
+  *   error      :: exception error code
+  *   mark       :: top of cleanup stack when @FT_XTRY is used
+  */
+  typedef struct FT_XHandlerRec_
+  {
+    FT_XHandler        previous;
+    ft_jmp_buf         jump_buffer;
+    volatile FT_Error  error;
+    FT_Pointer         mark;
+
+  } FT_XHandlerRec;
+
+  FT_BASE( void )
+  ft_xhandler_enter( FT_XHandler  xhandler,
+                     FT_Memory    memory );
+
+  FT_BASE( void )
+  ft_xhandler_exit( FT_XHandler  xhandler );
+
+
+
+
+
+
+
+
+FT_END_HEADER
+
+#endif /* __FT_CORE_H__ */
--- /dev/null
+++ b/include/freetype/internal/ftdebug.h
@@ -1,0 +1,196 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftdebug.h                                                              */
+/*                                                                         */
+/*    Debugging and logging component (specification).                     */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/*                                                                         */
+/*  IMPORTANT: A description of FreeType's debugging support can be        */
+/*             found in "docs/DEBUG.TXT".  Read it if you need to use or   */
+/*             understand this code.                                       */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTDEBUG_H__
+#define __FTDEBUG_H__
+
+
+#include <ft2build.h>
+#include FT_CONFIG_CONFIG_H
+
+
+FT_BEGIN_HEADER
+
+
+  /* force the definition of FT_DEBUG_LEVEL_ERROR if FT_DEBUG_LEVEL_TRACE */
+  /* is already defined; this simplifies the following #ifdefs            */
+  /*                                                                      */
+#ifdef FT_DEBUG_LEVEL_TRACE
+#undef  FT_DEBUG_LEVEL_ERROR
+#define FT_DEBUG_LEVEL_ERROR
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define the trace enums as well as the trace levels array when they    */
+  /* are needed.                                                           */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifdef FT_DEBUG_LEVEL_TRACE
+
+#define FT_TRACE_DEF( x )  trace_ ## x ,
+
+  /* defining the enumeration */
+  typedef enum
+  {
+#include FT_INTERNAL_TRACE_H
+    trace_count
+
+  } FT_Trace;
+
+
+  /* defining the array of trace levels, provided by `src/base/ftdebug.c' */
+  extern int  ft_trace_levels[trace_count];
+
+#undef FT_TRACE_DEF
+
+#endif /* FT_DEBUG_LEVEL_TRACE */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define the FT_TRACE macro                                             */
+  /*                                                                       */
+  /* IMPORTANT!                                                            */
+  /*                                                                       */
+  /* Each component must define the macro FT_COMPONENT to a valid FT_Trace */
+  /* value before using any TRACE macro.                                   */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifdef FT_DEBUG_LEVEL_TRACE
+
+#define FT_TRACE( level, varformat )                      \
+          do                                              \
+          {                                               \
+            if ( ft_trace_levels[FT_COMPONENT] >= level ) \
+              FT_Message varformat;                       \
+          } while ( 0 )
+
+#else /* !FT_DEBUG_LEVEL_TRACE */
+
+#define FT_TRACE( level, varformat )  do ; while ( 0 )      /* nothing */
+
+#endif /* !FT_DEBUG_LEVEL_TRACE */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* You need two opening resp. closing parentheses!                       */
+  /*                                                                       */
+  /* Example: FT_TRACE0(( "Value is %i", foo ))                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+#define FT_TRACE0( varformat )  FT_TRACE( 0, varformat )
+#define FT_TRACE1( varformat )  FT_TRACE( 1, varformat )
+#define FT_TRACE2( varformat )  FT_TRACE( 2, varformat )
+#define FT_TRACE3( varformat )  FT_TRACE( 3, varformat )
+#define FT_TRACE4( varformat )  FT_TRACE( 4, varformat )
+#define FT_TRACE5( varformat )  FT_TRACE( 5, varformat )
+#define FT_TRACE6( varformat )  FT_TRACE( 6, varformat )
+#define FT_TRACE7( varformat )  FT_TRACE( 7, varformat )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  Define the FT_ERROR macro                                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifdef FT_DEBUG_LEVEL_ERROR
+
+#define FT_ERROR( varformat )  FT_Message  varformat
+
+#else  /* !FT_DEBUG_LEVEL_ERROR */
+
+#define FT_ERROR( varformat )  do ; while ( 0 )      /* nothing */
+
+#endif /* !FT_DEBUG_LEVEL_ERROR */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Define the FT_ASSERT macro                                            */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifdef FT_DEBUG_LEVEL_ERROR
+
+#define FT_ASSERT( condition )                                      \
+          do                                                        \
+          {                                                         \
+            if ( !( condition ) )                                   \
+              FT_Panic( "assertion failed on line %d of file %s\n", \
+                        __LINE__, __FILE__ );                       \
+          } while ( 0 )
+
+#else /* !FT_DEBUG_LEVEL_ERROR */
+
+#define FT_ASSERT( condition )  do ; while ( 0 )
+
+#endif /* !FT_DEBUG_LEVEL_ERROR */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  Define 'FT_Message' and 'FT_Panic' when needed                       */
+  /*                                                                       */
+  /*************************************************************************/
+
+#ifdef FT_DEBUG_LEVEL_ERROR
+
+#include "stdio.h"  /* for vprintf() */
+
+  /* print a message */
+  FT_EXPORT( void )
+  FT_Message( const char*  fmt, ... );
+
+  /* print a message and exit */
+  FT_EXPORT( void )
+  FT_Panic( const char*  fmt, ... );
+
+#endif /* FT_DEBUG_LEVEL_ERROR */
+
+
+  FT_BASE( void )
+  ft_debug_init( void );
+
+
+#if defined( _MSC_VER )      /* Visual C++ (and Intel C++) */
+
+  /* we disable the warning `conditional expression is constant' here */
+  /* in order to compile cleanly with the maximum level of warnings   */
+#pragma warning( disable : 4127 )
+
+#endif /* _MSC_VER */
+
+
+FT_END_HEADER
+
+#endif /* __FTDEBUG_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/ftdriver.h
@@ -1,0 +1,202 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftdriver.h                                                             */
+/*                                                                         */
+/*    FreeType font driver interface (specification).                      */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTDRIVER_H__
+#define __FTDRIVER_H__
+
+
+#include <ft2build.h>
+#include FT_MODULE_H
+
+
+FT_BEGIN_HEADER
+
+
+  typedef FT_Error
+  (*FT_Face_InitFunc)( FT_Stream      stream,
+                       FT_Face        face,
+                       FT_Int         typeface_index,
+                       FT_Int         num_params,
+                       FT_Parameter*  parameters );
+
+  typedef void
+  (*FT_Face_DoneFunc)( FT_Face  face );
+
+
+  typedef FT_Error
+  (*FT_Size_InitFunc)( FT_Size  size );
+
+  typedef void
+  (*FT_Size_DoneFunc)( FT_Size  size );
+
+
+  typedef FT_Error
+  (*FT_Slot_InitFunc)( FT_GlyphSlot  slot );
+
+  typedef void
+  (*FT_Slot_DoneFunc)( FT_GlyphSlot  slot );
+
+
+  typedef FT_Error
+  (*FT_Size_ResetPointsFunc)( FT_Size     size,
+                              FT_F26Dot6  char_width,
+                              FT_F26Dot6  char_height,
+                              FT_UInt     horz_resolution,
+                              FT_UInt     vert_resolution );
+
+  typedef FT_Error
+  (*FT_Size_ResetPixelsFunc)( FT_Size  size,
+                              FT_UInt  pixel_width,
+                              FT_UInt  pixel_height );
+
+  typedef FT_Error
+  (*FT_Slot_LoadFunc)( FT_GlyphSlot  slot,
+                       FT_Size       size,
+                       FT_UInt       glyph_index,
+                       FT_Int32      load_flags );
+
+
+  typedef FT_UInt
+  (*FT_CharMap_CharIndexFunc)( FT_CharMap  charmap,
+                               FT_Long     charcode );
+
+  typedef FT_Long
+  (*FT_CharMap_CharNextFunc)( FT_CharMap  charmap,
+                              FT_Long     charcode );
+
+  typedef FT_Error
+  (*FT_Face_GetKerningFunc)( FT_Face     face,
+                             FT_UInt     left_glyph,
+                             FT_UInt     right_glyph,
+                             FT_Vector*  kerning );
+
+
+  typedef FT_Error
+  (*FT_Face_AttachFunc)( FT_Face    face,
+                         FT_Stream  stream );
+
+
+  typedef FT_Error
+  (*FT_Face_GetAdvancesFunc)( FT_Face     face,
+                              FT_UInt     first,
+                              FT_UInt     count,
+                              FT_Bool     vertical,
+                              FT_UShort*  advances );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Driver_ClassRec                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The font driver class.  This structure mostly contains pointers to */
+  /*    driver methods.                                                    */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    root             :: The parent module.                             */
+  /*                                                                       */
+  /*    face_object_size :: The size of a face object in bytes.            */
+  /*                                                                       */
+  /*    size_object_size :: The size of a size object in bytes.            */
+  /*                                                                       */
+  /*    slot_object_size :: The size of a glyph object in bytes.           */
+  /*                                                                       */
+  /*    init_face        :: The format-specific face constructor.          */
+  /*                                                                       */
+  /*    done_face        :: The format-specific face destructor.           */
+  /*                                                                       */
+  /*    init_size        :: The format-specific size constructor.          */
+  /*                                                                       */
+  /*    done_size        :: The format-specific size destructor.           */
+  /*                                                                       */
+  /*    init_slot        :: The format-specific slot constructor.          */
+  /*                                                                       */
+  /*    done_slot        :: The format-specific slot destructor.           */
+  /*                                                                       */
+  /*    set_char_sizes   :: A handle to a function used to set the new     */
+  /*                        character size in points + resolution.  Can be */
+  /*                        set to 0 to indicate default behaviour.        */
+  /*                                                                       */
+  /*    set_pixel_sizes  :: A handle to a function used to set the new     */
+  /*                        character size in pixels.  Can be set to 0 to  */
+  /*                        indicate default behaviour.                    */
+  /*                                                                       */
+  /*    load_glyph       :: A function handle to load a given glyph image  */
+  /*                        in a slot.  This field is mandatory!           */
+  /*                                                                       */
+  /*    get_char_index   :: A function handle to return the glyph index of */
+  /*                        a given character for a given charmap.  This   */
+  /*                        field is mandatory!                            */
+  /*                                                                       */
+  /*    get_kerning      :: A function handle to return the unscaled       */
+  /*                        kerning for a given pair of glyphs.  Can be    */
+  /*                        set to 0 if the format doesn't support         */
+  /*                        kerning.                                       */
+  /*                                                                       */
+  /*    attach_file      :: This function handle is used to read           */
+  /*                        additional data for a face from another        */
+  /*                        file/stream.  For example, this can be used to */
+  /*                        add data from AFM or PFM files on a Type 1     */
+  /*                        face, or a CIDMap on a CID-keyed face.         */
+  /*                                                                       */
+  /*    get_advances     :: A function handle used to return the advances  */
+  /*                        of 'count' glyphs, starting at `index'.  the   */
+  /*                        `vertical' flags must be set when vertical     */
+  /*                        advances are queried.  The advances buffer is  */
+  /*                        caller-allocated.                              */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Most function pointers, with the exception of `load_glyph' and     */
+  /*    `get_char_index' can be set to 0 to indicate a default behaviour.  */
+  /*                                                                       */
+  typedef struct  FT_Driver_ClassRec_
+  {
+    FT_Module_Class           root;
+
+    FT_Int                    face_object_size;
+    FT_Int                    size_object_size;
+    FT_Int                    slot_object_size;
+
+    FT_Face_InitFunc          init_face;
+    FT_Face_DoneFunc          done_face;
+
+    FT_Size_InitFunc          init_size;
+    FT_Size_DoneFunc          done_size;
+
+    FT_Slot_InitFunc          init_slot;
+    FT_Slot_DoneFunc          done_slot;
+
+    FT_Size_ResetPointsFunc   set_char_sizes;
+    FT_Size_ResetPixelsFunc   set_pixel_sizes;
+
+    FT_Slot_LoadFunc          load_glyph;
+
+    FT_Face_GetKerningFunc    get_kerning;
+    FT_Face_AttachFunc        attach_file;
+    FT_Face_GetAdvancesFunc   get_advances;
+
+  } FT_Driver_ClassRec, *FT_Driver_Class;
+
+
+FT_END_HEADER
+
+#endif /* __FTDRIVER_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/ftexcept.h
@@ -1,0 +1,82 @@
+#ifndef __FT_EXCEPT_H__
+#define __FT_EXCEPT_H__
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+
+FT_BEGIN_HEADER
+
+
+
+ /* I can't find a better place for this for now */
+
+<<<<<<< ftexcept.h
+=======
+
+/* the size of a cleanup chunk in bytes is FT_CLEANUP_CHUNK_SIZE*12 + 4 */
+/* this must be a small power of 2 whenever possible..                  */
+/*                                                                      */
+/* with a value of 5, we have a byte size of 64 bytes per chunk..       */
+/*                                                                      */
+#define  FT_CLEANUP_CHUNK_SIZE   5
+
+
+
+  typedef struct FT_CleanupItemRec_
+  {
+    FT_Pointer      item;
+    FT_CleanupFunc  item_func;
+    FT_Pointer      item_data;
+
+  } FT_CleanupItemRec;
+
+  typedef struct FT_CleanupChunkRec_*   FT_CleanupChunk;
+  
+  typedef struct FT_CleanupChunkRec_
+  {
+    FT_CleanupChunk    link;
+    FT_CleanupItemRec  items[ FT_CLEANUP_CHUNK_SIZE ];
+
+  } FT_CleanupChunkRec;
+
+
+  typedef struct FT_CleanupStackRec_
+  {
+    FT_CleanupItem     top;
+    FT_CleanupItem     limit;
+    FT_CleanupChunk    chunk;
+    FT_CleanupChunkRec chunk_0;  /* avoids stupid dynamic allocation */
+    FT_Memory          memory;
+
+  } FT_CleanupStackRec, *FT_CleanupStack;
+
+
+  FT_BASE( void )
+  ft_cleanup_stack_push( FT_CleanupStack  stack,
+                         FT_Pointer       item,
+                         FT_CleanupFunc   item_func,
+                         FT_Pointer       item_data );
+
+  FT_BASE( void )
+  ft_cleanup_stack_pop( FT_CleanupStack   stack,
+                        FT_Int            destroy );
+
+  FT_BASE( FT_CleanupItem )
+  ft_cleanup_stack_peek( FT_CleanupStack  stack );
+
+  FT_BASE( void )
+  ft_xhandler_enter( FT_XHandler  xhandler,
+                     FT_Memory    memory );                         
+
+  FT_BASE( void )
+  ft_xhandler_exit( FT_XHandler  xhandler );
+
+
+  FT_BASE( void )
+  ft_cleanup_throw( FT_CleanupStack  stack,
+                    FT_Error         error );
+
+>>>>>>> 1.2
+FT_END_HEADER
+
+#endif /* __FT_EXCEPT_H__ */
--- /dev/null
+++ b/include/freetype/internal/ftgloadr.h
@@ -1,0 +1,153 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftgloadr.h                                                             */
+/*                                                                         */
+/*    The FreeType glyph loader (specification).                           */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg                       */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTGLOADR_H__
+#define __FTGLOADR_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_GlyphLoader                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The glyph loader is an internal object used to load several glyphs */
+  /*    together (for example, in the case of composites).                 */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The glyph loader implementation is not part of the high-level API, */
+  /*    hence the forward structure declaration.                           */
+  /*                                                                       */
+  typedef struct FT_GlyphLoaderRec_*  FT_GlyphLoader ;
+
+
+#define FT_SUBGLYPH_FLAG_ARGS_ARE_WORDS          1
+#define FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES      2
+#define FT_SUBGLYPH_FLAG_ROUND_XY_TO_GRID        4
+#define FT_SUBGLYPH_FLAG_SCALE                   8
+#define FT_SUBGLYPH_FLAG_XY_SCALE             0x40
+#define FT_SUBGLYPH_FLAG_2X2                  0x80
+#define FT_SUBGLYPH_FLAG_USE_MY_METRICS      0x200
+
+
+  enum
+  {
+    FT_GLYPH_OWN_BITMAP = 1
+  };
+
+
+  typedef struct  FT_SubGlyphRec_
+  {
+    FT_Int     index;
+    FT_UShort  flags;
+    FT_Int     arg1;
+    FT_Int     arg2;
+    FT_Matrix  transform;
+    
+  } FT_SubGlyphRec;
+
+
+  typedef struct  FT_GlyphLoadRec_
+  {
+    FT_Outline   outline;       /* outline             */
+    FT_Vector*   extra_points;  /* extra points table  */
+    FT_UInt      num_subglyphs; /* number of subglyphs */
+    FT_SubGlyph  subglyphs;     /* subglyphs           */
+
+  } FT_GlyphLoadRec, *FT_GlyphLoad;
+
+
+  typedef struct  FT_GlyphLoaderRec_
+  {
+    FT_Memory        memory;
+    FT_UInt          max_points;
+    FT_UInt          max_contours;
+    FT_UInt          max_subglyphs;
+    FT_Bool          use_extra;
+
+    FT_GlyphLoadRec  base;
+    FT_GlyphLoadRec  current;
+
+    void*            other;            /* for possible future extension? */
+
+  } FT_GlyphLoaderRec;
+
+
+  /* create new empty glyph loader */
+  FT_BASE( FT_Error )
+  FT_GlyphLoader_New( FT_Memory        memory,
+                      FT_GlyphLoader  *aloader );
+
+  /* add an extra points table to a glyph loader */
+  FT_BASE( FT_Error )
+  FT_GlyphLoader_CreateExtra( FT_GlyphLoader  loader );
+
+  /* destroy a glyph loader */
+  FT_BASE( void )
+  FT_GlyphLoader_Done( FT_GlyphLoader  loader );
+
+  /* reset a glyph loader (frees everything int it) */
+  FT_BASE( void )
+  FT_GlyphLoader_Reset( FT_GlyphLoader  loader );
+
+  /* rewind a glyph loader */
+  FT_BASE( void )
+  FT_GlyphLoader_Rewind( FT_GlyphLoader  loader );
+
+  /* check that there is enough room to add 'n_points' and 'n_contours' */
+  /* to the glyph loader                                                */
+  FT_BASE( FT_Error )
+  FT_GlyphLoader_CheckPoints( FT_GlyphLoader  loader,
+                              FT_UInt         n_points,
+                              FT_UInt         n_contours );
+
+  /* check that there is enough room to add 'n_subs' sub-glyphs to */
+  /* a glyph loader                                                */
+  FT_BASE( FT_Error )
+  FT_GlyphLoader_CheckSubGlyphs( FT_GlyphLoader  loader,
+                                 FT_UInt         n_subs );
+
+  /* prepare a glyph loader, i.e. empty the current glyph */
+  FT_BASE( void )
+  FT_GlyphLoader_Prepare( FT_GlyphLoader  loader );
+
+  /* add the current glyph to the base glyph */
+  FT_BASE( void )
+  FT_GlyphLoader_Add( FT_GlyphLoader  loader );
+
+  /* copy points from one glyph loader to another */
+  FT_BASE( FT_Error )
+  FT_GlyphLoader_CopyPoints( FT_GlyphLoader  target,
+                             FT_GlyphLoader  source );
+
+ /* */
+
+
+FT_END_HEADER
+
+#endif /* __FTGLOADR_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/fthash.h
@@ -1,0 +1,502 @@
+/******************************************************************
+ *
+ *  fthash.h  - fast dynamic hash tables
+ *
+ *  Copyright 2002 by
+ *  David Turner, Robert Wilhelm, and Werner Lemberg
+ *
+ *  This file is part of the FreeType project, and may only be used,
+ *  modified, and distributed under the terms of the FreeType project
+ *  license, LICENSE.TXT.  By continuing to use, modify, or distribute
+ *  this file you indicate that you have read the license and
+ *  understand and accept it fully.
+ *
+ *
+ *  This header is used to define dynamic hash tables as described
+ *  by the article "Main-Memory Linear Hashing - Some Enhancements
+ *  of Larson's Algorithm" by Mikael Petterson.
+ *
+ *  Basically, linear hashing prevents big "stalls" during
+ *  resizes of the buckets array by only splitting one bucket
+ *  at a time. This ensures excellent response time even when
+ *  the table is frequently resized..
+ *
+ *
+ *  Note that the use of the FT_Hash type is rather unusual in order
+ *  to be as generic and efficient as possible. See the comments in the
+ *  following definitions for more details.
+ */
+
+#ifndef __FT_HASH_H__
+#define __FT_HASH_H__
+
+#include <ft2build.h>
+#include FT_TYPES_H
+
+FT_BEGIN_HEADER
+
+ /***********************************************************
+  *
+  * @type: FT_Hash
+  *
+  * @description:
+  *   handle to a @FT_HashRec structure used to model a
+  *   dynamic hash table
+  */
+  typedef struct FT_HashRec_*      FT_Hash;
+
+
+ /***********************************************************
+  *
+  * @type: FT_HashNode
+  *
+  * @description:
+  *   handle to a @FT_HashNodeRec structure used to model a
+  *   single node of a hash table
+  */
+  typedef struct FT_HashNodeRec_*  FT_HashNode;
+
+
+ /***********************************************************
+  *
+  * @type: FT_HashLookup
+  *
+  * @description:
+  *   handle to a @FT_HashNode pointer. This is returned by
+  *   the @ft_hash_lookup function and can later be used by
+  *   @ft_hash_add or @ft_hash_remove
+  */
+  typedef FT_HashNode*     FT_HashLookup;
+
+
+ /***********************************************************
+  *
+  * @type: FT_Hash_EqualFunc
+  *
+  * @description:
+  *   a function used to compare two nodes of the hash table
+  *
+  * @input:
+  *   node1 :: handle to first node
+  *   node2 :: handle to second node
+  *
+  * @return:
+  *   1 iff the 'keys' in 'node1' and 'node2' are identical.
+  *   0 otherwise.
+  */
+  typedef FT_Int  (*FT_Hash_EqualFunc)( FT_HashNode  node1,
+                                        FT_HashNode  node2 );
+
+
+ /***********************************************************
+  *
+  * @struct: FT_HashRec
+  *
+  * @description:
+  *   a structure used to model a dynamic hash table.
+  *
+  * @fields:
+  *   memory       :: memory manager used to allocate
+  *                   the buckets array and the hash nodes
+  *
+  *   buckets      :: array of hash buckets
+  *
+  *   node_size    :: size of node in bytes
+  *   node_compare :: a function used to compare two nodes
+  *   node_hash    :: a function used to compute the hash
+  *                   value of a given node
+  *   p            ::
+  *   mask         ::
+  *   slack        ::
+  *
+  * @note:
+  *   'p', 'mask' and 'slack' are control values managed by
+  *   the hash table. Do not try to interpret them directly.
+  *
+  *   You can grab the hash table size by calling
+  *   '@ft_hash_get_size'.
+  */
+  typedef struct FT_HashRec_
+  {
+    FT_HashNode*         buckets;
+    FT_UInt              p;
+    FT_UInt              mask;  /* really maxp-1 */
+    FT_Long              slack;
+    FT_Hash_EqualFunc    node_equal;
+    FT_Memory            memory;
+
+  } FT_HashRec;
+
+
+ /***********************************************************
+  *
+  * @struct: FT_HashNodeRec
+  *
+  * @description:
+  *   a structure used to model the root fields of a dynamic
+  *   hash table node.
+  *
+  *   it's up to client applications to "sub-class" this
+  *   structure to add relevant (key,value) definitions
+  *
+  * @fields:
+  *   link :: pointer to next node in bucket's collision list
+  *   hash :: 32-bit hash value for this node
+  *
+  * @note:
+  *   it's up to client applications to "sub-class" this structure
+  *   to add relevant (key,value) type definitions. For example,
+  *   if we want to build a "string -> int" mapping, we could use
+  *   something like:
+  *
+  *   {
+  *     typedef struct MyNodeRec_
+  *     {
+  *       FT_HashNodeRec  hnode;
+  *       const char*     key;
+  *       int             value;
+  *
+  *     } MyNodeRec, *MyNode;
+  *   }
+  *
+  */
+  typedef struct FT_HashNodeRec_
+  {
+    FT_HashNode  link;
+    FT_UInt32    hash;
+
+  } FT_HashNodeRec;
+
+
+ /****************************************************************
+  *
+  * @function: ft_hash_init
+  *
+  * @description:
+  *   initialize a dynamic hash table
+  *
+  * @input:
+  *   table      :: handle to target hash table structure
+  *   node_equal :: node comparison function
+  *   memory     :: memory manager handle used to allocate the
+  *                 buckets array within the hash table
+  *
+  * @return:
+  *   error code. 0 means success
+  *
+  * @note:
+  *   the node comparison function should only compare node _keys_
+  *   and ignore values !! with good hashing computation (which the
+  *   user must perform itself), the comparison function should be
+  *   pretty seldom called.
+  *
+  *   here is a simple example:
+  *
+  *   {
+  *     static int my_equal( MyNode  node1,
+  *                          MyNode  node2 )
+  *     {
+  *       // compare keys of 'node1' and 'node2'
+  *       return (strcmp( node1->key, node2->key ) == 0);
+  *     }
+  *
+  *     ....
+  *
+  *     ft_hash_init( &hash, (FT_Hash_EqualFunc) my_compare, memory );
+  *     ....
+  *   }
+  */
+  FT_BASE( FT_Error )
+  ft_hash_init( FT_Hash              table,
+                FT_Hash_EqualFunc  compare,
+                FT_Memory            memory );
+
+
+ /****************************************************************
+  *
+  * @function: ft_hash_lookup
+  *
+  * @description:
+  *   search a hash table to find a node corresponding to a given
+  *   key.
+  *
+  * @input:
+  *   table   :: handle to target hash table structure
+  *   keynode :: handle to a reference hash node that will be
+  *              only used for key comparisons with the table's
+  *              elements
+  *
+  * @return:
+  *   a pointer-to-hash-node value, which must be used as followed:
+  *
+  *   - if '*result' is NULL, the key wasn't found in the hash
+  *     table. The value of 'result' can be used to add new elements
+  *     through @ft_hash_add however..
+  *
+  *   - if '*result' is not NULL, it's a handle to the first table
+  *     node that corresponds to the search key. The value of 'result'
+  *     can be used to remove this element through @ft_hash_remove
+  *
+  * @note:
+  *   here is an example:
+  *
+  *   {
+  *     // maps a string to an integer with a hash table
+  *     // returns -1 in case of failure
+  *     //
+  *     int  my_lookup( FT_Hash      table,
+  *                     const char*  key )
+  *     {
+  *       MyNode*    pnode;
+  *       MyNodeRec  noderec;
+  *
+  *       // set-up key node. It's 'hash' and 'key' fields must
+  *       // be set correctly.. we ignore 'link' and 'value'
+  *       //
+  *       noderec.hnode.hash = strhash( key );
+  *       noderec.key        = key;
+  *
+  *       // perform search - return value
+  *       //
+  *       pnode = (MyNode) ft_hash_lookup( table, &noderec );
+  *       if ( *pnode )
+  *       {
+  *         // we found it
+  *         return (*pnode)->value;
+  *       }
+  *       return -1;
+  *     }
+  *   }
+  */
+  FT_BASE_DEF( FT_HashLookup )
+  ft_hash_lookup( FT_Hash      table,
+                  FT_HashNode  keynode );
+
+
+ /****************************************************************
+  *
+  * @function: ft_hash_add
+  *
+  * @description:
+  *   add a new node to a dynamic hash table. the user must
+  *   call @ft_hash_lookup and allocate a new node before calling
+  *   this function.
+  *
+  * @input:
+  *   table    :: hash table handle
+  *   lookup   :: pointer-to-hash-node value returned by @ft_hash_lookup
+  *   new_node :: handle to new hash node. All its fields must be correctly
+  *               set, including 'hash'.
+  *
+  * @return:
+  *   error code. 0 means success
+  *
+  * @note:
+  *   this function should always be used _after_ a call to @ft_hash_lookup
+  *   that returns a pointer to a NULL  handle. Here's an example:
+  *
+  *   {
+  *     // sets the value corresponding to a given string key
+  *     //
+  *     void  my_set( FT_Hash      table,
+  *                   const char*  key,
+  *                   int          value )
+  *     {
+  *       MyNode*    pnode;
+  *       MyNodeRec  noderec;
+  *       MyNode     node;
+  *
+  *       // set-up key node. It's 'hash' and 'key' fields must
+  *       // be set correctly..
+  *       noderec.hnode.hash = strhash( key );
+  *       noderec.key        = key;
+  *
+  *       // perform search - return value
+  *       pnode = (MyNode) ft_hash_lookup( table, &noderec );
+  *       if ( *pnode )
+  *       {
+  *         // we found it, simply replace the value in the node
+  *         (*pnode)->value = value;
+  *         return;
+  *       }
+  *
+  *       // allocate a new node - and set it up
+  *       node = (MyNode) malloc( sizeof(*node) );
+  *       if ( node == NULL ) .....
+  *
+  *       node->hnode.hash = noderec.hnode.hash;
+  *       node->key        = key;
+  *       node->value      = value;
+  *
+  *       // add it to the hash table
+  *       error = ft_hash_add( table, pnode, node );
+  *       if (error) ....
+  *     }
+  */
+  FT_BASE( FT_Error )
+  ft_hash_add( FT_Hash        table,
+               FT_HashLookup  lookup,
+               FT_HashNode    new_node );
+
+
+ /****************************************************************
+  *
+  * @function: ft_hash_remove
+  *
+  * @description:
+  *   try to remove the node corresponding to a given key from
+  *   a hash table. This must be called after @ft_hash_lookup
+  *
+  * @input:
+  *   table   :: hash table handle
+  *   lookup  :: pointer-to-hash-node value returned by @ft_hash_lookup
+  *
+  * @note:
+  *   this function doesn't free the node itself !! Here's an example:
+  *
+  *   {
+  *     // sets the value corresponding to a given string key
+  *     //
+  *     void  my_remove( FT_Hash      table,
+  *                      const char*  key )
+  *     {
+  *       MyNodeRec  noderec;
+  *       MyNode     node;
+  *
+  *       noderec.hnode.hash = strhash(key);
+  *       noderec.key        = key;
+  *       node               = &noderec;
+  *
+  *       pnode = ft_hash_lookup( table, &noderec );
+  *       node  = *pnode;
+  *       if ( node != NULL )
+  *       {
+  *         error = ft_hash_remove( table, pnode );
+  *         if ( !error )
+  *           free( node );
+  *       }
+  *     }
+  *   }
+  */
+  FT_BASE( FT_Error )
+  ft_hash_remove( FT_Hash        table,
+                  FT_HashLookup  lookup );
+
+
+
+ /****************************************************************
+  *
+  * @function: ft_hash_get_size
+  *
+  * @description:
+  *   return the number of elements in a given hash table
+  *
+  * @input:
+  *   table   :: handle to target hash table structure
+  *
+  * @return:
+  *   number of elements. 0 if empty
+  */
+  FT_BASE( FT_UInt )
+  ft_hash_get_size( FT_Hash  table );
+
+
+
+ /****************************************************************
+  *
+  * @functype: FT_Hash_ForeachFunc
+  *
+  * @description:
+  *   a function used to iterate over all elements of a given
+  *   hash table
+  *
+  * @input:
+  *   node :: handle to target @FT_HashNodeRec node structure
+  *   data :: optional argument to iteration routine
+  *
+  * @also:  @ft_hash_foreach
+  */
+  typedef void  (*FT_Hash_ForeachFunc)( const FT_HashNode  node,
+                                        const FT_Pointer   data );
+
+
+ /****************************************************************
+  *
+  * @function: ft_hash_foreach
+  *
+  * @description:
+  *   parse over all elements in a hash table
+  *
+  * @input:
+  *   table        :: handle to target hash table structure
+  *   foreach_func :: iteration routine called for each element
+  *   foreach_data :: optional argument to the iteration routine
+  *
+  * @note:
+  *   this function is often used to release all elements from a
+  *   hash table. See the example given for @ft_hash_done
+  */
+  FT_BASE( void )
+  ft_hash_foreach( FT_Hash              table,
+                   FT_Hash_ForeachFunc  foreach_func,
+                   const FT_Pointer     foreach_data );
+
+
+
+ /****************************************************************
+  *
+  * @function: ft_hash_done
+  *
+  * @description:
+  *   finalize a given hash table
+  *
+  * @input:
+  *   table     :: handle to target hash table structure
+  *   node_func :: optional iteration function pointer. this
+  *                can be used to destroy all nodes explicitely
+  *   node_data :: optional argument to the node iterator
+  *
+  * @note:
+  *   this function simply frees the hash table's buckets.
+  *   you probably will need to call @ft_hash_foreach to
+  *   destroy all its elements before @ft_hash_done, as in
+  *   the following example:
+  *
+  *   {
+  *     static void  my_node_clear( const MyNode  node )
+  *     {
+  *       free( node );
+  *     }
+  *
+  *     static void  my_done( FT_Hash  table )
+  *     {
+  *       ft_hash_done( table, (FT_Hash_ForeachFunc) my_node_clear, NULL );
+  *     }
+  *   }
+  */
+  FT_BASE( void )
+  ft_hash_done( FT_Hash              table,
+                FT_Hash_ForeachFunc  item_func,
+                const FT_Pointer     item_data );
+
+ /* */
+
+ /* compute bucket index from hash value in a dynamic hash table */
+ /* this is only used to break encapsulation to speed lookups in */
+ /* the FreeType cache manager !!                                */
+ /*                                                              */
+
+#define  FT_HASH_COMPUTE_INDEX(_table,_hash,_index)                  \
+             {                                                       \
+               FT_UInt  _mask  = (_table)->mask;                     \
+               FT_UInt  _hash0 = (_hash);                            \
+                                                                     \
+               (_index) = (FT_UInt)( (_hash0) & _mask ) );           \
+               if ( (_index) < (_table)->p )                         \
+                 (_index) = (FT_uInt)( (_hash0) & ( 2*_mask+1 ) );   \
+             }
+
+
+FT_END_HEADER
+
+#endif /* __FT_HASH_H__ */
--- /dev/null
+++ b/include/freetype/internal/ftmemory.h
@@ -1,0 +1,296 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftmemory.h                                                             */
+/*                                                                         */
+/*    The FreeType memory management macros (specification).               */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg                       */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTMEMORY_H__
+#define __FTMEMORY_H__
+
+
+#include <ft2build.h>
+#include FT_CONFIG_CONFIG_H
+#include FT_TYPES_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Macro>                                                               */
+  /*    FT_SET_ERROR                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This macro is used to set an implicit `error' variable to a given  */
+  /*    expression's value (usually a function call), and convert it to a  */
+  /*    boolean which is set whenever the value is != 0.                   */
+  /*                                                                       */
+#undef  FT_SET_ERROR
+#define FT_SET_ERROR( expression ) \
+          ( ( error = (expression) ) != 0 )
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                           M E M O R Y                           ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+#ifdef FT_DEBUG_MEMORY
+
+  FT_BASE( FT_Error )
+  FT_Alloc_Debug( FT_Memory    memory,
+                  FT_Long      size,
+                  void*       *P,
+                  const char*  file_name,
+                  FT_Long      line_no );
+
+  FT_BASE( FT_Error )
+  FT_Realloc_Debug( FT_Memory    memory,
+                    FT_Long      current,
+                    FT_Long      size,
+                    void*       *P,
+                    const char*  file_name,
+                    FT_Long      line_no );
+
+  FT_BASE( void )
+  FT_Free_Debug( FT_Memory    memory,
+                 FT_Pointer   block,
+                 const char*  file_name,
+                 FT_Long      line_no );
+
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Alloc                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Allocates a new block of memory.  The returned area is always      */
+  /*    zero-filled; this is a strong convention in many FreeType parts.   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    memory :: A handle to a given `memory object' which handles        */
+  /*              allocation.                                              */
+  /*                                                                       */
+  /*    size   :: The size in bytes of the block to allocate.              */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    P      :: A pointer to the fresh new block.  It should be set to   */
+  /*              NULL if `size' is 0, or in case of error.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_BASE( FT_Error )
+  FT_Alloc( FT_Memory  memory,
+            FT_Long    size,
+            void*     *P );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Realloc                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Reallocates a block of memory pointed to by `*P' to `Size' bytes   */
+  /*    from the heap, possibly changing `*P'.                             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    memory  :: A handle to a given `memory object' which handles       */
+  /*               reallocation.                                           */
+  /*                                                                       */
+  /*    current :: The current block size in bytes.                        */
+  /*                                                                       */
+  /*    size    :: The new block size in bytes.                            */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    P       :: A pointer to the fresh new block.  It should be set to  */
+  /*               NULL if `size' is 0, or in case of error.               */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    All callers of FT_Realloc() _must_ provide the current block size  */
+  /*    as well as the new one.                                            */
+  /*                                                                       */
+  FT_BASE( FT_Error )
+  FT_Realloc( FT_Memory  memory,
+              FT_Long    current,
+              FT_Long    size,
+              void**     P );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Free                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Releases a given block of memory allocated through FT_Alloc().     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    memory :: A handle to a given `memory object' which handles        */
+  /*              memory deallocation                                      */
+  /*                                                                       */
+  /*    P      :: This is the _address_ of a _pointer_ which points to the */
+  /*              allocated block.  It is always set to NULL on exit.      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    If P or *P are NULL, this function should return successfully.     */
+  /*    This is a strong convention within all of FreeType and its         */
+  /*    drivers.                                                           */
+  /*                                                                       */
+  FT_BASE( void )
+  FT_Free( FT_Memory  memory,
+           void**     P );
+
+
+#define FT_MEM_SET( dest, byte, count )     ft_memset( dest, byte, count )
+
+#define FT_MEM_COPY( dest, source, count )  ft_memcpy( dest, source, count )
+
+#define FT_MEM_MOVE( dest, source, count )  ft_memmove( dest, source, count )
+
+
+#define FT_MEM_ZERO( dest, count )  FT_MEM_SET( dest, 0, count )
+
+#define FT_ZERO( p )                FT_MEM_ZERO( p, sizeof ( *(p) ) )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* We first define FT_MEM_ALLOC, FT_MEM_REALLOC, and FT_MEM_FREE.  All   */
+  /* macros use an _implicit_ `memory' parameter to access the current     */
+  /* memory allocator.                                                     */
+  /*                                                                       */
+
+#ifdef FT_DEBUG_MEMORY
+
+#define FT_MEM_ALLOC( _pointer_, _size_ )                            \
+          FT_Alloc_Debug( memory, _size_,                            \
+                          (void**)&(_pointer_), __FILE__, __LINE__ )
+
+#define FT_MEM_REALLOC( _pointer_, _current_, _size_ )                 \
+          FT_Realloc_Debug( memory, _current_, _size_,                 \
+                            (void**)&(_pointer_), __FILE__, __LINE__ )
+
+#define FT_MEM_FREE( _pointer_ )                                            \
+          FT_Free_Debug( memory, (void**)&(_pointer_), __FILE__, __LINE__ )
+
+
+#else  /* !FT_DEBUG_MEMORY */
+
+
+#define FT_MEM_ALLOC( _pointer_, _size_ )                  \
+          FT_Alloc( memory, _size_, (void**)&(_pointer_) )
+
+#define FT_MEM_FREE( _pointer_ )                  \
+          FT_Free( memory, (void**)&(_pointer_) )
+
+#define FT_MEM_REALLOC( _pointer_, _current_, _size_ )                  \
+          FT_Realloc( memory, _current_, _size_, (void**)&(_pointer_) )
+
+
+#endif /* !FT_DEBUG_MEMORY */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The following functions macros expect that their pointer argument is  */
+  /* _typed_ in order to automatically compute array element sizes.        */
+  /*                                                                       */
+
+#define FT_MEM_NEW( _pointer_ )                               \
+          FT_MEM_ALLOC( _pointer_, sizeof ( *(_pointer_) ) )
+
+#define FT_MEM_NEW_ARRAY( _pointer_, _count_ )                           \
+          FT_MEM_ALLOC( _pointer_, (_count_) * sizeof ( *(_pointer_) ) )
+
+#define FT_MEM_RENEW_ARRAY( _pointer_, _old_, _new_ )                    \
+          FT_MEM_REALLOC( _pointer_, (_old_) * sizeof ( *(_pointer_) ),  \
+                                     (_new_) * sizeof ( *(_pointer_) ) )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* the following macros are obsolete but kept for compatibility reasons  */
+  /*                                                                       */
+
+#define FT_MEM_ALLOC_ARRAY( _pointer_, _count_, _type_ )           \
+          FT_MEM_ALLOC( _pointer_, (_count_) * sizeof ( _type_ ) )
+
+#define FT_MEM_REALLOC_ARRAY( _pointer_, _old_, _new_, _type_ )    \
+          FT_MEM_REALLOC( _pointer_, (_old_) * sizeof ( _type ),   \
+                                     (_new_) * sizeof ( _type_ ) )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The following macros are variants of their FT_MEM_XXXX equivalents;   */
+  /* they are used to set an _implicit_ `error' variable and return TRUE   */
+  /* if an error occured (i.e. if 'error != 0').                           */
+  /*                                                                       */
+
+#define FT_ALLOC( _pointer_, _size_ )                       \
+          FT_SET_ERROR( FT_MEM_ALLOC( _pointer_, _size_ ) )
+
+#define FT_REALLOC( _pointer_, _current_, _size_ )                       \
+          FT_SET_ERROR( FT_MEM_REALLOC( _pointer_, _current_, _size_ ) )
+
+#define FT_FREE( _pointer_ )       \
+          FT_MEM_FREE( _pointer_ )
+
+#define FT_NEW( _pointer_ )  \
+          FT_SET_ERROR( FT_MEM_NEW( _pointer_ ) )
+
+#define FT_NEW_ARRAY( _pointer_, _count_ )  \
+          FT_SET_ERROR( FT_MEM_NEW_ARRAY( _pointer_, _count_ ) )
+
+#define FT_RENEW_ARRAY( _pointer_, _old_, _new_ )   \
+          FT_SET_ERROR( FT_MEM_RENEW_ARRAY( _pointer_, _old_, _new_ ) )
+
+#define FT_ALLOC_ARRAY( _pointer_, _count_, _type_ )                    \
+          FT_SET_ERROR( FT_MEM_ALLOC( _pointer_,                        \
+                                      (_count_) * sizeof ( _type_ ) ) )
+
+#define FT_REALLOC_ARRAY( _pointer_, _old_, _new_, _type_ )             \
+          FT_SET_ERROR( FT_MEM_REALLOC( _pointer_,                      \
+                                        (_old_) * sizeof ( _type_ ),    \
+                                        (_new_) * sizeof ( _type_ ) ) )
+
+ /* */
+
+
+FT_END_HEADER
+
+#endif /* __FTMEMORY_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/ftobject.h
@@ -1,0 +1,533 @@
+#ifndef __FT_OBJECT_H__
+#define __FT_OBJECT_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+FT_BEGIN_HEADER
+
+ /**************************************************************
+  *
+  * @type: FT_Object
+  *
+  * @description:
+  *   handle to a FreeType Object. See @FT_ObjectRec
+  */
+  typedef struct FT_ObjectRec_*        FT_Object;
+
+
+ /**************************************************************
+  *
+  * @type: FT_Class
+  *
+  * @description:
+  *   handle to a constant class handle to a FreeType Object.
+  *
+  *   Note that a class is itself a @FT_Object and are dynamically
+  *   allocated on the heap.
+  *
+  * @also:
+  *  @FT_ClassRec, @FT_Object, @FT_ObjectRec, @FT_Type, @FT_TypeRec
+  */
+  typedef const struct FT_ClassRec_*   FT_Class;
+
+
+ /**************************************************************
+  *
+  * @type: FT_Type
+  *
+  * @description:
+  *   handle to a constant structure (of type @FT_TypeRec) used
+  *   to describe a given @FT_Class type to the FreeType object
+  *   sub-system.
+  */
+  typedef const struct FT_TypeRec_*    FT_Type;
+
+
+
+ /**************************************************************
+  *
+  * @struct: FT_ObjectRec
+  *
+  * @description:
+  *   a structure describing the root fields of all @FT_Object
+  *   class instances in FreeType
+  *
+  * @fields:
+  *   clazz     :: handle to the object's class
+  *   ref_count :: object's reference count. Starts at 1
+  */
+  typedef struct FT_ObjectRec_
+  {
+    FT_Class  clazz;
+    FT_Int    ref_count;
+
+  } FT_ObjectRec;
+
+
+ /**************************************************************
+  *
+  * @macro: FT_OBJECT (x)
+  *
+  * @description:
+  *   a useful macro to type-cast anything to a @FT_Object
+  *   handle. No check performed..
+  */
+#define  FT_OBJECT(x)    ((FT_Object)(x))
+
+
+ /**************************************************************
+  *
+  * @macro: FT_OBJECT_P (x)
+  *
+  * @description:
+  *   a useful macro to type-cast anything to a pointer to
+  *   @FT_Object handle.
+  */
+#define  FT_OBJECT_P(x)  ((FT_Object*)(x))
+
+
+ /**************************************************************
+  *
+  * @macro: FT_OBJECT__CLASS (obj)
+  *
+  * @description:
+  *   a useful macro to return the class of any object
+  */
+#define  FT_OBJECT__CLASS(x)      FT_OBJECT(x)->clazz
+
+
+ /**************************************************************
+  *
+  * @macro: FT_OBJECT__REF_COUNT (obj)
+  *
+  * @description:
+  *   a useful macro to return the reference count of any object
+  */
+#define  FT_OBJECT__REF_COUNT(x)  FT_OBJECT(x)->ref_count
+
+
+ /**************************************************************
+  *
+  * @macro: FT_OBJECT__MEMORY (obj)
+  *
+  * @description:
+  *   a useful macro to return a handle to the memory manager
+  *   used to allocate a given object
+  */
+#define  FT_OBJECT__MEMORY(x)     FT_CLASS__MEMORY(FT_OBJECT(x)->clazz)
+
+
+ /**************************************************************
+  *
+  * @macro: FT_OBJECT__LIBRARY (obj)
+  *
+  * @description:
+  *   a useful macro to return a handle to the library handle
+  *   that owns the object
+  */
+#define  FT_OBJECT__LIBRARY(x)    FT_CLASS__LIBRARY(FT_OBJECT(x)->clazz)
+
+
+ /**************************************************************
+  *
+  * @functype: FT_Object_InitFunc
+  *
+  * @description:
+  *   a function used to initialize a new object
+  *
+  * @input:
+  *   object    :: target object handle
+  *   init_data :: optional pointer to initialization data
+  *
+  * @return:
+  *   error code. 0 means success
+  */
+  typedef FT_Error  (*FT_Object_InitFunc)( FT_Object   object,
+                                           FT_Pointer  init_data );
+
+ /**************************************************************
+  *
+  * @functype: FT_Object_DoneFunc
+  *
+  * @description:
+  *   a function used to finalize a given object
+  *
+  * @input:
+  *   object    :: handle to target object
+  */
+  typedef void  (*FT_Object_DoneFunc)( FT_Object   object );
+
+
+ /**************************************************************
+  *
+  * @struct: FT_ClassRec
+  *
+  * @description:
+  *   a structure used to describe a given object class within
+  *   FreeType
+  *
+  * @fields:
+  *   object   :: root @FT_ObjectRec fields, since each class is
+  *               itself an object. (it's an instance of the
+  *               "metaclass", a special object of the FreeType
+  *               object sub-system.)
+  *
+  *   magic    :: a 32-bit magic number used for decoding
+  *   super    :: pointer to super class
+  *   type     :: the @FT_Type descriptor of this class
+  *   memory   :: the current memory manager handle
+  *   library  :: the current library handle
+  *   info     :: an opaque pointer to class-specific information
+  *               managed by the FreeType object sub-system
+  *
+  *   class_done :: the class destructor function
+  *
+  *   obj_size :: size of class instances in bytes
+  *   obj_init :: class instance constructor
+  *   obj_done :: class instance destructor
+  */
+  typedef struct FT_ClassRec_
+  {
+    FT_ObjectRec        object;
+    FT_UInt32           magic;
+    FT_Class            super;
+    FT_Type             type;
+    FT_Memory           memory;
+    FT_Library          library;
+    FT_Pointer          info;
+
+    FT_Object_DoneFunc  class_done;
+
+    FT_UInt             obj_size;
+    FT_Object_InitFunc  obj_init;
+    FT_Object_DoneFunc  obj_done;
+
+  } FT_ClassRec;
+
+
+ /**************************************************************
+  *
+  * @macro: FT_CLASS (x)
+  *
+  * @description:
+  *   a useful macro to convert anything to a class handle
+  *   without checks
+  */
+#define  FT_CLASS(x)    ((FT_Class)(x))
+
+
+ /**************************************************************
+  *
+  * @macro: FT_CLASS_P (x)
+  *
+  * @description:
+  *   a useful macro to convert anything to a pointer to a class
+  *   handle without checks
+  */
+#define  FT_CLASS_P(x)  ((FT_Class*)(x))
+
+
+ /**************************************************************
+  *
+  * @macro: FT_CLASS__MEMORY (clazz)
+  *
+  * @description:
+  *   a useful macro to return the memory manager handle of a
+  *   given class
+  */
+#define  FT_CLASS__MEMORY(x)   FT_CLASS(x)->memory
+
+
+ /**************************************************************
+  *
+  * @macro: FT_CLASS__LIBRARY (clazz)
+  *
+  * @description:
+  *   a useful macro to return the library handle of a
+  *   given class
+  */
+#define  FT_CLASS__LIBRARY(x)  FT_CLASS(x)->library
+
+
+
+ /**************************************************************
+  *
+  * @macro: FT_CLASS__TYPE (clazz)
+  *
+  * @description:
+  *   a useful macro to return the type of a given class
+  *   given class
+  */
+#define  FT_CLASS__TYPE(x)     FT_CLASS(x)->type
+
+ /* */
+#define  FT_CLASS__INFO(x)     FT_CLASS(x)->info
+#define  FT_CLASS__MAGIC(x)    FT_CLASS(x)->magic
+
+
+ /**************************************************************
+  *
+  * @struct: FT_TypeRec
+  *
+  * @description:
+  *   a structure used to describe a given class to the FreeType
+  *   object sub-system.
+  *
+  * @fields:
+  *   name       :: class name. only used for debugging
+  *   super      :: type of super-class. NULL if none
+  *
+  *   class_size :: size of class structure in bytes
+  *   class_init :: class constructor
+  *   class_done :: class finalizer
+  *
+  *   obj_size   :: instance size in bytes
+  *   obj_init   :: instance constructor. can be NULL
+  *   obj_done   :: instance destructor. can be NULL
+  *
+  * @note:
+  *   if 'obj_init' is NULL, the class will use it's parent
+  *   constructor, if any
+  *
+  *   if 'obj_done' is NULL, the class will use it's parent
+  *   finalizer, if any
+  *
+  *   the object sub-system allocates a new class, copies
+  *   the content of its super-class into the new structure,
+  *   _then_ calls 'clazz_init'.
+  *
+  *   'class_init' and 'class_done' can be NULL, in which case
+  *   the parent's class constructor and destructor wil be used
+  */
+  typedef struct FT_TypeRec_
+  {
+    const char*         name;
+    FT_Type             super;
+
+    FT_UInt             class_size;
+    FT_Object_InitFunc  class_init;
+    FT_Object_DoneFunc  class_done;
+
+    FT_UInt             obj_size;
+    FT_Object_InitFunc  obj_init;
+    FT_Object_DoneFunc  obj_done;
+
+  } FT_TypeRec;
+
+
+ /**************************************************************
+  *
+  * @macro: FT_TYPE (x)
+  *
+  * @description:
+  *   a useful macro to convert anything to a class type handle
+  *   without checks
+  */
+#define  FT_TYPE(x)  ((FT_Type)(x))
+
+
+ /**************************************************************
+  *
+  * @function: ft_object_check
+  *
+  * @description:
+  *   checks that a handle points to a valid @FT_Object
+  *
+  * @input:
+  *   obj :: handle/pointer
+  *
+  * @return:
+  *   1 iff the handle points to a valid object. 0 otherwise
+  */
+  FT_BASE( FT_Int )
+  ft_object_check( FT_Pointer  obj );
+
+
+ /**************************************************************
+  *
+  * @function: ft_object_is_a
+  *
+  * @description:
+  *   checks that a handle points to a valid @FT_Object that
+  *   is an instance of a given class (or of any of its sub-classes)
+  *
+  * @input:
+  *   obj   :: handle/pointer
+  *   clazz :: class handle to check
+  *
+  * @return:
+  *   1 iff the handle points to a valid 'clazz' instance. 0
+  *   otherwise.
+  */
+  FT_BASE( FT_Int )
+  ft_object_is_a( FT_Pointer  obj,
+                  FT_Class    clazz );
+
+
+ /**************************************************************
+  *
+  * @function: ft_object_create
+  *
+  * @description:
+  *   create a new object (class instance)
+  *
+  * @output:
+  *   aobject   :: new object handle. NULL in case of error
+  *
+  * @input:
+  *   clazz     :: object's class pointer
+  *   init_data :: optional pointer to initialization data
+  *
+  * @return:
+  *   error code. 0 means success
+  */
+  FT_BASE( FT_Error )
+  ft_object_create( FT_Object  *aobject,
+                    FT_Class    clazz,
+                    FT_Pointer  init_data );
+
+
+ /**************************************************************
+  *
+  * @function: ft_object_create_from_type
+  *
+  * @description:
+  *   create a new object (class instance) from a @FT_Type
+  *
+  * @output:
+  *   aobject   :: new object handle. NULL in case of error
+  *
+  * @input:
+  *   type      :: object's type descriptor
+  *   init_data :: optional pointer to initialization data
+  *
+  * @return:
+  *   error code. 0 means success
+  *
+  * @note:
+  *   this function is slower than @ft_object_create
+  *
+  *   this is equivalent to calling @ft_class_from_type followed by
+  *   @ft_object_create
+  */
+  FT_BASE( FT_Error )
+  ft_object_create_from_type( FT_Object  *aobject,
+                              FT_Type     type,
+                              FT_Pointer  init_data,
+                              FT_Library  library );
+
+
+
+ /**************************************************************
+  *
+  * @macro FT_OBJ_CREATE (object,class,init)
+  *
+  * @description:
+  *   a convenient macro used to create new objects. see
+  *   @ft_object_create for details
+  */
+#define  FT_OBJ_CREATE( _obj, _clazz, _init )   \
+               ft_object_create( FT_OBJECT_P(&(_obj)), _clazz, _init )
+
+
+ /**************************************************************
+  *
+  * @macro FT_CREATE (object,class,init)
+  *
+  * @description:
+  *   a convenient macro used to create new objects. It also
+  *   sets an _implicit_ local variable named "error" to the error
+  *   code returned by the object constructor.
+  */
+#define  FT_CREATE( _obj, _clazz, _init )  \
+             FT_SET_ERROR( FT_OBJ_CREATE( _obj, _clazz, _init ) )
+
+ /**************************************************************
+  *
+  * @macro FT_OBJ_CREATE_FROM_TYPE (object,type,init)
+  *
+  * @description:
+  *   a convenient macro used to create new objects. see
+  *   @ft_object_create_from_type for details
+  */
+#define  FT_OBJ_CREATE_FROM_TYPE( _obj, _type, _init, _lib )   \
+               ft_object_create_from_type( FT_OBJECT_P(&(_obj)), _type, _init, _lib )
+
+
+ /**************************************************************
+  *
+  * @macro FT_CREATE_FROM_TYPE (object,type,init)
+  *
+  * @description:
+  *   a convenient macro used to create new objects. It also
+  *   sets an _implicit_ local variable named "error" to the error
+  *   code returned by the object constructor.
+  */
+#define  FT_CREATE_FROM_TYPE( _obj, _type, _init, _lib )  \
+             FT_SET_ERROR( FT_OBJ_CREATE_FROM_TYPE( _obj, _type, _init, _lib ) )
+
+
+ /* */
+
+ /**************************************************************
+  *
+  * @function: ft_class_from_type
+  *
+  * @description:
+  *   retrieves the class object corresponding to a given type
+  *   descriptor. The class is created when needed
+  *
+  * @output:
+  *   aclass  :: handle to corresponding class object. NULL in
+  *              case of error
+  *
+  * @input:
+  *   type    :: type descriptor handle
+  *   library :: library handle
+  *
+  * @return:
+  *   error code. 0 means success
+  */
+  FT_BASE( FT_Error )
+  ft_class_from_type( FT_Class   *aclass,
+                      FT_Type     type,
+                      FT_Library  library );
+
+
+ /* */
+
+#include FT_INTERNAL_HASH_H
+
+  typedef struct FT_ClassHNodeRec_*  FT_ClassHNode;
+
+  typedef struct FT_ClassHNodeRec_
+  {
+    FT_HashNodeRec  hnode;
+    FT_Type         type;
+    FT_Class        clazz;
+
+  } FT_ClassHNodeRec;
+
+  typedef struct FT_MetaClassRec_
+  {
+    FT_ClassRec   clazz;         /* the meta-class is a class itself */
+    FT_HashRec    type_to_class; /* the type => class hash table */
+
+  } FT_MetaClassRec, *FT_MetaClass;
+
+
+ /* initialize meta class */
+  FT_BASE( FT_Error )
+  ft_metaclass_init( FT_MetaClass  meta,
+                     FT_Library    library );
+
+ /* finalize meta class - destroy all registered class objects */
+  FT_BASE( void )
+  ft_metaclass_done( FT_MetaClass  meta );
+
+ /* */
+
+FT_END_HEADER
+
+#endif /* __FT_OBJECT_H__ */
--- /dev/null
+++ b/include/freetype/internal/ftobjs.h
@@ -1,0 +1,794 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftobjs.h                                                               */
+/*                                                                         */
+/*    The FreeType private base classes (specification).                   */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  This file contains the definition of all internal FreeType classes.  */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#ifndef __FTOBJS_H__
+#define __FTOBJS_H__
+
+#include <ft2build.h>
+#include FT_CONFIG_STANDARD_LIBRARY_H   /* for ft_setjmp and ft_longjmp */
+#include FT_RENDER_H
+#include FT_SIZES_H
+#include FT_INTERNAL_MEMORY_H
+#include FT_INTERNAL_GLYPH_LOADER_H
+#include FT_INTERNAL_DRIVER_H
+#include FT_INTERNAL_AUTOHINT_H
+#include FT_INTERNAL_OBJECT_H
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+#include FT_INCREMENTAL_H
+#endif
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Some generic definitions.                                             */
+  /*                                                                       */
+#ifndef TRUE
+#define TRUE  1
+#endif
+
+#ifndef FALSE
+#define FALSE  0
+#endif
+
+#ifndef NULL
+#define NULL  (void*)0
+#endif
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* The min and max functions missing in C.  As usual, be careful not to  */
+  /* write things like MIN( a++, b++ ) to avoid side effects.              */
+  /*                                                                       */
+#ifndef MIN
+#define MIN( a, b )  ( (a) < (b) ? (a) : (b) )
+#endif
+
+#ifndef MAX
+#define MAX( a, b )  ( (a) > (b) ? (a) : (b) )
+#endif
+
+#ifndef ABS
+#define ABS( a )     ( (a) < 0 ? -(a) : (a) )
+#endif
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                    V A L I D A T I O N                          ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* handle to a validation object */
+  typedef struct FT_ValidatorRec_*  FT_Validator;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* There are three distinct validation levels defined here:              */
+  /*                                                                       */
+  /* FT_VALIDATE_DEFAULT ::                                                */
+  /*   A table that passes this validation level can be used reliably by   */
+  /*   FreeType.  It generally means that all offsets have been checked to */
+  /*   prevent out-of-bound reads, array counts are correct, etc.          */
+  /*                                                                       */
+  /* FT_VALIDATE_TIGHT ::                                                  */
+  /*   A table that passes this validation level can be used reliably and  */
+  /*   doesn't contain invalid data.  For example, a charmap table that    */
+  /*   returns invalid glyph indices will not pass, even though it can     */
+  /*   be used with FreeType in default mode (the library will simply      */
+  /*   return an error later when trying to load the glyph).               */
+  /*                                                                       */
+  /*   It also check that fields that must be a multiple of 2, 4, or 8     */
+  /*   dont' have incorrect values, etc.                                   */
+  /*                                                                       */
+  /* FT_VALIDATE_PARANOID ::                                               */
+  /*   Only for font debugging.  Checks that a table follows the           */
+  /*   specification by 100%.  Very few fonts will be able to pass this    */
+  /*   level anyway but it can be useful for certain tools like font       */
+  /*   editors/converters.                                                 */
+  /*                                                                       */
+  typedef enum  FT_ValidationLevel_
+  {
+    FT_VALIDATE_DEFAULT = 0,
+    FT_VALIDATE_TIGHT,
+    FT_VALIDATE_PARANOID
+
+  } FT_ValidationLevel;
+
+
+  /* validator structure */
+  typedef struct  FT_ValidatorRec_
+  {
+    const FT_Byte*      base;        /* address of table in memory       */
+    const FT_Byte*      limit;       /* `base' + sizeof(table) in memory */
+    FT_ValidationLevel  level;       /* validation level                 */
+    FT_Error            error;       /* error returned. 0 means success  */
+
+    ft_jmp_buf          jump_buffer; /* used for exception handling      */
+
+  } FT_ValidatorRec;
+
+
+#define FT_VALIDATOR( x )  ((FT_Validator)( x ))
+
+
+  FT_BASE( void )
+  ft_validator_init( FT_Validator        valid,
+                     const FT_Byte*      base,
+                     const FT_Byte*      limit,
+                     FT_ValidationLevel  level );
+
+  FT_BASE( FT_Int )
+  ft_validator_run( FT_Validator  valid );
+
+  /* Sets the error field in a validator, then calls `longjmp' to return */
+  /* to high-level caller.  Using `setjmp/longjmp' avoids many stupid    */
+  /* error checks within the validation routines.                        */
+  /*                                                                     */
+  FT_BASE( void )
+  ft_validator_error( FT_Validator  valid,
+                      FT_Error      error );
+
+
+  /* Calls ft_validate_error.  Assumes that the `valid' local variable */
+  /* holds a pointer to the current validator object.                  */
+  /*                                                                   */
+#define FT_INVALID( _error )  ft_validator_error( valid, _error )
+
+  /* called when a broken table is detected */
+#define FT_INVALID_TOO_SHORT  FT_INVALID( FT_Err_Invalid_Table )
+
+  /* called when an invalid offset is detected */
+#define FT_INVALID_OFFSET     FT_INVALID( FT_Err_Invalid_Offset )
+
+  /* called when an invalid format/value is detected */
+#define FT_INVALID_FORMAT     FT_INVALID( FT_Err_Invalid_Table )
+
+  /* called when an invalid glyph index is detected */
+#define FT_INVALID_GLYPH_ID   FT_INVALID( FT_Err_Invalid_Glyph_Index )
+
+  /* called when an invalid field value is detected */
+#define FT_INVALID_DATA       FT_INVALID( FT_Err_Invalid_Table )
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                       C H A R M A P S                           ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* handle to internal charmap object */
+  typedef struct FT_CMapRec_*              FT_CMap;
+
+  /* handle to charmap class structure */
+  typedef const struct FT_CMap_ClassRec_*  FT_CMap_Class;
+
+  /* internal charmap object structure */
+  typedef struct  FT_CMapRec_
+  {
+    FT_CharMapRec  charmap;
+    FT_CMap_Class  clazz;
+
+  } FT_CMapRec;
+
+  /* typecase any pointer to a charmap handle */
+#define FT_CMAP( x )              ((FT_CMap)( x ))
+
+  /* obvious macros */
+#define FT_CMAP_PLATFORM_ID( x )  FT_CMAP( x )->charmap.platform_id
+#define FT_CMAP_ENCODING_ID( x )  FT_CMAP( x )->charmap.encoding_id
+#define FT_CMAP_ENCODING( x )     FT_CMAP( x )->charmap.encoding
+#define FT_CMAP_FACE( x )         FT_CMAP( x )->charmap.face
+
+
+  /* class method definitions */
+  typedef FT_Error
+  (*FT_CMap_InitFunc)( FT_CMap     cmap,
+                       FT_Pointer  init_data );
+
+  typedef void
+  (*FT_CMap_DoneFunc)( FT_CMap  cmap );
+
+  typedef FT_UInt
+  (*FT_CMap_CharIndexFunc)( FT_CMap    cmap,
+                            FT_UInt32  char_code );
+
+  typedef FT_UInt
+  (*FT_CMap_CharNextFunc)( FT_CMap     cmap,
+                           FT_UInt32  *achar_code );
+
+
+  typedef struct  FT_CMap_ClassRec_
+  {
+    FT_UInt                size;
+    FT_CMap_InitFunc       init;
+    FT_CMap_DoneFunc       done;
+    FT_CMap_CharIndexFunc  char_index;
+    FT_CMap_CharNextFunc   char_next;
+
+  } FT_CMap_ClassRec;
+
+
+  /* create a new charmap and add it to charmap->face */
+  FT_BASE( FT_Error )
+  FT_CMap_New( FT_CMap_Class  clazz,
+               FT_Pointer     init_data,
+               FT_CharMap     charmap,
+               FT_CMap       *acmap );
+
+  /* destroy a charmap (don't remove it from face's list though) */
+  FT_BASE( void )
+  FT_CMap_Done( FT_CMap  cmap );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Face_InternalRec                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This structure contains the internal fields of each FT_Face        */
+  /*    object.  These fields may change between different releases of     */
+  /*    FreeType.                                                          */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    max_points       :: The maximal number of points used to store the */
+  /*                        vectorial outline of any glyph in this face.   */
+  /*                        If this value cannot be known in advance, or   */
+  /*                        if the face isn't scalable, this should be set */
+  /*                        to 0.  Only relevant for scalable formats.     */
+  /*                                                                       */
+  /*    max_contours     :: The maximal number of contours used to store   */
+  /*                        the vectorial outline of any glyph in this     */
+  /*                        face.  If this value cannot be known in        */
+  /*                        advance, or if the face isn't scalable, this   */
+  /*                        should be set to 0.  Only relevant for         */
+  /*                        scalable formats.                              */
+  /*                                                                       */
+  /*    transform_matrix :: A 2x2 matrix of 16.16 coefficients used to     */
+  /*                        transform glyph outlines after they are loaded */
+  /*                        from the font.  Only used by the convenience   */
+  /*                        functions.                                     */
+  /*                                                                       */
+  /*    transform_delta  :: A translation vector used to transform glyph   */
+  /*                        outlines after they are loaded from the font.  */
+  /*                        Only used by the convenience functions.        */
+  /*                                                                       */
+  /*    transform_flags  :: Some flags used to classify the transform.     */
+  /*                        Only used by the convenience functions.        */
+  /*                                                                       */
+  /*    hint_flags       :: Some flags used to change the hinters'         */
+  /*                        behaviour.  Only used for debugging for now.   */
+  /*                                                                       */
+  /*    postscript_name  :: Postscript font name for this face.            */
+  /*                                                                       */
+  /*    incremental_interface ::                                           */
+  /*                        If non-null, the interface through             */
+  /*                        which glyph data and metrics are loaded        */
+  /*                        incrementally for faces that do not provide    */
+  /*                        all of this data when first opened.            */
+  /*                        This field exists only if                      */
+  /*                        @FT_CONFIG_OPTION_INCREMENTAL is defined.      */
+  /*                                                                       */
+  typedef struct  FT_Face_InternalRec_
+  {
+    FT_UShort    max_points;
+    FT_Short     max_contours;
+
+    FT_Matrix    transform_matrix;
+    FT_Vector    transform_delta;
+    FT_Int       transform_flags;
+
+    FT_UInt32    hint_flags;
+
+    const char*  postscript_name;
+
+#ifdef FT_CONFIG_OPTION_INCREMENTAL
+    FT_Incremental_InterfaceRec*  incremental_interface;
+#endif
+
+  } FT_Face_InternalRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_Slot_InternalRec                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This structure contains the internal fields of each FT_GlyphSlot   */
+  /*    object.  These fields may change between different releases of     */
+  /*    FreeType.                                                          */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    loader            :: The glyph loader object used to load outlines */
+  /*                         into the glyph slot.                          */
+  /*                                                                       */
+  /*    glyph_transformed :: Boolean.  Set to TRUE when the loaded glyph   */
+  /*                         must be transformed through a specific        */
+  /*                         font transformation.  This is _not_ the same  */
+  /*                         as the face transform set through             */
+  /*                         FT_Set_Transform().                           */
+  /*                                                                       */
+  /*    glyph_matrix      :: The 2x2 matrix corresponding to the glyph     */
+  /*                         transformation, if necessary.                 */
+  /*                                                                       */
+  /*    glyph_delta       :: The 2d translation vector corresponding to    */
+  /*                         the glyph transformation, if necessary.       */
+  /*                                                                       */
+  /*    glyph_hints       :: Format-specific glyph hints management.       */
+  /*                                                                       */
+  typedef struct  FT_Slot_InternalRec_
+  {
+    FT_GlyphLoader  loader;
+    FT_Bool         glyph_transformed;
+    FT_Matrix       glyph_matrix;
+    FT_Vector       glyph_delta;
+    void*           glyph_hints;
+
+  } FT_GlyphSlot_InternalRec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                         M O D U L E S                           ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_ModuleRec                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A module object instance.                                          */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    clazz   :: A pointer to the module's class.                        */
+  /*                                                                       */
+  /*    library :: A handle to the parent library object.                  */
+  /*                                                                       */
+  /*    memory  :: A handle to the memory manager.                         */
+  /*                                                                       */
+  /*    generic :: A generic structure for user-level extensibility (?).   */
+  /*                                                                       */
+  typedef struct  FT_ModuleRec_
+  {
+    FT_Module_Class*  clazz;
+    FT_Library        library;
+    FT_Memory         memory;
+    FT_Generic        generic;
+
+  } FT_ModuleRec;
+
+
+  /* typecast an object to a FT_Module */
+#define FT_MODULE( x )          ((FT_Module)( x ))
+#define FT_MODULE_CLASS( x )    FT_MODULE( x )->clazz
+#define FT_MODULE_LIBRARY( x )  FT_MODULE( x )->library
+#define FT_MODULE_MEMORY( x )   FT_MODULE( x )->memory
+
+
+#define FT_MODULE_IS_DRIVER( x )  ( FT_MODULE_CLASS( x )->module_flags & \
+                                    ft_module_font_driver )
+
+#define FT_MODULE_IS_RENDERER( x )  ( FT_MODULE_CLASS( x )->module_flags & \
+                                      ft_module_renderer )
+
+#define FT_MODULE_IS_HINTER( x )  ( FT_MODULE_CLASS( x )->module_flags & \
+                                    ft_module_hinter )
+
+#define FT_MODULE_IS_STYLER( x )  ( FT_MODULE_CLASS( x )->module_flags & \
+                                    ft_module_styler )
+
+#define FT_DRIVER_IS_SCALABLE( x )  ( FT_MODULE_CLASS( x )->module_flags & \
+                                      ft_module_driver_scalable )
+
+#define FT_DRIVER_USES_OUTLINES( x )  !( FT_MODULE_CLASS( x )->module_flags & \
+                                         ft_module_driver_no_outlines )
+
+#define FT_DRIVER_HAS_HINTER( x )  ( FT_MODULE_CLASS( x )->module_flags & \
+                                     ft_module_driver_has_hinter )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Module_Interface                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Finds a module and returns its specific interface as a typeless    */
+  /*    pointer.                                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    library     :: A handle to the library object.                     */
+  /*                                                                       */
+  /*    module_name :: The module's name (as an ASCII string).             */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A module-specific interface if available, 0 otherwise.             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    You should better be familiar with FreeType internals to know      */
+  /*    which module to look for, and what its interface is :-)            */
+  /*                                                                       */
+  FT_BASE( const void* )
+  FT_Get_Module_Interface( FT_Library   library,
+                           const char*  mod_name );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****               FACE, SIZE & GLYPH SLOT OBJECTS                   ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /* a few macros used to perform easy typecasts with minimal brain damage */
+
+#define FT_FACE( x )          ((FT_Face)(x))
+#define FT_SIZE( x )          ((FT_Size)(x))
+#define FT_SLOT( x )          ((FT_GlyphSlot)(x))
+
+#define FT_FACE_DRIVER( x )   FT_FACE( x )->driver
+#define FT_FACE_LIBRARY( x )  FT_FACE_DRIVER( x )->root.library
+#define FT_FACE_MEMORY( x )   FT_FACE( x )->memory
+#define FT_FACE_STREAM( x )   FT_FACE( x )->stream
+
+#define FT_SIZE_FACE( x )     FT_SIZE( x )->face
+#define FT_SLOT_FACE( x )     FT_SLOT( x )->face
+
+#define FT_FACE_SLOT( x )     FT_FACE( x )->glyph
+#define FT_FACE_SIZE( x )     FT_FACE( x )->size
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_GlyphSlot                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    It is sometimes useful to have more than one glyph slot for a      */
+  /*    given face object.  This function is used to create additional     */
+  /*    slots.  All of them are automatically discarded when the face is   */
+  /*    destroyed.                                                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face  :: A handle to a parent face object.                         */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    aslot :: A handle to a new glyph slot object.                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  FT_BASE( FT_Error )
+  FT_New_GlyphSlot( FT_Face        face,
+                    FT_GlyphSlot  *aslot );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Done_GlyphSlot                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroys a given glyph slot.  Remember however that all slots are  */
+  /*    automatically destroyed with its parent.  Using this function is   */
+  /*    not always mandatory.                                              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    slot :: A handle to a target glyph slot.                           */
+  /*                                                                       */
+  FT_BASE( void )
+  FT_Done_GlyphSlot( FT_GlyphSlot  slot );
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                        R E N D E R E R S                        ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+#define FT_RENDERER( x )      ((FT_Renderer)( x ))
+#define FT_GLYPH( x )         ((FT_Glyph)( x ))
+#define FT_BITMAP_GLYPH( x )  ((FT_BitmapGlyph)( x ))
+#define FT_OUTLINE_GLYPH( x ) ((FT_OutlineGlyph)( x ))
+
+
+  typedef struct  FT_RendererRec_
+  {
+    FT_ModuleRec            root;
+    FT_Renderer_Class*      clazz;
+    FT_Glyph_Format         glyph_format;
+    FT_Glyph_Class          glyph_class;
+
+    FT_Raster               raster;
+    FT_Raster_Render_Func   raster_render;
+    FT_Renderer_RenderFunc  render;
+
+  } FT_RendererRec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                    F O N T   D R I V E R S                      ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /* typecast a module into a driver easily */
+#define FT_DRIVER( x )        ((FT_Driver)(x))
+
+  /* typecast a module as a driver, and get its driver class */
+#define FT_DRIVER_CLASS( x )  FT_DRIVER( x )->clazz
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_DriverRec                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The root font driver class.  A font driver is responsible for      */
+  /*    managing and loading font files of a given format.                 */
+  /*                                                                       */
+  /*  <Fields>                                                             */
+  /*     root         :: Contains the fields of the root module class.     */
+  /*                                                                       */
+  /*     clazz        :: A pointer to the font driver's class.  Note that  */
+  /*                     this is NOT root.clazz.  `class' wasn't used      */
+  /*                     as it is a reserved word in C++.                  */
+  /*                                                                       */
+  /*     faces_list   :: The list of faces currently opened by this        */
+  /*                     driver.                                           */
+  /*                                                                       */
+  /*     extensions   :: A typeless pointer to the driver's extensions     */
+  /*                     registry, if they are supported through the       */
+  /*                     configuration macro FT_CONFIG_OPTION_EXTENSIONS.  */
+  /*                                                                       */
+  /*     glyph_loader :: The glyph loader for all faces managed by this    */
+  /*                     driver.  This object isn't defined for unscalable */
+  /*                     formats.                                          */
+  /*                                                                       */
+  typedef struct  FT_DriverRec_
+  {
+    FT_ModuleRec     root;
+    FT_Driver_Class  clazz;
+
+    FT_ListRec       faces_list;
+    void*            extensions;
+
+    FT_GlyphLoader   glyph_loader;
+
+  } FT_DriverRec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /****                       L I B R A R I E S                         ****/
+  /****                                                                 ****/
+  /****                                                                 ****/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+#define FT_DEBUG_HOOK_TRUETYPE  0
+#define FT_DEBUG_HOOK_TYPE1     1
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    FT_LibraryRec                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The FreeType library class.  This is the root of all FreeType      */
+  /*    data.  Use FT_New_Library() to create a library object, and        */
+  /*    FT_Done_Library() to discard it and all child objects.             */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    memory           :: The library's memory object.  Manages memory   */
+  /*                        allocation.                                    */
+  /*                                                                       */
+  /*    generic          :: Client data variable.  Used to extend the      */
+  /*                        Library class by higher levels and clients.    */
+  /*                                                                       */
+  /*    num_modules      :: The number of modules currently registered     */
+  /*                        within this library.  This is set to 0 for new */
+  /*                        libraries.  New modules are added through the  */
+  /*                        FT_Add_Module() API function.                  */
+  /*                                                                       */
+  /*    modules          :: A table used to store handles to the currently */
+  /*                        registered modules. Note that each font driver */
+  /*                        contains a list of its opened faces.           */
+  /*                                                                       */
+  /*    renderers        :: The list of renderers currently registered     */
+  /*                        within the library.                            */
+  /*                                                                       */
+  /*    cur_renderer     :: The current outline renderer.  This is a       */
+  /*                        shortcut used to avoid parsing the list on     */
+  /*                        each call to FT_Outline_Render().  It is a     */
+  /*                        handle to the current renderer for the         */
+  /*                        FT_GLYPH_FORMAT_OUTLINE format.                */
+  /*                                                                       */
+  /*    auto_hinter      :: XXX                                            */
+  /*                                                                       */
+  /*    raster_pool      :: The raster object's render pool.  This can     */
+  /*                        ideally be changed dynamically at run-time.    */
+  /*                                                                       */
+  /*    raster_pool_size :: The size of the render pool in bytes.          */
+  /*                                                                       */
+  /*    debug_hooks      :: XXX                                            */
+  /*                                                                       */
+  typedef struct  FT_LibraryRec_
+  {
+    FT_Memory          memory;           /* library's memory manager */
+
+    FT_Generic         generic;
+
+    FT_Int             version_major;
+    FT_Int             version_minor;
+    FT_Int             version_patch;
+
+    FT_UInt            num_modules;
+    FT_Module          modules[FT_MAX_MODULES];  /* module objects  */
+
+    FT_ListRec         renderers;        /* list of renderers        */
+    FT_Renderer        cur_renderer;     /* current outline renderer */
+    FT_Module          auto_hinter;
+
+    FT_Byte*           raster_pool;      /* scan-line conversion */
+                                         /* render pool          */
+    FT_ULong           raster_pool_size; /* size of render pool in bytes */
+
+    FT_DebugHook_Func  debug_hooks[4];
+
+    FT_MetaClassRec    meta_class;
+
+  } FT_LibraryRec;
+
+
+  FT_BASE( FT_Renderer )
+  FT_Lookup_Renderer( FT_Library       library,
+                      FT_Glyph_Format  format,
+                      FT_ListNode*     node );
+
+  FT_BASE( FT_Error )
+  FT_Render_Glyph_Internal( FT_Library      library,
+                            FT_GlyphSlot    slot,
+                            FT_Render_Mode  render_mode );
+
+  typedef const char*
+  (*FT_Face_GetPostscriptNameFunc)( FT_Face  face );
+
+  typedef FT_Error
+  (*FT_Face_GetGlyphNameFunc)( FT_Face     face,
+                               FT_UInt     glyph_index,
+                               FT_Pointer  buffer,
+                               FT_UInt     buffer_max );
+
+  typedef FT_UInt
+  (*FT_Face_GetGlyphNameIndexFunc)( FT_Face     face,
+                                    FT_String*  glyph_name );
+
+
+#ifndef FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_New_Memory                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Creates a new memory object.                                       */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A pointer to the new memory object.  0 in case of error.           */
+  /*                                                                       */
+  FT_EXPORT( FT_Memory )
+  FT_New_Memory( void );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Done_Memory                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Discards memory manager.                                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    memory :: A handle to the memory manager.                          */
+  /*                                                                       */
+  FT_EXPORT( void )
+  FT_Done_Memory( FT_Memory  memory );
+
+#endif /* !FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM */
+
+
+  /* Define default raster's interface.  The default raster is located in  */
+  /* `src/base/ftraster.c'.                                                */
+  /*                                                                       */
+  /* Client applications can register new rasters through the              */
+  /* FT_Set_Raster() API.                                                  */
+
+#ifndef FT_NO_DEFAULT_RASTER
+  FT_EXPORT_VAR( FT_Raster_Funcs )  ft_default_raster;
+#endif
+
+
+FT_END_HEADER
+
+#endif /* __FTOBJS_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/ftstream.h
@@ -1,0 +1,498 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftstream.h                                                             */
+/*                                                                         */
+/*    Stream handling (specification).                                     */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __FTSTREAM_H__
+#define __FTSTREAM_H__
+
+
+#include <ft2build.h>
+#include FT_SYSTEM_H
+#include FT_INTERNAL_OBJECTS_H
+
+
+FT_BEGIN_HEADER
+
+
+  /* format of an 8-bit frame_op value:           */
+  /*                                              */
+  /* bit  76543210                                */
+  /*      xxxxxxes                                */
+  /*                                              */
+  /* s is set to 1 if the value is signed.        */
+  /* e is set to 1 if the value is little-endian. */
+  /* xxx is a command.                            */
+
+#define FT_FRAME_OP_SHIFT         2
+#define FT_FRAME_OP_SIGNED        1
+#define FT_FRAME_OP_LITTLE        2
+#define FT_FRAME_OP_COMMAND( x )  ( x >> FT_FRAME_OP_SHIFT )
+
+#define FT_MAKE_FRAME_OP( command, little, sign ) \
+          ( ( command << FT_FRAME_OP_SHIFT ) | ( little << 1 ) | sign )
+
+#define FT_FRAME_OP_END    0
+#define FT_FRAME_OP_START  1  /* start a new frame     */
+#define FT_FRAME_OP_BYTE   2  /* read 1-byte value     */
+#define FT_FRAME_OP_SHORT  3  /* read 2-byte value     */
+#define FT_FRAME_OP_LONG   4  /* read 4-byte value     */
+#define FT_FRAME_OP_OFF3   5  /* read 3-byte value     */
+#define FT_FRAME_OP_BYTES  6  /* read a bytes sequence */
+
+
+  typedef enum  FT_Frame_Op_
+  {
+    ft_frame_end       = 0,
+    ft_frame_start     = FT_MAKE_FRAME_OP( FT_FRAME_OP_START, 0, 0 ),
+
+    ft_frame_byte      = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTE,  0, 0 ),
+    ft_frame_schar     = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTE,  0, 1 ),
+
+    ft_frame_ushort_be = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 0, 0 ),
+    ft_frame_short_be  = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 0, 1 ),
+    ft_frame_ushort_le = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 1, 0 ),
+    ft_frame_short_le  = FT_MAKE_FRAME_OP( FT_FRAME_OP_SHORT, 1, 1 ),
+
+    ft_frame_ulong_be  = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 0, 0 ),
+    ft_frame_long_be   = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 0, 1 ),
+    ft_frame_ulong_le  = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 1, 0 ),
+    ft_frame_long_le   = FT_MAKE_FRAME_OP( FT_FRAME_OP_LONG, 1, 1 ),
+
+    ft_frame_uoff3_be  = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 0, 0 ),
+    ft_frame_off3_be   = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 0, 1 ),
+    ft_frame_uoff3_le  = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 1, 0 ),
+    ft_frame_off3_le   = FT_MAKE_FRAME_OP( FT_FRAME_OP_OFF3, 1, 1 ),
+
+    ft_frame_bytes     = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTES, 0, 0 ),
+    ft_frame_skip      = FT_MAKE_FRAME_OP( FT_FRAME_OP_BYTES, 0, 1 )
+
+  } FT_Frame_Op;
+
+
+  typedef struct  FT_Frame_Field_
+  {
+    FT_Byte    value;
+    FT_Byte    size;
+    FT_UShort  offset;
+
+  } FT_Frame_Field;
+
+
+  /* Construct an FT_Frame_Field out of a structure type and a field name. */
+  /* The structure type must be set in the FT_STRUCTURE macro before       */
+  /* calling the FT_FRAME_START() macro.                                   */
+  /*                                                                       */
+#define FT_FIELD_SIZE( f ) \
+          (FT_Byte)sizeof ( ((FT_STRUCTURE*)0)->f )
+
+#define FT_FIELD_SIZE_DELTA( f ) \
+          (FT_Byte)sizeof ( ((FT_STRUCTURE*)0)->f[0] )
+
+#define FT_FIELD_OFFSET( f ) \
+          (FT_UShort)( offsetof( FT_STRUCTURE, f ) )
+
+#define FT_FRAME_FIELD( frame_op, field ) \
+          {                               \
+            frame_op,                     \
+            FT_FIELD_SIZE( field ),       \
+            FT_FIELD_OFFSET( field )      \
+          }
+
+#define FT_MAKE_EMPTY_FIELD( frame_op )  { frame_op, 0, 0 }
+
+#define FT_FRAME_START( size )   { ft_frame_start, 0, size }
+#define FT_FRAME_END             { ft_frame_end, 0, 0 }
+
+#define FT_FRAME_LONG( f )       FT_FRAME_FIELD( ft_frame_long_be, f )
+#define FT_FRAME_ULONG( f )      FT_FRAME_FIELD( ft_frame_ulong_be, f )
+#define FT_FRAME_SHORT( f )      FT_FRAME_FIELD( ft_frame_short_be, f )
+#define FT_FRAME_USHORT( f )     FT_FRAME_FIELD( ft_frame_ushort_be, f )
+#define FT_FRAME_OFF3( f )       FT_FRAME_FIELD( ft_frame_off3_be, f )
+#define FT_FRAME_UOFF3( f )      FT_FRAME_FIELD( ft_frame_uoff3_be, f )
+#define FT_FRAME_BYTE( f )       FT_FRAME_FIELD( ft_frame_byte, f )
+#define FT_FRAME_CHAR( f )       FT_FRAME_FIELD( ft_frame_schar, f )
+
+#define FT_FRAME_LONG_LE( f )    FT_FRAME_FIELD( ft_frame_long_le, f )
+#define FT_FRAME_ULONG_LE( f )   FT_FRAME_FIELD( ft_frame_ulong_le, f )
+#define FT_FRAME_SHORT_LE( f )   FT_FRAME_FIELD( ft_frame_short_le, f )
+#define FT_FRAME_USHORT_LE( f )  FT_FRAME_FIELD( ft_frame_ushort_le, f )
+#define FT_FRAME_OFF3_LE( f )    FT_FRAME_FIELD( ft_frame_off3_le, f )
+#define FT_FRAME_UOFF3_LE( f )   FT_FRAME_FIELD( ft_frame_uoff3_le, f )
+
+#define FT_FRAME_SKIP_LONG       { ft_frame_long_be, 0, 0 }
+#define FT_FRAME_SKIP_SHORT      { ft_frame_short_be, 0, 0 }
+#define FT_FRAME_SKIP_BYTE       { ft_frame_byte, 0, 0 }
+
+#define FT_FRAME_BYTES( field, count ) \
+          {                            \
+            ft_frame_bytes,            \
+            count,                     \
+            FT_FIELD_OFFSET( field )   \
+          }
+
+#define FT_FRAME_SKIP_BYTES( count )  { ft_frame_skip, count, 0 }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Integer extraction macros -- the `buffer' parameter must ALWAYS be of */
+  /* type `char*' or equivalent (1-byte elements).                         */
+  /*                                                                       */
+
+#define FT_BYTE_( p, i )  ( ((const FT_Byte*)(p))[(i)] )
+#define FT_INT8_( p, i )  ( ((const FT_Char*)(p))[(i)] )
+
+#define FT_INT16( x )   ( (FT_Int16)(x)  )
+#define FT_UINT16( x )  ( (FT_UInt16)(x) )
+#define FT_INT32( x )   ( (FT_Int32)(x)  )
+#define FT_UINT32( x )  ( (FT_UInt32)(x) )
+
+#define FT_BYTE_I16( p, i, s )  ( FT_INT16(  FT_BYTE_( p, i ) ) << (s) )
+#define FT_BYTE_U16( p, i, s )  ( FT_UINT16( FT_BYTE_( p, i ) ) << (s) )
+#define FT_BYTE_I32( p, i, s )  ( FT_INT32(  FT_BYTE_( p, i ) ) << (s) )
+#define FT_BYTE_U32( p, i, s )  ( FT_UINT32( FT_BYTE_( p, i ) ) << (s) )
+
+#define FT_INT8_I16( p, i, s )  ( FT_INT16(  FT_INT8_( p, i ) ) << (s) )
+#define FT_INT8_U16( p, i, s )  ( FT_UINT16( FT_INT8_( p, i ) ) << (s) )
+#define FT_INT8_I32( p, i, s )  ( FT_INT32(  FT_INT8_( p, i ) ) << (s) )
+#define FT_INT8_U32( p, i, s )  ( FT_UINT32( FT_INT8_( p, i ) ) << (s) )
+
+
+#define FT_PEEK_SHORT( p )  FT_INT16( FT_INT8_I16( p, 0, 8) | \
+                                      FT_BYTE_I16( p, 1, 0) )
+
+#define FT_PEEK_USHORT( p )  FT_UINT16( FT_BYTE_U16( p, 0, 8 ) | \
+                                        FT_BYTE_U16( p, 1, 0 ) )
+
+#define FT_PEEK_LONG( p )  FT_INT32( FT_INT8_I32( p, 0, 24 ) | \
+                                     FT_BYTE_I32( p, 1, 16 ) | \
+                                     FT_BYTE_I32( p, 2,  8 ) | \
+                                     FT_BYTE_I32( p, 3,  0 ) )
+
+#define FT_PEEK_ULONG( p )  FT_UINT32( FT_BYTE_U32( p, 0, 24 ) | \
+                                       FT_BYTE_U32( p, 1, 16 ) | \
+                                       FT_BYTE_U32( p, 2,  8 ) | \
+                                       FT_BYTE_U32( p, 3,  0 ) )
+
+#define FT_PEEK_OFF3( p )  FT_INT32( FT_INT8_I32( p, 0, 16 ) | \
+                                     FT_BYTE_I32( p, 1,  8 ) | \
+                                     FT_BYTE_I32( p, 2,  0 ) )
+
+#define FT_PEEK_UOFF3( p )  FT_UINT32( FT_BYTE_U32( p, 0, 16 ) | \
+                                       FT_BYTE_U32( p, 1,  8 ) | \
+                                       FT_BYTE_U32( p, 2,  0 ) )
+
+#define FT_PEEK_SHORT_LE( p )  FT_INT16( FT_INT8_I16( p, 1, 8 ) | \
+                                         FT_BYTE_I16( p, 0, 0 ) )
+
+#define FT_PEEK_USHORT_LE( p )  FT_UINT16( FT_BYTE_U16( p, 1, 8 ) |  \
+                                           FT_BYTE_U16( p, 0, 0 ) )
+
+#define FT_PEEK_LONG_LE( p )  FT_INT32( FT_INT8_I32( p, 3, 24 ) | \
+                                        FT_BYTE_I32( p, 2, 16 ) | \
+                                        FT_BYTE_I32( p, 1,  8 ) | \
+                                        FT_BYTE_I32( p, 0,  0 ) )
+
+#define FT_PEEK_ULONG_LE( p )  FT_UINT32( FT_BYTE_U32( p, 3, 24 ) | \
+                                          FT_BYTE_U32( p, 2, 16 ) | \
+                                          FT_BYTE_U32( p, 1,  8 ) | \
+                                          FT_BYTE_U32( p, 0,  0 ) )
+
+#define FT_PEEK_OFF3_LE( p )  FT_INT32( FT_INT8_I32( p, 2, 16 ) | \
+                                        FT_BYTE_I32( p, 1,  8 ) | \
+                                        FT_BYTE_I32( p, 0,  0 ) )
+
+#define FT_PEEK_UOFF3_LE( p )  FT_UINT32( FT_BYTE_U32( p, 2, 16 ) | \
+                                          FT_BYTE_U32( p, 1,  8 ) | \
+                                          FT_BYTE_U32( p, 0,  0 ) )
+
+
+#define FT_NEXT_CHAR( buffer )       \
+          ( (signed char)*buffer++ )
+
+#define FT_NEXT_BYTE( buffer )         \
+          ( (unsigned char)*buffer++ )
+
+#define FT_NEXT_SHORT( buffer )                                   \
+          ( (short)( buffer += 2, FT_PEEK_SHORT( buffer - 2 ) ) )
+
+#define FT_NEXT_USHORT( buffer )                                            \
+          ( (unsigned short)( buffer += 2, FT_PEEK_USHORT( buffer - 2 ) ) )
+
+#define FT_NEXT_OFF3( buffer )                                  \
+          ( (long)( buffer += 3, FT_PEEK_OFF3( buffer - 3 ) ) )
+
+#define FT_NEXT_UOFF3( buffer )                                           \
+          ( (unsigned long)( buffer += 3, FT_PEEK_UOFF3( buffer - 3 ) ) )
+
+#define FT_NEXT_LONG( buffer )                                  \
+          ( (long)( buffer += 4, FT_PEEK_LONG( buffer - 4 ) ) )
+
+#define FT_NEXT_ULONG( buffer )                                           \
+          ( (unsigned long)( buffer += 4, FT_PEEK_ULONG( buffer - 4 ) ) )
+
+
+#define FT_NEXT_SHORT_LE( buffer )                                   \
+          ( (short)( buffer += 2, FT_PEEK_SHORT_LE( buffer - 2 ) ) )
+
+#define FT_NEXT_USHORT_LE( buffer )                                            \
+          ( (unsigned short)( buffer += 2, FT_PEEK_USHORT_LE( buffer - 2 ) ) )
+
+#define FT_NEXT_OFF3_LE( buffer )                                  \
+          ( (long)( buffer += 3, FT_PEEK_OFF3_LE( buffer - 3 ) ) )
+
+#define FT_NEXT_UOFF3_LE( buffer )                                           \
+          ( (unsigned long)( buffer += 3, FT_PEEK_UOFF3_LE( buffer - 3 ) ) )
+
+#define FT_NEXT_LONG_LE( buffer )                                  \
+          ( (long)( buffer += 4, FT_PEEK_LONG_LE( buffer - 4 ) ) )
+
+#define FT_NEXT_ULONG_LE( buffer )                                           \
+          ( (unsigned long)( buffer += 4, FT_PEEK_ULONG_LE( buffer - 4 ) ) )
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Each GET_xxxx() macro uses an implicit `stream' variable.             */
+  /*                                                                       */
+#define FT_GET_MACRO( func, type )        ( (type)func( stream ) )
+
+#define FT_GET_CHAR()       FT_GET_MACRO( FT_Stream_GetChar, FT_Char )
+#define FT_GET_BYTE()       FT_GET_MACRO( FT_Stream_GetChar, FT_Byte )
+#define FT_GET_SHORT()      FT_GET_MACRO( FT_Stream_GetShort, FT_Short )
+#define FT_GET_USHORT()     FT_GET_MACRO( FT_Stream_GetShort, FT_UShort )
+#define FT_GET_OFF3()       FT_GET_MACRO( FT_Stream_GetOffset, FT_Long )
+#define FT_GET_UOFF3()      FT_GET_MACRO( FT_Stream_GetOffset, FT_ULong )
+#define FT_GET_LONG()       FT_GET_MACRO( FT_Stream_GetLong, FT_Long )
+#define FT_GET_ULONG()      FT_GET_MACRO( FT_Stream_GetLong, FT_ULong )
+#define FT_GET_TAG4()       FT_GET_MACRO( FT_Stream_GetLong, FT_ULong )
+
+#define FT_GET_SHORT_LE()   FT_GET_MACRO( FT_Stream_GetShortLE, FT_Short )
+#define FT_GET_USHORT_LE()  FT_GET_MACRO( FT_Stream_GetShortLE, FT_UShort )
+#define FT_GET_LONG_LE()    FT_GET_MACRO( FT_Stream_GetLongLE, FT_Long )
+#define FT_GET_ULONG_LE()   FT_GET_MACRO( FT_Stream_GetLongLE, FT_ULong )
+
+#define FT_READ_MACRO( func, type, var )        \
+          ( var = (type)func( stream, &error ), \
+            error != FT_Err_Ok )
+
+#define FT_READ_BYTE( var )       FT_READ_MACRO( FT_Stream_ReadChar, FT_Byte, var )
+#define FT_READ_CHAR( var )       FT_READ_MACRO( FT_Stream_ReadChar, FT_Char, var )
+#define FT_READ_SHORT( var )      FT_READ_MACRO( FT_Stream_ReadShort, FT_Short, var )
+#define FT_READ_USHORT( var )     FT_READ_MACRO( FT_Stream_ReadShort, FT_UShort, var )
+#define FT_READ_OFF3( var )       FT_READ_MACRO( FT_Stream_ReadOffset, FT_Long, var )
+#define FT_READ_UOFF3( var )      FT_READ_MACRO( FT_Stream_ReadOffset, FT_ULong, var )
+#define FT_READ_LONG( var )       FT_READ_MACRO( FT_Stream_ReadLong, FT_Long, var )
+#define FT_READ_ULONG( var )      FT_READ_MACRO( FT_Stream_ReadLong, FT_ULong, var )
+
+#define FT_READ_SHORT_LE( var )   FT_READ_MACRO( FT_Stream_ReadShortLE, FT_Short, var )
+#define FT_READ_USHORT_LE( var )  FT_READ_MACRO( FT_Stream_ReadShortLE, FT_UShort, var )
+#define FT_READ_LONG_LE( var )    FT_READ_MACRO( FT_Stream_ReadLongLE, FT_Long, var )
+#define FT_READ_ULONG_LE( var )   FT_READ_MACRO( FT_Stream_ReadLongLE, FT_ULong, var )
+
+
+#ifndef FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM
+
+  /* initialize a stream for reading a regular system stream */
+  FT_EXPORT( FT_Error )
+  FT_Stream_Open( FT_Stream    stream,
+                  const char*  filepathname );
+
+#endif /* FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM */
+
+
+  /* initialize a stream for reading in-memory data */
+  FT_BASE( void )
+  FT_Stream_OpenMemory( FT_Stream       stream,
+                        const FT_Byte*  base,
+                        FT_ULong        size );
+
+  /* close a stream (does not destroy the stream structure) */
+  FT_BASE( void )
+  FT_Stream_Close( FT_Stream  stream );
+
+
+  /* seek within a stream. position is relative to start of stream */
+  FT_BASE( FT_Error )
+  FT_Stream_Seek( FT_Stream  stream,
+                  FT_ULong   pos );
+
+  /* skip bytes in a stream */
+  FT_BASE( FT_Error )
+  FT_Stream_Skip( FT_Stream  stream,
+                  FT_Long    distance );
+
+  /* return current stream position */
+  FT_BASE( FT_Long )
+  FT_Stream_Pos( FT_Stream  stream );
+
+  /* read bytes from a stream into a user-allocated buffer, returns an */
+  /* error if not all bytes could be read.                             */
+  FT_BASE( FT_Error )
+  FT_Stream_Read( FT_Stream  stream,
+                  FT_Byte*   buffer,
+                  FT_ULong   count );
+
+  /* read bytes from a stream at a given position */
+  FT_BASE( FT_Error )
+  FT_Stream_ReadAt( FT_Stream  stream,
+                    FT_ULong   pos,
+                    FT_Byte*   buffer,
+                    FT_ULong   count );
+
+  /* Enter a frame of `count' consecutive bytes in a stream.  Returns an */
+  /* error if the frame could not be read/accessed.  The caller can use  */
+  /* the FT_Stream_Get_XXX functions to retrieve frame data without      */
+  /* error checks.                                                       */
+  /*                                                                     */
+  /* You must _always_ call FT_Stream_ExitFrame() once you have entered  */
+  /* a stream frame!                                                     */
+  /*                                                                     */
+  FT_BASE( FT_Error )
+  FT_Stream_EnterFrame( FT_Stream  stream,
+                        FT_ULong   count );
+
+  /* exit a stream frame */
+  FT_BASE( void )
+  FT_Stream_ExitFrame( FT_Stream  stream );
+
+  /* Extract a stream frame.  If the stream is disk-based, a heap block */
+  /* is allocated and the frame bytes are read into it.  If the stream  */
+  /* is memory-based, this function simply set a pointer to the data.   */
+  /*                                                                    */
+  /* Useful to optimize access to memory-based streams transparently.   */
+  /*                                                                    */
+  /* All extracted frames must be `freed` with a call to the function   */
+  /* FT_Stream_ReleaseFrame().                                          */
+  /*                                                                    */
+  FT_BASE( FT_Error )
+  FT_Stream_ExtractFrame( FT_Stream  stream,
+                          FT_ULong   count,
+                          FT_Byte**  pbytes );
+
+  /* release an extract frame (see FT_Stream_ExtractFrame) */
+  FT_BASE( void )
+  FT_Stream_ReleaseFrame( FT_Stream  stream,
+                          FT_Byte**  pbytes );
+
+  /* read a byte from an entered frame */
+  FT_BASE( FT_Char )
+  FT_Stream_GetChar( FT_Stream  stream );
+
+  /* read a 16-bit big-endian integer from an entered frame */
+  FT_BASE( FT_Short )
+  FT_Stream_GetShort( FT_Stream  stream );
+
+  /* read a 24-bit big-endian integer from an entered frame */
+  FT_BASE( FT_Long )
+  FT_Stream_GetOffset( FT_Stream  stream );
+
+  /* read a 32-bit big-endian integer from an entered frame */
+  FT_BASE( FT_Long )
+  FT_Stream_GetLong( FT_Stream  stream );
+
+  /* read a 16-bit little-endian integer from an entered frame */
+  FT_BASE( FT_Short )
+  FT_Stream_GetShortLE( FT_Stream  stream );
+
+  /* read a 32-bit little-endian integer from an entered frame */
+  FT_BASE( FT_Long )
+  FT_Stream_GetLongLE( FT_Stream  stream );
+
+
+  /* read a byte from a stream */
+  FT_BASE( FT_Char )
+  FT_Stream_ReadChar( FT_Stream  stream,
+                      FT_Error*  error );
+
+  /* read a 16-bit big-endian integer from a stream */
+  FT_BASE( FT_Short )
+  FT_Stream_ReadShort( FT_Stream  stream,
+                       FT_Error*  error );
+
+  /* read a 24-bit big-endian integer from a stream */
+  FT_BASE( FT_Long )
+  FT_Stream_ReadOffset( FT_Stream  stream,
+                        FT_Error*  error );
+
+  /* read a 32-bit big-endian integer from a stream */
+  FT_BASE( FT_Long )
+  FT_Stream_ReadLong( FT_Stream  stream,
+                      FT_Error*  error );
+
+  /* read a 16-bit little-endian integer from a stream */
+  FT_BASE( FT_Short )
+  FT_Stream_ReadShortLE( FT_Stream  stream,
+                         FT_Error*  error );
+
+  /* read a 32-bit little-endian integer from a stream */
+  FT_BASE( FT_Long )
+  FT_Stream_ReadLongLE( FT_Stream  stream,
+                        FT_Error*  error );
+
+  /* Read a structure from a stream.  The structure must be described */
+  /* by an array of FT_Frame_Field records.                           */
+  FT_BASE( FT_Error )
+  FT_Stream_ReadFields( FT_Stream              stream,
+                        const FT_Frame_Field*  fields,
+                        void*                  structure );
+
+
+#define FT_STREAM_POS()           \
+          FT_Stream_Pos( stream )
+
+#define FT_STREAM_SEEK( position )                           \
+          FT_SET_ERROR( FT_Stream_Seek( stream, position ) )
+
+#define FT_STREAM_SKIP( distance )                           \
+          FT_SET_ERROR( FT_Stream_Skip( stream, distance ) )
+
+#define FT_STREAM_READ( buffer, count )                   \
+          FT_SET_ERROR( FT_Stream_Read( stream,           \
+                                        (FT_Byte*)buffer, \
+                                        count ) )
+
+#define FT_STREAM_READ_AT( position, buffer, count )         \
+          FT_SET_ERROR( FT_Stream_ReadAt( stream,            \
+                                           position,         \
+                                           (FT_Byte*)buffer, \
+                                           count ) )
+
+#define FT_STREAM_READ_FIELDS( fields, object )                          \
+          FT_SET_ERROR( FT_Stream_ReadFields( stream, fields, object ) )
+
+
+#define FT_FRAME_ENTER( size )                                 \
+          FT_SET_ERROR( FT_Stream_EnterFrame( stream, size ) )
+
+#define FT_FRAME_EXIT()                 \
+          FT_Stream_ExitFrame( stream )
+
+#define FT_FRAME_EXTRACT( size, bytes )                                 \
+          FT_SET_ERROR( FT_Stream_ExtractFrame( stream, size,           \
+                                                (FT_Byte**)&(bytes) ) )
+
+#define FT_FRAME_RELEASE( bytes )                               \
+          FT_Stream_ReleaseFrame( stream, (FT_Byte**)&(bytes) )
+
+
+FT_END_HEADER
+
+#endif /* __FTSTREAM_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/fttrace.h
@@ -1,0 +1,106 @@
+/***************************************************************************/
+/*                                                                         */
+/*  fttrace.h                                                              */
+/*                                                                         */
+/*    Tracing handling (specification only).                               */
+/*                                                                         */
+/*  Copyright 2002 by                                                      */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+/* definitions of trace levels for FreeType 2 */
+
+/* the first level must always be `trace_any' */
+FT_TRACE_DEF( any )
+
+/* base components */
+FT_TRACE_DEF( calc )      /* calculations            (ftcalc.c)   */
+FT_TRACE_DEF( memory )    /* memory manager          (ftobjs.c)   */
+FT_TRACE_DEF( stream )    /* stream manager          (ftstream.c) */
+FT_TRACE_DEF( io )        /* i/o interface           (ftsystem.c) */
+FT_TRACE_DEF( list )      /* list management         (ftlist.c)   */
+FT_TRACE_DEF( init )      /* initialization          (ftinit.c)   */
+FT_TRACE_DEF( objs )      /* base objects            (ftobjs.c)   */
+FT_TRACE_DEF( outline )   /* outline management      (ftoutln.c)  */
+FT_TRACE_DEF( glyph )     /* glyph management        (ftglyph.c)  */
+
+FT_TRACE_DEF( raster )    /* monochrome rasterizer   (ftraster.c) */
+FT_TRACE_DEF( smooth )    /* anti-aliasing raster    (ftgrays.c)  */
+FT_TRACE_DEF( mm )        /* MM interface            (ftmm.c)     */
+
+/* Cache sub-system */
+FT_TRACE_DEF( cache )     /* cache sub-system        (ftcache.c, etc..) */
+
+/* SFNT driver components */
+FT_TRACE_DEF( sfobjs )    /*  SFNT object handler     (sfobjs.c)   */
+FT_TRACE_DEF( ttcmap )    /* charmap handler         (ttcmap.c)    */
+FT_TRACE_DEF( ttload )    /* basic TrueType tables   (ttload.c)    */
+FT_TRACE_DEF( ttpost )    /* PS table processing     (ttpost.c)   */
+FT_TRACE_DEF( ttsbit )    /* TrueType sbit handling  (ttsbit.c)   */
+
+/* TrueType driver components */
+FT_TRACE_DEF( ttdriver )  /* TT font driver          (ttdriver.c) */
+FT_TRACE_DEF( ttgload )   /* TT glyph loader         (ttgload.c)  */
+FT_TRACE_DEF( ttinterp )  /* bytecode interpreter    (ttinterp.c) */
+FT_TRACE_DEF( ttobjs )    /* TT objects manager      (ttobjs.c)   */
+FT_TRACE_DEF( ttpload )   /* TT data/program loader  (ttpload.c)  */
+
+/* Type 1 driver components */
+FT_TRACE_DEF( t1driver )
+FT_TRACE_DEF( t1gload )
+FT_TRACE_DEF( t1hint )
+FT_TRACE_DEF( t1load )
+FT_TRACE_DEF( t1objs )
+FT_TRACE_DEF( t1parse )
+
+/* PostScript helper module `psaux' */
+FT_TRACE_DEF( t1decode )
+FT_TRACE_DEF( psobjs )
+
+/* PostScript hinting module `pshinter' */
+FT_TRACE_DEF( pshrec )
+FT_TRACE_DEF( pshalgo1 )
+FT_TRACE_DEF( pshalgo2 )
+
+/* Type 2 driver components */
+FT_TRACE_DEF( cffdriver )
+FT_TRACE_DEF( cffgload )
+FT_TRACE_DEF( cffload )
+FT_TRACE_DEF( cffobjs )
+FT_TRACE_DEF( cffparse )
+
+/* Type 42 driver component */
+FT_TRACE_DEF( t42 )
+
+/* CID driver components */
+FT_TRACE_DEF( cidafm )
+FT_TRACE_DEF( ciddriver )
+FT_TRACE_DEF( cidgload )
+FT_TRACE_DEF( cidload )
+FT_TRACE_DEF( cidobjs )
+FT_TRACE_DEF( cidparse )
+
+/* Windows fonts component */
+FT_TRACE_DEF( winfnt )
+
+/* PCF fonts components */
+FT_TRACE_DEF( pcfdriver )
+FT_TRACE_DEF( pcfread )
+
+/* BDF fonts component */
+FT_TRACE_DEF( bdfdriver )
+FT_TRACE_DEF( bdflib )
+
+/* PFR fonts component */
+FT_TRACE_DEF( pfr )
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/internal.h
@@ -1,0 +1,57 @@
+/***************************************************************************/
+/*                                                                         */
+/*  internal.h                                                             */
+/*                                                                         */
+/*    Internal header files (specification only).                          */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This file is automatically included by `ft2build.h'.                  */
+  /* Do not include it manually!                                           */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+#define FT_INTERNAL_OBJECTS_H             <freetype/internal/ftobjs.h>
+#define FT_INTERNAL_STREAM_H              <freetype/internal/ftstream.h>
+#define FT_INTERNAL_MEMORY_H              <freetype/internal/ftmemory.h>
+#define FT_INTERNAL_EXTENSION_H           <freetype/internal/ftextend.h>
+#define FT_INTERNAL_DEBUG_H               <freetype/internal/ftdebug.h>
+#define FT_INTERNAL_CALC_H                <freetype/internal/ftcalc.h>
+#define FT_INTERNAL_DRIVER_H              <freetype/internal/ftdriver.h>
+#define FT_INTERNAL_EXTEND_H              <freetype/internal/ftextend.h>
+#define FT_INTERNAL_TRACE_H               <freetype/internal/fttrace.h>
+#define FT_INTERNAL_GLYPH_LOADER_H        <freetype/internal/ftgloadr.h>
+#define FT_INTERNAL_SFNT_H                <freetype/internal/sfnt.h>
+#define FT_INTERNAL_HASH_H                <freetype/internal/fthash.h>
+#define FT_INTERNAL_OBJECT_H              <freetype/internal/ftobject.h>
+
+#define FT_INTERNAL_TRUETYPE_TYPES_H      <freetype/internal/tttypes.h>
+#define FT_INTERNAL_TYPE1_TYPES_H         <freetype/internal/t1types.h>
+#define FT_INTERNAL_TYPE42_TYPES_H        <freetype/internal/t42types.h>
+#define FT_INTERNAL_CFF_TYPES_H           <freetype/internal/cfftypes.h>
+#define FT_INTERNAL_FNT_TYPES_H           <freetype/internal/fnttypes.h>
+#define FT_INTERNAL_BDF_TYPES_H           <freetype/internal/bdftypes.h>
+#define FT_INTERNAL_PFR_H                 <freetype/internal/pfr.h>
+
+#define FT_INTERNAL_POSTSCRIPT_NAMES_H    <freetype/internal/psnames.h>
+#define FT_INTERNAL_POSTSCRIPT_AUX_H      <freetype/internal/psaux.h>
+#define FT_INTERNAL_POSTSCRIPT_HINTS_H    <freetype/internal/pshints.h>
+#define FT_INTERNAL_POSTSCRIPT_GLOBALS_H  <freetype/internal/psglobal.h>
+
+#define FT_INTERNAL_AUTOHINT_H            <freetype/internal/autohint.h>
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/pcftypes.h
@@ -1,0 +1,56 @@
+/*  pcftypes.h
+
+  FreeType font driver for pcf fonts
+
+  Copyright (C) 2000-2001 by
+  Francesco Zappa Nardelli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+
+#ifndef __PCFTYPES_H__
+#define __PCFTYPES_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  PCF_Public_FaceRec_
+  {
+    FT_FaceRec    root;
+    FT_StreamRec  gzip_stream;
+    FT_Stream     gzip_source;
+
+    char*         charset_encoding;
+    char*         charset_registry;
+
+  } PCF_Public_FaceRec, *PCF_Public_Face;
+
+
+FT_END_HEADER
+
+#endif  /* __PCFTYPES_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/pfr.h
@@ -1,0 +1,36 @@
+#ifndef __FT_INTERNAL_PFR_H__
+#define __FT_INTERNAL_PFR_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+FT_BEGIN_HEADER
+
+  typedef FT_Error  (*FT_PFR_GetMetricsFunc)( FT_Face    face,
+                                              FT_UInt   *aoutline,
+                                              FT_UInt   *ametrics,
+                                              FT_Fixed  *ax_scale,
+                                              FT_Fixed  *ay_scale );
+
+  typedef FT_Error  (*FT_PFR_GetKerningFunc)( FT_Face     face,
+                                              FT_UInt     left,
+                                              FT_UInt     right,
+                                              FT_Vector  *avector );
+
+  typedef FT_Error  (*FT_PFR_GetAdvanceFunc)( FT_Face   face,
+                                              FT_UInt   gindex,
+                                              FT_Pos   *aadvance );
+
+  typedef struct FT_PFR_ServiceRec_
+  {
+    FT_PFR_GetMetricsFunc    get_metrics;
+    FT_PFR_GetKerningFunc    get_kerning;
+    FT_PFR_GetAdvanceFunc    get_advance;
+
+  } FT_PFR_ServiceRec, *FT_PFR_Service;
+
+#define  FT_PFR_SERVICE_NAME  "pfr"
+
+FT_END_HEADER
+
+#endif /* __FT_INTERNAL_PFR_H__ */
--- /dev/null
+++ b/include/freetype/internal/psaux.h
@@ -1,0 +1,717 @@
+/***************************************************************************/
+/*                                                                         */
+/*  psaux.h                                                                */
+/*                                                                         */
+/*    Auxiliary functions and data structures related to PostScript fonts  */
+/*    (specification).                                                     */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __PSAUX_H__
+#define __PSAUX_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_TYPE1_TYPES_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                             T1_TABLE                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  typedef struct PS_TableRec_*              PS_Table;
+  typedef const struct PS_Table_FuncsRec_*  PS_Table_Funcs;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    PS_Table_FuncsRec                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A set of function pointers to manage PS_Table objects.             */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    table_init    :: Used to initialize a table.                       */
+  /*                                                                       */
+  /*    table_done    :: Finalizes resp. destroy a given table.            */
+  /*                                                                       */
+  /*    table_add     :: Adds a new object to a table.                     */
+  /*                                                                       */
+  /*    table_release :: Releases table data, then finalizes it.           */
+  /*                                                                       */
+  typedef struct  PS_Table_FuncsRec_
+  {
+    FT_Error
+    (*init)( PS_Table   table,
+             FT_Int     count,
+             FT_Memory  memory );
+
+    void
+    (*done)( PS_Table  table );
+
+    FT_Error
+    (*add)( PS_Table   table,
+            FT_Int     index,
+            void*      object,
+            FT_Int     length );
+
+    void
+    (*release)( PS_Table  table );
+
+  } PS_Table_FuncsRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    PS_TableRec                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A PS_Table is a simple object used to store an array of objects in */
+  /*    a single memory block.                                             */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    block     :: The address in memory of the growheap's block.  This  */
+  /*                 can change between two object adds, due to            */
+  /*                 reallocation.                                         */
+  /*                                                                       */
+  /*    cursor    :: The current top of the grow heap within its block.    */
+  /*                                                                       */
+  /*    capacity  :: The current size of the heap block.  Increments by    */
+  /*                 1kByte chunks.                                        */
+  /*                                                                       */
+  /*    max_elems :: The maximum number of elements in table.              */
+  /*                                                                       */
+  /*    num_elems :: The current number of elements in table.              */
+  /*                                                                       */
+  /*    elements  :: A table of element addresses within the block.        */
+  /*                                                                       */
+  /*    lengths   :: A table of element sizes within the block.            */
+  /*                                                                       */
+  /*    memory    :: The object used for memory operations                 */
+  /*                 (alloc/realloc).                                      */
+  /*                                                                       */
+  /*    funcs     :: A table of method pointers for this object.           */
+  /*                                                                       */
+  typedef struct  PS_TableRec_
+  {
+    FT_Byte*           block;          /* current memory block           */
+    FT_Offset          cursor;         /* current cursor in memory block */
+    FT_Offset          capacity;       /* current size of memory block   */
+    FT_Long            init;
+
+    FT_Int             max_elems;
+    FT_Int             num_elems;
+    FT_Byte**          elements;       /* addresses of table elements */
+    FT_Int*            lengths;        /* lengths of table elements   */
+
+    FT_Memory          memory;
+    PS_Table_FuncsRec  funcs;
+
+  } PS_TableRec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                       T1 FIELDS & TOKENS                      *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef struct PS_ParserRec_*  PS_Parser;
+
+  typedef struct T1_TokenRec_*   T1_Token;
+
+  typedef struct T1_FieldRec_*   T1_Field;
+
+
+  /* simple enumeration type used to identify token types */
+  typedef enum  T1_TokenType_
+  {
+    T1_TOKEN_TYPE_NONE = 0,
+    T1_TOKEN_TYPE_ANY,
+    T1_TOKEN_TYPE_STRING,
+    T1_TOKEN_TYPE_ARRAY,
+
+    /* do not remove */
+    T1_TOKEN_TYPE_MAX
+
+  } T1_TokenType;
+
+
+  /* a simple structure used to identify tokens */
+  typedef struct  T1_TokenRec_
+  {
+    FT_Byte*      start;   /* first character of token in input stream */
+    FT_Byte*      limit;   /* first character after the token          */
+    T1_TokenType  type;    /* type of token                            */
+
+  } T1_TokenRec;
+
+
+  /* enumeration type used to identify object fields */
+  typedef enum  T1_FieldType_
+  {
+    T1_FIELD_TYPE_NONE = 0,
+    T1_FIELD_TYPE_BOOL,
+    T1_FIELD_TYPE_INTEGER,
+    T1_FIELD_TYPE_FIXED,
+    T1_FIELD_TYPE_STRING,
+    T1_FIELD_TYPE_BBOX,
+    T1_FIELD_TYPE_INTEGER_ARRAY,
+    T1_FIELD_TYPE_FIXED_ARRAY,
+    T1_FIELD_TYPE_CALLBACK,
+
+    /* do not remove */
+    T1_FIELD_TYPE_MAX
+
+  } T1_FieldType;
+
+
+  typedef enum  T1_FieldLocation_
+  {
+    T1_FIELD_LOCATION_CID_INFO,
+    T1_FIELD_LOCATION_FONT_DICT,
+    T1_FIELD_LOCATION_FONT_INFO,
+    T1_FIELD_LOCATION_PRIVATE,
+    T1_FIELD_LOCATION_BBOX,
+
+    /* do not remove */
+    T1_FIELD_LOCATION_MAX
+
+  } T1_FieldLocation;
+
+
+  typedef void
+  (*T1_Field_ParseFunc)( FT_Face     face,
+                         FT_Pointer  parser );
+
+
+  /* structure type used to model object fields */
+  typedef struct  T1_FieldRec_
+  {
+    const char*         ident;        /* field identifier               */
+    T1_FieldLocation    location;
+    T1_FieldType        type;         /* type of field                  */
+    T1_Field_ParseFunc  reader;
+    FT_UInt             offset;       /* offset of field in object      */
+    FT_Byte             size;         /* size of field in bytes         */
+    FT_UInt             array_max;    /* maximal number of elements for */
+                                      /* array                          */
+    FT_UInt             count_offset; /* offset of element count for    */
+                                      /* arrays                         */
+  } T1_FieldRec;
+
+
+#define T1_NEW_SIMPLE_FIELD( _ident, _type, _fname ) \
+          {                                          \
+            _ident, T1CODE, _type,                   \
+            0,                                       \
+            FT_FIELD_OFFSET( _fname ),               \
+            FT_FIELD_SIZE( _fname ),                 \
+            0, 0                                     \
+          },
+
+#define T1_NEW_CALLBACK_FIELD( _ident, _reader )    \
+          {                                         \
+            _ident, T1CODE, T1_FIELD_TYPE_CALLBACK, \
+            (T1_Field_ParseFunc)_reader,            \
+            0, 0,                                   \
+            0, 0                                    \
+          },
+
+#define T1_NEW_TABLE_FIELD( _ident, _type, _fname, _max ) \
+          {                                               \
+            _ident, T1CODE, _type,                        \
+            0,                                            \
+            FT_FIELD_OFFSET( _fname ),                    \
+            FT_FIELD_SIZE_DELTA( _fname ),                \
+            _max,                                         \
+            FT_FIELD_OFFSET( num_ ## _fname )             \
+          },
+
+#define T1_NEW_TABLE_FIELD2( _ident, _type, _fname, _max ) \
+          {                                                \
+            _ident, T1CODE, _type,                         \
+            0,                                             \
+            FT_FIELD_OFFSET( _fname ),                     \
+            FT_FIELD_SIZE_DELTA( _fname ),                 \
+            _max, 0                                        \
+          },
+
+
+#define T1_FIELD_TYPE_BOOL( _ident, _fname )                        \
+          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_BOOL, _fname )
+
+#define T1_FIELD_NUM( _ident, _fname )                                 \
+          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_INTEGER, _fname )
+
+#define T1_FIELD_FIXED( _ident, _fname )                             \
+          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_FIXED, _fname )
+
+#define T1_FIELD_STRING( _ident, _fname )                             \
+          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_STRING, _fname )
+
+#define T1_FIELD_BBOX( _ident, _fname )                             \
+          T1_NEW_SIMPLE_FIELD( _ident, T1_FIELD_TYPE_BBOX, _fname )
+
+
+#define T1_FIELD_NUM_TABLE( _ident, _fname, _fmax )                \
+          T1_NEW_TABLE_FIELD( _ident, T1_FIELD_TYPE_INTEGER_ARRAY, \
+                              _fname, _fmax )
+
+#define T1_FIELD_FIXED_TABLE( _ident, _fname, _fmax )            \
+          T1_NEW_TABLE_FIELD( _ident, T1_FIELD_TYPE_FIXED_ARRAY, \
+                              _fname, _fmax )
+
+#define T1_FIELD_NUM_TABLE2( _ident, _fname, _fmax )                \
+          T1_NEW_TABLE_FIELD2( _ident, T1_FIELD_TYPE_INTEGER_ARRAY, \
+                               _fname, _fmax )
+
+#define T1_FIELD_FIXED_TABLE2( _ident, _fname, _fmax )            \
+          T1_NEW_TABLE_FIELD2( _ident, T1_FIELD_TYPE_FIXED_ARRAY, \
+                               _fname, _fmax )
+
+#define T1_FIELD_CALLBACK( _ident, _name )       \
+          T1_NEW_CALLBACK_FIELD( _ident, _name )
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                            T1 PARSER                          *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef const struct PS_Parser_FuncsRec_*  PS_Parser_Funcs;
+
+  typedef struct  PS_Parser_FuncsRec_
+  {
+    void
+    (*init)( PS_Parser  parser,
+             FT_Byte*   base,
+             FT_Byte*   limit,
+             FT_Memory  memory );
+
+    void
+    (*done)( PS_Parser  parser );
+
+    void
+    (*skip_spaces)( PS_Parser  parser );
+    void
+    (*skip_alpha)( PS_Parser  parser );
+
+    FT_Long
+    (*to_int)( PS_Parser  parser );
+    FT_Fixed
+    (*to_fixed)( PS_Parser  parser,
+                 FT_Int     power_ten );
+    FT_Int
+    (*to_coord_array)( PS_Parser  parser,
+                       FT_Int     max_coords,
+                       FT_Short*  coords );
+    FT_Int
+    (*to_fixed_array)( PS_Parser  parser,
+                       FT_Int     max_values,
+                       FT_Fixed*  values,
+                       FT_Int     power_ten );
+
+    void
+    (*to_token)( PS_Parser  parser,
+                 T1_Token   token );
+    void
+    (*to_token_array)( PS_Parser  parser,
+                       T1_Token   tokens,
+                       FT_UInt    max_tokens,
+                       FT_Int*    pnum_tokens );
+
+    FT_Error
+    (*load_field)( PS_Parser       parser,
+                   const T1_Field  field,
+                   void**          objects,
+                   FT_UInt         max_objects,
+                   FT_ULong*       pflags );
+
+    FT_Error
+    (*load_field_table)( PS_Parser       parser,
+                         const T1_Field  field,
+                         void**          objects,
+                         FT_UInt         max_objects,
+                         FT_ULong*       pflags );
+
+  } PS_Parser_FuncsRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    PS_ParserRec                                                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A PS_Parser is an object used to parse a Type 1 font very quickly. */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    cursor :: The current position in the text.                        */
+  /*                                                                       */
+  /*    base   :: Start of the processed text.                             */
+  /*                                                                       */
+  /*    limit  :: End of the processed text.                               */
+  /*                                                                       */
+  /*    error  :: The last error returned.                                 */
+  /*                                                                       */
+  /*    memory :: The object used for memory operations (alloc/realloc).   */
+  /*                                                                       */
+  /*    funcs  :: A table of functions for the parser.                     */
+  /*                                                                       */
+  typedef struct  PS_ParserRec_
+  {
+    FT_Byte*   cursor;
+    FT_Byte*   base;
+    FT_Byte*   limit;
+    FT_Error   error;
+    FT_Memory  memory;
+
+    PS_Parser_FuncsRec  funcs;
+
+  } PS_ParserRec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                         T1 BUILDER                            *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  typedef struct T1_BuilderRec_*  T1_Builder;
+
+
+  typedef FT_Error
+  (*T1_Builder_Check_Points_Func)( T1_Builder  builder,
+                                   FT_Int      count );
+
+  typedef void
+  (*T1_Builder_Add_Point_Func)( T1_Builder  builder,
+                                FT_Pos      x,
+                                FT_Pos      y,
+                                FT_Byte     flag );
+
+  typedef FT_Error
+  (*T1_Builder_Add_Point1_Func)( T1_Builder  builder,
+                                 FT_Pos      x,
+                                 FT_Pos      y );
+
+  typedef FT_Error
+  (*T1_Builder_Add_Contour_Func)( T1_Builder  builder );
+
+  typedef FT_Error
+  (*T1_Builder_Start_Point_Func)( T1_Builder  builder,
+                                  FT_Pos      x,
+                                  FT_Pos      y );
+
+  typedef void
+  (*T1_Builder_Close_Contour_Func)( T1_Builder  builder );
+
+
+  typedef const struct T1_Builder_FuncsRec_*  T1_Builder_Funcs;
+
+  typedef struct  T1_Builder_FuncsRec_
+  {
+    void
+    (*init)( T1_Builder    builder,
+             FT_Face       face,
+             FT_Size       size,
+             FT_GlyphSlot  slot,
+             FT_Bool       hinting );
+
+    void
+    (*done)( T1_Builder   builder );
+
+    T1_Builder_Check_Points_Func   check_points;
+    T1_Builder_Add_Point_Func      add_point;
+    T1_Builder_Add_Point1_Func     add_point1;
+    T1_Builder_Add_Contour_Func    add_contour;
+    T1_Builder_Start_Point_Func    start_point;
+    T1_Builder_Close_Contour_Func  close_contour;
+
+  } T1_Builder_FuncsRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Structure>                                                           */
+  /*    T1_BuilderRec                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*     A structure used during glyph loading to store its outline.       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    memory       :: The current memory object.                         */
+  /*                                                                       */
+  /*    face         :: The current face object.                           */
+  /*                                                                       */
+  /*    glyph        :: The current glyph slot.                            */
+  /*                                                                       */
+  /*    loader       :: XXX                                                */
+  /*                                                                       */
+  /*    base         :: The base glyph outline.                            */
+  /*                                                                       */
+  /*    current      :: The current glyph outline.                         */
+  /*                                                                       */
+  /*    max_points   :: maximum points in builder outline                  */
+  /*                                                                       */
+  /*    max_contours :: Maximal number of contours in builder outline.     */
+  /*                                                                       */
+  /*    last         :: The last point position.                           */
+  /*                                                                       */
+  /*    scale_x      :: The horizontal scale (FUnits to sub-pixels).       */
+  /*                                                                       */
+  /*    scale_y      :: The vertical scale (FUnits to sub-pixels).         */
+  /*                                                                       */
+  /*    pos_x        :: The horizontal translation (if composite glyph).   */
+  /*                                                                       */
+  /*    pos_y        :: The vertical translation (if composite glyph).     */
+  /*                                                                       */
+  /*    left_bearing :: The left side bearing point.                       */
+  /*                                                                       */
+  /*    advance      :: The horizontal advance vector.                     */
+  /*                                                                       */
+  /*    bbox         :: Unused.                                            */
+  /*                                                                       */
+  /*    path_begun   :: A flag which indicates that a new path has begun.  */
+  /*                                                                       */
+  /*    load_points  :: If this flag is not set, no points are loaded.     */
+  /*                                                                       */
+  /*    no_recurse   :: Set but not used.                                  */
+  /*                                                                       */
+  /*    error        :: An error code that is only used to report memory   */
+  /*                    allocation problems.                               */
+  /*                                                                       */
+  /*    metrics_only :: A boolean indicating that we only want to compute  */
+  /*                    the metrics of a given glyph, not load all of its  */
+  /*                    points.                                            */
+  /*                                                                       */
+  /*    funcs        :: An array of function pointers for the builder.     */
+  /*                                                                       */
+  typedef struct  T1_BuilderRec_
+  {
+    FT_Memory       memory;
+    FT_Face         face;
+    FT_GlyphSlot    glyph;
+    FT_GlyphLoader  loader;
+    FT_Outline*     base;
+    FT_Outline*     current;
+
+    FT_Vector       last;
+
+    FT_Fixed        scale_x;
+    FT_Fixed        scale_y;
+
+    FT_Pos          pos_x;
+    FT_Pos          pos_y;
+
+    FT_Vector       left_bearing;
+    FT_Vector       advance;
+
+    FT_BBox         bbox;          /* bounding box */
+    FT_Bool         path_begun;
+    FT_Bool         load_points;
+    FT_Bool         no_recurse;
+    FT_Bool         shift;
+
+    FT_Error        error;         /* only used for memory errors */
+    FT_Bool         metrics_only;
+
+    void*           hints_funcs;    /* hinter-specific */
+    void*           hints_globals;  /* hinter-specific */
+
+    T1_Builder_FuncsRec  funcs;
+
+  } T1_BuilderRec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                         T1 DECODER                            *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+#if 0
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* T1_MAX_SUBRS_CALLS details the maximum number of nested sub-routine   */
+  /* calls during glyph loading.                                           */
+  /*                                                                       */
+#define T1_MAX_SUBRS_CALLS  8
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* T1_MAX_CHARSTRING_OPERANDS is the charstring stack's capacity.  A     */
+  /* minimum of 16 is required.                                            */
+  /*                                                                       */
+#define T1_MAX_CHARSTRINGS_OPERANDS  32
+
+#endif /* 0 */
+
+
+  typedef struct  T1_Decoder_ZoneRec_
+  {
+    FT_Byte*  cursor;
+    FT_Byte*  base;
+    FT_Byte*  limit;
+
+  } T1_Decoder_ZoneRec, *T1_Decoder_Zone;
+
+
+  typedef struct T1_DecoderRec_*              T1_Decoder;
+  typedef const struct T1_Decoder_FuncsRec_*  T1_Decoder_Funcs;
+
+
+  typedef FT_Error
+  (*T1_Decoder_Callback)( T1_Decoder  decoder,
+                          FT_UInt     glyph_index );
+
+
+  typedef struct  T1_Decoder_FuncsRec_
+  {
+    FT_Error
+    (*init)( T1_Decoder           decoder,
+             FT_Face              face,
+             FT_Size              size,
+             FT_GlyphSlot         slot,
+             FT_Byte**            glyph_names,
+             PS_Blend             blend,
+             FT_Bool              hinting,
+             FT_Render_Mode       hint_mode,
+             T1_Decoder_Callback  callback );
+
+    void
+    (*done)( T1_Decoder  decoder );
+
+    FT_Error
+    (*parse_charstrings)( T1_Decoder  decoder,
+                          FT_Byte*    base,
+                          FT_UInt     len );
+
+  } T1_Decoder_FuncsRec;
+
+
+  typedef struct  T1_DecoderRec_
+  {
+    T1_BuilderRec        builder;
+
+    FT_Long              stack[T1_MAX_CHARSTRINGS_OPERANDS];
+    FT_Long*             top;
+
+    T1_Decoder_ZoneRec   zones[T1_MAX_SUBRS_CALLS + 1];
+    T1_Decoder_Zone      zone;
+
+    PSNames_Service      psnames;      /* for seac */
+    FT_UInt              num_glyphs;
+    FT_Byte**            glyph_names;
+
+    FT_Int               lenIV;        /* internal for sub routine calls */
+    FT_UInt              num_subrs;
+    FT_Byte**            subrs;
+    FT_Int*              subrs_len;    /* array of subrs length (optional) */
+
+    FT_Matrix            font_matrix;
+    FT_Vector            font_offset;
+
+    FT_Int               flex_state;
+    FT_Int               num_flex_vectors;
+    FT_Vector            flex_vectors[7];
+
+    PS_Blend             blend;       /* for multiple master support */
+
+    FT_UInt32            hint_flags;
+    FT_Render_Mode       hint_mode;
+
+    T1_Decoder_Callback  parse_callback;
+    T1_Decoder_FuncsRec  funcs;
+
+  } T1_DecoderRec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                     TYPE1 CHARMAPS                            *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef const struct T1_CMap_ClassesRec_*  T1_CMap_Classes;
+
+  typedef struct T1_CMap_ClassesRec_
+  {
+    FT_CMap_Class  standard;
+    FT_CMap_Class  expert;
+    FT_CMap_Class  custom;
+    FT_CMap_Class  unicode;
+
+  } T1_CMap_ClassesRec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                        PSAux Module Interface                 *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef struct  PSAux_ServiceRec_
+  {
+    /* don't use `PS_Table_Funcs' and friends to avoid compiler warnings */
+    const PS_Table_FuncsRec*    ps_table_funcs;
+    const PS_Parser_FuncsRec*   ps_parser_funcs;
+    const T1_Builder_FuncsRec*  t1_builder_funcs;
+    const T1_Decoder_FuncsRec*  t1_decoder_funcs;
+
+    void
+    (*t1_decrypt)( FT_Byte*   buffer,
+                   FT_Offset  length,
+                   FT_UShort  seed );
+
+    T1_CMap_Classes  t1_cmap_classes;
+
+  } PSAux_ServiceRec, *PSAux_Service;
+
+  /* backwards-compatible type definition */
+  typedef PSAux_ServiceRec   PSAux_Interface;
+
+FT_END_HEADER
+
+#endif /* __PSAUX_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/pshints.h
@@ -1,0 +1,626 @@
+/***************************************************************************/
+/*                                                                         */
+/*  pshints.h                                                              */
+/*                                                                         */
+/*    Interface to Postscript-specific (Type 1 and Type 2) hints           */
+/*    recorders (specification only).  These are used to support native    */
+/*    T1/T2 hints in the "type1", "cid" and "cff" font drivers.            */
+/*                                                                         */
+/*  Copyright 2001, 2002 by                                                */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __PSHINTS_H__
+#define __PSHINTS_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TYPE1_TABLES_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****               INTERNAL REPRESENTATION OF GLOBALS              *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  typedef struct PSH_GlobalsRec_*  PSH_Globals;
+
+  typedef FT_Error
+  (*PSH_Globals_NewFunc)( FT_Memory     memory,
+                          T1_Private*   private_dict,
+                          PSH_Globals*  aglobals );
+
+  typedef FT_Error
+  (*PSH_Globals_SetScaleFunc)( PSH_Globals  globals,
+                               FT_Fixed     x_scale,
+                               FT_Fixed     y_scale,
+                               FT_Fixed     x_delta,
+                               FT_Fixed     y_delta );
+
+  typedef void
+  (*PSH_Globals_DestroyFunc)( PSH_Globals  globals );
+
+
+  typedef struct  PSH_Globals_FuncsRec_
+  {
+    PSH_Globals_NewFunc       create;
+    PSH_Globals_SetScaleFunc  set_scale;
+    PSH_Globals_DestroyFunc   destroy;
+
+  } PSH_Globals_FuncsRec, *PSH_Globals_Funcs;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                  PUBLIC TYPE 1 HINTS RECORDER                 *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @type:                                                                */
+  /*    T1_Hints                                                           */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    This is a handle to an opaque structure used to record glyph hints */
+  /*    from a Type 1 character glyph character string.                    */
+  /*                                                                       */
+  /*    The methods used to operate on this object are defined by the      */
+  /*    @T1_Hints_FuncsRec structure.  Recording glyph hints is normally   */
+  /*    achieved through the following scheme:                             */
+  /*                                                                       */
+  /*    - Open a new hint recording session by calling the "open" method.  */
+  /*      This will rewind the recorder and prepare it for new input.      */
+  /*                                                                       */
+  /*    - For each hint found in the glyph charstring, call the            */
+  /*      corresponding method ("stem", "stem3", or "reset").  Note that   */
+  /*      these functions do not return an error code.                     */
+  /*                                                                       */
+  /*    - Close the recording session by calling the "close" method.  It   */
+  /*      will return an error code if the hints were invalid or something */
+  /*      strange happened (e.g. memory shortage).                         */
+  /*                                                                       */
+  /*    The hints accumulated in the object can later be used by the       */
+  /*    PostScript hinter.                                                 */
+  /*                                                                       */
+  typedef struct T1_HintsRec_*  T1_Hints;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @type:                                                                */
+  /*    T1_Hints_Funcs                                                     */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A pointer to the @T1_Hints_FuncsRec structure that defines the     */
+  /*    API of a given @T1_Hints object.                                   */
+  /*                                                                       */
+  typedef const struct T1_Hints_FuncsRec_*  T1_Hints_Funcs;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    T1_Hints_OpenFunc                                                  */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A method of the @T1_Hints class used to prepare it for a new       */
+  /*    Type 1 hints recording session.                                    */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    hints :: A handle to the Type 1 hints recorder.                    */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    You should always call the @T1_Hints_CloseFunc method in order to  */
+  /*    close an opened recording session.                                 */
+  /*                                                                       */
+  typedef void
+  (*T1_Hints_OpenFunc)( T1_Hints  hints );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    T1_Hints_SetStemFunc                                               */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A method of the @T1_Hints class used to record a new horizontal or */
+  /*    vertical stem.  This corresponds to the Type 1 "hstem" and "vstem" */
+  /*    operators.                                                         */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    hints     :: A handle to the Type 1 hints recorder.                */
+  /*                                                                       */
+  /*    dimension :: 0 for horizontal stems (hstem), 1 for vertical ones   */
+  /*                 (vstem).                                              */
+  /*                                                                       */
+  /*    coords    :: Array of 2 integers, used as (position,length) stem   */
+  /*                 descriptor.                                           */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    Use vertical coordinates (y) for horizontal stems (dim=0).  Use    */
+  /*    horizontal coordinates (x) for vertical stems (dim=1).             */
+  /*                                                                       */
+  /*    "coords[0]" is the absolute stem position (lowest coordinate);     */
+  /*    "coords[1]" is the length.                                         */
+  /*                                                                       */
+  /*    The length can be negative, in which case it must be either -20 or */
+  /*    -21.  It will be interpreted as a "ghost" stem, according to       */
+  /*    Type 1 specification.                                              */
+  /*                                                                       */
+  /*    If the length is -21 (corresponding to a bottom ghost stem), then  */
+  /*    the real stem position is "coords[0]+coords[1]".                   */
+  /*                                                                       */
+  typedef void
+  (*T1_Hints_SetStemFunc)( T1_Hints  hints,
+                           FT_UInt   dimension,
+                           FT_Long*  coords );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    T1_Hints_SetStem3Func                                              */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A method of the @T1_Hints class used to record three               */
+  /*    counter-controlled horizontal or vertical stems at once.           */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    hints     :: A handle to the Type 1 hints recorder.                */
+  /*                                                                       */
+  /*    dimension :: 0 for horizontal stems, 1 for vertical ones.          */
+  /*                                                                       */
+  /*    coords    :: An array of 6 integers, holding 3 (position,length)   */
+  /*                 pairs for the counter-controlled stems.               */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    Use vertical coordinates (y) for horizontal stems (dim=0).  Use    */
+  /*    horizontal coordinates (x) for vertical stems (dim=1).             */
+  /*                                                                       */
+  /*    The lengths cannot be negative (ghost stems are never              */
+  /*    counter-controlled).                                               */
+  /*                                                                       */
+  typedef void
+  (*T1_Hints_SetStem3Func)( T1_Hints  hints,
+                            FT_UInt   dimension,
+                            FT_Long*  coords );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    T1_Hints_ResetFunc                                                 */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A method of the @T1_Hints class used to reset the stems hints in a */
+  /*    recording session.                                                 */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    hints     :: A handle to the Type 1 hints recorder.                */
+  /*                                                                       */
+  /*    end_point :: The index of the last point in the input glyph in     */
+  /*                 which the previously defined hints apply.             */
+  /*                                                                       */
+  typedef void
+  (*T1_Hints_ResetFunc)( T1_Hints  hints,
+                         FT_UInt   end_point );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    T1_Hints_CloseFunc                                                 */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A method of the @T1_Hints class used to close a hint recording     */
+  /*    session.                                                           */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    hints     :: A handle to the Type 1 hints recorder.                */
+  /*                                                                       */
+  /*    end_point :: The index of the last point in the input glyph.       */
+  /*                                                                       */
+  /* @return:                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    The error code will be set to indicate that an error occured       */
+  /*    during the recording session.                                      */
+  /*                                                                       */
+  typedef FT_Error
+  (*T1_Hints_CloseFunc)( T1_Hints  hints,
+                         FT_UInt   end_point );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    T1_Hints_ApplyFunc                                                 */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A method of the @T1_Hints class used to apply hints to the         */
+  /*    corresponding glyph outline.  Must be called once all hints have   */
+  /*    been recorded.                                                     */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*   hints      :: A handle to the Type 1 hints recorder.                */
+  /*                                                                       */
+  /*   outline    :: A pointer to the target outline descriptor.           */
+  /*                                                                       */
+  /*   globals    :: The hinter globals for this font.                     */
+  /*                                                                       */
+  /*   hint_flags :: Hinter bit flags.                                     */
+  /*                                                                       */
+  /* @return:                                                              */
+  /*   FreeType error code.  0 means success.                              */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    On input, all points within the outline are in font coordinates.   */
+  /*    On output, they are in 1/64th of pixels.                           */
+  /*                                                                       */
+  /*    The scaling transformation is taken from the "globals" object      */
+  /*    which must correspond to the same font as the glyph.               */
+  /*                                                                       */
+  typedef FT_Error
+  (*T1_Hints_ApplyFunc)( T1_Hints        hints,
+                         FT_Outline*     outline,
+                         PSH_Globals     globals,
+                         FT_Render_Mode  hint_mode );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @struct:                                                              */
+  /*    T1_Hints_FuncsRec                                                  */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    The structure used to provide the API to @T1_Hints objects.        */
+  /*                                                                       */
+  /* @fields:                                                              */
+  /*    hints :: A handle to the T1 Hints recorder.                        */
+  /*                                                                       */
+  /*    open  :: The function to open a recording session.                 */
+  /*                                                                       */
+  /*    close :: The function to close a recording session.                */
+  /*                                                                       */
+  /*    stem  :: The function to set a simple stem.                        */
+  /*                                                                       */
+  /*    stem3 :: The function to set counter-controlled stems.             */
+  /*                                                                       */
+  /*    reset :: The function to reset stem hints.                         */
+  /*                                                                       */
+  /*    apply :: The function to apply the hints to the corresponding      */
+  /*             glyph outline.                                            */
+  /*                                                                       */
+  typedef struct  T1_Hints_FuncsRec_
+  {
+    T1_Hints               hints;
+    T1_Hints_OpenFunc      open;
+    T1_Hints_CloseFunc     close;
+    T1_Hints_SetStemFunc   stem;
+    T1_Hints_SetStem3Func  stem3;
+    T1_Hints_ResetFunc     reset;
+    T1_Hints_ApplyFunc     apply;
+
+  } T1_Hints_FuncsRec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*****                                                               *****/
+  /*****                  PUBLIC TYPE 2 HINTS RECORDER                 *****/
+  /*****                                                               *****/
+  /*************************************************************************/
+  /*************************************************************************/
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @type:                                                                */
+  /*    T2_Hints                                                           */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    This is a handle to an opaque structure used to record glyph hints */
+  /*    from a Type 2 character glyph character string.                    */
+  /*                                                                       */
+  /*    The methods used to operate on this object are defined by the      */
+  /*    @T2_Hints_FuncsRec structure.  Recording glyph hints is normally   */
+  /*    achieved through the following scheme:                             */
+  /*                                                                       */
+  /*    - Open a new hint recording session by calling the "open" method.  */
+  /*      This will rewind the recorder and prepare it for new input.      */
+  /*                                                                       */
+  /*    - For each hint found in the glyph charstring, call the            */
+  /*      corresponding method ("stems", "hintmask", "counters").  Note    */
+  /*      that these functions do not return an error code.                */
+  /*                                                                       */
+  /*    - Close the recording session by calling the "close" method.  It   */
+  /*      will return an error code if the hints were invalid or something */
+  /*      strange happened (e.g. memory shortage).                         */
+  /*                                                                       */
+  /*    The hints accumulated in the object can later be used by the       */
+  /*    Postscript hinter.                                                 */
+  /*                                                                       */
+  typedef struct T2_HintsRec_*  T2_Hints;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @type:                                                                */
+  /*    T2_Hints_Funcs                                                     */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A pointer to the @T2_Hints_FuncsRec structure that defines the API */
+  /*    of a given @T2_Hints object.                                       */
+  /*                                                                       */
+  typedef const struct T2_Hints_FuncsRec_*  T2_Hints_Funcs;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    T2_Hints_OpenFunc                                                  */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A method of the @T2_Hints class used to prepare it for a new       */
+  /*    Type 2 hints recording session.                                    */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    hints :: A handle to the Type 2 hints recorder.                    */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    You should always call the @T2_Hints_CloseFunc method in order to  */
+  /*    close an opened recording session.                                 */
+  /*                                                                       */
+  typedef void
+  (*T2_Hints_OpenFunc)( T2_Hints  hints );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    T2_Hints_StemsFunc                                                 */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A method of the @T2_Hints class used to set the table of stems in  */
+  /*    either the vertical or horizontal dimension.  Equivalent to the    */
+  /*    "hstem", "vstem", "hstemhm", and "vstemhm" Type 2 operators.       */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    hints     :: A handle to the Type 2 hints recorder.                */
+  /*                                                                       */
+  /*    dimension :: 0 for horizontal stems (hstem), 1 for vertical ones   */
+  /*                 (vstem).                                              */
+  /*                                                                       */
+  /*    count     :: The number of stems.                                  */
+  /*                                                                       */
+  /*    coords    :: An array of "count" (position,length) pairs.          */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    Use vertical coordinates (y) for horizontal stems (dim=0).  Use    */
+  /*    horizontal coordinates (x) for vertical stems (dim=1).             */
+  /*                                                                       */
+  /*    There are "2*count" elements in the "coords" aray.  Each even      */
+  /*    element is an absolute position in font units, each odd element is */
+  /*    a length in font units.                                            */
+  /*                                                                       */
+  /*    A length can be negative, in which case it must be either -20 or   */
+  /*    -21.  It will be interpreted as a "ghost" stem, according to the   */
+  /*    Type 1 specification.                                              */
+  /*                                                                       */
+  typedef void
+  (*T2_Hints_StemsFunc)( T2_Hints   hints,
+                         FT_UInt    dimension,
+                         FT_UInt    count,
+                         FT_Fixed*  coordinates );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    T2_Hints_MaskFunc                                                  */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A method of the @T2_Hints class used to set a given hintmask       */
+  /*    (this corresponds to the "hintmask" Type 2 operator).              */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    hints     :: A handle to the Type 2 hints recorder.                */
+  /*                                                                       */
+  /*    end_point :: The glyph index of the last point to which the        */
+  /*                 previously defined/activated hints apply.             */
+  /*                                                                       */
+  /*    bit_count :: The number of bits in the hint mask.                  */
+  /*                                                                       */
+  /*    bytes     :: An array of bytes modelling the hint mask.            */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    If the hintmask starts the charstring (before any glyph point      */
+  /*    definition), the value of "end_point" should be 0.                 */
+  /*                                                                       */
+  /*    "bit_count" is the number of meaningful bits in the "bytes" array; */
+  /*    it must be equal to the total number of hints defined so far       */
+  /*    (i.e. horizontal+verticals).                                       */
+  /*                                                                       */
+  /*    The "bytes" array can come directly from the Type 2 charstring and */
+  /*    respects the same format.                                          */
+  /*                                                                       */
+  typedef void
+  (*T2_Hints_MaskFunc)( T2_Hints        hints,
+                        FT_UInt         end_point,
+                        FT_UInt         bit_count,
+                        const FT_Byte*  bytes );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    T2_Hints_CounterFunc                                               */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A method of the @T2_Hints class used to set a given counter mask   */
+  /*    (this corresponds to the "hintmask" Type 2 operator).              */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    hints     :: A handle to the Type 2 hints recorder.                */
+  /*                                                                       */
+  /*    end_point :: A glyph index of the last point to which the          */
+  /*                 previously defined/active hints apply.                */
+  /*                                                                       */
+  /*    bit_count :: The number of bits in the hint mask.                  */
+  /*                                                                       */
+  /*    bytes     :: An array of bytes modelling the hint mask.            */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    If the hintmask starts the charstring (before any glyph point      */
+  /*    definition), the value of "end_point" should be 0.                 */
+  /*                                                                       */
+  /*    "bit_count" is the number of meaningful bits in the "bytes" array; */
+  /*    it must be equal to the total number of hints defined so far       */
+  /*    (i.e. horizontal+verticals).                                       */
+  /*                                                                       */
+  /*    The "bytes" array can come directly from the Type 2 charstring and */
+  /*    respects the same format.                                          */
+  /*                                                                       */
+  typedef void
+  (*T2_Hints_CounterFunc)( T2_Hints        hints,
+                           FT_UInt         bit_count,
+                           const FT_Byte*  bytes );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    T2_Hints_CloseFunc                                                 */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A method of the @T2_Hints class used to close a hint recording     */
+  /*    session.                                                           */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    hints     :: A handle to the Type 2 hints recorder.                */
+  /*                                                                       */
+  /*    end_point :: The index of the last point in the input glyph.       */
+  /*                                                                       */
+  /* @return:                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    The error code will be set to indicate that an error occured       */
+  /*    during the recording session.                                      */
+  /*                                                                       */
+  typedef FT_Error
+  (*T2_Hints_CloseFunc)( T2_Hints  hints,
+                         FT_UInt   end_point );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @functype:                                                            */
+  /*    T2_Hints_ApplyFunc                                                 */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    A method of the @T2_Hints class used to apply hints to the         */
+  /*    corresponding glyph outline.  Must be called after the "close"     */
+  /*    method.                                                            */
+  /*                                                                       */
+  /* @input:                                                               */
+  /*    hints      :: A handle to the Type 2 hints recorder.               */
+  /*                                                                       */
+  /*    outline    :: A pointer to the target outline descriptor.          */
+  /*                                                                       */
+  /*    globals    :: The hinter globals for this font.                    */
+  /*                                                                       */
+  /*    hint_flags :: Hinter bit flags.                                    */
+  /*                                                                       */
+  /* @return:                                                              */
+  /*   FreeType error code.  0 means success.                              */
+  /*                                                                       */
+  /* @note:                                                                */
+  /*    On input, all points within the outline are in font coordinates.   */
+  /*    On output, they are in 1/64th of pixels.                           */
+  /*                                                                       */
+  /*    The scaling transformation is taken from the "globals" object      */
+  /*    which must correspond to the same font than the glyph.             */
+  /*                                                                       */
+  typedef FT_Error
+  (*T2_Hints_ApplyFunc)( T2_Hints        hints,
+                         FT_Outline*     outline,
+                         PSH_Globals     globals,
+                         FT_Render_Mode  hint_mode );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* @struct:                                                              */
+  /*    T2_Hints_FuncsRec                                                  */
+  /*                                                                       */
+  /* @description:                                                         */
+  /*    The structure used to provide the API to @T2_Hints objects.        */
+  /*                                                                       */
+  /* @fields:                                                              */
+  /*    hints    :: A handle to the T2 hints recorder object.              */
+  /*                                                                       */
+  /*    open     :: The function to open a recording session.              */
+  /*                                                                       */
+  /*    close    :: The function to close a recording session.             */
+  /*                                                                       */
+  /*    stems    :: The function to set the dimension's stems table.       */
+  /*                                                                       */
+  /*    hintmask :: The function to set hint masks.                        */
+  /*                                                                       */
+  /*    counter  :: The function to set counter masks.                     */
+  /*                                                                       */
+  /*    apply    :: The function to apply the hints on the corresponding   */
+  /*                glyph outline.                                         */
+  /*                                                                       */
+  typedef struct  T2_Hints_FuncsRec_
+  {
+    T2_Hints              hints;
+    T2_Hints_OpenFunc     open;
+    T2_Hints_CloseFunc    close;
+    T2_Hints_StemsFunc    stems;
+    T2_Hints_MaskFunc     hintmask;
+    T2_Hints_CounterFunc  counter;
+    T2_Hints_ApplyFunc    apply;
+
+  } T2_Hints_FuncsRec;
+
+
+  /* */
+
+
+  typedef struct  PSHinter_Interface_
+  {
+    PSH_Globals_Funcs  (*get_globals_funcs)( FT_Module  module );
+    T1_Hints_Funcs     (*get_t1_funcs)     ( FT_Module  module );
+    T2_Hints_Funcs     (*get_t2_funcs)     ( FT_Module  module );
+
+  } PSHinter_Interface;
+
+  typedef PSHinter_Interface*  PSHinter_Service;
+
+
+FT_END_HEADER
+
+#endif /* __PSHINTS_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/psnames.h
@@ -1,0 +1,241 @@
+/***************************************************************************/
+/*                                                                         */
+/*  psnames.h                                                              */
+/*                                                                         */
+/*    High-level interface for the `PSNames' module (in charge of          */
+/*    various functions related to Postscript glyph names conversion).     */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __PSNAMES_H__
+#define __PSNAMES_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    PS_Unicode_Value_Func                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to return the Unicode index corresponding to a     */
+  /*    given glyph name.                                                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    glyph_name :: The glyph name.                                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The Unicode character index resp. the non-Unicode value 0xFFFF if  */
+  /*    the glyph name has no known Unicode meaning.                       */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function is able to map several different glyph names to the  */
+  /*    same Unicode value, according to the rules defined in the Adobe    */
+  /*    Glyph List table.                                                  */
+  /*                                                                       */
+  /*    This function will not be compiled if the configuration macro      */
+  /*    FT_CONFIG_OPTION_ADOBE_GLYPH_LIST is undefined.                    */
+  /*                                                                       */
+  typedef FT_UInt32
+  (*PS_Unicode_Value_Func)( const char*  glyph_name );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    PS_Unicode_Index_Func                                              */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to return the glyph index corresponding to a given */
+  /*    Unicode value.                                                     */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    num_glyphs  :: The number of glyphs in the face.                   */
+  /*                                                                       */
+  /*    glyph_names :: An array of glyph name pointers.                    */
+  /*                                                                       */
+  /*    unicode     :: The Unicode value.                                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The glyph index resp. 0xFFFF if no glyph corresponds to this       */
+  /*    Unicode value.                                                     */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function is able to recognize several glyph names per Unicode */
+  /*    value, according to the Adobe Glyph List.                          */
+  /*                                                                       */
+  /*    This function will not be compiled if the configuration macro      */
+  /*    FT_CONFIG_OPTION_ADOBE_GLYPH_LIST is undefined.                    */
+  /*                                                                       */
+  typedef FT_UInt
+  (*PS_Unicode_Index_Func)( FT_UInt       num_glyphs,
+                            const char**  glyph_names,
+                            FT_ULong      unicode );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    PS_Macintosh_Name_Func                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A function used to return the glyph name corresponding to an Apple */
+  /*    glyph name index.                                                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    name_index :: The index of the Mac name.                           */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    The glyph name, or 0 if the index is invalid.                      */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function will not be compiled if the configuration macro      */
+  /*    FT_CONFIG_OPTION_POSTSCRIPT_NAMES is undefined.                    */
+  /*                                                                       */
+  typedef const char*
+  (*PS_Macintosh_Name_Func)( FT_UInt  name_index );
+
+
+  typedef const char*
+  (*PS_Adobe_Std_Strings_Func)( FT_UInt  string_index );
+
+
+  typedef struct  PS_UniMap_
+  {
+    FT_UInt  unicode;
+    FT_UInt  glyph_index;
+
+  } PS_UniMap;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    PS_Unicodes                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple table used to map Unicode values to glyph indices.  It is */
+  /*    built by the PS_Build_Unicodes table according to the glyphs       */
+  /*    present in a font file.                                            */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    num_codes :: The number of glyphs in the font that match a given   */
+  /*                 Unicode value.                                        */
+  /*                                                                       */
+  /*    unicodes  :: An array of unicode values, sorted in increasing      */
+  /*                 order.                                                */
+  /*                                                                       */
+  /*    gindex    :: An array of glyph indices, corresponding to each      */
+  /*                 Unicode value.                                        */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    Use the function PS_Lookup_Unicode() to retrieve the glyph index   */
+  /*    corresponding to a given Unicode character code.                   */
+  /*                                                                       */
+  typedef struct  PS_Unicodes_
+  {
+    FT_UInt     num_maps;
+    PS_UniMap*  maps;
+
+  } PS_Unicodes;
+
+
+  typedef FT_Error
+  (*PS_Build_Unicodes_Func)( FT_Memory     memory,
+                             FT_UInt       num_glyphs,
+                             const char**  glyph_names,
+                             PS_Unicodes*  unicodes );
+
+  typedef FT_UInt
+  (*PS_Lookup_Unicode_Func)( PS_Unicodes*  unicodes,
+                             FT_UInt       unicode );
+
+  typedef FT_ULong
+  (*PS_Next_Unicode_Func)( PS_Unicodes*  unicodes,
+                           FT_ULong      unicode );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    PSNames_Interface                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This structure defines the PSNames interface.                      */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    unicode_value         :: A function used to convert a glyph name   */
+  /*                             into a Unicode character code.            */
+  /*                                                                       */
+  /*    build_unicodes        :: A function which builds up the Unicode    */
+  /*                             mapping table.                            */
+  /*                                                                       */
+  /*    lookup_unicode        :: A function used to return the glyph index */
+  /*                             corresponding to a given Unicode          */
+  /*                             character.                                */
+  /*                                                                       */
+  /*    macintosh_name        :: A function used to return the standard    */
+  /*                             Apple glyph Postscript name corresponding */
+  /*                             to a given string index (used by the      */
+  /*                             TrueType `post' table).                   */
+  /*                                                                       */
+  /*    adobe_std_strings     :: A function that returns a pointer to a    */
+  /*                             Adobe Standard String for a given SID.    */
+  /*                                                                       */
+  /*    adobe_std_encoding    :: A table of 256 unsigned shorts that maps  */
+  /*                             character codes in the Adobe Standard     */
+  /*                             Encoding to SIDs.                         */
+  /*                                                                       */
+  /*    adobe_expert_encoding :: A table of 256 unsigned shorts that maps  */
+  /*                             character codes in the Adobe Expert       */
+  /*                             Encoding to SIDs.                         */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    `unicode_value' and `unicode_index' will be set to 0 if the        */
+  /*    configuration macro FT_CONFIG_OPTION_ADOBE_GLYPH_LIST is           */
+  /*    undefined.                                                         */
+  /*                                                                       */
+  /*    `macintosh_name' will be set to 0 if the configuration macro       */
+  /*    FT_CONFIG_OPTION_POSTSCRIPT_NAMES is undefined.                    */
+  /*                                                                       */
+  typedef struct  PSNames_Interface_
+  {
+    PS_Unicode_Value_Func      unicode_value;
+    PS_Build_Unicodes_Func     build_unicodes;
+    PS_Lookup_Unicode_Func     lookup_unicode;
+    PS_Macintosh_Name_Func     macintosh_name;
+
+    PS_Adobe_Std_Strings_Func  adobe_std_strings;
+    const unsigned short*      adobe_std_encoding;
+    const unsigned short*      adobe_expert_encoding;
+
+    PS_Next_Unicode_Func       next_unicode;
+
+  } PSNames_Interface;
+
+
+  typedef PSNames_Interface*  PSNames_Service;
+
+
+FT_END_HEADER
+
+#endif /* __PSNAMES_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/sfnt.h
@@ -1,0 +1,534 @@
+/***************************************************************************/
+/*                                                                         */
+/*  sfnt.h                                                                 */
+/*                                                                         */
+/*    High-level `sfnt' driver interface (specification).                  */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __SFNT_H__
+#define __SFNT_H__
+
+
+#include <ft2build.h>
+#include FT_INTERNAL_DRIVER_H
+#include FT_INTERNAL_TRUETYPE_TYPES_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Init_Face_Func                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    First part of the SFNT face object initialization.  This will find */
+  /*    the face in a SFNT file or collection, and load its format tag in  */
+  /*    face->format_tag.                                                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    stream     :: The input stream.                                    */
+  /*                                                                       */
+  /*    face       :: A handle to the target face object.                  */
+  /*                                                                       */
+  /*    face_index :: The index of the TrueType font, if we are opening a  */
+  /*                  collection.                                          */
+  /*                                                                       */
+  /*    num_params :: The number of additional parameters.                 */
+  /*                                                                       */
+  /*    params     :: Optional additional parameters.                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The stream cursor must be at the font file's origin.               */
+  /*                                                                       */
+  /*    This function recognizes fonts embedded in a `TrueType             */
+  /*    collection'.                                                       */
+  /*                                                                       */
+  /*    Once the format tag has been validated by the font driver, it      */
+  /*    should then call the TT_Load_Face_Func() callback to read the rest */
+  /*    of the SFNT tables in the object.                                  */
+  /*                                                                       */
+  typedef FT_Error
+  (*TT_Init_Face_Func)( FT_Stream      stream,
+                        TT_Face        face,
+                        FT_Int         face_index,
+                        FT_Int         num_params,
+                        FT_Parameter*  params );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Load_Face_Func                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Second part of the SFNT face object initialization.  This will     */
+  /*    load the common SFNT tables (head, OS/2, maxp, metrics, etc.) in   */
+  /*    the face object.                                                   */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    stream     :: The input stream.                                    */
+  /*                                                                       */
+  /*    face       :: A handle to the target face object.                  */
+  /*                                                                       */
+  /*    face_index :: The index of the TrueType font, if we are opening a  */
+  /*                  collection.                                          */
+  /*                                                                       */
+  /*    num_params :: The number of additional parameters.                 */
+  /*                                                                       */
+  /*    params     :: Optional additional parameters.                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function must be called after TT_Init_Face_Func().            */
+  /*                                                                       */
+  typedef FT_Error
+  (*TT_Load_Face_Func)( FT_Stream      stream,
+                        TT_Face        face,
+                        FT_Int         face_index,
+                        FT_Int         num_params,
+                        FT_Parameter*  params );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Done_Face_Func                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A callback used to delete the common SFNT data from a face.        */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to the target face object.                        */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function does NOT destroy the face object.                    */
+  /*                                                                       */
+  typedef void
+  (*TT_Done_Face_Func)( TT_Face  face );
+
+
+  typedef FT_Module_Interface
+  (*SFNT_Get_Interface_Func)( FT_Module    module,
+                              const char*  func_interface );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Load_SFNT_HeaderRec_Func                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the header of a SFNT font file.  Supports collections.       */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face       :: A handle to the target face object.                  */
+  /*                                                                       */
+  /*    stream     :: The input stream.                                    */
+  /*                                                                       */
+  /*    face_index :: The index of the TrueType font, if we are opening a  */
+  /*                  collection.                                          */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    sfnt       :: The SFNT header.                                     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The stream cursor must be at the font file's origin.               */
+  /*                                                                       */
+  /*    This function recognizes fonts embedded in a `TrueType             */
+  /*    collection'.                                                       */
+  /*                                                                       */
+  /*    This function checks that the header is valid by looking at the    */
+  /*    values of `search_range', `entry_selector', and `range_shift'.     */
+  /*                                                                       */
+  typedef FT_Error
+  (*TT_Load_SFNT_HeaderRec_Func)( TT_Face      face,
+                                  FT_Stream    stream,
+                                  FT_Long      face_index,
+                                  SFNT_Header  sfnt );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Load_Directory_Func                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the table directory into a face object.                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face      :: A handle to the target face object.                   */
+  /*                                                                       */
+  /*    stream    :: The input stream.                                     */
+  /*                                                                       */
+  /*    sfnt      :: The SFNT header.                                      */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The stream cursor must be on the first byte after the 4-byte font  */
+  /*    format tag.  This is the case just after a call to                 */
+  /*    TT_Load_Format_Tag().                                              */
+  /*                                                                       */
+  typedef FT_Error
+  (*TT_Load_Directory_Func)( TT_Face      face,
+                             FT_Stream    stream,
+                             SFNT_Header  sfnt );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Load_Any_Func                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads any font table into client memory.                           */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: The face object to look for.                             */
+  /*                                                                       */
+  /*    tag    :: The tag of table to load.  Use the value 0 if you want   */
+  /*              to access the whole font file, else set this parameter   */
+  /*              to a valid TrueType table tag that you can forge with    */
+  /*              the MAKE_TT_TAG macro.                                   */
+  /*                                                                       */
+  /*    offset :: The starting offset in the table (or the file if         */
+  /*              tag == 0).                                               */
+  /*                                                                       */
+  /*    length :: The address of the decision variable:                    */
+  /*                                                                       */
+  /*                If length == NULL:                                     */
+  /*                  Loads the whole table.  Returns an error if          */
+  /*                  `offset' == 0!                                       */
+  /*                                                                       */
+  /*                If *length == 0:                                       */
+  /*                  Exits immediately; returning the length of the given */
+  /*                  table or of the font file, depending on the value of */
+  /*                  `tag'.                                               */
+  /*                                                                       */
+  /*                If *length != 0:                                       */
+  /*                  Loads the next `length' bytes of table or font,      */
+  /*                  starting at offset `offset' (in table or font too).  */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    buffer :: The address of target buffer.                            */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    TrueType error code.  0 means success.                             */
+  /*                                                                       */
+  typedef FT_Error
+  (*TT_Load_Any_Func)( TT_Face    face,
+                       FT_ULong   tag,
+                       FT_Long    offset,
+                       FT_Byte   *buffer,
+                       FT_ULong*  length );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Load_SBit_Image_Func                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads a given glyph sbit image from the font resource.  This also  */
+  /*    returns its metrics.                                               */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face        :: The target face object.                             */
+  /*                                                                       */
+  /*    x_ppem      :: The horizontal resolution in points per EM.         */
+  /*                                                                       */
+  /*    y_ppem      :: The vertical resolution in points per EM.           */
+  /*                                                                       */
+  /*    glyph_index :: The current glyph index.                            */
+  /*                                                                       */
+  /*    stream      :: The input stream.                                   */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    amap        :: The target pixmap.                                  */
+  /*                                                                       */
+  /*    ametrics    :: A big sbit metrics structure for the glyph image.   */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.  Returns an error if no     */
+  /*    glyph sbit exists for the index.                                   */
+  /*                                                                       */
+  /*  <Note>                                                               */
+  /*    The `map.buffer' field is always freed before the glyph is loaded. */
+  /*                                                                       */
+  typedef FT_Error
+  (*TT_Load_SBit_Image_Func)( TT_Face              face,
+                              FT_ULong             strike_index,
+                              FT_UInt              glyph_index,
+                              FT_UInt              load_flags,
+                              FT_Stream            stream,
+                              FT_Bitmap           *amap,
+                              TT_SBit_MetricsRec  *ametrics );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Set_SBit_Strike_Func                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Selects an sbit strike for given horizontal and vertical ppem      */
+  /*    values.                                                            */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face          :: The target face object.                           */
+  /*                                                                       */
+  /*    x_ppem        :: The horizontal resolution in points per EM.       */
+  /*                                                                       */
+  /*    y_ppem        :: The vertical resolution in points per EM.         */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    astrike_index :: The index of the sbit strike.                     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.  Returns an error if no     */
+  /*    sbit strike exists for the selected ppem values.                   */
+  /*                                                                       */
+  typedef FT_Error
+  (*TT_Set_SBit_Strike_Func)( TT_Face    face,
+                              FT_Int     x_ppem,
+                              FT_Int     y_ppem,
+                              FT_ULong  *astrike_index );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Get_PS_Name_Func                                                */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Gets the PostScript glyph name of a glyph.                         */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    idx  :: The glyph index.                                           */
+  /*                                                                       */
+  /*    PSname :: The address of a string pointer.  Will be NULL in case   */
+  /*              of error, otherwise it is a pointer to the glyph name.   */
+  /*                                                                       */
+  /*              You must not modify the returned string!                 */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  typedef FT_Error
+  (*TT_Get_PS_Name_Func)( TT_Face      face,
+                          FT_UInt      idx,
+                          FT_String**  PSname );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Load_Metrics_Func                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads the horizontal or vertical header in a face object.          */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face     :: A handle to the target face object.                    */
+  /*                                                                       */
+  /*    stream   :: The input stream.                                      */
+  /*                                                                       */
+  /*    vertical :: A boolean flag.  If set, load vertical metrics.        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  typedef FT_Error
+  (*TT_Load_Metrics_Func)( TT_Face    face,
+                           FT_Stream  stream,
+                           FT_Bool    vertical );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_CharMap_Load_Func                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads a given TrueType character map into memory.                  */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the parent face object.                      */
+  /*                                                                       */
+  /*    stream :: A handle to the current stream object.                   */
+  /*                                                                       */
+  /* <InOut>                                                               */
+  /*    cmap   :: A pointer to a cmap object.                              */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The function assumes that the stream is already in use (i.e.,      */
+  /*    opened).  In case of error, all partially allocated tables are     */
+  /*    released.                                                          */
+  /*                                                                       */
+  typedef FT_Error
+  (*TT_CharMap_Load_Func)( TT_Face       face,
+                           TT_CMapTable  cmap,
+                           FT_Stream     input );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_CharMap_Free_Func                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Destroys a character mapping table.                                */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to the parent face object.                        */
+  /*                                                                       */
+  /*    cmap :: A handle to a cmap object.                                 */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  typedef FT_Error
+  (*TT_CharMap_Free_Func)( TT_Face       face,
+                           TT_CMapTable  cmap );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Load_Table_Func                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Loads a given TrueType table.                                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /*    stream :: The input stream.                                        */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The function will use `face->goto_table' to seek the stream to     */
+  /*    the start of the table.                                            */
+  /*                                                                       */
+  typedef FT_Error
+  (*TT_Load_Table_Func)( TT_Face    face,
+                         FT_Stream  stream );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Free_Table_Func                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Frees a given TrueType table.                                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to the target face object.                        */
+  /*                                                                       */
+  typedef void
+  (*TT_Free_Table_Func)( TT_Face  face );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    SFNT_Interface                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This structure holds pointers to the functions used to load and    */
+  /*    free the basic tables that are required in a `sfnt' font file.     */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    Check the various xxx_Func() descriptions for details.             */
+  /*                                                                       */
+  typedef struct  SFNT_Interface_
+  {
+    TT_Loader_GotoTableFunc      goto_table;
+
+    TT_Init_Face_Func            init_face;
+    TT_Load_Face_Func            load_face;
+    TT_Done_Face_Func            done_face;
+    SFNT_Get_Interface_Func      get_interface;
+
+    TT_Load_Any_Func             load_any;
+    TT_Load_SFNT_HeaderRec_Func  load_sfnt_header;
+    TT_Load_Directory_Func       load_directory;
+
+    /* these functions are called by `load_face' but they can also  */
+    /* be called from external modules, if there is a need to do so */
+    TT_Load_Table_Func           load_header;
+    TT_Load_Metrics_Func         load_metrics;
+    TT_Load_Table_Func           load_charmaps;
+    TT_Load_Table_Func           load_max_profile;
+    TT_Load_Table_Func           load_os2;
+    TT_Load_Table_Func           load_psnames;
+
+    TT_Load_Table_Func           load_names;
+    TT_Free_Table_Func           free_names;
+
+    /* optional tables */
+    TT_Load_Table_Func           load_hdmx;
+    TT_Free_Table_Func           free_hdmx;
+
+    TT_Load_Table_Func           load_kerning;
+    TT_Load_Table_Func           load_gasp;
+    TT_Load_Table_Func           load_pclt;
+
+    /* see `ttload.h' */
+    TT_Load_Table_Func           load_bitmap_header;
+
+    /* see `ttsbit.h' */
+    TT_Set_SBit_Strike_Func      set_sbit_strike;
+    TT_Load_Table_Func           load_sbits;
+    TT_Load_SBit_Image_Func      load_sbit_image;
+    TT_Free_Table_Func           free_sbits;
+
+    /* see `ttpost.h' */
+    TT_Get_PS_Name_Func          get_psname;
+    TT_Free_Table_Func           free_psnames;
+
+    /* see `ttcmap.h' */
+    TT_CharMap_Load_Func         load_charmap;
+    TT_CharMap_Free_Func         free_charmap;
+
+  } SFNT_Interface;
+
+
+  /* transitional */
+  typedef SFNT_Interface*   SFNT_Service;
+
+
+FT_END_HEADER
+
+#endif /* __SFNT_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/t1types.h
@@ -1,0 +1,199 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1types.h                                                              */
+/*                                                                         */
+/*    Basic Type1/Type2 type definitions and interface (specification      */
+/*    only).                                                               */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __T1TYPES_H__
+#define __T1TYPES_H__
+
+
+#include <ft2build.h>
+#include FT_TYPE1_TABLES_H
+#include FT_INTERNAL_POSTSCRIPT_NAMES_H
+#include FT_INTERNAL_POSTSCRIPT_HINTS_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /***              REQUIRED TYPE1/TYPE2 TABLES DEFINITIONS              ***/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    T1_EncodingRec                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure modeling a custom encoding.                            */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    num_chars  :: The number of character codes in the encoding.       */
+  /*                  Usually 256.                                         */
+  /*                                                                       */
+  /*    code_first :: The lowest valid character code in the encoding.     */
+  /*                                                                       */
+  /*    code_last  :: The highest valid character code in the encoding.    */
+  /*                                                                       */
+  /*    char_index :: An array of corresponding glyph indices.             */
+  /*                                                                       */
+  /*    char_name  :: An array of corresponding glyph names.               */
+  /*                                                                       */
+  typedef struct  T1_EncodingRecRec_
+  {
+    FT_Int       num_chars;
+    FT_Int       code_first;
+    FT_Int       code_last;
+
+    FT_UShort*   char_index;
+    FT_String**  char_name;
+
+  } T1_EncodingRec, *T1_Encoding;
+
+
+  typedef enum  T1_EncodingType_
+  {
+    T1_ENCODING_TYPE_NONE = 0,
+    T1_ENCODING_TYPE_ARRAY,
+    T1_ENCODING_TYPE_STANDARD,
+    T1_ENCODING_TYPE_ISOLATIN1,
+    T1_ENCODING_TYPE_EXPERT
+
+  } T1_EncodingType;
+
+
+  typedef struct  T1_FontRec_
+  {
+    PS_FontInfoRec   font_info;         /* font info dictionary */
+    PS_PrivateRec    private_dict;      /* private dictionary   */
+    FT_String*       font_name;         /* top-level dictionary */
+
+    T1_EncodingType  encoding_type;
+    T1_EncodingRec   encoding;
+
+    FT_Byte*         subrs_block;
+    FT_Byte*         charstrings_block;
+    FT_Byte*         glyph_names_block;
+
+    FT_Int           num_subrs;
+    FT_Byte**        subrs;
+    FT_Int*          subrs_len;
+
+    FT_Int           num_glyphs;
+    FT_String**      glyph_names;       /* array of glyph names       */
+    FT_Byte**        charstrings;       /* array of glyph charstrings */
+    FT_Int*          charstrings_len;
+
+    FT_Byte          paint_type;
+    FT_Byte          font_type;
+    FT_Matrix        font_matrix;
+    FT_Vector        font_offset;
+    FT_BBox          font_bbox;
+    FT_Long          font_id;
+
+    FT_Int           stroke_width;
+
+  } T1_FontRec, *T1_Font;
+
+
+  typedef struct  CID_SubrsRec_
+  {
+    FT_UInt    num_subrs;
+    FT_Byte**  code;
+
+  } CID_SubrsRec, *CID_Subrs;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /***                ORIGINAL T1_FACE CLASS DEFINITION                  ***/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This structure/class is defined here because it is common to the      */
+  /* following formats: TTF, OpenType-TT, and OpenType-CFF.                */
+  /*                                                                       */
+  /* Note, however, that the classes TT_Size, TT_GlyphSlot, and TT_CharMap */
+  /* are not shared between font drivers, and are thus defined normally in */
+  /* `ttobjs.h'.                                                           */
+  /*                                                                       */
+  /*************************************************************************/
+
+  typedef struct T1_FaceRec_*   T1_Face;
+  typedef struct CID_FaceRec_*  CID_Face;
+
+
+  typedef struct  T1_FaceRec_
+  {
+    FT_FaceRec     root;
+    T1_FontRec     type1;
+    const void*    psnames;
+    const void*    psaux;
+    const void*    afm_data;
+    FT_CharMapRec  charmaprecs[2];
+    FT_CharMap     charmaps[2];
+    PS_Unicodes    unicode_map;
+
+    /* support for Multiple Masters fonts */
+    PS_Blend       blend;
+    
+    /* since FT 2.1 - interface to PostScript hinter */
+    const void*    pshinter;
+
+  } T1_FaceRec;
+
+
+  typedef struct  CID_FaceRec_
+  {
+    FT_FaceRec       root;
+    void*            psnames;
+    void*            psaux;
+    CID_FaceInfoRec  cid;
+    void*            afm_data;
+    CID_Subrs        subrs;
+    
+    /* since FT 2.1 - interface to PostScript hinter */
+    void*            pshinter;
+
+  } CID_FaceRec;
+
+
+FT_END_HEADER
+
+#endif /* __T1TYPES_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/t42types.h
@@ -1,0 +1,55 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t42types.h                                                             */
+/*                                                                         */
+/*    Type 42 font data types (specification only).                        */
+/*                                                                         */
+/*  Copyright 2002 by Roberto Alameda.                                     */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __T42TYPES_H__
+#define __T42TYPES_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TYPE1_TABLES_H
+#include FT_INTERNAL_TYPE1_TYPES_H
+#include FT_INTERNAL_POSTSCRIPT_NAMES_H
+#include FT_INTERNAL_POSTSCRIPT_HINTS_H
+
+
+FT_BEGIN_HEADER
+
+
+  typedef struct  T42_FaceRec_
+  {
+    FT_FaceRec     root;
+    T1_FontRec     type1;
+    const void*    psnames;
+    const void*    psaux;
+    const void*    afm_data;
+    FT_Byte*       ttf_data;
+    FT_ULong       ttf_size;
+    FT_Face        ttf_face;
+    FT_CharMapRec  charmaprecs[2];
+    FT_CharMap     charmaps[2];
+    PS_Unicodes    unicode_map;
+
+  } T42_FaceRec, *T42_Face;
+
+
+FT_END_HEADER
+
+#endif /* __T1TYPES_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/internal/tttypes.h
@@ -1,0 +1,1669 @@
+/***************************************************************************/
+/*                                                                         */
+/*  tttypes.h                                                              */
+/*                                                                         */
+/*    Basic SFNT/TrueType type definitions and interface (specification    */
+/*    only).                                                               */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __TTTYPES_H__
+#define __TTTYPES_H__
+
+
+#include <ft2build.h>
+#include FT_TRUETYPE_TABLES_H
+#include FT_INTERNAL_OBJECTS_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /***             REQUIRED TRUETYPE/OPENTYPE TABLES DEFINITIONS         ***/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TTC_HeaderRec                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    TrueType collection header.  This table contains the offsets of    */
+  /*    the font headers of each distinct TrueType face in the file.       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    tag     :: Must be `ttc ' to indicate a TrueType collection.       */
+  /*                                                                       */
+  /*    version :: The version number.                                     */
+  /*                                                                       */
+  /*    count   :: The number of faces in the collection.  The             */
+  /*               specification says this should be an unsigned long, but */
+  /*               we use a signed long since we need the value -1 for     */
+  /*               specific purposes.                                      */
+  /*                                                                       */
+  /*    offsets :: The offsets of the font headers, one per face.          */
+  /*                                                                       */
+  typedef struct  TTC_HeaderRec_
+  {
+    FT_ULong   tag;
+    FT_Fixed   version;
+    FT_Long    count;
+    FT_ULong*  offsets;
+
+  } TTC_HeaderRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    SFNT_HeaderRec                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    SFNT file format header.                                           */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    format_tag     :: The font format tag.                             */
+  /*                                                                       */
+  /*    num_tables     :: The number of tables in file.                    */
+  /*                                                                       */
+  /*    search_range   :: Must be `16 * (max power of 2 <= num_tables)'.   */
+  /*                                                                       */
+  /*    entry_selector :: Must be log2 of `search_range / 16'.             */
+  /*                                                                       */
+  /*    range_shift    :: Must be `num_tables * 16 - search_range'.        */
+  /*                                                                       */
+  typedef struct  SFNT_HeaderRec_
+  {
+    FT_ULong   format_tag;
+    FT_UShort  num_tables;
+    FT_UShort  search_range;
+    FT_UShort  entry_selector;
+    FT_UShort  range_shift;
+
+    FT_ULong   offset;  /* not in file */
+
+  } SFNT_HeaderRec, *SFNT_Header;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_TableDirRec                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This structure models a TrueType table directory.  It is used to   */
+  /*    access the various tables of the font face.                        */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    version       :: The version number; starts with 0x00010000.       */
+  /*                                                                       */
+  /*    numTables     :: The number of tables.                             */
+  /*                                                                       */
+  /*    searchRange   :: Unused.                                           */
+  /*                                                                       */
+  /*    entrySelector :: Unused.                                           */
+  /*                                                                       */
+  /*    rangeShift    :: Unused.                                           */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This structure is only used during font opening.                   */
+  /*                                                                       */
+  typedef struct  TT_TableDirRec_
+  {
+    FT_Fixed   version;        /* should be 0x10000 */
+    FT_UShort  numTables;      /* number of tables  */
+
+    FT_UShort  searchRange;    /* These parameters are only used  */
+    FT_UShort  entrySelector;  /* for a dichotomy search in the   */
+    FT_UShort  rangeShift;     /* directory.  We ignore them.     */
+
+  } TT_TableDirRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_TableRec                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This structure describes a given table of a TrueType font.         */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    Tag      :: A four-bytes tag describing the table.                 */
+  /*                                                                       */
+  /*    CheckSum :: The table checksum.  This value can be ignored.        */
+  /*                                                                       */
+  /*    Offset   :: The offset of the table from the start of the TrueType */
+  /*                font in its resource.                                  */
+  /*                                                                       */
+  /*    Length   :: The table length (in bytes).                           */
+  /*                                                                       */
+  typedef struct  TT_TableRec_
+  {
+    FT_ULong  Tag;        /*        table type */
+    FT_ULong  CheckSum;   /*    table checksum */
+    FT_ULong  Offset;     /* table file offset */
+    FT_ULong  Length;     /*      table length */
+
+  } TT_TableRec, *TT_Table;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_CMapDirRec                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This structure describes the directory of the `cmap' table,        */
+  /*    containing the font's character mappings table.                    */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    tableVersionNumber :: The version number.                          */
+  /*                                                                       */
+  /*    numCMaps           :: The number of charmaps in the font.          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This structure is only used during font loading.                   */
+  /*                                                                       */
+  typedef struct  TT_CMapDirRec_
+  {
+    FT_UShort  tableVersionNumber;
+    FT_UShort  numCMaps;
+
+  } TT_CMapDirRec, *TT_CMapDir;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_CMapDirEntryRec                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This structure describes a charmap in a TrueType font.             */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    platformID :: An ID used to specify for which platform this        */
+  /*                  charmap is defined (FreeType manages all platforms). */
+  /*                                                                       */
+  /*    encodingID :: A platform-specific ID used to indicate which source */
+  /*                  encoding is used in this charmap.                    */
+  /*                                                                       */
+  /*    offset     :: The offset of the charmap relative to the start of   */
+  /*                  the `cmap' table.                                    */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This structure is only used during font loading.                   */
+  /*                                                                       */
+  typedef struct  TT_CMapDirEntryRec_
+  {
+    FT_UShort  platformID;
+    FT_UShort  platformEncodingID;
+    FT_Long    offset;
+
+  } TT_CMapDirEntryRec, *TT_CMapDirEntry;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_LongMetricsRec                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure modeling the long metrics of the `hmtx' and `vmtx'     */
+  /*    TrueType tables.  The values are expressed in font units.          */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    advance :: The advance width or height for the glyph.              */
+  /*                                                                       */
+  /*    bearing :: The left-side or top-side bearing for the glyph.        */
+  /*                                                                       */
+  typedef struct  TT_LongMetricsRec_
+  {
+    FT_UShort  advance;
+    FT_Short   bearing;
+
+  } TT_LongMetricsRec, *TT_LongMetrics;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    TT_ShortMetrics                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple type to model the short metrics of the `hmtx' and `vmtx'  */
+  /*    tables.                                                            */
+  /*                                                                       */
+  typedef FT_Short  TT_ShortMetrics;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_NameEntryRec                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure modeling TrueType name records.  Name records are used */
+  /*    to store important strings like family name, style name,           */
+  /*    copyright, etc. in _localized_ versions (i.e., language, encoding, */
+  /*    etc).                                                              */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    platformID   :: The ID of the name's encoding platform.            */
+  /*                                                                       */
+  /*    encodingID   :: The platform-specific ID for the name's encoding.  */
+  /*                                                                       */
+  /*    languageID   :: The platform-specific ID for the name's language.  */
+  /*                                                                       */
+  /*    nameID       :: The ID specifying what kind of name this is.       */
+  /*                                                                       */
+  /*    stringLength :: The length of the string in bytes.                 */
+  /*                                                                       */
+  /*    stringOffset :: The offset to the string in the `name' table.      */
+  /*                                                                       */
+  /*    string       :: A pointer to the string's bytes.  Note that these  */
+  /*                    are usually UTF-16 encoded characters.             */
+  /*                                                                       */
+  typedef struct  TT_NameEntryRec_
+  {
+    FT_UShort  platformID;
+    FT_UShort  encodingID;
+    FT_UShort  languageID;
+    FT_UShort  nameID;
+    FT_UShort  stringLength;
+    FT_ULong   stringOffset;
+
+    /* this last field is not defined in the spec */
+    /* but used by the FreeType engine            */
+
+    FT_Byte*   string;
+
+  } TT_NameEntryRec, *TT_NameEntry;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_NameTableRec                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure modeling the TrueType name table.                      */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    format         :: The format of the name table.                    */
+  /*                                                                       */
+  /*    numNameRecords :: The number of names in table.                    */
+  /*                                                                       */
+  /*    storageOffset  :: The offset of the name table in the `name'       */
+  /*                      TrueType table.                                  */
+  /*                                                                       */
+  /*    names          :: An array of name records.                        */
+  /*                                                                       */
+  /*    stream         :: the file's input stream.                         */
+  /*                                                                       */
+  typedef struct  TT_NameTableRec_
+  {
+    FT_UShort         format;
+    FT_UInt           numNameRecords;
+    FT_UInt           storageOffset;
+    TT_NameEntryRec*  names;
+    FT_Stream         stream;
+
+  } TT_NameTableRec, *TT_NameTable;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /***             OPTIONAL TRUETYPE/OPENTYPE TABLES DEFINITIONS         ***/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_GaspRangeRec                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A tiny structure used to model a gasp range according to the       */
+  /*    TrueType specification.                                            */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    maxPPEM  :: The maximum ppem value to which `gaspFlag' applies.    */
+  /*                                                                       */
+  /*    gaspFlag :: A flag describing the grid-fitting and anti-aliasing   */
+  /*                modes to be used.                                      */
+  /*                                                                       */
+  typedef struct  TT_GaspRangeRec_
+  {
+    FT_UShort  maxPPEM;
+    FT_UShort  gaspFlag;
+
+  } TT_GaspRangeRec, *TT_GaspRange;
+
+
+#define TT_GASP_GRIDFIT  0x01
+#define TT_GASP_DOGRAY   0x02
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_GaspRec                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure modeling the TrueType `gasp' table used to specify     */
+  /*    grid-fitting and anti-aliasing behaviour.                          */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    version    :: The version number.                                  */
+  /*                                                                       */
+  /*    numRanges  :: The number of gasp ranges in table.                  */
+  /*                                                                       */
+  /*    gaspRanges :: An array of gasp ranges.                             */
+  /*                                                                       */
+  typedef struct  TT_Gasp_
+  {
+    FT_UShort     version;
+    FT_UShort     numRanges;
+    TT_GaspRange  gaspRanges;
+
+  } TT_GaspRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_HdmxEntryRec                                                    */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A small structure used to model the pre-computed widths of a given */
+  /*    size.  They are found in the `hdmx' table.                         */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    ppem      :: The pixels per EM value at which these metrics apply. */
+  /*                                                                       */
+  /*    max_width :: The maximum advance width for this metric.            */
+  /*                                                                       */
+  /*    widths    :: An array of widths.  Note: These are 8-bit bytes.     */
+  /*                                                                       */
+  typedef struct  TT_HdmxEntryRec_
+  {
+    FT_Byte   ppem;
+    FT_Byte   max_width;
+    FT_Byte*  widths;
+
+  } TT_HdmxEntryRec, *TT_HdmxEntry;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_HdmxRec                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model the `hdmx' table, which contains         */
+  /*    pre-computed widths for a set of given sizes/dimensions.           */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    version     :: The version number.                                 */
+  /*                                                                       */
+  /*    num_records :: The number of hdmx records.                         */
+  /*                                                                       */
+  /*    records     :: An array of hdmx records.                           */
+  /*                                                                       */
+  typedef struct  TT_HdmxRec_
+  {
+    FT_UShort     version;
+    FT_Short      num_records;
+    TT_HdmxEntry  records;
+
+  } TT_HdmxRec, *TT_Hdmx;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_Kern0_PairRec                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a kerning pair for the kerning table     */
+  /*    format 0.  The engine now loads this table if it finds one in the  */
+  /*    font file.                                                         */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    left  :: The index of the left glyph in pair.                      */
+  /*                                                                       */
+  /*    right :: The index of the right glyph in pair.                     */
+  /*                                                                       */
+  /*    value :: The kerning distance.  A positive value spaces the        */
+  /*             glyphs, a negative one makes them closer.                 */
+  /*                                                                       */
+  typedef struct  TT_Kern0_PairRec_
+  {
+    FT_UShort  left;   /* index of left  glyph in pair */
+    FT_UShort  right;  /* index of right glyph in pair */
+    FT_FWord   value;  /* kerning value                */
+
+  } TT_Kern0_PairRec, *TT_Kern0_Pair;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /***                    EMBEDDED BITMAPS SUPPORT                       ***/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_SBit_MetricsRec                                                 */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to hold the big metrics of a given glyph bitmap   */
+  /*    in a TrueType or OpenType font.  These are usually found in the    */
+  /*    `EBDT' (Microsoft) or `bloc' (Apple) table.                        */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    height       :: The glyph height in pixels.                        */
+  /*                                                                       */
+  /*    width        :: The glyph width in pixels.                         */
+  /*                                                                       */
+  /*    horiBearingX :: The horizontal left bearing.                       */
+  /*                                                                       */
+  /*    horiBearingY :: The horizontal top bearing.                        */
+  /*                                                                       */
+  /*    horiAdvance  :: The horizontal advance.                            */
+  /*                                                                       */
+  /*    vertBearingX :: The vertical left bearing.                         */
+  /*                                                                       */
+  /*    vertBearingY :: The vertical top bearing.                          */
+  /*                                                                       */
+  /*    vertAdvance  :: The vertical advance.                              */
+  /*                                                                       */
+  typedef struct  TT_SBit_MetricsRec_
+  {
+    FT_Byte  height;
+    FT_Byte  width;
+
+    FT_Char  horiBearingX;
+    FT_Char  horiBearingY;
+    FT_Byte  horiAdvance;
+
+    FT_Char  vertBearingX;
+    FT_Char  vertBearingY;
+    FT_Byte  vertAdvance;
+
+  } TT_SBit_MetricsRec, *TT_SBit_Metrics;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_SBit_SmallMetricsRec                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to hold the small metrics of a given glyph bitmap */
+  /*    in a TrueType or OpenType font.  These are usually found in the    */
+  /*    `EBDT' (Microsoft) or the `bdat' (Apple) table.                    */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    height   :: The glyph height in pixels.                            */
+  /*                                                                       */
+  /*    width    :: The glyph width in pixels.                             */
+  /*                                                                       */
+  /*    bearingX :: The left-side bearing.                                 */
+  /*                                                                       */
+  /*    bearingY :: The top-side bearing.                                  */
+  /*                                                                       */
+  /*    advance  :: The advance width or height.                           */
+  /*                                                                       */
+  typedef struct  TT_SBit_Small_Metrics_
+  {
+    FT_Byte  height;
+    FT_Byte  width;
+
+    FT_Char  bearingX;
+    FT_Char  bearingY;
+    FT_Byte  advance;
+
+  } TT_SBit_SmallMetricsRec, *TT_SBit_SmallMetrics;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_SBit_LineMetricsRec                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to describe the text line metrics of a given      */
+  /*    bitmap strike, for either a horizontal or vertical layout.         */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    ascender                :: The ascender in pixels.                 */
+  /*                                                                       */
+  /*    descender               :: The descender in pixels.                */
+  /*                                                                       */
+  /*    max_width               :: The maximum glyph width in pixels.      */
+  /*                                                                       */
+  /*    caret_slope_enumerator  :: Rise of the caret slope, typically set  */
+  /*                               to 1 for non-italic fonts.              */
+  /*                                                                       */
+  /*    caret_slope_denominator :: Rise of the caret slope, typically set  */
+  /*                               to 0 for non-italic fonts.              */
+  /*                                                                       */
+  /*    caret_offset            :: Offset in pixels to move the caret for  */
+  /*                               proper positioning.                     */
+  /*                                                                       */
+  /*    min_origin_SB           :: Minimum of horiBearingX (resp.          */
+  /*                               vertBearingY).                          */
+  /*    min_advance_SB          :: Minimum of                              */
+  /*                                                                       */
+  /*                                 horizontal advance -                  */
+  /*                                   ( horiBearingX + width )            */
+  /*                                                                       */
+  /*                               resp.                                   */
+  /*                                                                       */
+  /*                                 vertical advance -                    */
+  /*                                   ( vertBearingY + height )           */
+  /*                                                                       */
+  /*    max_before_BL           :: Maximum of horiBearingY (resp.          */
+  /*                               vertBearingY).                          */
+  /*                                                                       */
+  /*    min_after_BL            :: Minimum of                              */
+  /*                                                                       */
+  /*                                 horiBearingY - height                 */
+  /*                                                                       */
+  /*                               resp.                                   */
+  /*                                                                       */
+  /*                                 vertBearingX - width                  */
+  /*                                                                       */
+  /*    pads                    :: Unused (to make the size of the record  */
+  /*                               a multiple of 32 bits.                  */
+  /*                                                                       */
+  typedef struct  TT_SBit_LineMetricsRec_
+  {
+    FT_Char  ascender;
+    FT_Char  descender;
+    FT_Byte  max_width;
+    FT_Char  caret_slope_numerator;
+    FT_Char  caret_slope_denominator;
+    FT_Char  caret_offset;
+    FT_Char  min_origin_SB;
+    FT_Char  min_advance_SB;
+    FT_Char  max_before_BL;
+    FT_Char  min_after_BL;
+    FT_Char  pads[2];
+
+  } TT_SBit_LineMetricsRec, *TT_SBit_LineMetrics;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_SBit_RangeRec                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A TrueType/OpenType subIndexTable as defined in the `EBLC'         */
+  /*    (Microsoft) or `bloc' (Apple) tables.                              */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    first_glyph   :: The first glyph index in the range.               */
+  /*                                                                       */
+  /*    last_glyph    :: The last glyph index in the range.                */
+  /*                                                                       */
+  /*    index_format  :: The format of index table.  Valid values are 1    */
+  /*                     to 5.                                             */
+  /*                                                                       */
+  /*    image_format  :: The format of `EBDT' image data.                  */
+  /*                                                                       */
+  /*    image_offset  :: The offset to image data in `EBDT'.               */
+  /*                                                                       */
+  /*    image_size    :: For index formats 2 and 5.  This is the size in   */
+  /*                     bytes of each glyph bitmap.                       */
+  /*                                                                       */
+  /*    big_metrics   :: For index formats 2 and 5.  This is the big       */
+  /*                     metrics for each glyph bitmap.                    */
+  /*                                                                       */
+  /*    num_glyphs    :: For index formats 4 and 5.  This is the number of */
+  /*                     glyphs in the code array.                         */
+  /*                                                                       */
+  /*    glyph_offsets :: For index formats 1 and 3.                        */
+  /*                                                                       */
+  /*    glyph_codes   :: For index formats 4 and 5.                        */
+  /*                                                                       */
+  /*    table_offset  :: The offset of the index table in the `EBLC'       */
+  /*                     table.  Only used during strike loading.          */
+  /*                                                                       */
+  typedef struct  TT_SBit_RangeRec
+  {
+    FT_UShort           first_glyph;
+    FT_UShort           last_glyph;
+
+    FT_UShort           index_format;
+    FT_UShort           image_format;
+    FT_ULong            image_offset;
+
+    FT_ULong            image_size;
+    TT_SBit_MetricsRec  metrics;
+    FT_ULong            num_glyphs;
+
+    FT_ULong*           glyph_offsets;
+    FT_UShort*          glyph_codes;
+
+    FT_ULong            table_offset;
+
+  } TT_SBit_RangeRec, *TT_SBit_Range;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_SBit_StrikeRec                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used describe a given bitmap strike in the `EBLC'      */
+  /*    (Microsoft) or `bloc' (Apple) tables.                              */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*   num_index_ranges :: The number of index ranges.                     */
+  /*                                                                       */
+  /*   index_ranges     :: An array of glyph index ranges.                 */
+  /*                                                                       */
+  /*   color_ref        :: Unused.  `color_ref' is put in for future       */
+  /*                       enhancements, but these fields are already      */
+  /*                       in use by other platforms (e.g. Newton).        */
+  /*                       For details, please see                         */
+  /*                                                                       */
+  /*                         http://fonts.apple.com/                       */
+  /*                                TTRefMan/RM06/Chap6bloc.html           */
+  /*                                                                       */
+  /*   hori             :: The line metrics for horizontal layouts.        */
+  /*                                                                       */
+  /*   vert             :: The line metrics for vertical layouts.          */
+  /*                                                                       */
+  /*   start_glyph      :: The lowest glyph index for this strike.         */
+  /*                                                                       */
+  /*   end_glyph        :: The highest glyph index for this strike.        */
+  /*                                                                       */
+  /*   x_ppem           :: The number of horizontal pixels per EM.         */
+  /*                                                                       */
+  /*   y_ppem           :: The number of vertical pixels per EM.           */
+  /*                                                                       */
+  /*   bit_depth        :: The bit depth.  Valid values are 1, 2, 4,       */
+  /*                       and 8.                                          */
+  /*                                                                       */
+  /*   flags            :: Is this a vertical or horizontal strike?  For   */
+  /*                       details, please see                             */
+  /*                                                                       */
+  /*                         http://fonts.apple.com/                       */
+  /*                                TTRefMan/RM06/Chap6bloc.html           */
+  /*                                                                       */
+  typedef struct  TT_SBit_StrikeRec_
+  {
+    FT_Int                  num_ranges;
+    TT_SBit_Range           sbit_ranges;
+    FT_ULong                ranges_offset;
+
+    FT_ULong                color_ref;
+
+    TT_SBit_LineMetricsRec  hori;
+    TT_SBit_LineMetricsRec  vert;
+
+    FT_UShort               start_glyph;
+    FT_UShort               end_glyph;
+
+    FT_Byte                 x_ppem;
+    FT_Byte                 y_ppem;
+
+    FT_Byte                 bit_depth;
+    FT_Char                 flags;
+
+  } TT_SBit_StrikeRec, *TT_SBit_Strike;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_SBit_ComponentRec                                               */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A simple structure to describe a compound sbit element.            */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    glyph_code :: The element's glyph index.                           */
+  /*                                                                       */
+  /*    x_offset   :: The element's left bearing.                          */
+  /*                                                                       */
+  /*    y_offset   :: The element's top bearing.                           */
+  /*                                                                       */
+  typedef struct  TT_SBit_ComponentRec_
+  {
+    FT_UShort  glyph_code;
+    FT_Char    x_offset;
+    FT_Char    y_offset;
+
+  } TT_SBit_ComponentRec, *TT_SBit_Component;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_SBit_ScaleRec                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used describe a given bitmap scaling table, as defined */
+  /*    in the `EBSC' table.                                               */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    hori              :: The horizontal line metrics.                  */
+  /*                                                                       */
+  /*    vert              :: The vertical line metrics.                    */
+  /*                                                                       */
+  /*    x_ppem            :: The number of horizontal pixels per EM.       */
+  /*                                                                       */
+  /*    y_ppem            :: The number of vertical pixels per EM.         */
+  /*                                                                       */
+  /*    x_ppem_substitute :: Substitution x_ppem value.                    */
+  /*                                                                       */
+  /*    y_ppem_substitute :: Substitution y_ppem value.                    */
+  /*                                                                       */
+  typedef struct  TT_SBit_ScaleRec_
+  {
+    TT_SBit_LineMetricsRec  hori;
+    TT_SBit_LineMetricsRec  vert;
+
+    FT_Byte                 x_ppem;
+    FT_Byte                 y_ppem;
+
+    FT_Byte                 x_ppem_substitute;
+    FT_Byte                 y_ppem_substitute;
+
+  } TT_SBit_ScaleRec, *TT_SBit_Scale;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /***                  POSTSCRIPT GLYPH NAMES SUPPORT                   ***/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_Post_20Rec                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Postscript names sub-table, format 2.0.  Stores the PS name of     */
+  /*    each glyph in the font face.                                       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    num_glyphs    :: The number of named glyphs in the table.          */
+  /*                                                                       */
+  /*    num_names     :: The number of PS names stored in the table.       */
+  /*                                                                       */
+  /*    glyph_indices :: The indices of the glyphs in the names arrays.    */
+  /*                                                                       */
+  /*    glyph_names   :: The PS names not in Mac Encoding.                 */
+  /*                                                                       */
+  typedef struct  TT_Post_20Rec_
+  {
+    FT_UShort   num_glyphs;
+    FT_UShort   num_names;
+    FT_UShort*  glyph_indices;
+    FT_Char**   glyph_names;
+
+  } TT_Post_20Rec, *TT_Post_20;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_Post_25Rec                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Postscript names sub-table, format 2.5.  Stores the PS name of     */
+  /*    each glyph in the font face.                                       */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    num_glyphs :: The number of glyphs in the table.                   */
+  /*                                                                       */
+  /*    offsets    :: An array of signed offsets in a normal Mac           */
+  /*                  Postscript name encoding.                            */
+  /*                                                                       */
+  typedef struct  TT_Post_25_
+  {
+    FT_UShort  num_glyphs;
+    FT_Char*   offsets;
+
+  } TT_Post_25Rec, *TT_Post_25;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_Post_NamesRec                                                   */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Postscript names table, either format 2.0 or 2.5.                  */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    loaded    :: A flag to indicate whether the PS names are loaded.   */
+  /*                                                                       */
+  /*    format_20 :: The sub-table used for format 2.0.                    */
+  /*                                                                       */
+  /*    format_25 :: The sub-table used for format 2.5.                    */
+  /*                                                                       */
+  typedef struct  TT_Post_NamesRec_
+  {
+    FT_Bool  loaded;
+
+    union
+    {
+      TT_Post_20Rec  format_20;
+      TT_Post_25Rec  format_25;
+
+    } names;
+
+  } TT_Post_NamesRec, *TT_Post_Names;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /***                  TRUETYPE CHARMAPS SUPPORT                        ***/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /* format 0 */
+
+  typedef struct  TT_CMap0_
+  {
+    FT_ULong  language;       /* for Mac fonts (originally ushort) */
+
+    FT_Byte*  glyphIdArray;
+
+  } TT_CMap0Rec, *TT_CMap0;
+
+
+  /* format 2 */
+
+  typedef struct  TT_CMap2SubHeaderRec_
+  {
+    FT_UShort  firstCode;      /* first valid low byte         */
+    FT_UShort  entryCount;     /* number of valid low bytes    */
+    FT_Short   idDelta;        /* delta value to glyphIndex    */
+    FT_UShort  idRangeOffset;  /* offset from here to 1st code */
+
+  } TT_CMap2SubHeaderRec, *TT_CMap2SubHeader;
+
+
+  typedef struct  TT_CMap2Rec_
+  {
+    FT_ULong            language;     /* for Mac fonts (originally ushort) */
+
+    FT_UShort*          subHeaderKeys;  /* high byte mapping table     */
+                                        /* value = subHeader index * 8 */
+    TT_CMap2SubHeader   subHeaders;
+    FT_UShort*          glyphIdArray;
+    FT_UShort           numGlyphId;   /* control value */
+
+  } TT_CMap2Rec, *TT_CMap2;
+
+
+  /* format 4 */
+
+  typedef struct  TT_CMap4Segment_
+  {
+    FT_UShort  endCount;
+    FT_UShort  startCount;
+    FT_Short   idDelta;
+    FT_UShort  idRangeOffset;
+
+  } TT_CMap4SegmentRec, *TT_CMap4Segment;
+
+
+  typedef struct  TT_CMap4Rec_
+  {
+    FT_ULong         language;       /* for Mac fonts (originally ushort) */
+
+    FT_UShort        segCountX2;     /* number of segments * 2            */
+    FT_UShort        searchRange;    /* these parameters can be used      */
+    FT_UShort        entrySelector;  /* for a binary search               */
+    FT_UShort        rangeShift;
+
+    TT_CMap4Segment  segments;
+    FT_UShort*       glyphIdArray;
+    FT_UShort        numGlyphId;     /* control value */
+
+    TT_CMap4Segment  last_segment;   /* last used segment; this is a small  */
+                                     /* cache to potentially increase speed */
+  } TT_CMap4Rec, *TT_CMap4;
+
+
+  /* format 6 */
+
+  typedef struct  TT_CMap6_
+  {
+    FT_ULong    language;       /* for Mac fonts (originally ushort)     */
+
+    FT_UShort   firstCode;      /* first character code of subrange      */
+    FT_UShort   entryCount;     /* number of character codes in subrange */
+
+    FT_UShort*  glyphIdArray;
+
+  } TT_CMap6Rec, *TT_CMap6;
+
+
+  /* auxiliary table for format 8 and 12 */
+
+  typedef struct  TT_CMapGroupRec_
+  {
+    FT_ULong  startCharCode;
+    FT_ULong  endCharCode;
+    FT_ULong  startGlyphID;
+
+  } TT_CMapGroupRec, *TT_CMapGroup;
+
+
+  /* FreeType handles format 8 and 12 identically.  It is not necessary to
+     cover mixed 16bit and 32bit codes since FreeType always uses FT_ULong
+     for input character codes -- converting Unicode surrogates to 32bit
+     character codes must be done by the application.                      */
+
+  typedef struct  TT_CMap8_12Rec_
+  {
+    FT_ULong      language;        /* for Mac fonts */
+
+    FT_ULong      nGroups;
+    TT_CMapGroup  groups;
+
+    TT_CMapGroup  last_group;      /* last used group; this is a small    */
+                                   /* cache to potentially increase speed */
+  } TT_CMap8_12Rec, *TT_CMap8_12;
+
+
+  /* format 10 */
+
+  typedef struct  TT_CMap10Rec_
+  {
+    FT_ULong    language;           /* for Mac fonts */
+
+    FT_ULong    startCharCode;      /* first character covered */
+    FT_ULong    numChars;           /* number of characters covered */
+
+    FT_UShort*  glyphs;
+
+  } TT_CMap10Rec, *TT_CMap10;
+
+
+  typedef struct TT_CMapTableRec_*  TT_CMapTable;
+
+
+  typedef FT_UInt
+  (*TT_CharMap_Func)( TT_CMapTable  charmap,
+                      FT_ULong      char_code );
+
+  typedef FT_ULong
+  (*TT_CharNext_Func)( TT_CMapTable  charmap,
+                       FT_ULong      char_code );
+
+
+  /* charmap table */
+  typedef struct  TT_CMapTableRec_
+  {
+    FT_UShort  platformID;
+    FT_UShort  platformEncodingID;
+    FT_UShort  format;
+    FT_ULong   length;          /* must be ulong for formats 8, 10, and 12 */
+
+    FT_Bool    loaded;
+    FT_ULong   offset;
+
+    union
+    {
+      TT_CMap0Rec     cmap0;
+      TT_CMap2Rec     cmap2;
+      TT_CMap4Rec     cmap4;
+      TT_CMap6Rec     cmap6;
+      TT_CMap8_12Rec  cmap8_12;
+      TT_CMap10Rec    cmap10;
+    } c;
+
+    TT_CharMap_Func   get_index;
+    TT_CharNext_Func  get_next_char;
+
+  } TT_CMapTableRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_CharMapRec                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The TrueType character map object type.                            */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    root :: The parent character map structure.                        */
+  /*                                                                       */
+  /*    cmap :: The used character map.                                    */
+  /*                                                                       */
+  typedef struct  TT_CharMapRec_
+  {
+    FT_CharMapRec    root;
+    TT_CMapTableRec  cmap;
+
+  } TT_CharMapRec;
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /***                  ORIGINAL TT_FACE CLASS DEFINITION                ***/
+  /***                                                                   ***/
+  /***                                                                   ***/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* This structure/class is defined here because it is common to the      */
+  /* following formats: TTF, OpenType-TT, and OpenType-CFF.                */
+  /*                                                                       */
+  /* Note, however, that the classes TT_Size, TT_GlyphSlot, and TT_CharMap */
+  /* are not shared between font drivers, and are thus defined in          */
+  /* `ttobjs.h'.                                                           */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    TT_Face                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a TrueType face/font object.  A TT_Face encapsulates   */
+  /*    the resolution and scaling independent parts of a TrueType font    */
+  /*    resource.                                                          */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The TT_Face structure is also used as a `parent class' for the     */
+  /*    OpenType-CFF class (T2_Face).                                      */
+  /*                                                                       */
+  typedef struct TT_FaceRec_*  TT_Face;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Type>                                                                */
+  /*    TT_CharMap                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A handle to a TrueType character mapping object.                   */
+  /*                                                                       */
+  typedef struct TT_CharMapRec_*  TT_CharMap;
+
+
+  /* a function type used for the truetype bytecode interpreter hooks */
+  typedef FT_Error
+  (*TT_Interpreter)( void*  exec_context );
+
+  /* forward declaration */
+  typedef struct TT_LoaderRec_*  TT_Loader;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Loader_GotoTableFunc                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Seeks a stream to the start of a given TrueType table.             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face   :: A handle to the target face object.                      */
+  /*                                                                       */
+  /*    tag    :: A 4-byte tag used to name the table.                     */
+  /*                                                                       */
+  /*    stream :: The input stream.                                        */
+  /*                                                                       */
+  /* <Output>                                                              */
+  /*    length :: The length of the table in bytes.  Set to 0 if not       */
+  /*              needed.                                                  */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The stream cursor must be at the font file's origin.               */
+  /*                                                                       */
+  typedef FT_Error
+  (*TT_Loader_GotoTableFunc)( TT_Face    face,
+                              FT_ULong   tag,
+                              FT_Stream  stream,
+                              FT_ULong*  length );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Loader_StartGlyphFunc                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Seeks a stream to the start of a given glyph element, and opens a  */
+  /*    frame for it.                                                      */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    loader      :: The current TrueType glyph loader object.           */
+  /*                                                                       */
+  /*    glyph index :: The index of the glyph to access.                   */
+  /*                                                                       */
+  /*    offset      :: The offset of the glyph according to the            */
+  /*                   `locations' table.                                  */
+  /*                                                                       */
+  /*    byte_count  :: The size of the frame in bytes.                     */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This function is normally equivalent to FT_STREAM_SEEK(offset)     */
+  /*    followed by FT_FRAME_ENTER(byte_count) with the loader's stream,   */
+  /*    but alternative formats (e.g. compressed ones) might use something */
+  /*    different.                                                         */
+  /*                                                                       */
+  typedef FT_Error
+  (*TT_Loader_StartGlyphFunc)( TT_Loader  loader,
+                               FT_UInt    glyph_index,
+                               FT_ULong   offset,
+                               FT_UInt    byte_count );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Loader_ReadGlyphFunc                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Reads one glyph element (its header, a simple glyph, or a          */
+  /*    composite) from the loader's current stream frame.                 */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    loader :: The current TrueType glyph loader object.                */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    FreeType error code.  0 means success.                             */
+  /*                                                                       */
+  typedef FT_Error
+  (*TT_Loader_ReadGlyphFunc)( TT_Loader  loader );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <FuncType>                                                            */
+  /*    TT_Loader_EndGlyphFunc                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Closes the current loader stream frame for the glyph.              */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    loader :: The current TrueType glyph loader object.                */
+  /*                                                                       */
+  typedef void
+  (*TT_Loader_EndGlyphFunc)( TT_Loader  loader );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*                         TrueType Face Type                            */
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_Face                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The TrueType face class.  These objects model the resolution and   */
+  /*    point-size independent data found in a TrueType font file.         */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    root                 :: The base FT_Face structure, managed by the */
+  /*                            base layer.                                */
+  /*                                                                       */
+  /*    ttc_header           :: The TrueType collection header, used when  */
+  /*                            the file is a `ttc' rather than a `ttf'.   */
+  /*                            For ordinary font files, the field         */
+  /*                            `ttc_header.count' is set to 0.            */
+  /*                                                                       */
+  /*    format_tag           :: The font format tag.                       */
+  /*                                                                       */
+  /*    num_tables           :: The number of TrueType tables in this font */
+  /*                            file.                                      */
+  /*                                                                       */
+  /*    dir_tables           :: The directory of TrueType tables for this  */
+  /*                            font file.                                 */
+  /*                                                                       */
+  /*    header               :: The font's font header (`head' table).     */
+  /*                            Read on font opening.                      */
+  /*                                                                       */
+  /*    horizontal           :: The font's horizontal header (`hhea'       */
+  /*                            table).  This field also contains the      */
+  /*                            associated horizontal metrics table        */
+  /*                            (`hmtx').                                  */
+  /*                                                                       */
+  /*    max_profile          :: The font's maximum profile table.  Read on */
+  /*                            font opening.  Note that some maximum      */
+  /*                            values cannot be taken directly from this  */
+  /*                            table.  We thus define additional fields   */
+  /*                            below to hold the computed maxima.         */
+  /*                                                                       */
+  /*    max_components       :: The maximum number of glyph components     */
+  /*                            required to load any composite glyph from  */
+  /*                            this font.  Used to size the load stack.   */
+  /*                                                                       */
+  /*    vertical_info        :: A boolean which is set when the font file  */
+  /*                            contains vertical metrics.  If not, the    */
+  /*                            value of the `vertical' field is           */
+  /*                            undefined.                                 */
+  /*                                                                       */
+  /*    vertical             :: The font's vertical header (`vhea' table). */
+  /*                            This field also contains the associated    */
+  /*                            vertical metrics table (`vmtx'), if found. */
+  /*                            IMPORTANT: The contents of this field is   */
+  /*                            undefined if the `verticalInfo' field is   */
+  /*                            unset.                                     */
+  /*                                                                       */
+  /*    num_names            :: The number of name records within this     */
+  /*                            TrueType font.                             */
+  /*                                                                       */
+  /*    name_table           :: The table of name records (`name').        */
+  /*                                                                       */
+  /*    os2                  :: The font's OS/2 table (`OS/2').            */
+  /*                                                                       */
+  /*    postscript           :: The font's PostScript table (`post'        */
+  /*                            table).  The PostScript glyph names are    */
+  /*                            not loaded by the driver on face opening.  */
+  /*                            See the `ttpost' module for more details.  */
+  /*                                                                       */
+  /*    cmap_table           :: Address of the face's `cmap' SFNT table    */
+  /*                            in memory (it's an extracted frame).       */
+  /*                                                                       */
+  /*    cmap_size            :: The size in bytes of the `cmap_table'      */
+  /*                            described above.                           */
+  /*                                                                       */
+  /*    num_charmaps         :: The number of character mappings in the    */
+  /*                            font.                                      */
+  /*                                                                       */
+  /*    charmaps             :: The array of charmap objects for this font */
+  /*                            file.  Note that this field is a typeless  */
+  /*                            pointer.  The Reason is that the format of */
+  /*                            charmaps varies with the underlying font   */
+  /*                            format and cannot be determined here.      */
+  /*                                                                       */
+  /*    goto_table           :: A function called by each TrueType table   */
+  /*                            loader to position a stream's cursor to    */
+  /*                            the start of a given table according to    */
+  /*                            its tag.  It defaults to TT_Goto_Face but  */
+  /*                            can be different for strange formats (e.g. */
+  /*                            Type 42).                                  */
+  /*                                                                       */
+  /*    access_glyph_frame   :: A function used to access the frame of a   */
+  /*                            given glyph within the face's font file.   */
+  /*                                                                       */
+  /*    forget_glyph_frame   :: A function used to forget the frame of a   */
+  /*                            given glyph when all data has been loaded. */
+  /*                                                                       */
+  /*    read_glyph_header    :: A function used to read a glyph header.    */
+  /*                            It must be called between an `access' and  */
+  /*                            `forget'.                                  */
+  /*                                                                       */
+  /*    read_simple_glyph    :: A function used to read a simple glyph.    */
+  /*                            It must be called after the header was     */
+  /*                            read, and before the `forget'.             */
+  /*                                                                       */
+  /*    read_composite_glyph :: A function used to read a composite glyph. */
+  /*                            It must be called after the header was     */
+  /*                            read, and before the `forget'.             */
+  /*                                                                       */
+  /*    sfnt                 :: A pointer to the SFNT `driver' interface.  */
+  /*                                                                       */
+  /*    psnames              :: A pointer to the `PSNames' module          */
+  /*                            interface.                                 */
+  /*                                                                       */
+  /*    hdmx                 :: The face's horizontal device metrics       */
+  /*                            (`hdmx' table).  This table is optional in */
+  /*                            TrueType/OpenType fonts.                   */
+  /*                                                                       */
+  /*    gasp                 :: The grid-fitting and scaling properties    */
+  /*                            table (`gasp').  This table is optional in */
+  /*                            TrueType/OpenType fonts.                   */
+  /*                                                                       */
+  /*    pclt                 :: The `pclt' SFNT table.                     */
+  /*                                                                       */
+  /*    num_sbit_strikes     :: The number of sbit strikes, i.e., bitmap   */
+  /*                            sizes, embedded in this font.              */
+  /*                                                                       */
+  /*    sbit_strikes         :: An array of sbit strikes embedded in this  */
+  /*                            font.  This table is optional in a         */
+  /*                            TrueType/OpenType font.                    */
+  /*                                                                       */
+  /*    num_sbit_scales      :: The number of sbit scales for this font.   */
+  /*                                                                       */
+  /*    sbit_scales          :: Array of sbit scales embedded in this      */
+  /*                            font.  This table is optional in a         */
+  /*                            TrueType/OpenType font.                    */
+  /*                                                                       */
+  /*    postscript_names     :: A table used to store the Postscript names */
+  /*                            of  the glyphs for this font.  See the     */
+  /*                            file  `ttconfig.h' for comments on the     */
+  /*                            TT_CONFIG_OPTION_POSTSCRIPT_NAMES option.  */
+  /*                                                                       */
+  /*    num_locations        :: The number of glyph locations in this      */
+  /*                            TrueType file.  This should be             */
+  /*                            identical to the number of glyphs.         */
+  /*                            Ignored for Type 2 fonts.                  */
+  /*                                                                       */
+  /*    glyph_locations      :: An array of longs.  These are offsets to   */
+  /*                            glyph data within the `glyf' table.        */
+  /*                            Ignored for Type 2 font faces.             */
+  /*                                                                       */
+  /*    font_program_size    :: Size in bytecodes of the face's font       */
+  /*                            program.  0 if none defined.  Ignored for  */
+  /*                            Type 2 fonts.                              */
+  /*                                                                       */
+  /*    font_program         :: The face's font program (bytecode stream)  */
+  /*                            executed at load time, also used during    */
+  /*                            glyph rendering.  Comes from the `fpgm'    */
+  /*                            table.  Ignored for Type 2 font fonts.     */
+  /*                                                                       */
+  /*    cvt_program_size     :: The size in bytecodes of the face's cvt    */
+  /*                            program.  Ignored for Type 2 fonts.        */
+  /*                                                                       */
+  /*    cvt_program          :: The face's cvt program (bytecode stream)   */
+  /*                            executed each time an instance/size is     */
+  /*                            changed/reset.  Comes from the `prep'      */
+  /*                            table.  Ignored for Type 2 fonts.          */
+  /*                                                                       */
+  /*    cvt_size             :: Size of the control value table (in        */
+  /*                            entries).   Ignored for Type 2 fonts.      */
+  /*                                                                       */
+  /*    cvt                  :: The face's original control value table.   */
+  /*                            Coordinates are expressed in unscaled font */
+  /*                            units.  Comes from the `cvt ' table.       */
+  /*                            Ignored for Type 2 fonts.                  */
+  /*                                                                       */
+  /*    num_kern_pairs       :: The number of kerning pairs present in the */
+  /*                            font file.  The engine only loads the      */
+  /*                            first horizontal format 0 kern table it    */
+  /*                            finds in the font file.  Ignored for       */
+  /*                            Type 2 fonts.                              */
+  /*                                                                       */
+  /*    kern_table_index     :: The index of the kerning table in the font */
+  /*                            kerning directory.  Ignored for Type 2     */
+  /*                            fonts.                                     */
+  /*                                                                       */
+  /*    interpreter          :: A pointer to the TrueType bytecode         */
+  /*                            interpreters field is also used to hook    */
+  /*                            the debugger in `ttdebug'.                 */
+  /*                                                                       */
+  /*    extra                :: Reserved for third-party font drivers.     */
+  /*                                                                       */
+  typedef struct  TT_FaceRec_
+  {
+    FT_FaceRec            root;
+
+    TTC_HeaderRec         ttc_header;
+
+    FT_ULong              format_tag;
+    FT_UShort             num_tables;
+    TT_Table              dir_tables;
+
+    TT_Header             header;       /* TrueType header table          */
+    TT_HoriHeader         horizontal;   /* TrueType horizontal header     */
+
+    TT_MaxProfile         max_profile;
+    FT_ULong              max_components;
+
+    FT_Bool               vertical_info;
+    TT_VertHeader         vertical;     /* TT Vertical header, if present */
+
+    FT_UShort             num_names;    /* number of name records  */
+    TT_NameTableRec       name_table;   /* name table              */
+
+    TT_OS2                os2;          /* TrueType OS/2 table            */
+    TT_Postscript         postscript;   /* TrueType Postscript table      */
+
+    FT_Byte*              cmap_table;   /* extracted 'cmap' table */
+    FT_ULong              cmap_size;
+
+    TT_Loader_GotoTableFunc   goto_table;
+
+    TT_Loader_StartGlyphFunc  access_glyph_frame;
+    TT_Loader_EndGlyphFunc    forget_glyph_frame;
+    TT_Loader_ReadGlyphFunc   read_glyph_header;
+    TT_Loader_ReadGlyphFunc   read_simple_glyph;
+    TT_Loader_ReadGlyphFunc   read_composite_glyph;
+
+    /* a typeless pointer to the SFNT_Interface table used to load     */
+    /* the basic TrueType tables in the face object                    */
+    void*                 sfnt;
+
+    /* a typeless pointer to the PSNames_Interface table used to       */
+    /* handle glyph names <-> unicode & Mac values                     */
+    void*                 psnames;
+
+    /***********************************************************************/
+    /*                                                                     */
+    /* Optional TrueType/OpenType tables                                   */
+    /*                                                                     */
+    /***********************************************************************/
+
+    /* horizontal device metrics */
+    TT_HdmxRec            hdmx;
+
+    /* grid-fitting and scaling table */
+    TT_GaspRec            gasp;                 /* the `gasp' table */
+
+    /* PCL 5 table */
+    TT_PCLT               pclt;
+
+    /* embedded bitmaps support */
+    FT_ULong              num_sbit_strikes;
+    TT_SBit_Strike        sbit_strikes;
+
+    FT_ULong              num_sbit_scales;
+    TT_SBit_Scale         sbit_scales;
+
+    /* postscript names table */
+    TT_Post_NamesRec      postscript_names;
+
+
+    /***********************************************************************/
+    /*                                                                     */
+    /* TrueType-specific fields (ignored by the OTF-Type2 driver)          */
+    /*                                                                     */
+    /***********************************************************************/
+
+    /* the glyph locations */
+    FT_UShort             num_locations;
+    FT_Long*              glyph_locations;
+
+    /* the font program, if any */
+    FT_ULong              font_program_size;
+    FT_Byte*              font_program;
+
+    /* the cvt program, if any */
+    FT_ULong              cvt_program_size;
+    FT_Byte*              cvt_program;
+
+    /* the original, unscaled, control value table */
+    FT_ULong              cvt_size;
+    FT_Short*             cvt;
+
+    /* the format 0 kerning table, if any */
+    FT_Int                num_kern_pairs;
+    FT_Int                kern_table_index;
+    TT_Kern0_Pair         kern_pairs;
+
+    /* A pointer to the bytecode interpreter to use.  This is also */
+    /* used to hook the debugger for the `ttdebug' utility.        */
+    TT_Interpreter        interpreter;
+
+
+    /***********************************************************************/
+    /*                                                                     */
+    /* Other tables or fields. This is used by derivative formats like     */
+    /* OpenType.                                                           */
+    /*                                                                     */
+    /***********************************************************************/
+
+    FT_Generic            extra;
+
+  } TT_FaceRec;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /*  <Struct>                                                             */
+  /*     TT_GlyphZoneRec                                                   */
+  /*                                                                       */
+  /*  <Description>                                                        */
+  /*     A glyph zone is used to load, scale and hint glyph outline        */
+  /*     coordinates.                                                      */
+  /*                                                                       */
+  /*  <Fields>                                                             */
+  /*     memory       :: A handle to the memory manager.                   */
+  /*                                                                       */
+  /*     max_points   :: The maximal size in points of the zone.           */
+  /*                                                                       */
+  /*     max_contours :: Max size in links contours of thez one.           */
+  /*                                                                       */
+  /*     n_points     :: The current number of points in the zone.         */
+  /*                                                                       */
+  /*     n_contours   :: The current number of contours in the zone.       */
+  /*                                                                       */
+  /*     org          :: The original glyph coordinates (font              */
+  /*                     units/scaled).                                    */
+  /*                                                                       */
+  /*     cur          :: The current glyph coordinates (scaled/hinted).    */
+  /*                                                                       */
+  /*     tags         :: The point control tags.                           */
+  /*                                                                       */
+  /*     contours     :: The contours end points.                          */
+  /*                                                                       */
+  typedef struct  TT_GlyphZoneRec_
+  {
+    FT_Memory   memory;
+    FT_UShort   max_points;
+    FT_UShort   max_contours;
+    FT_UShort   n_points;   /* number of points in zone    */
+    FT_Short    n_contours; /* number of contours          */
+
+    FT_Vector*  org;        /* original point coordinates  */
+    FT_Vector*  cur;        /* current point coordinates   */
+
+    FT_Byte*    tags;       /* current touch flags         */
+    FT_UShort*  contours;   /* contour end points          */
+
+  } TT_GlyphZoneRec, *TT_GlyphZone;
+
+
+  /* handle to execution context */
+  typedef struct TT_ExecContextRec_*  TT_ExecContext;
+
+  /* glyph loader structure */
+  typedef struct  TT_LoaderRec_
+  {
+    FT_Face          face;
+    FT_Size          size;
+    FT_GlyphSlot     glyph;
+    FT_GlyphLoader   gloader;
+
+    FT_ULong         load_flags;
+    FT_UInt          glyph_index;
+
+    FT_Stream        stream;
+    FT_Int           byte_len;
+
+    FT_Short         n_contours;
+    FT_BBox          bbox;
+    FT_Int           left_bearing;
+    FT_Int           advance;
+    FT_Int           linear;
+    FT_Bool          linear_def;
+    FT_Bool          preserve_pps;
+    FT_Vector        pp1;
+    FT_Vector        pp2;
+
+    FT_ULong         glyf_offset;
+
+    /* the zone where we load our glyphs */
+    TT_GlyphZoneRec  base;
+    TT_GlyphZoneRec  zone;
+
+    TT_ExecContext   exec;
+    FT_Byte*         instructions;
+    FT_ULong         ins_pos;
+
+    /* for possible extensibility in other formats */
+    void*            other;
+
+  } TT_LoaderRec;
+
+
+FT_END_HEADER
+
+#endif /* __TTTYPES_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/t1tables.h
@@ -1,0 +1,391 @@
+/***************************************************************************/
+/*                                                                         */
+/*  t1tables.h                                                             */
+/*                                                                         */
+/*    Basic Type 1/Type 2 tables definitions and interface (specification  */
+/*    only).                                                               */
+/*                                                                         */
+/*  Copyright 1996-2001, 2002 by                                           */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __T1TABLES_H__
+#define __T1TABLES_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    type1_tables                                                       */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    Type 1 Tables                                                      */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    Type 1 (PostScript) specific font tables.                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the definition of Type 1-specific tables,    */
+  /*    including structures related to other PostScript font formats.     */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /* Note that we separate font data in PS_FontInfoRec and PS_PrivateRec */
+  /* structures in order to support Multiple Master fonts.               */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    PS_FontInfoRec                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a Type1/Type2 FontInfo dictionary.  Note */
+  /*    that for Multiple Master fonts, each instance has its own          */
+  /*    FontInfo.                                                          */
+  /*                                                                       */
+  typedef struct  PS_FontInfoRec
+  {
+    FT_String*  version;
+    FT_String*  notice;
+    FT_String*  full_name;
+    FT_String*  family_name;
+    FT_String*  weight;
+    FT_Long     italic_angle;
+    FT_Bool     is_fixed_pitch;
+    FT_Short    underline_position;
+    FT_UShort   underline_thickness;
+
+  } PS_FontInfoRec, *PS_FontInfo;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    T1_FontInfo                                                        */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This type is equivalent to @PS_FontInfoRec.  It is deprecated but  */
+  /*    kept to maintain source compatibility between various versions of  */
+  /*    FreeType.                                                          */
+  /*                                                                       */
+  typedef PS_FontInfoRec  T1_FontInfo;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    PS_PrivateRec                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a Type1/Type2 private dictionary.  Note  */
+  /*    that for Multiple Master fonts, each instance has its own Private  */
+  /*    dictionary.                                                        */
+  /*                                                                       */
+  typedef struct  PS_PrivateRec_
+  {
+    FT_Int     unique_id;
+    FT_Int     lenIV;
+
+    FT_Byte    num_blue_values;
+    FT_Byte    num_other_blues;
+    FT_Byte    num_family_blues;
+    FT_Byte    num_family_other_blues;
+
+    FT_Short   blue_values[14];
+    FT_Short   other_blues[10];
+
+    FT_Short   family_blues      [14];
+    FT_Short   family_other_blues[10];
+
+    FT_Fixed   blue_scale;
+    FT_Int     blue_shift;
+    FT_Int     blue_fuzz;
+
+    FT_UShort  standard_width[1];
+    FT_UShort  standard_height[1];
+
+    FT_Byte    num_snap_widths;
+    FT_Byte    num_snap_heights;
+    FT_Bool    force_bold;
+    FT_Bool    round_stem_up;
+
+    FT_Short   snap_widths [13];  /* including std width  */
+    FT_Short   snap_heights[13];  /* including std height */
+
+    FT_Long    language_group;
+    FT_Long    password;
+
+    FT_Short   min_feature[2];
+
+  } PS_PrivateRec, *PS_Private;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    T1_Private                                                         */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   This type is equivalent to @PS_PrivateRec.  It is deprecated but    */
+  /*   kept to maintain source compatibility between various versions of   */
+  /*   FreeType.                                                           */
+  /*                                                                       */
+  typedef PS_PrivateRec  T1_Private;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Enum>                                                                */
+  /*    T1_Blend_Flags                                                     */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A set of flags used to indicate which fields are present in a      */
+  /*    given blen dictionary (font info or private).  Used to support     */
+  /*    Multiple Masters fonts.                                            */
+  /*                                                                       */
+  typedef enum
+  {
+    /*# required fields in a FontInfo blend dictionary */
+    T1_BLEND_UNDERLINE_POSITION = 0,
+    T1_BLEND_UNDERLINE_THICKNESS,
+    T1_BLEND_ITALIC_ANGLE,
+
+    /*# required fields in a Private blend dictionary */
+    T1_BLEND_BLUE_VALUES,
+    T1_BLEND_OTHER_BLUES,
+    T1_BLEND_STANDARD_WIDTH,
+    T1_BLEND_STANDARD_HEIGHT,
+    T1_BLEND_STEM_SNAP_WIDTHS,
+    T1_BLEND_STEM_SNAP_HEIGHTS,
+    T1_BLEND_BLUE_SCALE,
+    T1_BLEND_BLUE_SHIFT,
+    T1_BLEND_FAMILY_BLUES,
+    T1_BLEND_FAMILY_OTHER_BLUES,
+    T1_BLEND_FORCE_BOLD,
+
+    /*# never remove */
+    T1_BLEND_MAX
+
+  } T1_Blend_Flags;
+
+
+  /*# backwards compatible definitions */
+#define t1_blend_underline_position   T1_BLEND_UNDERLINE_POSITION
+#define t1_blend_underline_thickness  T1_BLEND_UNDERLINE_THICKNESS
+#define t1_blend_italic_angle         T1_BLEND_ITALIC_ANGLE
+#define t1_blend_blue_values          T1_BLEND_BLUE_VALUES
+#define t1_blend_other_blues          T1_BLEND_OTHER_BLUES
+#define t1_blend_standard_widths      T1_BLEND_STANDARD_WIDTH
+#define t1_blend_standard_height      T1_BLEND_STANDARD_HEIGHT
+#define t1_blend_stem_snap_widths     T1_BLEND_STEM_SNAP_WIDTHS
+#define t1_blend_stem_snap_heights    T1_BLEND_STEM_SNAP_HEIGHTS
+#define t1_blend_blue_scale           T1_BLEND_BLUE_SCALE
+#define t1_blend_blue_shift           T1_BLEND_BLUE_SHIFT
+#define t1_blend_family_blues         T1_BLEND_FAMILY_BLUES
+#define t1_blend_family_other_blues   T1_BLEND_FAMILY_OTHER_BLUES
+#define t1_blend_force_bold           T1_BLEND_FORCE_BOLD
+#define t1_blend_max                  T1_BLEND_MAX
+
+
+  /* maximum number of Multiple Masters designs, as defined in the spec */
+#define T1_MAX_MM_DESIGNS     16
+
+  /* maximum number of Multiple Masters axes, as defined in the spec */
+#define T1_MAX_MM_AXIS        4
+
+  /* maximum number of elements in a design map */
+#define T1_MAX_MM_MAP_POINTS  20
+
+
+  /* this structure is used to store the BlendDesignMap entry for an axis */
+  typedef struct  PS_DesignMap_
+  {
+    FT_Byte    num_points;
+    FT_Fixed*  design_points;
+    FT_Fixed*  blend_points;
+
+  } PS_DesignMapRec, *PS_DesignMap;
+
+  /* backwards-compatible definition */
+  typedef PS_DesignMapRec  T1_DesignMap;
+
+
+  typedef struct  PS_BlendRec_
+  {
+    FT_UInt          num_designs;
+    FT_UInt          num_axis;
+
+    FT_String*       axis_names[T1_MAX_MM_AXIS];
+    FT_Fixed*        design_pos[T1_MAX_MM_DESIGNS];
+    PS_DesignMapRec  design_map[T1_MAX_MM_AXIS];
+
+    FT_Fixed*        weight_vector;
+    FT_Fixed*        default_weight_vector;
+
+    PS_FontInfo      font_infos[T1_MAX_MM_DESIGNS + 1];
+    PS_Private       privates  [T1_MAX_MM_DESIGNS + 1];
+
+    FT_ULong         blend_bitflags;
+
+    FT_BBox*         bboxes    [T1_MAX_MM_DESIGNS + 1];
+
+  } PS_BlendRec, *PS_Blend;
+
+
+  /* backwards-compatible definition */
+  typedef PS_BlendRec  T1_Blend;
+
+
+  typedef struct  CID_FaceDictRec_
+  {
+    PS_PrivateRec  private_dict;
+
+    FT_UInt        len_buildchar;
+    FT_Fixed       forcebold_threshold;
+    FT_Pos         stroke_width;
+    FT_Fixed       expansion_factor;
+
+    FT_Byte        paint_type;
+    FT_Byte        font_type;
+    FT_Matrix      font_matrix;
+    FT_Vector      font_offset;
+
+    FT_UInt        num_subrs;
+    FT_ULong       subrmap_offset;
+    FT_Int         sd_bytes;
+
+  } CID_FaceDictRec, *CID_FaceDict;
+
+
+  /* backwards-compatible definition */
+  typedef CID_FaceDictRec  CID_FontDict;
+
+
+  typedef struct  CID_FaceInfoRec_
+  {
+    FT_String*      cid_font_name;
+    FT_Fixed        cid_version;
+    FT_Int          cid_font_type;
+
+    FT_String*      registry;
+    FT_String*      ordering;
+    FT_Int          supplement;
+
+    PS_FontInfoRec  font_info;
+    FT_BBox         font_bbox;
+    FT_ULong        uid_base;
+
+    FT_Int          num_xuid;
+    FT_ULong        xuid[16];
+
+    FT_ULong        cidmap_offset;
+    FT_Int          fd_bytes;
+    FT_Int          gd_bytes;
+    FT_ULong        cid_count;
+
+    FT_Int          num_dicts;
+    CID_FaceDict    font_dicts;
+
+    FT_ULong        data_offset;
+
+  } CID_FaceInfoRec, *CID_FaceInfo;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    CID_Info                                                           */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*   This type is equivalent to @CID_FaceInfoRec. It is deprecated but   */
+  /*   kept to maintain source compatibility between various versions of   */
+  /*   FreeType.                                                           */
+  /*                                                                       */
+  typedef CID_FaceInfoRec  CID_Info;
+
+  /* */
+
+
+ /************************************************************************
+  *
+  * @function:
+  *    FT_Has_PS_Glyph_Names
+  *
+  * @description:
+  *    Return true if a given face provides reliable Postscript glyph
+  *    names.  This is similar to using the @FT_HAS_GLYPH_NAMES macro,
+  *    except that certain fonts (mostly TrueType) contain incorrect
+  *    glyph name tables.
+  *
+  *    When this function returns true, the caller is sure that the glyph
+  *    names returned by @FT_Get_Glyph_Name are reliable.
+  *
+  * @input:
+  *    face ::
+  *       face handle
+  *
+  * @return:
+  *    Boolean.  True if glyph names are reliable.
+  */
+  FT_EXPORT( FT_Int )
+  FT_Has_PS_Glyph_Names( FT_Face  face );
+
+
+ /************************************************************************
+  *
+  * @function:
+  *    FT_Get_PS_Font_Info
+  *
+  * @description:
+  *    Retrieve the @PS_FontInfoRec structure corresponding to a given
+  *    Postscript font.
+  *
+  * @input:
+  *    face ::
+  *       Postscript face handle.
+  *
+  * @output:
+  *    afont_info ::
+  *       Output font info structure pointer.
+  *
+  * @return:
+  *    FreeType error code.  0 means success.
+  *
+  * @note:
+  *    The string pointers within the font info structure are owned by
+  *    the face and don't need to be freed by the caller.
+  *
+  *    If the font's format is not Postscript-based, this function will
+  *    return the @FT_Err_Invalid_Argument error code.
+  */
+  FT_EXPORT( FT_Error )
+  FT_Get_PS_Font_Info( FT_Face          face,
+                       PS_FontInfoRec  *afont_info );
+
+ /* */
+
+
+
+FT_END_HEADER
+
+#endif /* __T1TABLES_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/ttnameid.h
@@ -1,0 +1,1022 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ttnameid.h                                                             */
+/*                                                                         */
+/*    TrueType name ID definitions (specification only).                   */
+/*                                                                         */
+/*  Copyright 1996-2002 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __TTNAMEID_H__
+#define __TTNAMEID_H__
+
+
+#include <ft2build.h>
+
+
+FT_BEGIN_HEADER
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Possible values for the `platform' identifier code in the name        */
+  /* records of the TTF `name' table.                                      */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_PLATFORM_XXX
+   *
+   * @description:
+   *   A list of valid values for the `platform_id' identifier code in
+   *   @FT_CharmapRec and @FT_SfntName structures.
+   *
+   * @values:
+   *   TT_PLATFORM_APPLE_UNICODE ::
+   *     Used by Apple to indicate a Unicode character map and/or name entry.
+   *     See @TT_APPLE_ID_XXX for corresponding `encoding_id' values.  Note
+   *     that name entries in this format are coded as big-endian UCS-2
+   *     character codes _only_.
+   *
+   *   TT_PLATFORM_MACINTOSH ::
+   *     Used by Apple to indicate a MacOS-specific charmap and/or name entry.
+   *     See @TT_MAC_ID_XXX for corresponding `encoding_id' values.  Note that
+   *     most TrueType fonts contain an Apple roman charmap to be usable on
+   *     MacOS systems (even if they contain a Microsoft charmap as well).
+   *
+   *   TT_PLATFORM_ISO ::
+   *     This value was used to specify Unicode charmaps.  It is however
+   *     now deprecated.  See @TT_ISO_ID_XXX for a list of corresponding
+   *     `encoding_id' values.
+   *
+   *   TT_PLATFORM_MICROSOFT ::
+   *     Used by Microsoft to indicate Windows-specific charmaps.  See
+   *     @TT_MS_ID_XXX for a list of corresponding `encoding_id' values.
+   *     Note that most fonts contain a Unicode charmap using
+   *     (@TT_PLATFORM_MICROSOFT, @TT_MS_ID_UNICODE_CS).
+   *
+   *   TT_PLATFORM_CUSTOM ::
+   *     Used to indicate application-specific charmaps.
+   *
+   *   TT_PLATFORM_ADOBE ::
+   *     This value isn't part of any font format specification, but is used
+   *     by FreeType to report Adobe-specific charmaps in an @FT_CharMapRec
+   *     structure.  See @TT_ADOBE_ID_XXX.
+   */
+
+#define TT_PLATFORM_APPLE_UNICODE  0
+#define TT_PLATFORM_MACINTOSH      1
+#define TT_PLATFORM_ISO            2 /* deprecated */
+#define TT_PLATFORM_MICROSOFT      3
+#define TT_PLATFORM_CUSTOM         4
+#define TT_PLATFORM_ADOBE          7 /* artificial */
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_APPLE_ID_XXX
+   *
+   * @description:
+   *   A list of valid values for the `encoding_id' for
+   *   @TT_PLATFORM_APPLE_UNICODE charmaps and name entries.
+   *
+   * @values:
+   *   TT_APPLE_ID_DEFAULT ::
+   *     Unicode version 1.0.
+   *   TT_APPLE_ID_UNICODE_1_1 ::
+   *     Unicode 1.1; specifies Hangul characters starting at U+34xx.
+   *   TT_APPLE_ID_ISO_10646 ::
+   *     Deprecated.
+   *   TT_APPLE_ID_UNICODE_2_0 ::
+   *     Unicode 2.0 and beyond (UTF-16 BMP only).
+   *   TT_APPLE_ID_UNICODE_32 ::
+   *     UTF-32 (Adobe proposal for OpenType).
+   */
+
+#define TT_APPLE_ID_DEFAULT      0 /* Unicode 1.0 */
+#define TT_APPLE_ID_UNICODE_1_1  1 /* specify Hangul at U+34xx */
+#define TT_APPLE_ID_ISO_10646    2 /* deprecated */
+#define TT_APPLE_ID_UNICODE_2_0  3 /* or later */
+#define TT_APPLE_ID_UNICODE_32   4 /* Adobe proposal */
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_MAC_ID_XXX
+   *
+   * @description:
+   *   A list of valid values for the `encoding_id' for
+   *   @TT_PLATFORM_MACINTOSH charmaps and name entries.
+   *
+   * @values:
+   *   TT_MAC_ID_ROMAN ::
+   *   TT_MAC_ID_JAPANESE ::
+   *   TT_MAC_ID_TRADITIONAL_CHINESE ::
+   *   TT_MAC_ID_KOREAN ::
+   *   TT_MAC_ID_ARABIC ::
+   *   TT_MAC_ID_HEBREW ::
+   *   TT_MAC_ID_GREEK ::
+   *   TT_MAC_ID_RUSSIAN ::
+   *   TT_MAC_ID_RSYMBOL ::
+   *   TT_MAC_ID_DEVANAGARI ::
+   *   TT_MAC_ID_GURMUKHI ::
+   *   TT_MAC_ID_GUJARATI ::
+   *   TT_MAC_ID_ORIYA ::
+   *   TT_MAC_ID_BENGALI ::
+   *   TT_MAC_ID_TAMIL ::
+   *   TT_MAC_ID_TELUGU ::
+   *   TT_MAC_ID_KANNADA ::
+   *   TT_MAC_ID_MALAYALAM ::
+   *   TT_MAC_ID_SINHALESE ::
+   *   TT_MAC_ID_BURMESE ::
+   *   TT_MAC_ID_KHMER ::
+   *   TT_MAC_ID_THAI ::
+   *   TT_MAC_ID_LAOTIAN ::
+   *   TT_MAC_ID_GEORGIAN ::
+   *   TT_MAC_ID_ARMENIAN ::
+   *   TT_MAC_ID_MALDIVIAN ::
+   *   TT_MAC_ID_SIMPLIFIED_CHINESE ::
+   *   TT_MAC_ID_TIBETAN ::
+   *   TT_MAC_ID_MONGOLIAN ::
+   *   TT_MAC_ID_GEEZ ::
+   *   TT_MAC_ID_SLAVIC ::
+   *   TT_MAC_ID_VIETNAMESE ::
+   *   TT_MAC_ID_SINDHI ::
+   *   TT_MAC_ID_UNINTERP ::
+   */
+
+#define TT_MAC_ID_ROMAN                 0
+#define TT_MAC_ID_JAPANESE              1
+#define TT_MAC_ID_TRADITIONAL_CHINESE   2
+#define TT_MAC_ID_KOREAN                3
+#define TT_MAC_ID_ARABIC                4
+#define TT_MAC_ID_HEBREW                5
+#define TT_MAC_ID_GREEK                 6
+#define TT_MAC_ID_RUSSIAN               7
+#define TT_MAC_ID_RSYMBOL               8
+#define TT_MAC_ID_DEVANAGARI            9
+#define TT_MAC_ID_GURMUKHI             10
+#define TT_MAC_ID_GUJARATI             11
+#define TT_MAC_ID_ORIYA                12
+#define TT_MAC_ID_BENGALI              13
+#define TT_MAC_ID_TAMIL                14
+#define TT_MAC_ID_TELUGU               15
+#define TT_MAC_ID_KANNADA              16
+#define TT_MAC_ID_MALAYALAM            17
+#define TT_MAC_ID_SINHALESE            18
+#define TT_MAC_ID_BURMESE              19
+#define TT_MAC_ID_KHMER                20
+#define TT_MAC_ID_THAI                 21
+#define TT_MAC_ID_LAOTIAN              22
+#define TT_MAC_ID_GEORGIAN             23
+#define TT_MAC_ID_ARMENIAN             24
+#define TT_MAC_ID_MALDIVIAN            25
+#define TT_MAC_ID_SIMPLIFIED_CHINESE   25
+#define TT_MAC_ID_TIBETAN              26
+#define TT_MAC_ID_MONGOLIAN            27
+#define TT_MAC_ID_GEEZ                 28
+#define TT_MAC_ID_SLAVIC               29
+#define TT_MAC_ID_VIETNAMESE           30
+#define TT_MAC_ID_SINDHI               31
+#define TT_MAC_ID_UNINTERP             32
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_ISO_ID_XXX
+   *
+   * @description:
+   *   A list of valid values for the `encoding_id' for
+   *   @TT_PLATFORM_ISO charmaps and name entries.
+   *
+   *   Their use is now deprecated.
+   *
+   * @values:
+   *   TT_ISO_ID_7BIT_ASCII ::
+   *     ASCII.
+   *   TT_ISO_ID_10646 ::
+   *     ISO/10646.
+   *   TT_ISO_ID_8859_1 ::
+   *     Also known as Latin-1.
+   */
+
+#define TT_ISO_ID_7BIT_ASCII  0
+#define TT_ISO_ID_10646       1
+#define TT_ISO_ID_8859_1      2
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_MS_ID_XXX
+   *
+   * @description:
+   *   A list of valid values for the `encoding_id' for
+   *   @TT_PLATFORM_MICROSOFT charmaps and name entries.
+   *
+   * @values:
+   *   TT_MS_ID_SYMBOL_CS ::
+   *     Corresponds to symbol encodings. see @FT_ENCODING_MS_SYMBOL.
+   *
+   *   TT_MS_ID_UNICODE_CS ::
+   *     Corresponds to a Microsoft WGL4 charmap, matching Unicode.  See
+   *     @FT_ENCODING_UNICODE.
+   *
+   *   TT_MS_ID_SJIS ::
+   *     Corresponds to Microsoft SJIS Japanese encoding.
+   *     See @FT_ENCODING_MS_SJIS.
+   *
+   *   TT_MS_ID_GB2312 ::
+   *     Corresponds to Microsoft Simplified Chinese as used in Mainland
+   *     China.  See @FT_ENCODING_MS_GB2312.
+   *
+   *   TT_MS_ID_BIG_5 ::
+   *     Corresponds to Microsoft Traditional Chinese as used in Taiwan and
+   *     Hong Kong.  See @FT_ENCODING_MS_BIG5.
+   *
+   *   TT_MS_ID_WANSUNG ::
+   *     Corresponds to Microsoft Korean Wansung encoding.  See
+   *     @FT_ENCODING_MS_WANSUNG.
+   *
+   *   TT_MS_ID_JOHAB ::
+   *     Corresponds to Microsoft Johab encoding.  See @FT_ENCODING_MS_JOHAB.
+   *
+   *   TT_MS_ID_UCS_4 ::
+   *     Corresponds to UCS-4 or UTF-32 charmaps.  This is a recent Adobe
+   *     proposal for OpenType.
+   */
+
+#define TT_MS_ID_SYMBOL_CS    0
+#define TT_MS_ID_UNICODE_CS   1
+#define TT_MS_ID_SJIS         2
+#define TT_MS_ID_GB2312       3
+#define TT_MS_ID_BIG_5        4
+#define TT_MS_ID_WANSUNG      5
+#define TT_MS_ID_JOHAB        6
+#define TT_MS_ID_UCS_4       10
+
+
+  /***********************************************************************
+   *
+   * @enum:
+   *   TT_ADOBE_ID_XXX
+   *
+   * @description:
+   *   A list of valid values for the `encoding_id' for
+   *   @TT_PLATFORM_ADOBE charmaps.  This is a FreeType-specific extension!
+   *
+   * @values:
+   *   TT_ADOBE_ID_STANDARD ::
+   *     Adobe standard encoding.
+   *   TT_ADOBE_ID_EXPERT ::
+   *     Adobe expert encoding.
+   *   TT_ADOBE_ID_CUSTOM ::
+   *     Adobe custom encoding.
+   */
+
+#define TT_ADOBE_ID_STANDARD  0
+#define TT_ADOBE_ID_EXPERT    1
+#define TT_ADOBE_ID_CUSTOM    2
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Possible values of the language identifier field in the name records  */
+  /* of the TTF `name' table if the `platform' identifier code is          */
+  /* TT_PLATFORM_MACINTOSH.                                                */
+  /*                                                                       */
+  /* The canonical source for the Apple assigned Language ID's is at       */
+  /*                                                                       */
+  /*   http://fonts.apple.com/TTRefMan/RM06/Chap6name.html                 */
+  /*                                                                       */
+#define TT_MAC_LANGID_ENGLISH                       0
+#define TT_MAC_LANGID_FRENCH                        1
+#define TT_MAC_LANGID_GERMAN                        2
+#define TT_MAC_LANGID_ITALIAN                       3
+#define TT_MAC_LANGID_DUTCH                         4
+#define TT_MAC_LANGID_SWEDISH                       5
+#define TT_MAC_LANGID_SPANISH                       6
+#define TT_MAC_LANGID_DANISH                        7
+#define TT_MAC_LANGID_PORTUGUESE                    8
+#define TT_MAC_LANGID_NORWEGIAN                     9
+#define TT_MAC_LANGID_HEBREW                       10
+#define TT_MAC_LANGID_JAPANESE                     11
+#define TT_MAC_LANGID_ARABIC                       12
+#define TT_MAC_LANGID_FINNISH                      13
+#define TT_MAC_LANGID_GREEK                        14
+#define TT_MAC_LANGID_ICELANDIC                    15
+#define TT_MAC_LANGID_MALTESE                      16
+#define TT_MAC_LANGID_TURKISH                      17
+#define TT_MAC_LANGID_CROATIAN                     18
+#define TT_MAC_LANGID_CHINESE_TRADITIONAL          19
+#define TT_MAC_LANGID_URDU                         20
+#define TT_MAC_LANGID_HINDI                        21
+#define TT_MAC_LANGID_THAI                         22
+#define TT_MAC_LANGID_KOREAN                       23
+#define TT_MAC_LANGID_LITHUANIAN                   24
+#define TT_MAC_LANGID_POLISH                       25
+#define TT_MAC_LANGID_HUNGARIAN                    26
+#define TT_MAC_LANGID_ESTONIAN                     27
+#define TT_MAC_LANGID_LETTISH                      28
+#define TT_MAC_LANGID_SAAMISK                      29
+#define TT_MAC_LANGID_FAEROESE                     30
+#define TT_MAC_LANGID_FARSI                        31
+#define TT_MAC_LANGID_RUSSIAN                      32
+#define TT_MAC_LANGID_CHINESE_SIMPLIFIED           33
+#define TT_MAC_LANGID_FLEMISH                      34
+#define TT_MAC_LANGID_IRISH                        35
+#define TT_MAC_LANGID_ALBANIAN                     36
+#define TT_MAC_LANGID_ROMANIAN                     37
+#define TT_MAC_LANGID_CZECH                        38
+#define TT_MAC_LANGID_SLOVAK                       39
+#define TT_MAC_LANGID_SLOVENIAN                    40
+#define TT_MAC_LANGID_YIDDISH                      41
+#define TT_MAC_LANGID_SERBIAN                      42
+#define TT_MAC_LANGID_MACEDONIAN                   43
+#define TT_MAC_LANGID_BULGARIAN                    44
+#define TT_MAC_LANGID_UKRAINIAN                    45
+#define TT_MAC_LANGID_BYELORUSSIAN                 46
+#define TT_MAC_LANGID_UZBEK                        47
+#define TT_MAC_LANGID_KAZAKH                       48
+#define TT_MAC_LANGID_AZERBAIJANI                  49
+#define TT_MAC_LANGID_AZERBAIJANI_CYRILLIC_SCRIPT  49
+#define TT_MAC_LANGID_AZERBAIJANI_ARABIC_SCRIPT    50
+#define TT_MAC_LANGID_ARMENIAN                     51
+#define TT_MAC_LANGID_GEORGIAN                     52
+#define TT_MAC_LANGID_MOLDAVIAN                    53
+#define TT_MAC_LANGID_KIRGHIZ                      54
+#define TT_MAC_LANGID_TAJIKI                       55
+#define TT_MAC_LANGID_TURKMEN                      56
+#define TT_MAC_LANGID_MONGOLIAN                    57
+#define TT_MAC_LANGID_MONGOLIAN_MONGOLIAN_SCRIPT   57
+#define TT_MAC_LANGID_MONGOLIAN_CYRILLIC_SCRIPT    58
+#define TT_MAC_LANGID_PASHTO                       59
+#define TT_MAC_LANGID_KURDISH                      60
+#define TT_MAC_LANGID_KASHMIRI                     61
+#define TT_MAC_LANGID_SINDHI                       62
+#define TT_MAC_LANGID_TIBETAN                      63
+#define TT_MAC_LANGID_NEPALI                       64
+#define TT_MAC_LANGID_SANSKRIT                     65
+#define TT_MAC_LANGID_MARATHI                      66
+#define TT_MAC_LANGID_BENGALI                      67
+#define TT_MAC_LANGID_ASSAMESE                     68
+#define TT_MAC_LANGID_GUJARATI                     69
+#define TT_MAC_LANGID_PUNJABI                      70
+#define TT_MAC_LANGID_ORIYA                        71
+#define TT_MAC_LANGID_MALAYALAM                    72
+#define TT_MAC_LANGID_KANNADA                      73
+#define TT_MAC_LANGID_TAMIL                        74
+#define TT_MAC_LANGID_TELUGU                       75
+#define TT_MAC_LANGID_SINHALESE                    76
+#define TT_MAC_LANGID_BURMESE                      77
+#define TT_MAC_LANGID_KHMER                        78
+#define TT_MAC_LANGID_LAO                          79
+#define TT_MAC_LANGID_VIETNAMESE                   80
+#define TT_MAC_LANGID_INDONESIAN                   81
+#define TT_MAC_LANGID_TAGALOG                      82
+#define TT_MAC_LANGID_MALAY_ROMAN_SCRIPT           83
+#define TT_MAC_LANGID_MALAY_ARABIC_SCRIPT          84
+#define TT_MAC_LANGID_AMHARIC                      85
+#define TT_MAC_LANGID_TIGRINYA                     86
+#define TT_MAC_LANGID_GALLA                        87
+#define TT_MAC_LANGID_SOMALI                       88
+#define TT_MAC_LANGID_SWAHILI                      89
+#define TT_MAC_LANGID_RUANDA                       90
+#define TT_MAC_LANGID_RUNDI                        91
+#define TT_MAC_LANGID_CHEWA                        92
+#define TT_MAC_LANGID_MALAGASY                     93
+#define TT_MAC_LANGID_ESPERANTO                    94
+#define TT_MAC_LANGID_WELSH                       128
+#define TT_MAC_LANGID_BASQUE                      129
+#define TT_MAC_LANGID_CATALAN                     130
+#define TT_MAC_LANGID_LATIN                       131
+#define TT_MAC_LANGID_QUECHUA                     132
+#define TT_MAC_LANGID_GUARANI                     133
+#define TT_MAC_LANGID_AYMARA                      134
+#define TT_MAC_LANGID_TATAR                       135
+#define TT_MAC_LANGID_UIGHUR                      136
+#define TT_MAC_LANGID_DZONGKHA                    137
+#define TT_MAC_LANGID_JAVANESE                    138
+#define TT_MAC_LANGID_SUNDANESE                   139
+
+
+#if 0  /* these seem to be errors that have been dropped */
+
+#define TT_MAC_LANGID_SCOTTISH_GAELIC             140
+#define TT_MAC_LANGID_IRISH_GAELIC                141
+
+#endif
+
+
+  /* The following codes are new as of 2000-03-10 */
+#define TT_MAC_LANGID_GALICIAN                    140
+#define TT_MAC_LANGID_AFRIKAANS                   141
+#define TT_MAC_LANGID_BRETON                      142
+#define TT_MAC_LANGID_INUKTITUT                   143
+#define TT_MAC_LANGID_SCOTTISH_GAELIC             144
+#define TT_MAC_LANGID_MANX_GAELIC                 145
+#define TT_MAC_LANGID_IRISH_GAELIC                146
+#define TT_MAC_LANGID_TONGAN                      147
+#define TT_MAC_LANGID_GREEK_POLYTONIC             148
+#define TT_MAC_LANGID_GREELANDIC                  149
+#define TT_MAC_LANGID_AZERBAIJANI_ROMAN_SCRIPT    150
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Possible values of the language identifier field in the name records  */
+  /* of the TTF `name' table if the `platform' identifier code is          */
+  /* TT_PLATFORM_MICROSOFT.                                                */
+  /*                                                                       */
+  /* The canonical source for the MS assigned LCID's is at                 */
+  /*                                                                       */
+  /*   http://www.microsoft.com/typography/OTSPEC/lcid-cp.txt              */
+  /*                                                                       */
+#define TT_MS_LANGID_ARABIC_SAUDI_ARABIA               0x0401
+#define TT_MS_LANGID_ARABIC_IRAQ                       0x0801
+#define TT_MS_LANGID_ARABIC_EGYPT                      0x0c01
+#define TT_MS_LANGID_ARABIC_LIBYA                      0x1001
+#define TT_MS_LANGID_ARABIC_ALGERIA                    0x1401
+#define TT_MS_LANGID_ARABIC_MOROCCO                    0x1801
+#define TT_MS_LANGID_ARABIC_TUNISIA                    0x1c01
+#define TT_MS_LANGID_ARABIC_OMAN                       0x2001
+#define TT_MS_LANGID_ARABIC_YEMEN                      0x2401
+#define TT_MS_LANGID_ARABIC_SYRIA                      0x2801
+#define TT_MS_LANGID_ARABIC_JORDAN                     0x2c01
+#define TT_MS_LANGID_ARABIC_LEBANON                    0x3001
+#define TT_MS_LANGID_ARABIC_KUWAIT                     0x3401
+#define TT_MS_LANGID_ARABIC_UAE                        0x3801
+#define TT_MS_LANGID_ARABIC_BAHRAIN                    0x3c01
+#define TT_MS_LANGID_ARABIC_QATAR                      0x4001
+#define TT_MS_LANGID_BULGARIAN_BULGARIA                0x0402
+#define TT_MS_LANGID_CATALAN_SPAIN                     0x0403
+#define TT_MS_LANGID_CHINESE_TAIWAN                    0x0404
+#define TT_MS_LANGID_CHINESE_PRC                       0x0804
+#define TT_MS_LANGID_CHINESE_HONG_KONG                 0x0c04
+#define TT_MS_LANGID_CHINESE_SINGAPORE                 0x1004
+
+#if 1  /* this used to be this value (and it still is in many places) */
+#define TT_MS_LANGID_CHINESE_MACAU                     0x1404
+#else  /* but beware, Microsoft may change its mind...
+          the most recent Word reference has the following: */
+#define TT_MS_LANGID_CHINESE_MACAU  TT_MS_LANGID_CHINESE_HONG_KONG
+#endif
+
+#define TT_MS_LANGID_CZECH_CZECH_REPUBLIC              0x0405
+#define TT_MS_LANGID_DANISH_DENMARK                    0x0406
+#define TT_MS_LANGID_GERMAN_GERMANY                    0x0407
+#define TT_MS_LANGID_GERMAN_SWITZERLAND                0x0807
+#define TT_MS_LANGID_GERMAN_AUSTRIA                    0x0c07
+#define TT_MS_LANGID_GERMAN_LUXEMBOURG                 0x1007
+#define TT_MS_LANGID_GERMAN_LIECHTENSTEI               0x1407
+#define TT_MS_LANGID_GREEK_GREECE                      0x0408
+#define TT_MS_LANGID_ENGLISH_UNITED_STATES             0x0409
+#define TT_MS_LANGID_ENGLISH_UNITED_KINGDOM            0x0809
+#define TT_MS_LANGID_ENGLISH_AUSTRALIA                 0x0c09
+#define TT_MS_LANGID_ENGLISH_CANADA                    0x1009
+#define TT_MS_LANGID_ENGLISH_NEW_ZEALAND               0x1409
+#define TT_MS_LANGID_ENGLISH_IRELAND                   0x1809
+#define TT_MS_LANGID_ENGLISH_SOUTH_AFRICA              0x1c09
+#define TT_MS_LANGID_ENGLISH_JAMAICA                   0x2009
+#define TT_MS_LANGID_ENGLISH_CARIBBEAN                 0x2409
+#define TT_MS_LANGID_ENGLISH_BELIZE                    0x2809
+#define TT_MS_LANGID_ENGLISH_TRINIDAD                  0x2c09
+#define TT_MS_LANGID_ENGLISH_ZIMBABWE                  0x3009
+#define TT_MS_LANGID_ENGLISH_PHILIPPINES               0x3409
+#define TT_MS_LANGID_SPANISH_SPAIN_TRADITIONAL_SORT    0x040a
+#define TT_MS_LANGID_SPANISH_MEXICO                    0x080a
+#define TT_MS_LANGID_SPANISH_SPAIN_INTERNATIONAL_SORT  0x0c0a
+#define TT_MS_LANGID_SPANISH_GUATEMALA                 0x100a
+#define TT_MS_LANGID_SPANISH_COSTA_RICA                0x140a
+#define TT_MS_LANGID_SPANISH_PANAMA                    0x180a
+#define TT_MS_LANGID_SPANISH_DOMINICAN_REPUBLIC        0x1c0a
+#define TT_MS_LANGID_SPANISH_VENEZUELA                 0x200a
+#define TT_MS_LANGID_SPANISH_COLOMBIA                  0x240a
+#define TT_MS_LANGID_SPANISH_PERU                      0x280a
+#define TT_MS_LANGID_SPANISH_ARGENTINA                 0x2c0a
+#define TT_MS_LANGID_SPANISH_ECUADOR                   0x300a
+#define TT_MS_LANGID_SPANISH_CHILE                     0x340a
+#define TT_MS_LANGID_SPANISH_URUGUAY                   0x380a
+#define TT_MS_LANGID_SPANISH_PARAGUAY                  0x3c0a
+#define TT_MS_LANGID_SPANISH_BOLIVIA                   0x400a
+#define TT_MS_LANGID_SPANISH_EL_SALVADOR               0x440a
+#define TT_MS_LANGID_SPANISH_HONDURAS                  0x480a
+#define TT_MS_LANGID_SPANISH_NICARAGUA                 0x4c0a
+#define TT_MS_LANGID_SPANISH_PUERTO_RICO               0x500a
+#define TT_MS_LANGID_FINNISH_FINLAND                   0x040b
+#define TT_MS_LANGID_FRENCH_FRANCE                     0x040c
+#define TT_MS_LANGID_FRENCH_BELGIUM                    0x080c
+#define TT_MS_LANGID_FRENCH_CANADA                     0x0c0c
+#define TT_MS_LANGID_FRENCH_SWITZERLAND                0x100c
+#define TT_MS_LANGID_FRENCH_LUXEMBOURG                 0x140c
+#define TT_MS_LANGID_FRENCH_MONACO                     0x180c
+#define TT_MS_LANGID_HEBREW_ISRAEL                     0x040d
+#define TT_MS_LANGID_HUNGARIAN_HUNGARY                 0x040e
+#define TT_MS_LANGID_ICELANDIC_ICELAND                 0x040f
+#define TT_MS_LANGID_ITALIAN_ITALY                     0x0410
+#define TT_MS_LANGID_ITALIAN_SWITZERLAND               0x0810
+#define TT_MS_LANGID_JAPANESE_JAPAN                    0x0411
+#define TT_MS_LANGID_KOREAN_EXTENDED_WANSUNG_KOREA     0x0412
+#define TT_MS_LANGID_KOREAN_JOHAB_KOREA                0x0812
+#define TT_MS_LANGID_DUTCH_NETHERLANDS                 0x0413
+#define TT_MS_LANGID_DUTCH_BELGIUM                     0x0813
+#define TT_MS_LANGID_NORWEGIAN_NORWAY_BOKMAL           0x0414
+#define TT_MS_LANGID_NORWEGIAN_NORWAY_NYNORSK          0x0814
+#define TT_MS_LANGID_POLISH_POLAND                     0x0415
+#define TT_MS_LANGID_PORTUGUESE_BRAZIL                 0x0416
+#define TT_MS_LANGID_PORTUGUESE_PORTUGAL               0x0816
+#define TT_MS_LANGID_RHAETO_ROMANIC_SWITZERLAND        0x0417
+#define TT_MS_LANGID_ROMANIAN_ROMANIA                  0x0418
+#define TT_MS_LANGID_MOLDAVIAN_MOLDAVIA                0x0818
+#define TT_MS_LANGID_RUSSIAN_RUSSIA                    0x0419
+#define TT_MS_LANGID_RUSSIAN_MOLDAVIA                  0x0819
+#define TT_MS_LANGID_CROATIAN_CROATIA                  0x041a
+#define TT_MS_LANGID_SERBIAN_SERBIA_LATIN              0x081a
+#define TT_MS_LANGID_SERBIAN_SERBIA_CYRILLIC           0x0c1a
+#define TT_MS_LANGID_SLOVAK_SLOVAKIA                   0x041b
+#define TT_MS_LANGID_ALBANIAN_ALBANIA                  0x041c
+#define TT_MS_LANGID_SWEDISH_SWEDEN                    0x041d
+#define TT_MS_LANGID_SWEDISH_FINLAND                   0x081d
+#define TT_MS_LANGID_THAI_THAILAND                     0x041e
+#define TT_MS_LANGID_TURKISH_TURKEY                    0x041f
+#define TT_MS_LANGID_URDU_PAKISTAN                     0x0420
+#define TT_MS_LANGID_INDONESIAN_INDONESIA              0x0421
+#define TT_MS_LANGID_UKRAINIAN_UKRAINE                 0x0422
+#define TT_MS_LANGID_BELARUSIAN_BELARUS                0x0423
+#define TT_MS_LANGID_SLOVENE_SLOVENIA                  0x0424
+#define TT_MS_LANGID_ESTONIAN_ESTONIA                  0x0425
+#define TT_MS_LANGID_LATVIAN_LATVIA                    0x0426
+#define TT_MS_LANGID_LITHUANIAN_LITHUANIA              0x0427
+#define TT_MS_LANGID_CLASSIC_LITHUANIAN_LITHUANIA      0x0827
+
+#if 0  /* this seems to be an error that have been dropped */
+#define TT_MS_LANGID_MAORI_NEW_ZEALAND                 0x0428
+#endif
+
+#define TT_MS_LANGID_FARSI_IRAN                        0x0429
+#define TT_MS_LANGID_VIETNAMESE_VIET_NAM               0x042a
+#define TT_MS_LANGID_ARMENIAN_ARMENIA                  0x042b
+#define TT_MS_LANGID_AZERI_AZERBAIJAN_LATIN            0x042c
+#define TT_MS_LANGID_AZERI_AZERBAIJAN_CYRILLIC         0x082c
+#define TT_MS_LANGID_BASQUE_SPAIN                      0x042d
+#define TT_MS_LANGID_SORBIAN_GERMANY                   0x042e
+#define TT_MS_LANGID_MACEDONIAN_MACEDONIA              0x042f
+#define TT_MS_LANGID_SUTU_SOUTH_AFRICA                 0x0430
+#define TT_MS_LANGID_TSONGA_SOUTH_AFRICA               0x0431
+#define TT_MS_LANGID_TSWANA_SOUTH_AFRICA               0x0432
+#define TT_MS_LANGID_VENDA_SOUTH_AFRICA                0x0433
+#define TT_MS_LANGID_XHOSA_SOUTH_AFRICA                0x0434
+#define TT_MS_LANGID_ZULU_SOUTH_AFRICA                 0x0435
+#define TT_MS_LANGID_AFRIKAANS_SOUTH_AFRICA            0x0436
+#define TT_MS_LANGID_GEORGIAN_GEORGIA                  0x0437
+#define TT_MS_LANGID_FAEROESE_FAEROE_ISLANDS           0x0438
+#define TT_MS_LANGID_HINDI_INDIA                       0x0439
+#define TT_MS_LANGID_MALTESE_MALTA                     0x043a
+#define TT_MS_LANGID_SAAMI_LAPONIA                     0x043b
+
+#if 0 /* this seems to be a previous invertion */
+#define TT_MS_LANGID_IRISH_GAELIC_IRELAND              0x043c
+#define TT_MS_LANGID_SCOTTISH_GAELIC_UNITED_KINGDOM    0x083c
+#else
+#define TT_MS_LANGID_SCOTTISH_GAELIC_UNITED_KINGDOM    0x083c
+#define TT_MS_LANGID_IRISH_GAELIC_IRELAND              0x043c
+#endif
+
+#define TT_MS_LANGID_MALAY_MALAYSIA                    0x043e
+#define TT_MS_LANGID_MALAY_BRUNEI_DARUSSALAM           0x083e
+#define TT_MS_LANGID_KAZAK_KAZAKSTAN                   0x043f
+#define TT_MS_LANGID_SWAHILI_KENYA                     0x0441
+#define TT_MS_LANGID_UZBEK_UZBEKISTAN_LATIN            0x0443
+#define TT_MS_LANGID_UZBEK_UZBEKISTAN_CYRILLIC         0x0843
+#define TT_MS_LANGID_TATAR_TATARSTAN                   0x0444
+#define TT_MS_LANGID_BENGALI_INDIA                     0x0445
+#define TT_MS_LANGID_PUNJABI_INDIA                     0x0446
+#define TT_MS_LANGID_GUJARATI_INDIA                    0x0447
+#define TT_MS_LANGID_ORIYA_INDIA                       0x0448
+#define TT_MS_LANGID_TAMIL_INDIA                       0x0449
+#define TT_MS_LANGID_TELUGU_INDIA                      0x044a
+#define TT_MS_LANGID_KANNADA_INDIA                     0x044b
+#define TT_MS_LANGID_MALAYALAM_INDIA                   0x044c
+#define TT_MS_LANGID_ASSAMESE_INDIA                    0x044d
+#define TT_MS_LANGID_MARATHI_INDIA                     0x044e
+#define TT_MS_LANGID_SANSKRIT_INDIA                    0x044f
+#define TT_MS_LANGID_KONKANI_INDIA                     0x0457
+
+  /* new as of 2001-01-01 */
+#define TT_MS_LANGID_ARABIC_GENERAL                    0x0001
+#define TT_MS_LANGID_CHINESE_GENERAL                   0x0004
+#define TT_MS_LANGID_ENGLISH_GENERAL                   0x0009
+#define TT_MS_LANGID_FRENCH_WEST_INDIES                0x1c0c
+#define TT_MS_LANGID_FRENCH_REUNION                    0x200c
+#define TT_MS_LANGID_FRENCH_CONGO                      0x240c
+  /* which was formerly: */
+#define TT_MS_LANGID_FRENCH_ZAIRE  TT_MS_LANGID_FRENCH_CONGO
+
+#define TT_MS_LANGID_FRENCH_SENEGAL                    0x280c
+#define TT_MS_LANGID_FRENCH_CAMEROON                   0x2c0c
+#define TT_MS_LANGID_FRENCH_COTE_D_IVOIRE              0x300c
+#define TT_MS_LANGID_FRENCH_MALI                       0x340c
+#define TT_MS_LANGID_BOSNIAN_BOSNIA_HERZEGOVINA        0x101a
+#define TT_MS_LANGID_URDU_INDIA                        0x0820
+#define TT_MS_LANGID_TAJIK_TAJIKISTAN                  0x0428
+#define TT_MS_LANGID_YIDDISH_GERMANY                   0x043d
+#define TT_MS_LANGID_KIRGHIZ_KIRGHIZSTAN               0x0440
+  /* alias declared in Windows 2000 */
+#define TT_MS_LANGID_KIRGHIZ_KIRGHIZ_REPUBLIC \
+          TT_MS_LANGID_KIRGHIZ_KIRGHIZSTAN
+
+#define TT_MS_LANGID_TURKMEN_TURKMENISTAN              0x0442
+#define TT_MS_LANGID_MONGOLIAN_MONGOLIA /* Cyrillic */ 0x0450
+
+  /* the following seems to be inconsistent;
+     here is the current "official" way: */
+#define TT_MS_LANGID_TIBETAN_BHUTAN                    0x0451
+  /* and here is what is used by Passport SDK */
+#define TT_MS_LANGID_TIBETAN_CHINA                     0x0451
+#define TT_MS_LANGID_DZONGHKA_BHUTAN                   0x0851
+  /* end of inconsistency */
+
+#define TT_MS_LANGID_WELSH_WALES                       0x0452
+#define TT_MS_LANGID_KHMER_CAMBODIA                    0x0453
+#define TT_MS_LANGID_LAO_LAOS                          0x0454
+#define TT_MS_LANGID_BURMESE_MYANMAR                   0x0455
+#define TT_MS_LANGID_GALICIAN_SPAIN                    0x0456
+#define TT_MS_LANGID_MANIPURI_INDIA                    0x0458
+#define TT_MS_LANGID_SINDHI_INDIA                      0x0459
+  /* the following one is only encountered in Microsoft RTF specification */
+#define TT_MS_LANGID_KASHMIRI_PAKISTAN                 0x0460
+  /* the following one is not in the Passport list, looks like an omission */
+#define TT_MS_LANGID_KASHMIRI_INDIA                    0x0860
+#define TT_MS_LANGID_NEPALI_NEPAL                      0x0461
+#define TT_MS_LANGID_NEPALI_INDIA                      0x0861
+#define TT_MS_LANGID_FRISIAN_NETHERLANDS               0x0462
+
+  /* new as of 2001-03-01 (from Office Xp) */
+#define TT_MS_LANGID_ENGLISH_HONG_KONG                 0x3c09
+#define TT_MS_LANGID_ENGLISH_INDIA                     0x4009
+#define TT_MS_LANGID_ENGLISH_MALAYSIA                  0x4409
+#define TT_MS_LANGID_ENGLISH_SINGAPORE                 0x4809
+#define TT_MS_LANGID_SYRIAC_SYRIA                      0x045a
+#define TT_MS_LANGID_SINHALESE_SRI_LANKA               0x045b
+#define TT_MS_LANGID_CHEROKEE_UNITED_STATES            0x045c
+#define TT_MS_LANGID_INUKTITUT_CANADA                  0x045d
+#define TT_MS_LANGID_AMHARIC_ETHIOPIA                  0x045e
+#define TT_MS_LANGID_TAMAZIGHT_MOROCCO                 0x045f
+#define TT_MS_LANGID_TAMAZIGHT_MOROCCO_LATIN           0x085f
+#define TT_MS_LANGID_PASHTO_AFGHANISTAN                0x0463
+#define TT_MS_LANGID_FILIPINO_PHILIPPINES              0x0464
+#define TT_MS_LANGID_DHIVEHI_MALDIVES                  0x0465
+  /* alias declared in Windows 2000 */
+#define TT_MS_LANGID_DIVEHI_MALDIVES  TT_MS_LANGID_DHIVEHI_MALDIVES
+  /* for language codes from 0x0466 to 0x0471 see below */
+#define TT_MS_LANGID_OROMO_ETHIOPIA                    0x0472
+#define TT_MS_LANGID_TIGRIGNA_ETHIOPIA                 0x0473
+#define TT_MS_LANGID_TIGRIGNA_ERYTHREA                 0x0873
+  /* also spelled in the `Passport SDK' list as: */
+#define TT_MS_LANGID_TIGRIGNA_ERYTREA  TT_MS_LANGID_TIGRIGNA_ERYTHREA
+
+  /* New additions from Windows Xp/Passport SDK 2001-11-10. */
+
+  /* don't ask what this one means... It is commented out currently. */
+#if 0
+#define TT_MS_LANGID_GREEK_GREECE2                     0x2008
+#endif
+
+#define TT_MS_LANGID_SPANISH_UNITED_STATES             0x540a
+  /* The following two IDs blatantly violate MS specs by using a */
+  /* sublanguage > 0x1F.                                         */
+#define TT_MS_LANGID_SPANISH_LATIN_AMERICA             0xE40a
+#define TT_MS_LANGID_FRENCH_NORTH_AFRICA               0xE40c
+
+#define TT_MS_LANGID_FRENCH_MOROCCO                    0x380c
+#define TT_MS_LANGID_FRENCH_HAITI                      0x3c0c
+#define TT_MS_LANGID_BENGALI_BANGLADESH                0x0845
+#define TT_MS_LANGID_PUNJABI_ARABIC_PAKISTAN           0x0846
+#define TT_MS_LANGID_MONGOLIAN_MONGOLIA_MONGOLIAN      0x0850
+#define TT_MS_LANGID_EDO_NIGERIA                       0x0466
+#define TT_MS_LANGID_FULFULDE_NIGERIA                  0x0467
+#define TT_MS_LANGID_HAUSA_NIGERIA                     0x0468
+#define TT_MS_LANGID_IBIBIO_NIGERIA                    0x0469
+#define TT_MS_LANGID_YORUBA_NIGERIA                    0x046a
+  /* language codes from 0x046b to 0x046f are (still) unknown. */
+#define TT_MS_LANGID_IGBO_NIGERIA                      0x0470
+#define TT_MS_LANGID_KANURI_NIGERIA                    0x0471
+#define TT_MS_LANGID_GUARANI_PARAGUAY                  0x0474
+#define TT_MS_LANGID_HAWAIIAN_UNITED_STATES            0x0475
+#define TT_MS_LANGID_LATIN                             0x0476
+#define TT_MS_LANGID_SOMALI_SOMALIA                    0x0477
+  /* Note: Yi does not have a (proper) ISO 639-2 code, since it is mostly */
+  /*       not written (but OTOH the peculiar writing system is worth     */
+  /*       studying).                                                     */
+#define TT_MS_LANGID_YI_CHINA                          0x0478
+#define TT_MS_LANGID_PAPIAMENTU_NETHERLANDS_ANTILLES   0x0479
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Possible values of the `name' identifier field in the name records of */
+  /* the TTF `name' table.  These values are platform independent.         */
+  /*                                                                       */
+#define TT_NAME_ID_COPYRIGHT            0
+#define TT_NAME_ID_FONT_FAMILY          1
+#define TT_NAME_ID_FONT_SUBFAMILY       2
+#define TT_NAME_ID_UNIQUE_ID            3
+#define TT_NAME_ID_FULL_NAME            4
+#define TT_NAME_ID_VERSION_STRING       5
+#define TT_NAME_ID_PS_NAME              6
+#define TT_NAME_ID_TRADEMARK            7
+
+  /* the following values are from the OpenType spec */
+#define TT_NAME_ID_MANUFACTURER         8
+#define TT_NAME_ID_DESIGNER             9
+#define TT_NAME_ID_DESCRIPTION          10
+#define TT_NAME_ID_VENDOR_URL           11
+#define TT_NAME_ID_DESIGNER_URL         12
+#define TT_NAME_ID_LICENSE              13
+#define TT_NAME_ID_LICENSE_URL          14
+  /* number 15 is reserved */
+#define TT_NAME_ID_PREFERRED_FAMILY     16
+#define TT_NAME_ID_PREFERRED_SUBFAMILY  17
+#define TT_NAME_ID_MAC_FULL_NAME        18
+
+  /* The following code is new as of 2000-01-21 */
+#define TT_NAME_ID_SAMPLE_TEXT          19
+
+  /* This is new in OpenType 1.3 */
+#define TT_NAME_ID_CID_FINDFONT_NAME    20
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Bit mask values for the Unicode Ranges from the TTF `OS2 ' table.     */
+  /*                                                                       */
+  /* Updated 02-Jul-2000.                                                  */
+  /*                                                                       */
+
+  /* General Scripts Area */
+
+  /* Bit  0   Basic Latin */
+#define TT_UCR_BASIC_LATIN                     (1L <<  0) /* U+0020-U+007E */
+  /* Bit  1   C1 Controls and Latin-1 Supplement */
+#define TT_UCR_LATIN1_SUPPLEMENT               (1L <<  1) /* U+0080-U+00FF */
+  /* Bit  2   Latin Extended-A */
+#define TT_UCR_LATIN_EXTENDED_A                (1L <<  2) /* U+0100-U+017F */
+  /* Bit  3   Latin Extended-B */
+#define TT_UCR_LATIN_EXTENDED_B                (1L <<  3) /* U+0180-U+024F */
+  /* Bit  4   IPA Extensions */
+#define TT_UCR_IPA_EXTENSIONS                  (1L <<  4) /* U+0250-U+02AF */
+  /* Bit  5   Spacing Modifier Letters */
+#define TT_UCR_SPACING_MODIFIER                (1L <<  5) /* U+02B0-U+02FF */
+  /* Bit  6   Combining Diacritical Marks */
+#define TT_UCR_COMBINING_DIACRITICS            (1L <<  6) /* U+0300-U+036F */
+  /* Bit  7   Greek and Coptic */
+#define TT_UCR_GREEK                           (1L <<  7) /* U+0370-U+03FF */
+  /* Bit  8 is reserved (was: Greek Symbols and Coptic) */
+  /* Bit  9   Cyrillic */
+#define TT_UCR_CYRILLIC                        (1L <<  9) /* U+0400-U+04FF */
+  /* Bit 10   Armenian */
+#define TT_UCR_ARMENIAN                        (1L << 10) /* U+0530-U+058F */
+  /* Bit 11   Hebrew */
+#define TT_UCR_HEBREW                          (1L << 11) /* U+0590-U+05FF */
+  /* Bit 12 is reserved (was: Hebrew Extended) */
+  /* Bit 13   Arabic */
+#define TT_UCR_ARABIC                          (1L << 13) /* U+0600-U+06FF */
+  /* Bit 14 is reserved (was: Arabic Extended) */
+  /* Bit 15   Devanagari */
+#define TT_UCR_DEVANAGARI                      (1L << 15) /* U+0900-U+097F */
+  /* Bit 16   Bengali */
+#define TT_UCR_BENGALI                         (1L << 16) /* U+0980-U+09FF */
+  /* Bit 17   Gurmukhi */
+#define TT_UCR_GURMUKHI                        (1L << 17) /* U+0A00-U+0A7F */
+  /* Bit 18   Gujarati */
+#define TT_UCR_GUJARATI                        (1L << 18) /* U+0A80-U+0AFF */
+  /* Bit 19   Oriya */
+#define TT_UCR_ORIYA                           (1L << 19) /* U+0B00-U+0B7F */
+  /* Bit 20   Tamil */
+#define TT_UCR_TAMIL                           (1L << 20) /* U+0B80-U+0BFF */
+  /* Bit 21   Telugu */
+#define TT_UCR_TELUGU                          (1L << 21) /* U+0C00-U+0C7F */
+  /* Bit 22   Kannada */
+#define TT_UCR_KANNADA                         (1L << 22) /* U+0C80-U+0CFF */
+  /* Bit 23   Malayalam */
+#define TT_UCR_MALAYALAM                       (1L << 23) /* U+0D00-U+0D7F */
+  /* Bit 24   Thai */
+#define TT_UCR_THAI                            (1L << 24) /* U+0E00-U+0E7F */
+  /* Bit 25   Lao */
+#define TT_UCR_LAO                             (1L << 25) /* U+0E80-U+0EFF */
+  /* Bit 26   Georgian */
+#define TT_UCR_GEORGIAN                        (1L << 26) /* U+10A0-U+10FF */
+  /* Bit 27 is reserved (was Georgian Extended) */
+  /* Bit 28   Hangul Jamo */
+#define TT_UCR_HANGUL_JAMO                     (1L << 28) /* U+1100-U+11FF */
+  /* Bit 29   Latin Extended Additional */
+#define TT_UCR_LATIN_EXTENDED_ADDITIONAL       (1L << 29) /* U+1E00-U+1EFF */
+  /* Bit 30   Greek Extended */
+#define TT_UCR_GREEK_EXTENDED                  (1L << 30) /* U+1F00-U+1FFF */
+
+  /* Symbols Area */
+
+  /* Bit 31   General Punctuation */
+#define TT_UCR_GENERAL_PUNCTUATION             (1L << 31) /* U+2000-U+206F */
+  /* Bit 32   Superscripts And Subscripts */
+#define TT_UCR_SUPERSCRIPTS_SUBSCRIPTS         (1L <<  0) /* U+2070-U+209F */
+  /* Bit 33   Currency Symbols */
+#define TT_UCR_CURRENCY_SYMBOLS                (1L <<  1) /* U+20A0-U+20CF */
+  /* Bit 34   Combining Diacritical Marks For Symbols */
+#define TT_UCR_COMBINING_DIACRITICS_SYMB       (1L <<  2) /* U+20D0-U+20FF */
+  /* Bit 35   Letterlike Symbols */
+#define TT_UCR_LETTERLIKE_SYMBOLS              (1L <<  3) /* U+2100-U+214F */
+  /* Bit 36   Number Forms */
+#define TT_UCR_NUMBER_FORMS                    (1L <<  4) /* U+2150-U+218F */
+  /* Bit 37   Arrows */
+#define TT_UCR_ARROWS                          (1L <<  5) /* U+2190-U+21FF */
+  /* Bit 38   Mathematical Operators */
+#define TT_UCR_MATHEMATICAL_OPERATORS          (1L <<  6) /* U+2200-U+22FF */
+  /* Bit 39 Miscellaneous Technical */
+#define TT_UCR_MISCELLANEOUS_TECHNICAL         (1L <<  7) /* U+2300-U+23FF */
+  /* Bit 40   Control Pictures */
+#define TT_UCR_CONTROL_PICTURES                (1L <<  8) /* U+2400-U+243F */
+  /* Bit 41   Optical Character Recognition */
+#define TT_UCR_OCR                             (1L <<  9) /* U+2440-U+245F */
+  /* Bit 42   Enclosed Alphanumerics */
+#define TT_UCR_ENCLOSED_ALPHANUMERICS          (1L << 10) /* U+2460-U+24FF */
+  /* Bit 43   Box Drawing */
+#define TT_UCR_BOX_DRAWING                     (1L << 11) /* U+2500-U+257F */
+  /* Bit 44   Block Elements */
+#define TT_UCR_BLOCK_ELEMENTS                  (1L << 12) /* U+2580-U+259F */
+  /* Bit 45   Geometric Shapes */
+#define TT_UCR_GEOMETRIC_SHAPES                (1L << 13) /* U+25A0-U+25FF */
+  /* Bit 46   Miscellaneous Symbols */
+#define TT_UCR_MISCELLANEOUS_SYMBOLS           (1L << 14) /* U+2600-U+26FF */
+  /* Bit 47   Dingbats */
+#define TT_UCR_DINGBATS                        (1L << 15) /* U+2700-U+27BF */
+
+  /* CJK Phonetics and Symbols Area */
+
+  /* Bit 48   CJK Symbols and Punctuation */
+#define TT_UCR_CJK_SYMBOLS                     (1L << 16) /* U+3000-U+303F */
+  /* Bit 49   Hiragana */
+#define TT_UCR_HIRAGANA                        (1L << 17) /* U+3040-U+309F */
+  /* Bit 50   Katakana */
+#define TT_UCR_KATAKANA                        (1L << 18) /* U+30A0-U+30FF */
+  /* Bit 51   Bopomofo          + */
+  /*          Bopomofo Extended   */
+#define TT_UCR_BOPOMOFO                        (1L << 19) /* U+3100-U+312F */
+                                                          /* U+31A0-U+31BF */
+  /* Bit 52   Hangul Compatibility Jamo */
+#define TT_UCR_HANGUL_COMPATIBILITY_JAMO       (1L << 20) /* U+3130-U+318F */
+  /* Bit 53   Kanbun */
+#define TT_UCR_CJK_MISC                        (1L << 21) /* U+3190-U+319F */
+#define TT_UCR_KANBUN  TT_UCR_CJK_MISC
+  /* Bit 54   Enclosed CJK Letters and Months */
+#define TT_UCR_ENCLOSED_CJK_LETTERS_MONTHS     (1L << 22) /* U+3200-U+32FF */
+  /* Bit 55   CJK Compatibility */
+#define TT_UCR_CJK_COMPATIBILITY               (1L << 23) /* U+3300-U+33FF */
+
+  /* Hangul Syllables Area */
+
+  /* Bit 56   Hangul */
+#define TT_UCR_HANGUL                          (1L << 24) /* U+AC00-U+D7A3 */
+
+  /* Surrogates Area */
+
+  /* Bit 57   High Surrogates             + */
+  /*          High Private Use Surrogates + */
+  /*          Low Surrogates                */
+#define TT_UCR_SURROGATES                      (1L << 25) /* U+D800-U+DB7F */
+                                                          /* U+DB80-U+DBFF */
+                                                          /* U+DC00-U+DFFF */
+  /* According to OpenType specs v.1.3+, setting bit 57 implies that there */
+  /* is at least one codepoint beyond the Basic Multilingual Plane that is */
+  /* supported by this font.  So it really means:            >= U+10000    */
+
+  /* Bit 58 is reserved for Unicode SubRanges */
+
+  /* CJK Ideographs Area */
+
+  /* Bit 59   CJK Unified Ideographs             + */
+  /*          CJK Radicals Supplement            + */
+  /*          Kangxi Radicals                    + */
+  /*          Ideographic Description Characters + */
+  /*          CJK Unified Ideographs Extension A   */
+#define TT_UCR_CJK_UNIFIED_IDEOGRAPHS          (1L << 27) /* U+4E00-U+9FFF */
+                                                          /* U+2E80-U+2EFF */
+                                                          /* U+2F00-U+2FDF */
+                                                          /* U+2FF0-U+2FFF */
+                                                          /* U+3400-U+4DB5 */
+
+  /* Private Use Area */
+
+  /* Bit 60   Private Use */
+#define TT_UCR_PRIVATE_USE                     (1L << 28) /* U+E000-U+F8FF */
+
+  /* Compatibility Area and Specials */
+
+  /* Bit 61   CJK Compatibility Ideographs */
+#define TT_UCR_CJK_COMPATIBILITY_IDEOGRAPHS    (1L << 29) /* U+F900-U+FAFF */
+  /* Bit 62   Alphabetic Presentation Forms */
+#define TT_UCR_ALPHABETIC_PRESENTATION_FORMS   (1L << 30) /* U+FB00-U+FB4F */
+  /* Bit 63   Arabic Presentation Forms-A */
+#define TT_UCR_ARABIC_PRESENTATIONS_A          (1L << 31) /* U+FB50-U+FDFF */
+  /* Bit 64   Combining Half Marks */
+#define TT_UCR_COMBINING_HALF_MARKS            (1L <<  0) /* U+FE20-U+FE2F */
+  /* Bit 65   CJK Compatibility Forms */
+#define TT_UCR_CJK_COMPATIBILITY_FORMS         (1L <<  1) /* U+FE30-U+FE4F */
+  /* Bit 66   Small Form Variants */
+#define TT_UCR_SMALL_FORM_VARIANTS             (1L <<  2) /* U+FE50-U+FE6F */
+  /* Bit 67   Arabic Presentation Forms-B */
+#define TT_UCR_ARABIC_PRESENTATIONS_B          (1L <<  3) /* U+FE70-U+FEFE */
+  /* Bit 68   Halfwidth and Fullwidth Forms */
+#define TT_UCR_HALFWIDTH_FULLWIDTH_FORMS       (1L <<  4) /* U+FF00-U+FFEF */
+  /* Bit 69   Specials */
+#define TT_UCR_SPECIALS                        (1L <<  5) /* U+FFF0-U+FFFD */
+  /* Bit 70   Tibetan */
+#define TT_UCR_TIBETAN                         (1L <<  6) /* U+0F00-U+0FFF */
+  /* Bit 71   Syriac */
+#define TT_UCR_SYRIAC                          (1L <<  7) /* U+0700-U+074F */
+  /* Bit 72   Thaana */
+#define TT_UCR_THAANA                          (1L <<  8) /* U+0780-U+07BF */
+  /* Bit 73   Sinhala */
+#define TT_UCR_SINHALA                         (1L <<  9) /* U+0D80-U+0DFF */
+  /* Bit 74   Myanmar */
+#define TT_UCR_MYANMAR                         (1L << 10) /* U+1000-U+109F */
+  /* Bit 75   Ethiopic */
+#define TT_UCR_ETHIOPIC                        (1L << 11) /* U+1200-U+137F */
+  /* Bit 76   Cherokee */
+#define TT_UCR_CHEROKEE                        (1L << 12) /* U+13A0-U+13FF */
+  /* Bit 77   Unified Canadian Aboriginal Syllabics */
+#define TT_UCR_CANADIAN_ABORIGINAL_SYLLABICS   (1L << 13) /* U+1400-U+167F */
+  /* Bit 78   Ogham */
+#define TT_UCR_OGHAM                           (1L << 14) /* U+1680-U+169F */
+  /* Bit 79   Runic */
+#define TT_UCR_RUNIC                           (1L << 15) /* U+16A0-U+16FF */
+  /* Bit 80   Khmer */
+#define TT_UCR_KHMER                           (1L << 16) /* U+1780-U+17FF */
+  /* Bit 81   Mongolian */
+#define TT_UCR_MONGOLIAN                       (1L << 17) /* U+1800-U+18AF */
+  /* Bit 82   Braille Patterns */
+#define TT_UCR_BRAILLE                         (1L << 18) /* U+2800-U+28FF */
+  /* Bit 83   Yi Syllables + */
+  /*          Yi Radicals    */
+#define TT_UCR_YI                              (1L << 19) /* U+A000-U+A48F */
+                                                          /* U+A490-U+A4CF */
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Some compilers have a very limited length of identifiers.             */
+  /*                                                                       */
+#if defined( __TURBOC__ ) && __TURBOC__ < 0x0410 || defined( __PACIFIC__ )
+#define HAVE_LIMIT_ON_IDENTS
+#endif
+
+
+#ifndef HAVE_LIMIT_ON_IDENTS
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* Here some alias #defines in order to be clearer.                      */
+  /*                                                                       */
+  /* These are not always #defined to stay within the 31 character limit   */
+  /* which some compilers have.                                            */
+  /*                                                                       */
+  /* Credits go to Dave Hoo <dhoo@flash.net> for pointing out that modern  */
+  /* Borland compilers (read: from BC++ 3.1 on) can increase this limit.   */
+  /* If you get a warning with such a compiler, use the -i40 switch.       */
+  /*                                                                       */
+#define TT_UCR_ARABIC_PRESENTATION_FORMS_A      \
+         TT_UCR_ARABIC_PRESENTATIONS_A
+#define TT_UCR_ARABIC_PRESENTATION_FORMS_B      \
+         TT_UCR_ARABIC_PRESENTATIONS_B
+
+#define TT_UCR_COMBINING_DIACRITICAL_MARKS      \
+         TT_UCR_COMBINING_DIACRITICS
+#define TT_UCR_COMBINING_DIACRITICAL_MARKS_SYMB \
+         TT_UCR_COMBINING_DIACRITICS_SYMB
+
+
+#endif /* !HAVE_LIMIT_ON_IDENTS */
+
+
+FT_END_HEADER
+
+#endif /* __TTNAMEID_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/tttables.h
@@ -1,0 +1,605 @@
+/***************************************************************************/
+/*                                                                         */
+/*  tttables.h                                                             */
+/*                                                                         */
+/*    Basic SFNT/TrueType tables definitions and interface                 */
+/*    (specification only).                                                */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __TTTABLES_H__
+#define __TTTABLES_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Section>                                                             */
+  /*    truetype_tables                                                    */
+  /*                                                                       */
+  /* <Title>                                                               */
+  /*    TrueType Tables                                                    */
+  /*                                                                       */
+  /* <Abstract>                                                            */
+  /*    TrueType-specific table types and functions.                       */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    This section contains the definition of TrueType-specific tables   */
+  /*    as well as some routines used to access and process them.          */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_Header                                                          */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a TrueType font header table.  All       */
+  /*    fields follow the TrueType specification.                          */
+  /*                                                                       */
+  typedef struct  TT_Header_
+  {
+    FT_Fixed   Table_Version;
+    FT_Fixed   Font_Revision;
+
+    FT_Long    CheckSum_Adjust;
+    FT_Long    Magic_Number;
+
+    FT_UShort  Flags;
+    FT_UShort  Units_Per_EM;
+
+    FT_Long    Created [2];
+    FT_Long    Modified[2];
+
+    FT_Short   xMin;
+    FT_Short   yMin;
+    FT_Short   xMax;
+    FT_Short   yMax;
+
+    FT_UShort  Mac_Style;
+    FT_UShort  Lowest_Rec_PPEM;
+
+    FT_Short   Font_Direction;
+    FT_Short   Index_To_Loc_Format;
+    FT_Short   Glyph_Data_Format;
+
+  } TT_Header;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_HoriHeader                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a TrueType horizontal header, the `hhea' */
+  /*    table, as well as the corresponding horizontal metrics table,      */
+  /*    i.e., the `hmtx' table.                                            */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    Version                :: The table version.                       */
+  /*                                                                       */
+  /*    Ascender               :: The font's ascender, i.e., the distance  */
+  /*                              from the baseline to the top-most of all */
+  /*                              glyph points found in the font.          */
+  /*                                                                       */
+  /*                              This value is invalid in many fonts, as  */
+  /*                              it is usually set by the font designer,  */
+  /*                              and often reflects only a portion of the */
+  /*                              glyphs found in the font (maybe ASCII).  */
+  /*                                                                       */
+  /*                              You should use the `sTypoAscender' field */
+  /*                              of the OS/2 table instead if you want    */
+  /*                              the correct one.                         */
+  /*                                                                       */
+  /*    Descender              :: The font's descender, i.e., the distance */
+  /*                              from the baseline to the bottom-most of  */
+  /*                              all glyph points found in the font.  It  */
+  /*                              is negative.                             */
+  /*                                                                       */
+  /*                              This value is invalid in many fonts, as  */
+  /*                              it is usually set by the font designer,  */
+  /*                              and often reflects only a portion of the */
+  /*                              glyphs found in the font (maybe ASCII).  */
+  /*                                                                       */
+  /*                              You should use the `sTypoDescender'      */
+  /*                              field of the OS/2 table instead if you   */
+  /*                              want the correct one.                    */
+  /*                                                                       */
+  /*    Line_Gap               :: The font's line gap, i.e., the distance  */
+  /*                              to add to the ascender and descender to  */
+  /*                              get the BTB, i.e., the                   */
+  /*                              baseline-to-baseline distance for the    */
+  /*                              font.                                    */
+  /*                                                                       */
+  /*    advance_Width_Max      :: This field is the maximum of all advance */
+  /*                              widths found in the font.  It can be     */
+  /*                              used to compute the maximum width of an  */
+  /*                              arbitrary string of text.                */
+  /*                                                                       */
+  /*    min_Left_Side_Bearing  :: The minimum left side bearing of all     */
+  /*                              glyphs within the font.                  */
+  /*                                                                       */
+  /*    min_Right_Side_Bearing :: The minimum right side bearing of all    */
+  /*                              glyphs within the font.                  */
+  /*                                                                       */
+  /*    xMax_Extent            :: The maximum horizontal extent (i.e., the */
+  /*                              `width' of a glyph's bounding box) for   */
+  /*                              all glyphs in the font.                  */
+  /*                                                                       */
+  /*    caret_Slope_Rise       :: The rise coefficient of the cursor's     */
+  /*                              slope of the cursor (slope=rise/run).    */
+  /*                                                                       */
+  /*    caret_Slope_Run        :: The run coefficient of the cursor's      */
+  /*                              slope.                                   */
+  /*                                                                       */
+  /*    Reserved               :: 10 reserved bytes.                       */
+  /*                                                                       */
+  /*    metric_Data_Format     :: Always 0.                                */
+  /*                                                                       */
+  /*    number_Of_HMetrics     :: Number of HMetrics entries in the `hmtx' */
+  /*                              table -- this value can be smaller than  */
+  /*                              the total number of glyphs in the font.  */
+  /*                                                                       */
+  /*    long_metrics           :: A pointer into the `hmtx' table.         */
+  /*                                                                       */
+  /*    short_metrics          :: A pointer into the `hmtx' table.         */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    IMPORTANT: The TT_HoriHeader and TT_VertHeader structures should   */
+  /*               be identical except for the names of their fields which */
+  /*               are different.                                          */
+  /*                                                                       */
+  /*               This ensures that a single function in the `ttload'     */
+  /*               module is able to read both the horizontal and vertical */
+  /*               headers.                                                */
+  /*                                                                       */
+  typedef struct  TT_HoriHeader_
+  {
+    FT_Fixed   Version;
+    FT_Short   Ascender;
+    FT_Short   Descender;
+    FT_Short   Line_Gap;
+
+    FT_UShort  advance_Width_Max;      /* advance width maximum */
+
+    FT_Short   min_Left_Side_Bearing;  /* minimum left-sb       */
+    FT_Short   min_Right_Side_Bearing; /* minimum right-sb      */
+    FT_Short   xMax_Extent;            /* xmax extents          */
+    FT_Short   caret_Slope_Rise;
+    FT_Short   caret_Slope_Run;
+    FT_Short   caret_Offset;
+
+    FT_Short   Reserved[4];
+
+    FT_Short   metric_Data_Format;
+    FT_UShort  number_Of_HMetrics;
+
+    /* The following fields are not defined by the TrueType specification */
+    /* but they are used to connect the metrics header to the relevant    */
+    /* `HMTX' table.                                                      */
+
+    void*      long_metrics;
+    void*      short_metrics;
+
+  } TT_HoriHeader;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_VertHeader                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a TrueType vertical header, the `vhea'   */
+  /*    table, as well as the corresponding vertical metrics table, i.e.,  */
+  /*    the `vmtx' table.                                                  */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    Version                 :: The table version.                      */
+  /*                                                                       */
+  /*    Ascender                :: The font's ascender, i.e., the distance */
+  /*                               from the baseline to the top-most of    */
+  /*                               all glyph points found in the font.     */
+  /*                                                                       */
+  /*                               This value is invalid in many fonts, as */
+  /*                               it is usually set by the font designer, */
+  /*                               and often reflects only a portion of    */
+  /*                               the glyphs found in the font (maybe     */
+  /*                               ASCII).                                 */
+  /*                                                                       */
+  /*                               You should use the `sTypoAscender'      */
+  /*                               field of the OS/2 table instead if you  */
+  /*                               want the correct one.                   */
+  /*                                                                       */
+  /*    Descender               :: The font's descender, i.e., the         */
+  /*                               distance from the baseline to the       */
+  /*                               bottom-most of all glyph points found   */
+  /*                               in the font.  It is negative.           */
+  /*                                                                       */
+  /*                               This value is invalid in many fonts, as */
+  /*                               it is usually set by the font designer, */
+  /*                               and often reflects only a portion of    */
+  /*                               the glyphs found in the font (maybe     */
+  /*                               ASCII).                                 */
+  /*                                                                       */
+  /*                               You should use the `sTypoDescender'     */
+  /*                               field of the OS/2 table instead if you  */
+  /*                               want the correct one.                   */
+  /*                                                                       */
+  /*    Line_Gap                :: The font's line gap, i.e., the distance */
+  /*                               to add to the ascender and descender to */
+  /*                               get the BTB, i.e., the                  */
+  /*                               baseline-to-baseline distance for the   */
+  /*                               font.                                   */
+  /*                                                                       */
+  /*    advance_Height_Max      :: This field is the maximum of all        */
+  /*                               advance heights found in the font.  It  */
+  /*                               can be used to compute the maximum      */
+  /*                               height of an arbitrary string of text.  */
+  /*                                                                       */
+  /*    min_Top_Side_Bearing    :: The minimum top side bearing of all     */
+  /*                               glyphs within the font.                 */
+  /*                                                                       */
+  /*    min_Bottom_Side_Bearing :: The minimum bottom side bearing of all  */
+  /*                               glyphs within the font.                 */
+  /*                                                                       */
+  /*    yMax_Extent             :: The maximum vertical extent (i.e., the  */
+  /*                               `height' of a glyph's bounding box) for */
+  /*                               all glyphs in the font.                 */
+  /*                                                                       */
+  /*    caret_Slope_Rise        :: The rise coefficient of the cursor's    */
+  /*                               slope of the cursor (slope=rise/run).   */
+  /*                                                                       */
+  /*    caret_Slope_Run         :: The run coefficient of the cursor's     */
+  /*                               slope.                                  */
+  /*                                                                       */
+  /*    caret_Offset            :: The cursor's offset for slanted fonts.  */
+  /*                               This value is `reserved' in vmtx        */
+  /*                               version 1.0.                            */
+  /*                                                                       */
+  /*    Reserved                :: 8 reserved bytes.                       */
+  /*                                                                       */
+  /*    metric_Data_Format      :: Always 0.                               */
+  /*                                                                       */
+  /*    number_Of_HMetrics      :: Number of VMetrics entries in the       */
+  /*                               `vmtx' table -- this value can be       */
+  /*                               smaller than the total number of glyphs */
+  /*                               in the font.                            */
+  /*                                                                       */
+  /*    long_metrics           :: A pointer into the `vmtx' table.         */
+  /*                                                                       */
+  /*    short_metrics          :: A pointer into the `vmtx' table.         */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    IMPORTANT: The TT_HoriHeader and TT_VertHeader structures should   */
+  /*               be identical except for the names of their fields which */
+  /*               are different.                                          */
+  /*                                                                       */
+  /*               This ensures that a single function in the `ttload'     */
+  /*               module is able to read both the horizontal and vertical */
+  /*               headers.                                                */
+  /*                                                                       */
+  typedef struct  TT_VertHeader_
+  {
+    FT_Fixed   Version;
+    FT_Short   Ascender;
+    FT_Short   Descender;
+    FT_Short   Line_Gap;
+
+    FT_UShort  advance_Height_Max;      /* advance height maximum */
+
+    FT_Short   min_Top_Side_Bearing;    /* minimum left-sb or top-sb       */
+    FT_Short   min_Bottom_Side_Bearing; /* minimum right-sb or bottom-sb   */
+    FT_Short   yMax_Extent;             /* xmax or ymax extents            */
+    FT_Short   caret_Slope_Rise;
+    FT_Short   caret_Slope_Run;
+    FT_Short   caret_Offset;
+
+    FT_Short   Reserved[4];
+
+    FT_Short   metric_Data_Format;
+    FT_UShort  number_Of_VMetrics;
+
+    /* The following fields are not defined by the TrueType specification */
+    /* but they're used to connect the metrics header to the relevant     */
+    /* `HMTX' or `VMTX' table.                                            */
+
+    void*      long_metrics;
+    void*      short_metrics;
+
+  } TT_VertHeader;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_OS2                                                             */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a TrueType OS/2 table. This is the long  */
+  /*    table version.  All fields comply to the TrueType specification.   */
+  /*                                                                       */
+  /*    Note that we now support old Mac fonts which do not include an     */
+  /*    OS/2 table.  In this case, the `version' field is always set to    */
+  /*    0xFFFF.                                                            */
+  /*                                                                       */
+  typedef struct  TT_OS2_
+  {
+    FT_UShort  version;                /* 0x0001 - more or 0xFFFF */
+    FT_Short   xAvgCharWidth;
+    FT_UShort  usWeightClass;
+    FT_UShort  usWidthClass;
+    FT_Short   fsType;
+    FT_Short   ySubscriptXSize;
+    FT_Short   ySubscriptYSize;
+    FT_Short   ySubscriptXOffset;
+    FT_Short   ySubscriptYOffset;
+    FT_Short   ySuperscriptXSize;
+    FT_Short   ySuperscriptYSize;
+    FT_Short   ySuperscriptXOffset;
+    FT_Short   ySuperscriptYOffset;
+    FT_Short   yStrikeoutSize;
+    FT_Short   yStrikeoutPosition;
+    FT_Short   sFamilyClass;
+
+    FT_Byte    panose[10];
+
+    FT_ULong   ulUnicodeRange1;        /* Bits 0-31   */
+    FT_ULong   ulUnicodeRange2;        /* Bits 32-63  */
+    FT_ULong   ulUnicodeRange3;        /* Bits 64-95  */
+    FT_ULong   ulUnicodeRange4;        /* Bits 96-127 */
+
+    FT_Char    achVendID[4];
+
+    FT_UShort  fsSelection;
+    FT_UShort  usFirstCharIndex;
+    FT_UShort  usLastCharIndex;
+    FT_Short   sTypoAscender;
+    FT_Short   sTypoDescender;
+    FT_Short   sTypoLineGap;
+    FT_UShort  usWinAscent;
+    FT_UShort  usWinDescent;
+
+    /* only version 1 tables: */
+
+    FT_ULong   ulCodePageRange1;       /* Bits 0-31   */
+    FT_ULong   ulCodePageRange2;       /* Bits 32-63  */
+
+    /* only version 2 tables: */
+
+    FT_Short   sxHeight;
+    FT_Short   sCapHeight;
+    FT_UShort  usDefaultChar;
+    FT_UShort  usBreakChar;
+    FT_UShort  usMaxContext;
+
+  } TT_OS2;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_Postscript                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a TrueType Postscript table.  All fields */
+  /*    comply to the TrueType table.  This structure does not reference   */
+  /*    the Postscript glyph names, which can be nevertheless accessed     */
+  /*    with the `ttpost' module.                                          */
+  /*                                                                       */
+  typedef struct  TT_Postscript_
+  {
+    FT_Fixed  FormatType;
+    FT_Fixed  italicAngle;
+    FT_Short  underlinePosition;
+    FT_Short  underlineThickness;
+    FT_ULong  isFixedPitch;
+    FT_ULong  minMemType42;
+    FT_ULong  maxMemType42;
+    FT_ULong  minMemType1;
+    FT_ULong  maxMemType1;
+
+    /* Glyph names follow in the file, but we don't   */
+    /* load them by default.  See the ttpost.c file.  */
+
+  } TT_Postscript;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_PCLT                                                            */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    A structure used to model a TrueType PCLT table.  All fields       */
+  /*    comply to the TrueType table.                                      */
+  /*                                                                       */
+  typedef struct  TT_PCLT_
+  {
+    FT_Fixed   Version;
+    FT_ULong   FontNumber;
+    FT_UShort  Pitch;
+    FT_UShort  xHeight;
+    FT_UShort  Style;
+    FT_UShort  TypeFamily;
+    FT_UShort  CapHeight;
+    FT_UShort  SymbolSet;
+    FT_Char    TypeFace[16];
+    FT_Char    CharacterComplement[8];
+    FT_Char    FileName[6];
+    FT_Char    StrokeWeight;
+    FT_Char    WidthType;
+    FT_Byte    SerifStyle;
+    FT_Byte    Reserved;
+
+  } TT_PCLT;
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Struct>                                                              */
+  /*    TT_MaxProfile                                                      */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    The maximum profile is a table containing many max values which    */
+  /*    can be used to pre-allocate arrays.  This ensures that no memory   */
+  /*    allocation occurs during a glyph load.                             */
+  /*                                                                       */
+  /* <Fields>                                                              */
+  /*    version               :: The version number.                       */
+  /*                                                                       */
+  /*    numGlyphs             :: The number of glyphs in this TrueType     */
+  /*                             font.                                     */
+  /*                                                                       */
+  /*    maxPoints             :: The maximum number of points in a         */
+  /*                             non-composite TrueType glyph.  See also   */
+  /*                             the structure element                     */
+  /*                             `maxCompositePoints'.                     */
+  /*                                                                       */
+  /*    maxContours           :: The maximum number of contours in a       */
+  /*                             non-composite TrueType glyph.  See also   */
+  /*                             the structure element                     */
+  /*                             `maxCompositeContours'.                   */
+  /*                                                                       */
+  /*    maxCompositePoints    :: The maximum number of points in a         */
+  /*                             composite TrueType glyph.  See also the   */
+  /*                             structure element `maxPoints'.            */
+  /*                                                                       */
+  /*    maxCompositeContours  :: The maximum number of contours in a       */
+  /*                             composite TrueType glyph.  See also the   */
+  /*                             structure element `maxContours'.          */
+  /*                                                                       */
+  /*    maxZones              :: The maximum number of zones used for      */
+  /*                             glyph hinting.                            */
+  /*                                                                       */
+  /*    maxTwilightPoints     :: The maximum number of points in the       */
+  /*                             twilight zone used for glyph hinting.     */
+  /*                                                                       */
+  /*    maxStorage            :: The maximum number of elements in the     */
+  /*                             storage area used for glyph hinting.      */
+  /*                                                                       */
+  /*    maxFunctionDefs       :: The maximum number of function            */
+  /*                             definitions in the TrueType bytecode for  */
+  /*                             this font.                                */
+  /*                                                                       */
+  /*    maxInstructionDefs    :: The maximum number of instruction         */
+  /*                             definitions in the TrueType bytecode for  */
+  /*                             this font.                                */
+  /*                                                                       */
+  /*    maxStackElements      :: The maximum number of stack elements used */
+  /*                             during bytecode interpretation.           */
+  /*                                                                       */
+  /*    maxSizeOfInstructions :: The maximum number of TrueType opcodes    */
+  /*                             used for glyph hinting.                   */
+  /*                                                                       */
+  /*    maxComponentElements  :: An obscure value related to composite     */
+  /*                             glyphs definitions.                       */
+  /*                                                                       */
+  /*    maxComponentDepth     :: An obscure value related to composite     */
+  /*                             glyphs definitions.  Probably the maximum */
+  /*                             number of simple glyphs in a composite.   */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    This structure is only used during font loading.                   */
+  /*                                                                       */
+  typedef struct  TT_MaxProfile_
+  {
+    FT_Fixed   version;
+    FT_UShort  numGlyphs;
+    FT_UShort  maxPoints;
+    FT_UShort  maxContours;
+    FT_UShort  maxCompositePoints;
+    FT_UShort  maxCompositeContours;
+    FT_UShort  maxZones;
+    FT_UShort  maxTwilightPoints;
+    FT_UShort  maxStorage;
+    FT_UShort  maxFunctionDefs;
+    FT_UShort  maxInstructionDefs;
+    FT_UShort  maxStackElements;
+    FT_UShort  maxSizeOfInstructions;
+    FT_UShort  maxComponentElements;
+    FT_UShort  maxComponentDepth;
+
+  } TT_MaxProfile;
+
+
+  /* */
+
+  typedef enum
+  {
+    ft_sfnt_head = 0,
+    ft_sfnt_maxp = 1,
+    ft_sfnt_os2  = 2,
+    ft_sfnt_hhea = 3,
+    ft_sfnt_vhea = 4,
+    ft_sfnt_post = 5,
+    ft_sfnt_pclt = 6,
+
+    sfnt_max   /* don't remove */
+
+  } FT_Sfnt_Tag;
+
+
+  /* internal use only */
+  typedef void*
+  (*FT_Get_Sfnt_Table_Func)( FT_Face      face,
+                             FT_Sfnt_Tag  tag );
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    FT_Get_Sfnt_Table                                                  */
+  /*                                                                       */
+  /* <Description>                                                         */
+  /*    Returns a pointer to a given SFNT table within a face.             */
+  /*                                                                       */
+  /* <Input>                                                               */
+  /*    face :: A handle to the source.                                    */
+  /*                                                                       */
+  /*    tag  :: The index of the SFNT table.                               */
+  /*                                                                       */
+  /* <Return>                                                              */
+  /*    A type-less pointer to the table.  This will be 0 in case of       */
+  /*    error, or if the corresponding table was not found *OR* loaded     */
+  /*    from the file.                                                     */
+  /*                                                                       */
+  /* <Note>                                                                */
+  /*    The table is owned by the face object and disappears with it.      */
+  /*                                                                       */
+  /*    This function is only useful to access SFNT tables that are loaded */
+  /*    by the sfnt/truetype/opentype drivers.  See FT_Sfnt_Tag for a      */
+  /*    list.                                                              */
+  /*                                                                       */
+  FT_EXPORT( void* )
+  FT_Get_Sfnt_Table( FT_Face      face,
+                     FT_Sfnt_Tag  tag );
+
+
+  /* */
+
+
+FT_END_HEADER
+
+#endif /* __TTTABLES_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/freetype/tttags.h
@@ -1,0 +1,74 @@
+/***************************************************************************/
+/*                                                                         */
+/*  tttags.h                                                               */
+/*                                                                         */
+/*    Tags for TrueType tables (specification only).                       */
+/*                                                                         */
+/*  Copyright 1996-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+#ifndef __TTAGS_H__
+#define __TTAGS_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+#define TTAG_cmap  FT_MAKE_TAG( 'c', 'm', 'a', 'p' )
+#define TTAG_cvt   FT_MAKE_TAG( 'c', 'v', 't', ' ' )
+#define TTAG_CFF   FT_MAKE_TAG( 'C', 'F', 'F', ' ' )
+#define TTAG_DSIG  FT_MAKE_TAG( 'D', 'S', 'I', 'G' )
+#define TTAG_bhed  FT_MAKE_TAG( 'b', 'h', 'e', 'd' )
+#define TTAG_bdat  FT_MAKE_TAG( 'b', 'd', 'a', 't' )
+#define TTAG_bloc  FT_MAKE_TAG( 'b', 'l', 'o', 'c' )
+#define TTAG_EBDT  FT_MAKE_TAG( 'E', 'B', 'D', 'T' )
+#define TTAG_EBLC  FT_MAKE_TAG( 'E', 'B', 'L', 'C' )
+#define TTAG_EBSC  FT_MAKE_TAG( 'E', 'B', 'S', 'C' )
+#define TTAG_fpgm  FT_MAKE_TAG( 'f', 'p', 'g', 'm' )
+#define TTAG_fvar  FT_MAKE_TAG( 'f', 'v', 'a', 'r' )
+#define TTAG_gasp  FT_MAKE_TAG( 'g', 'a', 's', 'p' )
+#define TTAG_glyf  FT_MAKE_TAG( 'g', 'l', 'y', 'f' )
+#define TTAG_GSUB  FT_MAKE_TAG( 'G', 'S', 'U', 'B' )
+#define TTAG_hdmx  FT_MAKE_TAG( 'h', 'd', 'm', 'x' )
+#define TTAG_head  FT_MAKE_TAG( 'h', 'e', 'a', 'd' )
+#define TTAG_hhea  FT_MAKE_TAG( 'h', 'h', 'e', 'a' )
+#define TTAG_hmtx  FT_MAKE_TAG( 'h', 'm', 't', 'x' )
+#define TTAG_kern  FT_MAKE_TAG( 'k', 'e', 'r', 'n' )
+#define TTAG_loca  FT_MAKE_TAG( 'l', 'o', 'c', 'a' )
+#define TTAG_LTSH  FT_MAKE_TAG( 'L', 'T', 'S', 'H' )
+#define TTAG_maxp  FT_MAKE_TAG( 'm', 'a', 'x', 'p' )
+#define TTAG_MMSD  FT_MAKE_TAG( 'M', 'M', 'S', 'D' )
+#define TTAG_MMFX  FT_MAKE_TAG( 'M', 'M', 'F', 'X' )
+#define TTAG_name  FT_MAKE_TAG( 'n', 'a', 'm', 'e' )
+#define TTAG_OS2   FT_MAKE_TAG( 'O', 'S', '/', '2' )
+#define TTAG_OTTO  FT_MAKE_TAG( 'O', 'T', 'T', 'O' )
+#define TTAG_PCLT  FT_MAKE_TAG( 'P', 'C', 'L', 'T' )
+#define TTAG_post  FT_MAKE_TAG( 'p', 'o', 's', 't' )
+#define TTAG_prep  FT_MAKE_TAG( 'p', 'r', 'e', 'p' )
+#define TTAG_true  FT_MAKE_TAG( 't', 'r', 'u', 'e' )
+#define TTAG_ttc   FT_MAKE_TAG( 't', 't', 'c', ' ' )
+#define TTAG_ttcf  FT_MAKE_TAG( 't', 't', 'c', 'f' )
+#define TTAG_VDMX  FT_MAKE_TAG( 'V', 'D', 'M', 'X' )
+#define TTAG_vhea  FT_MAKE_TAG( 'v', 'h', 'e', 'a' )
+#define TTAG_vmtx  FT_MAKE_TAG( 'v', 'm', 't', 'x' )
+
+
+FT_END_HEADER
+
+#endif /* __TTAGS_H__ */
+
+
+/* END */
--- /dev/null
+++ b/include/interp.h
@@ -1,0 +1,540 @@
+typedef uchar		BYTE;		/* 8  bits */
+typedef int		WORD;		/* 32 bits */
+typedef unsigned int	UWORD;		/* 32 bits */
+typedef vlong		LONG;		/* 64 bits */
+typedef uvlong		ULONG;		/* 64 bits */
+typedef double		REAL;		/* 64 double IEEE754 */
+typedef short		SHORT;		/* 16 bits */
+typedef float		SREAL;		/* 32 float IEEE754 */
+
+enum ProgState
+{
+	Palt,				/* blocked in alt instruction */
+	Psend,				/* waiting to send */
+	Precv,				/* waiting to recv */
+	Pdebug,				/* debugged */
+	Pready,				/* ready to be scheduled */
+	Prelease,			/* interpreter released */
+	Pexiting,			/* exit because of kill or error */
+	Pbroken,			/* thread crashed */
+};
+
+enum
+{
+	propagator	= 3,		/* gc marking color */
+
+	PRNSIZE	= 1024,
+	BIHASH	= 23,
+	PQUANTA	= 2048,	/* prog time slice */
+
+	/* STRUCTALIGN is the unit to which the compiler aligns structs. */
+	/* It really should be defined somewhere else */
+	STRUCTALIGN = sizeof(int)	/* must be >=2 because of Strings */
+};
+
+enum
+{
+	/* Prog and Progs flags */
+	Ppropagate = 1<<0,	/* propagate exceptions within group */
+	Pnotifyleader = 1<<1,	/* send exceptions to group leader */
+	Prestrict = 1<<2,	/* enforce memory limits */
+	Prestricted = 1<<3,
+	Pkilled = 1<<4,
+	Pprivatemem = 1<<5	/* keep heap and stack private */
+};
+
+typedef struct Alt	Alt;
+typedef struct Channel	Channel;
+typedef struct Progq	Progq;
+typedef struct Import	Import;
+typedef struct ILock	ILock;
+typedef struct Inst	Inst;
+typedef struct Module	Module;
+typedef struct Modlink	Modlink;
+typedef struct Modl	Modl;
+typedef struct Type	Type;
+typedef struct Prog	Prog;
+typedef struct Progs	Progs;
+typedef struct Heap	Heap;
+typedef struct Link	Link;
+typedef struct List	List;
+typedef struct Array	Array;
+typedef struct String	String;
+typedef union  Linkpc	Linkpc;
+typedef struct REG	REG;
+typedef struct Frame	Frame;
+typedef union  Stkext	Stkext;
+typedef struct Atidle	Atidle;
+typedef struct Altc	Altc;
+typedef struct Except Except;
+typedef struct Handler Handler;
+
+struct ILock
+{
+	int	lk;
+	int	pid;
+	void*	ql;
+};
+
+struct Frame
+{
+	Inst*		lr;	/* REGLINK isa.h */
+	uchar*		fp;	/* REGFP */
+	Modlink*	mr;	/* REGMOD */
+	Type*		t;	/* REGTYPE */
+};
+
+union Stkext
+{
+	uchar	stack[1];
+	struct {
+		Type*	TR;
+		uchar*	SP;
+		uchar*	TS;
+		uchar*	EX;
+		union {
+			uchar	fu[1];
+			Frame	fr[1];
+		} tos;
+	} reg;
+};
+
+struct Array
+{
+	WORD	len;
+	Type*	t;
+	Array*	root;
+	uchar*	data;
+};
+
+struct List
+{
+	List*	tail;
+	Type*	t;
+	WORD	data[1];
+};
+
+struct Channel
+{
+	Array*	buf;		/* For buffered channels - must be first */
+	Progq*	send;		/* Queue of progs ready to send */
+	Progq*	recv;		/* Queue of progs ready to receive */
+	void*	aux;		/* Rock for devsrv */
+	void	(*mover)(void);	/* Data mover */
+	union {
+		WORD	w;
+		Type*	t;
+	} mid;
+	int	front;	/* Front of buffered queue */
+	int	size;		/* Number of data items in buffered queue */
+};
+
+struct Progq
+{
+	Prog*	prog;
+	Progq*	next;
+};
+	
+struct String
+{
+	int	len;		/* string length */
+	int	max;		/* maximum length in representation */
+	char*	tmp;
+	union {
+	#define	Sascii	data.ascii
+	#define Srune	data.runes
+		char	ascii[STRUCTALIGN];	/* string.c relies on having extra space (eg, in string2c) */
+		Rune	runes[1];
+	}data;	
+};
+
+union Linkpc
+{
+	void	(*runt)(void*);
+	Inst*	pc;
+};
+
+struct Link
+{
+	int	sig;
+	Type*	frame;
+	Linkpc	u;
+	char	*name;
+};
+
+typedef union	Adr	Adr;
+union Adr
+{
+	WORD	imm;
+	WORD	ind;
+	Inst*	ins;
+	struct {
+		ushort	f;	/* First indirection */	
+		ushort	s;	/* Second indirection */
+	} i;
+};
+
+struct Inst
+{
+	uchar	op;
+	uchar	add;
+	ushort	reg;
+	Adr	s;
+	Adr	d;
+};
+
+struct Altc
+{
+	Channel*	c;
+	void*		ptr;
+};
+
+struct Alt
+{
+	int	nsend;
+	int	nrecv;
+	Altc	ac[1];
+};
+
+struct Type
+{
+	int	ref;
+	void	(*free)(Heap*, int);
+	void	(*mark)(Type*, void*);
+	int	size;
+	int	np;
+	void*	destroy;
+	void*	initialize;
+	uchar	map[STRUCTALIGN];
+};
+
+struct REG
+{
+	Inst*		PC;		/* Program counter */
+	uchar*		MP;		/* Module data */
+	uchar*		FP;		/* Frame pointer */
+	uchar*		SP;		/* Stack pointer */
+	uchar*		TS;		/* Top of allocated stack */
+	uchar*		EX;		/* Extent register */
+	Modlink*	M;		/* Module */
+	int		IC;		/* Instruction count for this quanta */
+	Inst*		xpc;		/* Saved program counter */
+	void*		s;		/* Source */
+	void*		d;		/* Destination */
+	void*		m;		/* Middle */
+	WORD		t;		/* Middle temporary */
+	WORD		st;		/* Source temporary */
+	WORD		dt;		/* Destination temporary */
+};
+
+struct Progs
+{
+	int	id;
+	int	flags;
+	Progs*	parent;
+	Progs*	child;
+	Progs*	sib;
+	Prog*	head;	/* live group leader is at head */
+	Prog*	tail;
+};
+
+struct Prog
+{
+	REG		R;		/* Register set */
+	Prog*		link;		/* Run queue */
+	Channel*		chan;	/* Channel pointer */
+	void*		ptr;		/* Channel data pointer */
+	enum ProgState	state;		/* Scheduler state */
+	char*		kill;		/* Set if prog should error */
+	char*		killstr;	/* kill string buffer when needed */
+	int		pid;		/* unique Prog id */
+	int		quanta;		/* time slice */
+	ulong	ticks;		/* time used */
+	int		flags;		/* error recovery flags */
+	Prog*		prev;
+	Prog*		next;
+	Prog*	pidlink;	/* next in pid hash chain */
+	Progs*	group;	/* process group */
+	Prog*	grpprev;	/* previous group member */
+	Prog*	grpnext;	/* next group member */
+	void*	exval;	/* current exception */
+	char*	exstr;	/* last exception */
+	void		(*addrun)(Prog*);
+	void		(*xec)(Prog*);
+
+	void*		osenv;
+};
+
+struct Module
+{
+	int	ref;		/* Use count */
+	int	compiled;	/* Compiled into native assembler */
+	ulong	ss;		/* Stack size */
+	ulong	rt;		/* Runtime flags */
+	ulong	mtime;		/* Modtime of dis file */
+	Qid		qid;		/* Qid of dis file */
+	ushort	dtype;		/* type of dis file's server*/
+	uint	dev;	/* subtype of dis file's server */
+	int	nprog;		/* number of instructions */
+	Inst*	prog;		/* text segment */
+	uchar*	origmp;		/* unpolluted Module data */
+	int	ntype;		/* Number of type descriptors */
+	Type**	type;		/* Type descriptors */
+	Inst*	entry;		/* Entry PC */
+	Type*	entryt;		/* Entry frame */
+	char*	name;	/* Implements type */
+	char*	path;		/* File module loaded from */
+	Module*	link;		/* Links */
+	Link*	ext;		/* External dynamic links */
+	Import**	ldt;	/* Internal linkage descriptor tables */
+	Handler*	htab;	/* Exception handler table */
+	ulong*	pctab;	/* dis pc to code pc when compiled */
+	void*	dlm;		/* dynamic C module */
+};
+
+struct Modl
+{
+	Linkpc	u;		/* PC of Dynamic link */
+	Type*	frame;		/* Frame type for this entry */
+};
+
+struct Modlink
+{
+	uchar*	MP;		/* Module data for this instance */
+	Module*	m;		/* The real module */
+	int	compiled;	/* Compiled into native assembler */
+	Inst*	prog;		/* text segment */
+	Type**	type;		/* Type descriptors */
+	uchar*	data;		/* for dynamic C modules */
+	int	nlinks;		/* ?apparently required by Java */
+	Modl	links[1];
+};
+
+/* must be a multiple of 8 bytes */
+struct Heap
+{
+	int	color;		/* Allocation color */
+	ulong	ref;
+	Type*	t;
+	ulong	hprof;	/* heap profiling */
+};
+
+struct	Atidle
+{
+	int	(*fn)(void*);
+	void*	arg;
+	Atidle*	link;
+};
+
+struct Import
+{
+	int	sig;
+	char*	name;
+};
+
+struct Except
+{
+	char*	s;
+	ulong	pc;
+};
+
+struct Handler
+{
+	ulong	pc1;
+	ulong	pc2;
+	ulong	eoff;
+	ulong	ne;
+	Type*	t;
+	Except*	etab;
+};
+
+#define H2D(t, x)	((t)(((uchar*)(x))+sizeof(Heap)))
+#define D2H(x)		((Heap*)(((uchar*)(x))-sizeof(Heap)))
+#define H		((void*)(-1))
+#define SEXTYPE(f)	((Stkext*)((uchar*)(f)-OA(Stkext, reg.tos.fu)))
+#define Setmark(h)	if((h)->color!=mutator) { (h)->color = propagator; nprop=1; }
+#define gclock()	gchalt++
+#define gcunlock()	gchalt--
+#define gcruns()	(gchalt == 0)
+
+extern	int	bflag;
+extern	int	cflag;
+extern	int	nproc;
+extern	Type	Tarray;
+extern	Type	Tstring;
+extern	Type	Tchannel;
+extern	Type	Tlist;
+extern	Type	Tmodlink;
+extern	Type*	TImage;
+extern	Type	Tptr;
+extern	Type	Tbyte;
+extern	Type Tword;
+extern	Type Tlong;
+extern	Type Treal;
+extern	REG	R;
+extern	String	snil;
+extern	void	(*optab[256])(void);
+extern	void	(*comvec)(void);
+extern	void	(*dec[])(void);
+extern	Module*	modules;
+extern	int	mutator;
+extern	int	nprop;
+extern	int	gchalt;
+extern	int	gccolor;
+extern	int	minvalid;
+
+extern	int		Dconv(Fmt*);
+extern	void		acquire(void);
+extern	void		addrun(Prog*);
+extern	void		altdone(Alt*, Prog*, Channel*, int);
+extern	void		altgone(Prog*);
+extern	Array*		allocimgarray(Heap*, Heap*);
+extern	Module*	builtinmod(char*, void*, int);
+extern	void		cblock(Prog*);
+extern	void*		checktype(void*, Type*, char*, int);
+extern	void		cmovw(void*, void*);
+extern	Channel*	cnewc(Type*, void (*)(void), int);
+extern	int		compile(Module*, int, Modlink*);
+extern	void		cqadd(Progq**, Prog*);
+extern	void		cqdel(Progq**);
+extern	void		cqdelp(Progq**, Prog*);
+extern	void		crecv(Channel*, void*);
+extern	void		csend(Channel*, void*);
+extern	int		csendalt(Channel*, void*, Type *, int);
+extern	Prog*		currun(void);
+extern	void		dbgexit(Prog*, int, char*);
+extern	void		dbgxec(Prog*);
+extern	void		delprog(Prog*, char*);
+extern	Prog*		delrun(int);
+extern	void		delrunq(Prog*);
+extern	Prog*		delruntail(int);
+extern	void		destroy(void*);
+extern	void		destroyimage(ulong);
+extern	void		destroylinks(Module*);
+extern	void		destroystack(REG*);
+extern	void		drawmodinit(void);
+extern	Type*		dtype(void (*)(Heap*, int), int, uchar*, int);
+extern	Module*		dupmod(Module*);
+extern	int		dynldable(int);
+extern	void		iqlock(ILock*);
+extern	void		iqunlock(ILock*);
+extern	void		loadermodinit(void);
+extern	void		error(char*);
+extern	void		errorf(char*, ...);
+extern	void		extend(void);
+extern	void		freedyncode(Module*);
+extern	void		freedyndata(Modlink*);
+extern	void		freemod(Module*);
+extern	void		freeheap(Heap*, int);
+extern	void		freeptrs(void*, Type*);
+extern	void		freestring(Heap*, int);
+extern	void		freetype(Type*);
+extern	void		freetypemodinit(void);
+extern	long	getdbreg();
+extern	int		gfltconv(Fmt*);
+extern	void		go(Module*);
+extern	int		handler(char*);
+extern	Heap*	heap(Type*);
+extern	Heap*	heaparray(Type*, int);
+extern	void		(*heapmonitor)(int, void*, ulong);
+extern	int		heapref(void*);
+extern	Heap*		heapz(Type*);
+extern	int		hmsize(void*);
+extern	void		incmem(void*, Type*);
+extern	void		initarray(Type*, Array*);
+extern	void		initmem(Type*, void*);
+extern	void		irestore(Prog*);
+extern	Prog*		isave(void);
+extern	void		keyringmodinit(void);
+extern	void		killcomm(Progq **p);
+extern	int		killprog(Prog*, char*);
+extern	int		killgrp(Prog*, char*);
+extern	Modlink*	linkmod(Module*, Import*, int);
+extern	Modlink*	mklinkmod(Module*, int);
+extern	Module*		load(char*);
+extern	Module*		lookmod(char*);
+extern	long	magic(void);
+extern	void		markarray(Type*, void*);
+extern	void		markchan(Type*, void*);
+extern	void		markheap(Type*, void*);
+extern	void		marklist(Type*, void*);
+extern	void		markmodl(Type*, void*);
+extern	void		mathmodinit(void);
+extern	Array*		mem2array(void*, int);
+extern	void		mlink(Module*, Link*, uchar*, int, int, Type*);
+extern	void		modinit(void);
+extern	WORD		modstatus(REG*, char*, int);
+extern	void		movp(void);
+extern	void		movtmp(void);
+extern	void		movtmpsafe(void);
+extern	int			mustbesigned(char*, uchar*, ulong, Dir*);
+extern	Module*		newmod(char*);
+extern	Module*		newdyncode(int, char*, Dir*);
+extern	void		newdyndata(Modlink*);
+extern	void	newgrp(Prog*);
+extern	void		newmp(void*, void*, Type*);
+extern	Prog*		newprog(Prog*, Modlink*);
+extern	void		newstack(Prog*);
+extern	Heap*		nheap(int);
+extern	void		noptrs(Type*, void*);
+extern	int		nprog(void);
+extern	void		opinit(void);
+extern	Module*		parsemod(char*, uchar*, ulong, Dir*);
+extern	Module*		parsedmod(char*, int, ulong, Qid);
+extern	void		prefabmodinit(void);
+extern	Prog*		progn(int);
+extern	Prog*		progpid(int);
+extern	void		ptradd(Heap*);
+extern	void		ptrdel(Heap*);
+extern	void		pushrun(Prog*);
+extern	Module*		readmod(char*, Module*, int);
+extern	void		irecv(void);
+extern	void		release(void);
+extern	void		releasex(void);
+extern	void		retnstr(char*, int, String**);
+extern	void		retstr(char*, String**);
+extern	void		rungc(Prog*);
+extern	void		runtime(Module*, Link*, char*, int, void(*)(void*), Type*);
+extern	void		safemem(void*, Type*, void (*)(void*));
+extern	int		segflush(void *, ulong);
+extern	void		isend(void);
+extern	void	setdbreg(uchar*);
+extern	uchar*	setdbloc(uchar*);
+extern	void		seterror(char*, ...);
+extern	void		sethints(String*, int);
+extern	String*		splitc(String**, int);
+extern	uchar*		stack(Frame*);
+extern	int		stringblen(String*);
+extern	int		stringcmp(String*, String*);
+extern	String*		stringdup(String*);
+extern	String*		stringheap(int, int, int, int);
+extern	char*		syserr(char*, char*, Prog*);
+extern	void		sysinit(void);
+extern	void		sysmodinit(void);
+extern	void		tellsomeone(Prog*, char*);
+extern	void		tkmodinit(void);
+extern	void		unextend(Frame*);
+extern	void		unframe(void);
+extern	void		unload(Module*);
+extern	int		verifysigner(uchar*, int, uchar*, ulong);
+extern	void		xec(Prog*);
+extern	void		xecalt(int);
+extern	int		xprint(Prog*, void*, void*, String*, char*, int);
+extern	int		bigxprint(Prog*, void*, void*, String*, char**, int);
+extern	void		iyield(void);
+extern	String*		newrunes(int);
+extern	String*		newstring(int);
+extern	int		runeslen(Rune*, int);
+extern	String*		c2string(char*, int);
+extern	char*		string2c(String*);
+extern	List*		cons(ulong, List**);
+extern	String*		slicer(ulong, ulong, String*);
+extern	String*		addstring(String*, String*, int);
+extern	int		brpatch(Inst*, Module*);
+extern	void		readimagemodinit(void);
+
+#define	O(t,e)		((long)(&((t*)0)->e))
+#define	OA(t,e)		((long)(((t*)0)->e))
+
+#pragma	varargck	type	"D"	Inst*
+#pragma varargck argpos errorf 1
--- /dev/null
+++ b/include/isa.h
@@ -1,0 +1,249 @@
+/*
+ * VM instruction set
+ */
+enum
+{
+	INOP,
+	IALT,
+	INBALT,
+	IGOTO,
+	ICALL,
+	IFRAME,
+	ISPAWN,
+	IRUNT,
+	ILOAD,
+	IMCALL,
+	IMSPAWN,
+	IMFRAME,
+	IRET,
+	IJMP,
+	ICASE,
+	IEXIT,
+	INEW,
+	INEWA,
+	INEWCB,
+	INEWCW,
+	INEWCF,
+	INEWCP,
+	INEWCM,
+	INEWCMP,
+	ISEND,
+	IRECV,
+	ICONSB,
+	ICONSW,
+	ICONSP,
+	ICONSF,
+	ICONSM,
+	ICONSMP,
+	IHEADB,
+	IHEADW,
+	IHEADP,
+	IHEADF,
+	IHEADM,
+	IHEADMP,
+	ITAIL,
+	ILEA,
+	IINDX,
+	IMOVP,
+	IMOVM,
+	IMOVMP,
+	IMOVB,
+	IMOVW,
+	IMOVF,
+	ICVTBW,
+	ICVTWB,
+	ICVTFW,
+	ICVTWF,
+	ICVTCA,
+	ICVTAC,
+	ICVTWC,
+	ICVTCW,
+	ICVTFC,
+	ICVTCF,
+	IADDB,
+	IADDW,
+	IADDF,
+	ISUBB,
+	ISUBW,
+	ISUBF,
+	IMULB,
+	IMULW,
+	IMULF,
+	IDIVB,
+	IDIVW,
+	IDIVF,
+	IMODW,
+	IMODB,
+	IANDB,
+	IANDW,
+	IORB,
+	IORW,
+	IXORB,
+	IXORW,
+	ISHLB,
+	ISHLW,
+	ISHRB,
+	ISHRW,
+	IINSC,
+	IINDC,
+	IADDC,
+	ILENC,
+	ILENA,
+	ILENL,
+	IBEQB,
+	IBNEB,
+	IBLTB,
+	IBLEB,
+	IBGTB,
+	IBGEB,
+	IBEQW,
+	IBNEW,
+	IBLTW,
+	IBLEW,
+	IBGTW,
+	IBGEW,
+	IBEQF,
+	IBNEF,
+	IBLTF,
+	IBLEF,
+	IBGTF,
+	IBGEF,
+	IBEQC,
+	IBNEC,
+	IBLTC,
+	IBLEC,
+	IBGTC,
+	IBGEC,
+	ISLICEA,
+	ISLICELA,
+	ISLICEC,
+	IINDW,
+	IINDF,
+	IINDB,
+	INEGF,
+	IMOVL,
+	IADDL,
+	ISUBL,
+	IDIVL,
+	IMODL,
+	IMULL,
+	IANDL,
+	IORL,
+	IXORL,
+	ISHLL,
+	ISHRL,
+	IBNEL,
+	IBLTL,
+	IBLEL,
+	IBGTL,
+	IBGEL,
+	IBEQL,
+	ICVTLF,
+	ICVTFL,
+	ICVTLW,
+	ICVTWL,
+	ICVTLC,
+	ICVTCL,
+	IHEADL,
+	ICONSL,
+	INEWCL,
+	ICASEC,
+	IINDL,
+	IMOVPC,
+	ITCMP,
+	IMNEWZ,
+	ICVTRF,
+	ICVTFR,
+	ICVTWS,
+	ICVTSW,
+	ILSRW,
+	ILSRL,
+	IECLR,
+	INEWZ,
+	INEWAZ,
+	IRAISE,
+	ICASEL,
+	IMULX,
+	IDIVX,
+	ICVTXX,
+	IMULX0,
+	IDIVX0,
+	ICVTXX0,
+	IMULX1,
+	IDIVX1,
+	ICVTXX1,
+	ICVTFX,
+	ICVTXF,
+	IEXPW,
+	IEXPL,
+	IEXPF,
+	ISELF,
+	/* Fix MAXDIS if you add opcodes */
+};
+
+enum
+{
+	MAXDIS	= ISELF+1,
+
+	XMAGIC	= 819248,	/* Normal magic */
+	SMAGIC	= 923426,	/* Signed module */
+
+	AMP	= 0x00,		/* Src/Dst op addressing */
+	AFP	= 0x01,
+	AIMM	= 0x02,
+	AXXX	= 0x03,
+	AIND	= 0x04,
+	AMASK	= 0x07,
+	AOFF	= 0x08,
+	AVAL	= 0x10,
+
+	ARM	= 0xC0,		/* Middle op addressing */
+	AXNON	= 0x00,
+	AXIMM	= 0x40,
+	AXINF	= 0x80,
+	AXINM	= 0xC0,
+
+	DEFZ	= 0,
+	DEFB	= 1,		/* Byte */
+	DEFW	= 2,		/* Word */
+	DEFS	= 3,		/* Utf-string */
+	DEFF	= 4,		/* Real value */
+	DEFA	= 5,		/* Array */
+	DIND	= 6,		/* Set index */
+	DAPOP	= 7,		/* Restore address register */
+	DEFL	= 8,		/* BIG */
+	DEFSS = 9,	/* String share - not used yet */
+
+	DADEPTH = 4,		/* Array address stack size */
+
+	REGLINK	= 0,
+	REGFRAME= 1,
+	REGMOD	= 2,
+	REGTYP	= 3,
+	REGRET	= 4,
+	NREG	= 5,
+
+	IBY2WD	= 4,
+	IBY2FT	= 8,
+	IBY2LG	= 8,
+
+	MUSTCOMPILE	= (1<<0),
+	DONTCOMPILE	= (1<<1),
+	SHAREMP		= (1<<2),
+	DYNMOD		= (1<<3),
+	HASLDT0	= (1<<4),
+	HASEXCEPT	= (1<<5),
+	HASLDT	= (1<<6),
+};
+
+#define DTYPE(x)	(x>>4)
+#define DBYTE(x, l)	((x<<4)|l)
+#define DMAX		(1<<4)
+#define DLEN(x)		(x& (DMAX-1))
+
+#define SRC(x)		((x)<<3)
+#define DST(x)		((x)<<0)
+#define USRC(x)		(((x)>>3)&AMASK)
+#define UDST(x)		((x)&AMASK)
+#define UXSRC(x)	((x)&(AMASK<<3))
+#define UXDST(x)	((x)&(AMASK<<0))
--- /dev/null
+++ b/include/kern.h
@@ -1,0 +1,601 @@
+typedef unsigned long size_t;
+
+#define	nelem(x)	(sizeof(x)/sizeof((x)[0]))
+#define	offsetof(s, m)	(ulong)(&(((s*)0)->m))
+#define	assert(x)	if(x){}else _assert("x")
+
+/*
+ * mem routines
+ */
+extern	void*	memccpy(void*, void*, int, ulong);
+extern	void*	memset(void*, int, ulong);
+extern	int	memcmp(void*, void*, ulong);
+extern	void*	memcpy(void*, void*, ulong);
+extern	void*	memmove(void*, void*, ulong);
+extern	void*	memchr(void*, int, ulong);
+
+/*
+ * string routines
+ */
+extern	char*	strcat(char*, char*);
+extern	char*	strchr(char*, int);
+extern	int	strcmp(char*, char*);
+extern	char*	strcpy(char*, char*);
+extern	char*	strecpy(char*, char*, char*);
+extern	char*	strdup(char*);
+extern	char*	strncat(char*, char*, long);
+extern	char*	strncpy(char*, char*, long);
+extern	int	strncmp(char*, char*, long);
+extern	char*	strpbrk(char*, char*);
+extern	char*	strrchr(char*, int);
+extern	char*	strtok(char*, char*);
+extern	long	strlen(char*);
+extern	long	strspn(char*, char*);
+extern	long	strcspn(char*, char*);
+extern	char*	strstr(char*, char*);
+extern	int	cistrncmp(char*, char*, int);
+extern	int	cistrcmp(char*, char*);
+extern	char*	cistrstr(char*, char*);
+extern	int	tokenize(char*, char**, int);
+
+enum
+{
+	UTFmax		= 4,		/* maximum bytes per rune */
+	Runesync	= 0x80,		/* cannot represent part of a UTF sequence (<) */
+	Runeself	= 0x80,		/* rune and UTF sequences are the same (<) */
+	Runeerror	= 0xFFFD,	/* decoding error in UTF */
+	Runemax		= 0x10FFFF,	/* 21-bit rune */
+	Runemask	= 0x1FFFFF,	/* bits used by runes (see grep) */
+};
+
+/*
+ * rune routines
+ */
+extern	int	runetochar(char*, Rune*);
+extern	int	chartorune(Rune*, char*);
+extern	int	runelen(long);
+extern	int	runenlen(Rune*, int);
+extern	int	fullrune(char*, int);
+extern	int	utflen(char*);
+extern	int	utfnlen(char*, long);
+extern	char*	utfrune(char*, long);
+extern	char*	utfrrune(char*, long);
+extern	char*	utfutf(char*, char*);
+extern	char*	utfecpy(char*, char*, char*);
+
+extern	Rune*	runestrcat(Rune*, Rune*);
+extern	Rune*	runestrchr(Rune*, Rune);
+extern	int	runestrcmp(Rune*, Rune*);
+extern	Rune*	runestrcpy(Rune*, Rune*);
+extern	Rune*	runestrncpy(Rune*, Rune*, long);
+extern	Rune*	runestrecpy(Rune*, Rune*, Rune*);
+extern	Rune*	runestrdup(Rune*);
+extern	Rune*	runestrncat(Rune*, Rune*, long);
+extern	int	runestrncmp(Rune*, Rune*, long);
+extern	Rune*	runestrrchr(Rune*, Rune);
+extern	long	runestrlen(Rune*);
+extern	Rune*	runestrstr(Rune*, Rune*);
+
+extern	Rune	tolowerrune(Rune);
+extern	Rune	totitlerune(Rune);
+extern	Rune	toupperrune(Rune);
+extern	int	isalpharune(Rune);
+extern	int	islowerrune(Rune);
+extern	int	isspacerune(Rune);
+extern	int	istitlerune(Rune);
+extern	int	isupperrune(Rune);
+
+/*
+ * malloc
+ */
+extern	void*	malloc(ulong);
+extern	void*	mallocz(ulong, int);
+extern	void	free(void*);
+extern	ulong	msize(void*);
+extern	void*	calloc(ulong, ulong);
+extern	void*	realloc(void*, ulong);
+extern	void		setmalloctag(void*, ulong);
+extern	void		setrealloctag(void*, ulong);
+extern	ulong	getmalloctag(void*);
+extern	ulong	getrealloctag(void*);
+extern	void*	malloctopoolblock(void*);
+
+/*
+ * print routines
+ */
+typedef struct Fmt	Fmt;
+struct Fmt{
+	uchar	runes;			/* output buffer is runes or chars? */
+	void	*start;			/* of buffer */
+	void	*to;			/* current place in the buffer */
+	void	*stop;			/* end of the buffer; overwritten if flush fails */
+	int	(*flush)(Fmt *);	/* called when to == stop */
+	void	*farg;			/* to make flush a closure */
+	int	nfmt;			/* num chars formatted so far */
+	va_list	args;			/* args passed to dofmt */
+	int	r;			/* % format Rune */
+	int	width;
+	int	prec;
+	ulong	flags;
+};
+
+enum{
+	FmtWidth	= 1,
+	FmtLeft		= FmtWidth << 1,
+	FmtPrec		= FmtLeft << 1,
+	FmtSharp	= FmtPrec << 1,
+	FmtSpace	= FmtSharp << 1,
+	FmtSign		= FmtSpace << 1,
+	FmtZero		= FmtSign << 1,
+	FmtUnsigned	= FmtZero << 1,
+	FmtShort	= FmtUnsigned << 1,
+	FmtLong		= FmtShort << 1,
+	FmtVLong	= FmtLong << 1,
+	FmtComma	= FmtVLong << 1,
+	FmtByte	= FmtComma << 1,
+
+	FmtFlag		= FmtByte << 1
+};
+
+extern	int	print(char*, ...);
+extern	char*	seprint(char*, char*, char*, ...);
+extern	char*	vseprint(char*, char*, char*, va_list);
+extern	int	snprint(char*, int, char*, ...);
+extern	int	vsnprint(char*, int, char*, va_list);
+extern	char*	smprint(char*, ...);
+extern	char*	vsmprint(char*, va_list);
+extern	int	sprint(char*, char*, ...);
+extern	int	fprint(int, char*, ...);
+extern	int	vfprint(int, char*, va_list);
+
+extern	int	runesprint(Rune*, char*, ...);
+extern	int	runesnprint(Rune*, int, char*, ...);
+extern	int	runevsnprint(Rune*, int, char*, va_list);
+extern	Rune*	runeseprint(Rune*, Rune*, char*, ...);
+extern	Rune*	runevseprint(Rune*, Rune*, char*, va_list);
+extern	Rune*	runesmprint(char*, ...);
+extern	Rune*	runevsmprint(char*, va_list);
+
+extern	int	fmtfdinit(Fmt*, int, char*, int);
+extern	int	fmtfdflush(Fmt*);
+extern	int	fmtstrinit(Fmt*);
+extern	char*	fmtstrflush(Fmt*);
+extern	int	runefmtstrinit(Fmt*);
+extern	Rune*	runefmtstrflush(Fmt*);
+
+#pragma	varargck	argpos	fmtprint	2
+#pragma	varargck	argpos	fprint	2
+#pragma	varargck	argpos	print	1
+#pragma	varargck	argpos	runeseprint	3
+#pragma	varargck	argpos	runesmprint	1
+#pragma	varargck	argpos	runesnprint	3
+#pragma	varargck	argpos	runesprint	2
+#pragma	varargck	argpos	seprint	3
+#pragma	varargck	argpos	smprint	1
+#pragma	varargck	argpos	snprint	3
+#pragma	varargck	argpos	sprint	2
+#pragma	varargck	argpos	vseprint	3
+#pragma	varargck	argpos	vsnprint	3
+
+#pragma	varargck	type	"lld"	vlong
+#pragma	varargck	type	"llx"	vlong
+#pragma	varargck	type	"lld"	uvlong
+#pragma	varargck	type	"llx"	uvlong
+#pragma	varargck	type	"ld"	long
+#pragma	varargck	type	"lx"	long
+#pragma	varargck	type	"ld"	ulong
+#pragma	varargck	type	"lx"	ulong
+#pragma	varargck	type	"d"	int
+#pragma	varargck	type	"x"	int
+#pragma	varargck	type	"c"	int
+#pragma	varargck	type	"C"	int
+#pragma	varargck	type	"d"	uint
+#pragma	varargck	type	"x"	uint
+#pragma	varargck	type	"c"	uint
+#pragma	varargck	type	"C"	uint
+#pragma	varargck	type	"f"	double
+#pragma	varargck	type	"e"	double
+#pragma	varargck	type	"g"	double
+#pragma	varargck	type	"s"	char*
+#pragma	varargck	type	"q"	char*
+#pragma	varargck	type	"S"	Rune*
+#pragma	varargck	type	"Q"	Rune*
+#pragma	varargck	type	"r"	void
+#pragma	varargck	type	"%"	void
+#pragma	varargck	type	"n"	int*
+#pragma	varargck	type	"p"	void*
+#pragma	varargck	type	"p"	uintptr
+#pragma	varargck	flag	','
+#pragma varargck	type	"<" void*
+#pragma varargck	type	"[" void*
+#pragma varargck	type	"H" void*
+
+extern	int	fmtinstall(int, int (*)(Fmt*));
+extern	int	dofmt(Fmt*, char*);
+extern	int	dorfmt(Fmt*, Rune*);
+extern	int	fmtprint(Fmt*, char*, ...);
+extern	int	fmtvprint(Fmt*, char*, va_list);
+extern	int	fmtrune(Fmt*, int);
+extern	int	fmtstrcpy(Fmt*, char*);
+extern	int	fmtrunestrcpy(Fmt*, Rune*);
+/*
+ * error string for %r
+ * supplied on per os basis, not part of fmt library
+ */
+extern	int	errfmt(Fmt *f);
+
+/*
+ * quoted strings
+ */
+extern	char	*unquotestrdup(char*);
+extern	Rune	*unquoterunestrdup(Rune*);
+extern	char	*quotestrdup(char*);
+extern	Rune	*quoterunestrdup(Rune*);
+extern	int	quotestrfmt(Fmt*);
+extern	int	quoterunestrfmt(Fmt*);
+extern	void	quotefmtinstall(void);
+extern	int	(*doquote)(int);
+
+/*
+ * random number
+ */
+extern	void	srand(long);
+extern	int	rand(void);
+extern	int	nrand(int);
+extern	long	lrand(void);
+extern	long	lnrand(long);
+extern	double	frand(void);
+extern	ulong	truerand(void);
+extern	ulong	ntruerand(ulong);
+
+/*
+ * math
+ */
+extern	ulong	getfcr(void);
+extern	void	setfsr(ulong);
+extern	ulong	getfsr(void);
+extern	void	setfcr(ulong);
+extern	double	NaN(void);
+extern	double	Inf(int);
+extern	int	isNaN(double);
+extern	int	isInf(double, int);
+
+extern	double	pow(double, double);
+extern	double	atan2(double, double);
+extern	double	fabs(double);
+extern	double	atan(double);
+extern	double	log(double);
+extern	double	log10(double);
+extern	double	exp(double);
+extern	double	floor(double);
+extern	double	ceil(double);
+extern	double	hypot(double, double);
+extern	double	sin(double);
+extern	double	cos(double);
+extern	double	tan(double);
+extern	double	asin(double);
+extern	double	acos(double);
+extern	double	sinh(double);
+extern	double	cosh(double);
+extern	double	tanh(double);
+extern	double	sqrt(double);
+extern	double	fmod(double, double);
+
+#define	HUGE	3.4028234e38
+#define	PIO2	1.570796326794896619231e0
+#define	PI	(PIO2+PIO2)
+
+/*
+ * Time-of-day
+ */
+
+typedef
+struct Tm
+{
+	int	sec;
+	int	min;
+	int	hour;
+	int	mday;
+	int	mon;
+	int	year;
+	int	wday;
+	int	yday;
+	char	zone[4];
+	int	tzoff;
+} Tm;
+
+extern	Tm*	gmtime(long);
+extern	Tm*	localtime(long);
+extern	char*	asctime(Tm*);
+extern	char*	ctime(long);
+extern	double	cputime(void);
+extern	long	times(long*);
+extern	long	tm2sec(Tm*);
+extern	vlong	nsec(void);
+
+/*
+ * one-of-a-kind
+ */
+enum
+{
+	PNPROC		= 1,
+	PNGROUP		= 2,
+};
+extern	vlong	nsec(void);
+
+extern	void	_assert(char*);
+extern	int	abs(int);
+extern	int	atexit(void(*)(void));
+extern	void	atexitdont(void(*)(void));
+extern	int	atnotify(int(*)(void*, char*), int);
+extern	double	atof(char*);
+extern	int	atoi(char*);
+extern	long	atol(char*);
+extern	double	charstod(int(*)(void*), void*);
+extern	char*	cleanname(char*);
+extern	int	decrypt(void*, void*, int);
+extern	int	encrypt(void*, void*, int);
+extern	int	dec64(uchar*, int, char*, int);
+extern	int	enc64(char*, int, uchar*, int);
+extern	int	dec32(uchar*, int, char*, int);
+extern	int	enc32(char*, int, uchar*, int);
+extern	int	dec16(uchar*, int, char*, int);
+extern	int	enc16(char*, int, uchar*, int);
+extern	int	encodefmt(Fmt*);
+extern	void	exits(char*);
+extern	double	frexp(double, int*);
+extern	uintptr	getcallerpc(void*);
+extern	char*	getenv(char*);
+extern	int	getfields(char*, char**, int, int, char*);
+extern	char*	getuser(void);
+extern	char*	getwd(char*, int);
+extern	long	labs(long);
+extern	double	ldexp(double, int);
+/*extern	void	longjmp(jmp_buf, int);*/
+extern	char*	mktemp(char*);
+extern	double	modf(double, double*);
+extern	int	netcrypt(void*, void*);
+/*extern	void	notejmp(void*, jmp_buf, int);*/
+extern	void	perror(char*);
+extern  int	postnote(int, int, char *);
+extern	double	pow10(int);
+extern	double	ipow10(int);
+extern	int	putenv(char*, char*);
+extern	void	qsort(void*, long, long, int (*)(void*, void*));
+/*extern	int	setjmp(jmp_buf);*/
+extern	double	strtod(char*, char**);
+extern	long	strtol(char*, char**, int);
+extern	ulong	strtoul(char*, char**, int);
+extern	vlong	strtoll(char*, char**, int);
+extern	uvlong	strtoull(char*, char**, int);
+extern	void	sysfatal(char*, ...);
+#pragma	varargck	argpos	sysfatal	1
+extern	void	syslog(int, char*, char*, ...);
+#pragma	varargck	argpos	syslog	3
+extern	int	_tas(int*);
+extern	long	time(long*);
+extern	int	tolower(int);
+extern	int	toupper(int);
+
+/*
+ *  network dialing
+ */
+#define NETPATHLEN 40
+extern	int	accept(int, char*);
+extern	int	announce(char*, char*);
+extern	int	dial(char*, char*, char*, int*);
+extern	void	setnetmtpt(char*, int, char*);
+extern	int	hangup(int);
+extern	int	listen(char*, char*);
+extern	char*	netmkaddr(char*, char*, char*);
+extern	int	reject(int, char*, char*);
+
+/*
+ * system calls
+ *
+ */
+#define	STATMAX	65535U	/* max length of machine-independent stat structure */
+#define	DIRMAX	(sizeof(Dir)+STATMAX)	/* max length of Dir structure */
+#define	ERRMAX	128	/* max length of error string */
+
+#define	MORDER	0x0003	/* mask for bits defining order of mounting */
+#define	MREPL	0x0000	/* mount replaces object */
+#define	MBEFORE	0x0001	/* mount goes before others in union directory */
+#define	MAFTER	0x0002	/* mount goes after others in union directory */
+#define	MCREATE	0x0004	/* permit creation in mounted directory */
+#define	MCACHE	0x0010	/* cache some data */
+#define	MMASK	0x0017	/* all bits on */
+
+#define	OREAD	0	/* open for read */
+#define	OWRITE	1	/* write */
+#define	ORDWR	2	/* read and write */
+#define	OEXEC	3	/* execute, == read but check execute permission */
+#define	OTRUNC	16	/* or'ed in (except for exec), truncate file first */
+#define	OCEXEC	32	/* or'ed in, close on exec */
+#define	ORCLOSE	64	/* or'ed in, remove on close */
+#define	OEXCL	0x1000	/* or'ed in, exclusive use (create only) */
+
+#define	AEXIST	0	/* accessible: exists */
+#define	AEXEC	1	/* execute access */
+#define	AWRITE	2	/* write access */
+#define	AREAD	4	/* read access */
+
+/* Segattch */
+#define	SG_RONLY	0040	/* read only */
+#define	SG_CEXEC	0100	/* detach on exec */
+
+#define	NCONT	0	/* continue after note */
+#define	NDFLT	1	/* terminate after note */
+#define	NSAVE	2	/* clear note but hold state */
+#define	NRSTR	3	/* restore saved state */
+
+/* rfork */
+enum
+{
+	RFNAMEG		= (1<<0),
+	RFENVG		= (1<<1),
+	RFFDG		= (1<<2),
+	RFNOTEG		= (1<<3),
+	RFPROC		= (1<<4),
+	RFMEM		= (1<<5),
+	RFNOWAIT	= (1<<6),
+	RFCNAMEG	= (1<<10),
+	RFCENVG		= (1<<11),
+	RFCFDG		= (1<<12),
+	RFREND		= (1<<13),
+	RFNOMNT		= (1<<14)
+};
+
+/* bits in Qid.type */
+#define QTDIR		0x80		/* type bit for directories */
+#define QTAPPEND	0x40		/* type bit for append only files */
+#define QTEXCL		0x20		/* type bit for exclusive use files */
+#define QTMOUNT		0x10		/* type bit for mounted channel */
+#define QTAUTH		0x08		/* type bit for authentication file */
+#define QTFILE		0x00		/* plain file */
+
+/* bits in Dir.mode */
+#define DMDIR		0x80000000	/* mode bit for directories */
+#define DMAPPEND	0x40000000	/* mode bit for append only files */
+#define DMEXCL		0x20000000	/* mode bit for exclusive use files */
+#define DMMOUNT		0x10000000	/* mode bit for mounted channel */
+#define DMAUTH		0x08000000	/* mode bit for authentication file */
+#define DMREAD		0x4		/* mode bit for read permission */
+#define DMWRITE		0x2		/* mode bit for write permission */
+#define DMEXEC		0x1		/* mode bit for execute permission */
+
+typedef
+struct Qid
+{
+	uvlong	path;
+	ulong	vers;
+	uchar	type;
+} Qid;
+
+typedef
+struct Dir {
+
+	/* system-modified data */
+	ushort	type;	/* server type */
+	uint	dev;	/* server subtype */
+	/* file data */
+	Qid	qid;	/* unique id from server */
+	ulong	mode;	/* permissions */
+	ulong	atime;	/* last read time */
+	ulong	mtime;	/* last write time */
+	vlong	length;	/* file length */
+	char	*name;	/* last element of path */
+	char	*uid;	/* owner name */
+	char	*gid;	/* group name */
+	char	*muid;	/* last modifier name */
+} Dir;
+
+extern	Dir*	dirstat(char*);
+extern	Dir*	dirfstat(int);
+extern	int	dirwstat(char*, Dir*);
+extern	int	dirfwstat(int, Dir*);
+extern	long	dirread(int, Dir**);
+extern	void	nulldir(Dir*);
+extern	long	dirreadall(int, Dir**);
+
+#define CHDIR		0x80000000	/* mode bit for directories */
+#define CHAPPEND	0x40000000	/* mode bit for append only files */
+#define CHEXCL		0x20000000	/* mode bit for exclusive use files */
+#define CHMOUNT		0x10000000	/* mode bit for mounted channel */
+#define CHREAD		0x4		/* mode bit for read permission */
+#define CHWRITE		0x2		/* mode bit for write permission */
+#define CHEXEC		0x1		/* mode bit for execute permission */
+
+
+typedef
+struct Waitmsg
+{
+	char	pid[12];	/* of loved one */
+	char	time[3*12];	/* of loved one & descendants */
+	char	*msg;
+} Waitmsg;
+
+typedef
+struct IOchunk
+{
+	void	*addr;
+	ulong	len;
+} IOchunk;
+
+extern	void	_exits(char*);
+
+extern	void	abort(void);
+extern	int	access(char*, int);
+extern	long	alarm(ulong);
+extern	int	await(char*, int);
+extern	int	bind(char*, char*, int);
+extern	int	brk(void*);
+extern	int	chdir(char*);
+extern	int	close(int);
+extern	int	create(char*, int, ulong);
+extern	int	dup(int, int);
+extern	int	errstr(char*, uint);
+extern	int	exec(char*, char*[]);
+extern	int	execl(char*, ...);
+extern  int	filsys(int, int, char*);
+extern	int	fork(void);
+extern	int	rfork(int);
+extern	int	fauth(int, char*);
+extern	int	fstat(int, uchar*, int);
+extern	int	fwstat(int, uchar*, int);
+extern	int	fversion(int, int, char*, int);
+extern	int	mount(int, int, char*, int, char*);
+extern	int	unmount(char*, char*);
+extern	int	noted(int);
+extern	int	notify(void(*)(void*, char*));
+extern	int	open(char*, int);
+extern	int	fd2path(int, char*, int);
+extern	int	pipe(int*);
+extern	long	pread(int, void*, long, vlong);
+extern	long	pwrite(int, void*, long, vlong);
+extern	long	read(int, void*, long);
+extern	long	readn(int, void*, long);
+extern	int	remove(char*);
+extern	void*	sbrk(ulong);
+extern	vlong	seek(int, vlong, int);
+extern	long	segattach(int, char*, void*, ulong);
+extern	int	segbrk(void*, void*);
+extern	int	segdetach(void*);
+extern	int	segflush(void*, ulong);
+extern	int	segfree(void*, ulong);
+extern	int	sleep(long);
+extern	int	stat(char*, uchar*, int);
+extern	Waitmsg*	wait(void);
+extern	int	waitpid(void);
+extern	long	write(int, void*, long);
+extern	long	write9p(int, void*, long);
+extern	int	wstat(char*, char*);
+extern	ulong	rendezvous(ulong, ulong);
+
+extern	int	getpid(void);
+extern	int	getppid(void);
+extern	void	rerrstr(char*, uint);
+extern	char*	sysname(void);
+extern	void	werrstr(char*, ...);
+#pragma	varargck	argpos	werrstr	1
+
+extern char *argv0;
+#define	ARGBEGIN	for((argv0||(argv0=*argv)),argv++,argc--;\
+			    argv[0] && argv[0][0]=='-' && argv[0][1];\
+			    argc--, argv++) {\
+				char *_args, *_argt;\
+				Rune _argc;\
+				_args = &argv[0][1];\
+				if(_args[0]=='-' && _args[1]==0){\
+					argc--; argv++; break;\
+				}\
+				_argc = 0;\
+				while(*_args && (_args += chartorune(&_argc, _args)))\
+				switch(_argc)
+#define	ARGEND		SET(_argt);USED(_argt,_argc,_args);}USED(argv, argc);
+#define	ARGF()		(_argt=_args, _args="",\
+				(*_argt? _argt: argv[1]? (argc--, *++argv): 0))
+#define	EARGF(x)	(_argt=_args, _args="",\
+				(*_argt? _argt: argv[1]? (argc--, *++argv): ((x), abort(), (char*)0)))
+
+#define	ARGC()		_argc
--- /dev/null
+++ b/include/kernel.h
@@ -1,0 +1,50 @@
+extern	vlong	libseek(int, vlong, int);
+extern	int	libread(int, void*, int);
+extern	int	libreadn(int, void*, long);
+extern	int	libwrite(int, void*, int);
+extern	int	libopen(char*, int);
+extern	int	libclose(int);
+extern	Dir*	libdirfstat(int);
+extern	int	libbind(char*, char*, int);
+extern	void*	libqlalloc(void);
+extern	void	libqlfree(void*);
+extern	void	libqlock(void*);
+extern	void	libqunlock(void*);
+extern	void*	libqlowner(void*);
+extern	void*	libfdtochan(int, int);
+extern	void	libchanclose(void*);
+extern	int	kbind(char*, char*, int);
+extern	int	kchdir(char*);
+extern	int	kclose(int);
+extern	int	kcreate(char*, int, ulong);
+extern	Dir*	kdirfstat(int);
+extern	int	kdirfwstat(int, Dir*);
+extern	long	kdirread(int, Dir**);
+extern	Dir*	kdirstat(char*);
+extern	int	kdirwstat(char*, Dir*);
+extern	int	kdup(int, int);
+extern	int	kfauth(int, char*);
+extern	char*	kfd2path(int);
+extern	int	kfstat(int, uchar*, int);
+extern	int	kfversion(int, uint, char*, uint);
+extern	int	kfwstat(int, uchar*, int);
+extern	int	kmount(int, int, char*, int, char*);
+extern	int	kopen(char*, int);
+extern	int	kpipe(int[2]);
+extern	long	kpread(int, void*, long, vlong);
+extern	long	kread(int, void*, long);
+extern	int	kremove(char*);
+extern	vlong	kseek(int, vlong, int);
+extern	int	kstat(char*, uchar*, int);
+extern	int	kunmount(char*, char*);
+extern	long	kpwrite(int, void*, long, vlong);
+extern	long	kwrite(int, void*, long);
+extern	int	kwstat(char*, uchar*, int);
+extern	int	klisten(char*, char*);
+extern	int	kannounce(char*, char*);
+extern	int	kdial(char*, char*, char*, int*);
+extern	void	kerrstr(char*, uint);
+extern	int	kiounit(int);
+extern	void	kwerrstr(char *, ...);
+extern	void	kgerrstr(char*, uint);
+extern	long	kchanio(void*, void*, int, int);
--- /dev/null
+++ b/include/keyboard.h
@@ -1,0 +1,60 @@
+/************** Inferno Generic Scan Conversions ************/
+
+/* this file needs to be kept in sync with module/keyboard.m */
+
+enum {
+	Esc=		0x1b,
+
+	Spec=		0xe000,		/* Special Function Keys, mapped to Unicode reserved range (E000-F8FF) */
+
+	Shift=		Spec|0x0,	/* Shifter (Held and Toggle) Keys  */
+	View=		Spec|0x10,	/* View Keys 		*/
+	PF=		Spec|0x20,	/* num pad		*/
+	KF=		Spec|0x40,	/* function keys        */
+
+	LShift=		Shift|0,
+	RShift=		Shift|1,
+	LCtrl=		Shift|2,
+	RCtrl=		Shift|3,
+	Caps=		Shift|4,
+	Num=		Shift|5,	
+	Meta=		Shift|6,
+	LAlt=		Shift|7,
+	RAlt=		Shift|8,
+	NShifts=	9,
+
+	Home=	   	View|0,
+	End=		View|1,
+	Up=		View|2,
+	Down=		View|3,
+	Left=		View|4,
+	Right=		View|5,
+	Pgup=		View|6,
+	Pgdown=		View|7,
+	BackTab=	View|8,
+
+	Scroll=		Spec|0x62,
+	Ins=		Spec|0x63,
+	Del=		Spec|0x64,
+	Print=		Spec|0x65,
+	Pause=		Spec|0x66,
+	Middle=		Spec|0x67,
+	Break=		Spec|0x66,
+	SysRq=		Spec|0x69,
+	PwrOn=		Spec|0x6c,
+	PwrOff=		Spec|0x6d,
+	PwrLow=		Spec|0x6e,
+	Latin=		Spec|0x6f,
+
+	/* for German keyboard */
+	German=		Spec|0xf00,
+
+	Grave=		German|0x1,
+	Acute=		German|0x2,
+	Circumflex=	German|0x3,
+
+	APP=		Spec|0x200,		/* for ALT application keys */
+
+	No=			-1,			/* peter */
+};
+
--- /dev/null
+++ b/include/libsec.h
@@ -1,0 +1,391 @@
+#pragma	src	"/usr/inferno/libsec"
+
+#ifndef _MPINT
+typedef struct mpint mpint;
+#endif
+
+/*/////////////////////////////////////////////////////// */
+/* AES definitions */
+/*/////////////////////////////////////////////////////// */
+
+enum
+{
+	AESbsize=	16,
+	AESmaxkey=	32,
+	AESmaxrounds=	14
+};
+
+typedef struct AESstate AESstate;
+struct AESstate
+{
+	ulong	setup;
+	int	rounds;
+	int	keybytes;
+	uchar	key[AESmaxkey];		/* unexpanded key */
+	u32int	ekey[4*(AESmaxrounds + 1)];	/* encryption key */
+	u32int	dkey[4*(AESmaxrounds + 1)];	/* decryption key */
+	uchar	ivec[AESbsize];	/* initialization vector */
+};
+
+void	setupAESstate(AESstate *s, uchar key[], int keybytes, uchar *ivec);
+void	aesCBCencrypt(uchar *p, int len, AESstate *s);
+void	aesCBCdecrypt(uchar *p, int len, AESstate *s);
+
+/*/////////////////////////////////////////////////////// */
+/* Blowfish Definitions */
+/*/////////////////////////////////////////////////////// */
+
+enum
+{
+	BFbsize	= 8,
+	BFrounds	= 16
+};
+
+/* 16-round Blowfish */
+typedef struct BFstate BFstate;
+struct BFstate
+{
+	ulong	setup;
+
+	uchar	key[56];
+	uchar	ivec[8];
+
+	u32int 	pbox[BFrounds+2];
+	u32int	sbox[1024];
+};
+
+void	setupBFstate(BFstate *s, uchar key[], int keybytes, uchar *ivec);
+void	bfCBCencrypt(uchar*, int, BFstate*);
+void	bfCBCdecrypt(uchar*, int, BFstate*);
+void	bfECBencrypt(uchar*, int, BFstate*);
+void	bfECBdecrypt(uchar*, int, BFstate*);
+
+/*/////////////////////////////////////////////////////// */
+/* DES definitions */
+/*/////////////////////////////////////////////////////// */
+
+enum
+{
+	DESbsize=	8
+};
+
+/* single des */
+typedef struct DESstate DESstate;
+struct DESstate
+{
+	ulong	setup;
+	uchar	key[8];		/* unexpanded key */
+	ulong	expanded[32];	/* expanded key */
+	uchar	ivec[8];	/* initialization vector */
+};
+
+void	setupDESstate(DESstate *s, uchar key[8], uchar *ivec);
+void	des_key_setup(uchar[8], ulong[32]);
+void	block_cipher(ulong*, uchar*, int);
+void	desCBCencrypt(uchar*, int, DESstate*);
+void	desCBCdecrypt(uchar*, int, DESstate*);
+void	desECBencrypt(uchar*, int, DESstate*);
+void	desECBdecrypt(uchar*, int, DESstate*);
+
+/* for backward compatibility with 7 byte DES key format */
+void	des56to64(uchar *k56, uchar *k64);
+void	des64to56(uchar *k64, uchar *k56);
+void	key_setup(uchar[7], ulong[32]);
+
+/* triple des encrypt/decrypt orderings */
+enum {
+	DES3E=		0,
+	DES3D=		1,
+	DES3EEE=	0,
+	DES3EDE=	2,
+	DES3DED=	5,
+	DES3DDD=	7
+};
+
+typedef struct DES3state DES3state;
+struct DES3state
+{
+	ulong	setup;
+	uchar	key[3][8];		/* unexpanded key */
+	ulong	expanded[3][32];	/* expanded key */
+	uchar	ivec[8];		/* initialization vector */
+};
+
+void	setupDES3state(DES3state *s, uchar key[3][8], uchar *ivec);
+void	triple_block_cipher(ulong keys[3][32], uchar*, int);
+void	des3CBCencrypt(uchar*, int, DES3state*);
+void	des3CBCdecrypt(uchar*, int, DES3state*);
+void	des3ECBencrypt(uchar*, int, DES3state*);
+void	des3ECBdecrypt(uchar*, int, DES3state*);
+
+/* IDEA */
+typedef struct IDEAstate IDEAstate;
+struct IDEAstate
+{
+	uchar	key[16];
+	ushort	edkey[104];
+	uchar	ivec[8];
+};
+
+void	setupIDEAstate(IDEAstate*, uchar*, uchar*);
+void	idea_key_setup(uchar*, ushort*);
+void	idea_cipher(ushort*, uchar*, int);
+
+
+/*/////////////////////////////////////////////////////// */
+/* digests */
+/*/////////////////////////////////////////////////////// */
+
+enum
+{
+	/* digest lengths */
+	SHA1dlen=	20,
+	MD4dlen=	16,
+	MD5dlen=	16,
+
+	SHA224dlen=	28,
+	SHA256dlen=	32,
+
+	SHA384dlen=	48,
+	SHA512dlen=	64,
+
+	/* block sizes */
+	SHA256bsize=	64,
+	SHA512bsize=	128,
+	Digestbsize=	128,		/* maximum */
+};
+
+typedef struct DigestState DigestState;
+struct DigestState
+{
+	u64int len;
+	u32int state[5];
+	uchar buf[Digestbsize];
+	int blen;
+	u64int nb128[2];
+	u64int h64[8];
+	u32int h32[8];
+	char malloced;
+	char seeded;
+};
+typedef struct DigestState SHAstate;	/* obsolete name */
+typedef struct DigestState SHA1state;
+typedef struct DigestState MD5state;
+typedef struct DigestState MD4state;
+typedef struct DigestState SHA256state;
+typedef struct DigestState SHA512state;
+
+DigestState* md4(uchar*, ulong, uchar*, DigestState*);
+DigestState* md5(uchar*, ulong, uchar*, DigestState*);
+DigestState* sha1(uchar*, ulong, uchar*, DigestState*);
+DigestState* sha224(uchar*, ulong, uchar*, DigestState*);
+DigestState* sha256(uchar*, ulong, uchar*, DigestState*);
+DigestState* sha384(uchar*, ulong, uchar*, DigestState*);
+DigestState* sha512(uchar*, ulong, uchar*, DigestState*);
+DigestState* hmac_md5(uchar*, ulong, uchar*, ulong, uchar*, DigestState*);
+DigestState* hmac_sha1(uchar*, ulong, uchar*, ulong, uchar*, DigestState*);
+char* md5pickle(MD5state*);
+MD5state* md5unpickle(char*);
+char* sha1pickle(SHA1state*);
+SHA1state* sha1unpickle(char*);
+
+/*/////////////////////////////////////////////////////// */
+/* random number generation */
+/*/////////////////////////////////////////////////////// */
+void	genrandom(uchar *buf, int nbytes);
+void	_genrandomqlock(void);
+void	_genrandomqunlock(void);
+void	prng(uchar *buf, int nbytes);
+ulong	fastrand(void);
+ulong	nfastrand(ulong);
+
+/*/////////////////////////////////////////////////////// */
+/* primes */
+/*/////////////////////////////////////////////////////// */
+void	genprime(mpint *p, int n, int accuracy); /* generate an n bit probable prime */
+void	gensafeprime(mpint *p, mpint *alpha, int n, int accuracy);	/* prime and generator */
+void	genstrongprime(mpint *p, int n, int accuracy);	/* generate an n bit strong prime */
+void	DSAprimes(mpint *q, mpint *p, uchar seed[SHA1dlen]);
+int	probably_prime(mpint *n, int nrep);	/* miller-rabin test */
+int	smallprimetest(mpint *p);		/* returns -1 if not prime, 0 otherwise */
+
+/*/////////////////////////////////////////////////////// */
+/* rc4 */
+/*/////////////////////////////////////////////////////// */
+typedef struct RC4state RC4state;
+struct RC4state
+{
+	 uchar state[256];
+	 uchar x;
+	 uchar y;
+};
+
+void	setupRC4state(RC4state*, uchar*, int);
+void	rc4(RC4state*, uchar*, int);
+void	rc4skip(RC4state*, int);
+void	rc4back(RC4state*, int);
+
+/*/////////////////////////////////////////////////////// */
+/* rsa */
+/*/////////////////////////////////////////////////////// */
+typedef struct RSApub RSApub;
+typedef struct RSApriv RSApriv;
+typedef struct PEMChain PEMChain;
+
+/* public/encryption key */
+struct RSApub
+{
+	mpint	*n;	/* modulus */
+	mpint	*ek;	/* exp (encryption key) */
+};
+
+/* private/decryption key */
+struct RSApriv
+{
+	RSApub	pub;
+
+	mpint	*dk;	/* exp (decryption key) */
+
+	/* precomputed values to help with chinese remainder theorem calc */
+	mpint	*p;
+	mpint	*q;
+	mpint	*kp;	/* dk mod p-1 */
+	mpint	*kq;	/* dk mod q-1 */
+	mpint	*c2;	/* (inv p) mod q */
+};
+
+struct PEMChain{
+	PEMChain *next;
+	uchar *pem;
+	int pemlen;
+};
+
+RSApriv*	rsagen(int nlen, int elen, int rounds);
+RSApriv*	rsafill(mpint *n, mpint *e, mpint *d, mpint *p, mpint *q);
+mpint*		rsaencrypt(RSApub *k, mpint *in, mpint *out);
+mpint*		rsadecrypt(RSApriv *k, mpint *in, mpint *out);
+RSApub*		rsapuballoc(void);
+void		rsapubfree(RSApub*);
+RSApriv*	rsaprivalloc(void);
+void		rsaprivfree(RSApriv*);
+RSApub*		rsaprivtopub(RSApriv*);
+RSApub*		X509toRSApub(uchar*, int, char*, int);
+RSApriv*	asn1toRSApriv(uchar*, int);
+void		asn1dump(uchar *der, int len);
+uchar*		decodePEM(char *s, char *type, int *len, char **new_s);
+PEMChain*	decodepemchain(char *s, char *type);
+uchar*		X509gen(RSApriv *priv, char *subj, ulong valid[2], int *certlen);
+uchar*		X509req(RSApriv *priv, char *subj, int *certlen);
+char*		X509verify(uchar *cert, int ncert, RSApub *pk);
+void		X509dump(uchar *cert, int ncert);
+
+/*/////////////////////////////////////////////////////// */
+/* elgamal */
+/*/////////////////////////////////////////////////////// */
+typedef struct EGpub EGpub;
+typedef struct EGpriv EGpriv;
+typedef struct EGsig EGsig;
+
+/* public/encryption key */
+struct EGpub
+{
+	mpint	*p;	/* modulus */
+	mpint	*alpha;	/* generator */
+	mpint	*key;	/* (encryption key) alpha**secret mod p */
+};
+
+/* private/decryption key */
+struct EGpriv
+{
+	EGpub	pub;
+	mpint	*secret; /* (decryption key) */
+};
+
+/* signature */
+struct EGsig
+{
+	mpint	*r, *s;
+};
+
+EGpriv*		eggen(int nlen, int rounds);
+mpint*		egencrypt(EGpub *k, mpint *in, mpint *out);	/* deprecated */
+mpint*		egdecrypt(EGpriv *k, mpint *in, mpint *out);
+EGsig*		egsign(EGpriv *k, mpint *m);
+int		egverify(EGpub *k, EGsig *sig, mpint *m);
+EGpub*		egpuballoc(void);
+void		egpubfree(EGpub*);
+EGpriv*		egprivalloc(void);
+void		egprivfree(EGpriv*);
+EGsig*		egsigalloc(void);
+void		egsigfree(EGsig*);
+EGpub*		egprivtopub(EGpriv*);
+
+/*/////////////////////////////////////////////////////// */
+/* dsa */
+/*/////////////////////////////////////////////////////// */
+typedef struct DSApub DSApub;
+typedef struct DSApriv DSApriv;
+typedef struct DSAsig DSAsig;
+
+/* public/encryption key */
+struct DSApub
+{
+	mpint	*p;	/* modulus */
+	mpint	*q;	/* group order, q divides p-1 */
+	mpint	*alpha;	/* group generator */
+	mpint	*key;	/* (encryption key) alpha**secret mod p */
+};
+
+/* private/decryption key */
+struct DSApriv
+{
+	DSApub	pub;
+	mpint	*secret; /* (decryption key) */
+};
+
+/* signature */
+struct DSAsig
+{
+	mpint	*r, *s;
+};
+
+DSApriv*	dsagen(DSApub *opub);	/* opub not checked for consistency! */
+DSAsig*		dsasign(DSApriv *k, mpint *m);
+int		dsaverify(DSApub *k, DSAsig *sig, mpint *m);
+DSApub*		dsapuballoc(void);
+void		dsapubfree(DSApub*);
+DSApriv*	dsaprivalloc(void);
+void		dsaprivfree(DSApriv*);
+DSAsig*		dsasigalloc(void);
+void		dsasigfree(DSAsig*);
+DSApub*		dsaprivtopub(DSApriv*);
+
+/*/////////////////////////////////////////////////////// */
+/* TLS */
+/*/////////////////////////////////////////////////////// */
+typedef struct Thumbprint{
+	struct Thumbprint *next;
+	uchar sha1[SHA1dlen];
+} Thumbprint;
+
+typedef struct TLSconn{
+	char dir[40];  /* connection directory */
+	uchar *cert;   /* certificate (local on input, remote on output) */
+	uchar *sessionID;
+	int certlen, sessionIDlen;
+	int (*trace)(char*fmt, ...);
+	PEMChain *chain; /* optional extra certificate evidence for servers to present */
+} TLSconn;
+
+/* tlshand.c */
+int tlsClient(int fd, TLSconn *c);
+int tlsServer(int fd, TLSconn *c);
+
+/* thumb.c */
+Thumbprint* initThumbprints(char *ok, char *crl);
+void	freeThumbprints(Thumbprint *ok);
+int		okThumbprint(uchar *sha1, Thumbprint *ok);
+
+/* readcert.c */
+uchar	*readcert(char *filename, int *pcertlen);
+PEMChain *readcertchain(char *filename);
--- /dev/null
+++ b/include/logfs.h
@@ -1,0 +1,158 @@
+#pragma src "/usr/inferno/liblogfs"
+
+typedef struct LogfsLowLevel LogfsLowLevel;
+typedef struct LogfsBoot LogfsBoot;
+typedef struct Logfs Logfs;
+typedef struct LogfsServer LogfsServer;
+typedef struct LogfsIdentityStore LogfsIdentityStore;
+
+#pragma incomplete Logfs
+#pragma incomplete LogfsServer
+#pragma incomplete LogfsIdentityStore
+#pragma incomplete LogfsBoot
+
+typedef u64int Pageset;
+
+#define	BITSPERSET	(sizeof(Pageset)*8)
+#define	PAGETOP	((Pageset)1<<(BITSPERSET-1))
+
+enum {
+	LogfsTnone = 0xff,
+	LogfsTboot = 0x01,
+	LogfsTlog = 0x06,
+	LogfsTdata = 0x18,
+	LogfsTbad = -1,
+	LogfsTworse = -2,
+	LogfsMagic = 'V',
+};
+
+enum {
+	LogfsLogTstart = 's',
+	LogfsLogTcreate = 'c',
+	LogfsLogTtrunc = 't',
+	LogfsLogTremove = 'r',
+	LogfsLogTwrite = 'w',
+	LogfsLogTwstat = 'W',
+	LogfsLogTend = 'e',
+};
+
+enum {
+	LogfsOpenFlagNoPerm = 1,
+	LogfsOpenFlagWstatAllow = 2,
+};
+
+typedef enum LogfsLowLevelReadResult {
+	LogfsLowLevelReadResultOk,
+	LogfsLowLevelReadResultSoftError,
+	LogfsLowLevelReadResultHardError,
+	LogfsLowLevelReadResultBad,
+	LogfsLowLevelReadResultAllOnes,
+} LogfsLowLevelReadResult;
+
+typedef short LOGFSGETBLOCKTAGFN(LogfsLowLevel*, long);
+typedef void LOGFSSETBLOCKTAGFN(LogfsLowLevel*, long, short);
+typedef ulong LOGFSGETBLOCKPATHFN(LogfsLowLevel*, long);
+typedef void LOGFSSETBLOCKPATHFN(LogfsLowLevel*, long, ulong);
+typedef long LOGFSFINDFREEBLOCKFN(LogfsLowLevel*, long*);
+typedef char *LOGFSREADBLOCKFN(LogfsLowLevel*, void*, long, LogfsLowLevelReadResult*);
+typedef char *LOGFSWRITEBLOCKFN(LogfsLowLevel*, void*, uchar, ulong, int, long*, long);
+typedef char *LOGFSERASEBLOCKFN(LogfsLowLevel*, long, void **, int*);
+typedef char *LOGFSFORMATBLOCKFN(LogfsLowLevel*, long, uchar, long, long, long, int, long*, void*, int*);
+typedef char *LOGFSREFORMATBLOCKFN(LogfsLowLevel*, long, uchar, long, int, long*, void*, int*);
+typedef void LOGFSMARKBLOCKBADFN(LogfsLowLevel*, long);
+typedef int LOGFSGETBLOCKSFN(LogfsLowLevel*);
+typedef long LOGFSGETBASEBLOCKFN(LogfsLowLevel*);
+typedef int LOGFSGETBLOCKSIZEFN(LogfsLowLevel*);
+typedef int LOGFSGETBLOCKPARTIALFORMATSTATUSFN(LogfsLowLevel*, long);
+typedef ulong LOGFSCALCRAWADDRESSFN(LogfsLowLevel*, long, int);
+typedef char *LOGFSOPENFN(LogfsLowLevel*, long, long, int, int, long*);
+typedef char *LOGFSGETBLOCKSTATUSFN(LogfsLowLevel*, long, int*, void **, LogfsLowLevelReadResult*);
+typedef int LOGFSCALCFORMATFN(LogfsLowLevel*, long, long, long, long*, long*, long*);
+typedef int LOGFSGETOPENSTATUSFN(LogfsLowLevel*);
+typedef void LOGFSFREEFN(LogfsLowLevel*);
+typedef char *LOGFSREADPAGERANGEFN(LogfsLowLevel*, uchar*, long, int, int, int, LogfsLowLevelReadResult*);
+typedef char *LOGFSWRITEPAGEFN(LogfsLowLevel*, uchar*, long, int);
+typedef char *LOGFSSYNCFN(LogfsLowLevel*);
+
+struct LogfsLowLevel {
+	int l2pagesize;
+	int l2pagesperblock;
+	long blocks;
+	int pathbits;
+	LOGFSOPENFN *open;
+	LOGFSGETBLOCKTAGFN *getblocktag;
+	LOGFSSETBLOCKTAGFN *setblocktag;
+	LOGFSGETBLOCKPATHFN *getblockpath;
+	LOGFSSETBLOCKPATHFN *setblockpath;
+	LOGFSREADPAGERANGEFN *readpagerange;
+	LOGFSWRITEPAGEFN *writepage;
+	LOGFSFINDFREEBLOCKFN *findfreeblock;
+	LOGFSREADBLOCKFN *readblock;
+	LOGFSWRITEBLOCKFN *writeblock;
+	LOGFSERASEBLOCKFN *eraseblock;
+	LOGFSFORMATBLOCKFN *formatblock;
+	LOGFSREFORMATBLOCKFN *reformatblock;
+	LOGFSMARKBLOCKBADFN *markblockbad;
+	LOGFSGETBASEBLOCKFN *getbaseblock;
+	LOGFSGETBLOCKSIZEFN *getblocksize;
+	LOGFSGETBLOCKPARTIALFORMATSTATUSFN *getblockpartialformatstatus;
+	LOGFSCALCRAWADDRESSFN *calcrawaddress;
+	LOGFSGETBLOCKSTATUSFN *getblockstatus;
+	LOGFSCALCFORMATFN *calcformat;
+	LOGFSGETOPENSTATUSFN *getopenstatus;
+	LOGFSFREEFN *free;
+	LOGFSSYNCFN *sync;
+};
+
+char *logfstagname(uchar);
+
+char *logfsisnew(LogfsIdentityStore **);
+void logfsisfree(LogfsIdentityStore **);
+char *logfsisgroupcreate(LogfsIdentityStore*, char*, char*);
+char *logfsisgrouprename(LogfsIdentityStore*, char*, char*);
+char *logfsisgroupsetleader(LogfsIdentityStore*, char*, char*);
+char *logfsisgroupaddmember(LogfsIdentityStore*, char*, char*);
+char *logfsisgroupremovemember(LogfsIdentityStore*, char*, char*);
+char *logfsisusersread(LogfsIdentityStore*, void*, long, ulong, long*);
+
+char *logfsformat(LogfsLowLevel*, long, long, long, int);
+char *logfsbootopen(LogfsLowLevel*, long, long, int, int, LogfsBoot**);
+void logfsbootfree(LogfsBoot*);
+char *logfsbootread(LogfsBoot*, void*, long, ulong);
+char *logfsbootwrite(LogfsBoot*, void*, long, ulong);
+char *logfsbootio(LogfsBoot*, void*, long, ulong, int);
+char *logfsbootmap(LogfsBoot*, ulong, ulong*, int*, int*, int*, ulong*, ulong*);
+long logfsbootgetiosize(LogfsBoot*);
+long logfsbootgetsize(LogfsBoot*);
+void logfsboottrace(LogfsBoot*, int);
+
+char *logfsserverattach(LogfsServer*, u32int, char*, Qid*);
+char *logfsserverclunk(LogfsServer*, u32int);
+char *logfsservercreate(LogfsServer*, u32int, char*, u32int, uchar, Qid*);
+char *logfsserverflush(LogfsServer*);
+char *logfsservernew(LogfsBoot*, LogfsLowLevel*, LogfsIdentityStore*, ulong, int, LogfsServer**);
+char *logfsserveropen(LogfsServer*, u32int, uchar mode, Qid*);
+char *logfsserverread(LogfsServer*, u32int, u32int, u32int, uchar*, u32int, u32int*);
+char *logfsserverremove(LogfsServer*, u32int);
+char *logfsserverstat(LogfsServer*, u32int, uchar*, u32int, ushort*);
+char *logfsserverwalk(LogfsServer*, u32int, u32int, ushort, char **, ushort*, Qid*);
+char *logfsserverwrite(LogfsServer*, u32int, u32int, u32int, uchar*, u32int*);
+char *logfsserverwstat(LogfsServer*, u32int, uchar*, ushort nstat);
+void logfsserverfree(LogfsServer **);
+char *logfsserverlogsweep(LogfsServer*, int, int*);
+char *logfsserverreadpathextent(LogfsServer*, u32int, int, u32int*, u32int*, long*, int*, int*);
+
+char *logfsservertestcmd(LogfsServer*, int, char **);
+void logfsservertrace(LogfsServer*, int);
+
+/*
+ * implemented by the environment
+ */
+ulong logfsnow(void);
+void *logfsrealloc(void*, ulong);
+void logfsfreemem(void*);
+int	nrand(int);
+
+extern char Eio[];
+extern char Ebadarg[];
+extern char Eperm[];
--- /dev/null
+++ b/include/logfsos.h
@@ -1,0 +1,1 @@
+#include "lib9.h"
--- /dev/null
+++ b/include/mathi.h
@@ -1,0 +1,80 @@
+/*
+ * floating point control and status register masks
+ */
+enum
+{
+	INVAL		= 0x0001,
+	ZDIV		= 0x0002,
+	OVFL		= 0x0004,
+	UNFL		= 0x0008,
+	INEX		= 0x0010,
+	RND_NR		= 0x0000,
+	RND_NINF	= 0x0100,
+	RND_PINF	= 0x0200,
+	RND_Z		= 0x0300,
+	RND_MASK	= 0x0300
+};
+
+extern	double	ipow10(int);
+extern	void	FPinit(void);
+extern	double	dot(int, double*, double*);
+extern	ulong	FPcontrol(ulong, ulong);
+extern	ulong	FPstatus(ulong, ulong);
+extern	void	gemm(int, int, int, int, int, double,
+			double*, int, double*, int, double, double*, int);
+extern	ulong	getFPstatus(void);
+extern	ulong	getFPcontrol(void);
+extern	char*	g_fmt(char *, double, int);
+extern	int	iamax(int, double*);
+extern	double	fdim(double, double);
+extern	double	fmax(double, double);
+extern	double	fmin(double, double);
+extern	double	norm2(int, double*);
+extern	double	norm1(int, double*);
+extern	double	strtod(const char *, char **);
+
+/* fdlibm */
+extern double __ieee754_acos(double);
+extern double __ieee754_acosh(double);
+extern double __ieee754_asin(double);
+extern double asinh(double);
+extern double atan(double);
+extern double __ieee754_atan2(double, double);
+extern double __ieee754_atanh(double);
+extern double cbrt(double);
+extern double ceil(double);
+extern double copysign(double, double);
+extern double cos(double);
+extern double __ieee754_cosh(double);
+extern double erf(double);
+extern double erfc(double);
+extern double __ieee754_exp(double);
+extern double expm1(double);
+extern double fabs(double);
+extern int finite(double);
+extern double floor(double);
+extern double __ieee754_fmod(double, double);
+extern double __ieee754_hypot(double, double);
+extern int ilogb(double);
+extern double __ieee754_j0(double);
+extern double __ieee754_j1(double);
+extern double __ieee754_jn(int, double);
+extern double __ieee754_lgamma_r(double,int*);
+extern double __ieee754_log(double);
+extern double __ieee754_log10(double);
+extern double log1p(double);
+extern double logb(double);
+extern double modf(double, double *);
+extern double nextafter(double, double);
+extern double __ieee754_pow(double, double);
+extern double __ieee754_remainder(double, double);
+extern double rint(double);
+extern double scalbn(double, int);
+extern double sin(double);
+extern double __ieee754_sinh(double);
+extern double __ieee754_sqrt(double);
+extern double tan(double);
+extern double tanh(double);
+extern double __ieee754_y0(double);
+extern double __ieee754_y1(double);
+extern double __ieee754_yn(int, double);
--- /dev/null
+++ b/include/memdraw.h
@@ -1,0 +1,194 @@
+#pragma	src	"/usr/inferno/libmemdraw"
+
+typedef struct	Memimage Memimage;
+typedef struct	Memdata Memdata;
+typedef struct	Memsubfont Memsubfont;
+typedef struct	Memlayer Memlayer;
+typedef struct	Memcmap Memcmap;
+typedef struct	Memdrawparam	Memdrawparam;
+
+#pragma incomplete Memlayer
+
+/*
+ * Memdata is allocated from main pool, but .data from the image pool.
+ * Memdata is allocated separately to permit patching its pointer after
+ * compaction when windows share the image data.
+ * The first word of data is a back pointer to the Memdata, to find
+ * The word to patch.
+ */
+
+struct Memdata
+{
+	ulong	*base;	/* allocated data pointer */
+	uchar	*bdata;	/* pointer to first byte of actual data; word-aligned */
+	int		ref;		/* number of Memimages using this data */
+	void*	imref;
+	int		allocd;	/* is this malloc'd? */
+};
+
+enum {
+	Frepl		= 1<<0,	/* is replicated */
+	Fsimple	= 1<<1,	/* is 1x1 */
+	Fgrey	= 1<<2,	/* is grey */
+	Falpha	= 1<<3,	/* has explicit alpha */
+	Fcmap	= 1<<4,	/* has cmap channel */
+	Fbytes	= 1<<5,	/* has only 8-bit channels */
+};
+
+struct Memimage
+{
+	Rectangle	r;		/* rectangle in data area, local coords */
+	Rectangle	clipr;		/* clipping region */
+	int		depth;	/* number of bits of storage per pixel */
+	int		nchan;	/* number of channels */
+	ulong	chan;	/* channel descriptions */
+	Memcmap	*cmap;
+
+	Memdata	*data;	/* pointer to data; shared by windows in this image */
+	int		zero;		/* data->bdata+zero==&byte containing (0,0) */
+	ulong	width;	/* width in words of a single scan line */
+	Memlayer	*layer;	/* nil if not a layer*/
+	ulong	flags;
+
+	int		shift[NChan];
+	int		mask[NChan];
+	int		nbits[NChan];
+};
+
+struct Memcmap
+{
+	uchar	cmap2rgb[3*256];
+	uchar	rgb2cmap[16*16*16];
+};
+
+/*
+ * Subfonts
+ *
+ * given char c, Subfont *f, Fontchar *i, and Point p, one says
+ *	i = f->info+c;
+ *	draw(b, Rect(p.x+i->left, p.y+i->top,
+ *		p.x+i->left+((i+1)->x-i->x), p.y+i->bottom),
+ *		color, f->bits, Pt(i->x, i->top));
+ *	p.x += i->width;
+ * to draw characters in the specified color (itself a Memimage) in Memimage b.
+ */
+
+struct	Memsubfont
+{
+	char		*name;
+	short	n;		/* number of chars in font */
+	uchar	height;		/* height of bitmap */
+	char	ascent;		/* top of bitmap to baseline */
+	Fontchar *info;		/* n+1 character descriptors */
+	Memimage	*bits;		/* of font */
+};
+
+/*
+ * Encapsulated parameters and information for sub-draw routines.
+ */
+enum {
+	Simplesrc=1<<0,
+	Simplemask=1<<1,
+	Replsrc=1<<2,
+	Replmask=1<<3,
+	Fullmask=1<<4,
+};
+struct	Memdrawparam
+{
+	Memimage *dst;
+	Rectangle	r;
+	Memimage *src;
+	Rectangle sr;
+	Memimage *mask;
+	Rectangle mr;
+	int op;
+
+	ulong state;
+	ulong mval;	/* if Simplemask, the mask pixel in mask format */
+	ulong mrgba;	/* mval in rgba */
+	ulong sval;	/* if Simplesrc, the source pixel in src format */
+	ulong srgba;	/* sval in rgba */
+	ulong sdval;	/* sval in dst format */
+};
+
+/*
+ * Memimage management
+ */
+
+extern Memimage*	allocmemimage(Rectangle, ulong);
+extern Memimage*	allocmemimaged(Rectangle, ulong, Memdata*);
+extern Memimage*	readmemimage(int);
+extern Memimage*	creadmemimage(int);
+extern int	writememimage(int, Memimage*);
+extern void	freememimage(Memimage*);
+extern int		loadmemimage(Memimage*, Rectangle, uchar*, int);
+extern int		cloadmemimage(Memimage*, Rectangle, uchar*, int);
+extern int		unloadmemimage(Memimage*, Rectangle, uchar*, int);
+extern ulong*	wordaddr(Memimage*, Point);
+extern uchar*	byteaddr(Memimage*, Point);
+extern int		drawclip(Memimage*, Rectangle*, Memimage*, Point*, Memimage*, Point*, Rectangle*, Rectangle*);
+extern void	memfillcolor(Memimage*, ulong);
+extern int		memsetchan(Memimage*, ulong);
+
+/*
+ * Graphics
+ */
+extern void	memdraw(Memimage*, Rectangle, Memimage*, Point, Memimage*, Point, int);
+extern void	memline(Memimage*, Point, Point, int, int, int, Memimage*, Point, int);
+extern void	mempoly(Memimage*, Point*, int, int, int, int, Memimage*, Point, int);
+extern void	memfillpoly(Memimage*, Point*, int, int, Memimage*, Point, int);
+extern void	_memfillpolysc(Memimage*, Point*, int, int, Memimage*, Point, int, int, int, int);
+extern void	memimagedraw(Memimage*, Rectangle, Memimage*, Point, Memimage*, Point, int);
+extern int	hwdraw(Memdrawparam*);
+extern void	memimageline(Memimage*, Point, Point, int, int, int, Memimage*, Point, int);
+extern void	_memimageline(Memimage*, Point, Point, int, int, int, Memimage*, Point, Rectangle, int);
+extern Point	memimagestring(Memimage*, Point, Memimage*, Point, Memsubfont*, char*);
+extern void	memellipse(Memimage*, Point, int, int, int, Memimage*, Point, int);
+extern void	memarc(Memimage*, Point, int, int, int, Memimage*, Point, int, int, int);
+extern Rectangle	memlinebbox(Point, Point, int, int, int);
+extern int	memlineendsize(int);
+extern void	_memmkcmap(void);
+extern void	memimageinit(void);
+
+/*
+ * Subfont management
+ */
+extern Memsubfont*	allocmemsubfont(char*, int, int, int, Fontchar*, Memimage*);
+extern Memsubfont*	openmemsubfont(char*);
+extern void	freememsubfont(Memsubfont*);
+extern Point	memsubfontwidth(Memsubfont*, char*);
+extern Memsubfont*	getmemdefont(void);
+
+/*
+ * Predefined 
+ */
+extern	Memimage*	memwhite;
+extern	Memimage*	memblack;
+extern	Memimage*	memopaque;
+extern	Memimage*	memtransparent;
+extern	Memcmap	*memdefcmap;
+
+/*
+ * Kernel interface
+ */
+uchar*	attachscreen(Rectangle*, ulong*, int*, int*, int*);
+void		memimagemove(void*, void*);
+
+/*
+ * Kernel cruft
+ */
+extern void	rdb(void);
+extern int		iprint(char*, ...);
+#pragma varargck argpos iprint 1
+extern int		drawdebug;
+
+/*
+ * doprint interface: numbconv bit strings
+ */
+#pragma varargck type "llb" vlong
+#pragma varargck type "llb" uvlong
+#pragma varargck type "lb" long
+#pragma varargck type "lb" ulong
+#pragma varargck type "b" int
+#pragma varargck type "b" uint
+
--- /dev/null
+++ b/include/memlayer.h
@@ -1,0 +1,50 @@
+#pragma src "/usr/inferno/libmemlayer"
+
+typedef struct Memscreen Memscreen;
+typedef void (*Refreshfn)(Memimage*, Rectangle, void*);
+
+struct Memscreen
+{
+	Memimage	*frontmost;	/* frontmost layer on screen */
+	Memimage	*rearmost;	/* rearmost layer on screen */
+	Memimage	*image;		/* upon which all layers are drawn */
+	Memimage	*fill;			/* if non-zero, picture to use when repainting */
+};
+
+struct Memlayer
+{
+	Rectangle		screenr;	/* true position of layer on screen */
+	Point			delta;	/* add delta to go from image coords to screen */
+	Memscreen	*screen;	/* screen this layer belongs to */
+	Memimage	*front;	/* window in front of this one */
+	Memimage	*rear;	/* window behind this one*/
+	int		clear;	/* layer is fully visible */
+	Memimage	*save;	/* save area for obscured parts */
+	Refreshfn	refreshfn;		/* function to call to refresh obscured parts if save==nil */
+	void		*refreshptr;	/* argument to refreshfn */
+};
+
+/*
+ * These functions accept local coordinates
+ */
+int			memload(Memimage*, Rectangle, uchar*, int, int);
+int			memunload(Memimage*, Rectangle, uchar*, int);
+
+/*
+ * All these functions accept screen coordinates, not local ones.
+ */
+void			_memlayerop(void (*fn)(Memimage*, Rectangle, Rectangle, void*, int), Memimage*, Rectangle, Rectangle, void*);
+Memimage*	memlalloc(Memscreen*, Rectangle, Refreshfn, void*, ulong);
+void			memldelete(Memimage*);
+void			memlfree(Memimage*);
+void			memltofront(Memimage*);
+void			memltofrontn(Memimage**, int);
+void			_memltofrontfill(Memimage*, int);
+void			memltorear(Memimage*);
+void			memltorearn(Memimage**, int);
+int			memlsetrefresh(Memimage*, Refreshfn, void*);
+void			memlhide(Memimage*, Rectangle);
+void			memlexpose(Memimage*, Rectangle);
+void			_memlsetclear(Memscreen*);
+int			memlorigin(Memimage*, Point, Point);
+void			memlnorefresh(Memimage*, Rectangle, void*);
--- /dev/null
+++ b/include/mp.h
@@ -1,0 +1,139 @@
+#pragma	src	"/usr/inferno/src/libmp"
+
+#define _MPINT 1
+
+/* the code assumes mpdigit to be at least an int */
+/* mpdigit must be an atomic type.  mpdigit is defined */
+/* in the architecture specific u.h */
+
+typedef struct mpint mpint;
+
+struct mpint
+{
+	int	sign;	/* +1 or -1 */
+	int	size;	/* allocated digits */
+	int	top;	/* significant digits */
+	mpdigit	*p;
+	char	flags;
+};
+
+enum
+{
+	MPstatic=	0x01,
+	Dbytes=		sizeof(mpdigit),	/* bytes per digit */
+	Dbits=		Dbytes*8		/* bits per digit */
+};
+
+/* allocation */
+void	mpsetminbits(int n);	/* newly created mpint's get at least n bits */
+mpint*	mpnew(int n);		/* create a new mpint with at least n bits */
+void	mpfree(mpint *b);
+void	mpbits(mpint *b, int n);	/* ensure that b has at least n bits */
+void	mpnorm(mpint *b);		/* dump leading zeros */
+mpint*	mpcopy(mpint *b);
+void	mpassign(mpint *old, mpint *new);
+
+/* random bits */
+mpint*	mprand(int bits, void (*gen)(uchar*, int), mpint *b);
+
+/* conversion */
+mpint*	strtomp(char*, char**, int, mpint*);	/* ascii */
+int	mpfmt(Fmt*);
+char*	mptoa(mpint*, int, char*, int);
+mpint*	letomp(uchar*, uint, mpint*);	/* byte array, little-endian */
+int	mptole(mpint*, uchar*, uint, uchar**);
+mpint*	betomp(uchar*, uint, mpint*);	/* byte array, little-endian */
+int	mptobe(mpint*, uchar*, uint, uchar**);
+uint	mptoui(mpint*);			/* unsigned int */
+mpint*	uitomp(uint, mpint*);
+int	mptoi(mpint*);			/* int */
+mpint*	itomp(int, mpint*);
+uvlong	mptouv(mpint*);			/* unsigned vlong */
+mpint*	uvtomp(uvlong, mpint*);
+vlong	mptov(mpint*);			/* vlong */
+mpint*	vtomp(vlong, mpint*);
+
+/* divide 2 digits by one */
+void	mpdigdiv(mpdigit *dividend, mpdigit divisor, mpdigit *quotient);
+
+/* in the following, the result mpint may be */
+/* the same as one of the inputs. */
+void	mpadd(mpint *b1, mpint *b2, mpint *sum);	/* sum = b1+b2 */
+void	mpsub(mpint *b1, mpint *b2, mpint *diff);	/* diff = b1-b2 */
+void	mpleft(mpint *b, int shift, mpint *res);	/* res = b<<shift */
+void	mpright(mpint *b, int shift, mpint *res);	/* res = b>>shift */
+void	mpmul(mpint *b1, mpint *b2, mpint *prod);	/* prod = b1*b2 */
+void	mpexp(mpint *b, mpint *e, mpint *m, mpint *res);	/* res = b**e mod m */
+void	mpmod(mpint *b, mpint *m, mpint *remainder);	/* remainder = b mod m */
+
+/* quotient = dividend/divisor, remainder = dividend % divisor */
+void	mpdiv(mpint *dividend, mpint *divisor,  mpint *quotient, mpint *remainder);
+
+/* return neg, 0, pos as b1-b2 is neg, 0, pos */
+int	mpcmp(mpint *b1, mpint *b2);
+
+/* extended gcd return d, x, and y, s.t. d = gcd(a,b) and ax+by = d */
+void	mpextendedgcd(mpint *a, mpint *b, mpint *d, mpint *x, mpint *y);
+
+/* res = b**-1 mod m */
+void	mpinvert(mpint *b, mpint *m, mpint *res);
+
+/* bit counting */
+int	mpsignif(mpint*);	/* number of sigificant bits in mantissa */
+int	mplowbits0(mpint*);	/* k, where n = 2**k * q for odd q */
+
+/* well known constants */
+extern mpint	*mpzero, *mpone, *mptwo;
+
+/* sum[0:alen] = a[0:alen-1] + b[0:blen-1] */
+/* prereq: alen >= blen, sum has room for alen+1 digits */
+void	mpvecadd(mpdigit *a, int alen, mpdigit *b, int blen, mpdigit *sum);
+
+/* diff[0:alen-1] = a[0:alen-1] - b[0:blen-1] */
+/* prereq: alen >= blen, diff has room for alen digits */
+void	mpvecsub(mpdigit *a, int alen, mpdigit *b, int blen, mpdigit *diff);
+
+/* p[0:n] += m * b[0:n-1] */
+/* prereq: p has room for n+1 digits */
+void	mpvecdigmuladd(mpdigit *b, int n, mpdigit m, mpdigit *p);
+
+/* p[0:n] -= m * b[0:n-1] */
+/* prereq: p has room for n+1 digits */
+int	mpvecdigmulsub(mpdigit *b, int n, mpdigit m, mpdigit *p);
+
+/* p[0:alen*blen-1] = a[0:alen-1] * b[0:blen-1] */
+/* prereq: alen >= blen, p has room for m*n digits */
+void	mpvecmul(mpdigit *a, int alen, mpdigit *b, int blen, mpdigit *p);
+
+/* sign of a - b or zero if the same */
+int	mpveccmp(mpdigit *a, int alen, mpdigit *b, int blen);
+
+/* divide the 2 digit dividend by the one digit divisor and stick in quotient */
+/* we assume that the result is one digit - overflow is all 1's */
+void	mpdigdiv(mpdigit *dividend, mpdigit divisor, mpdigit *quotient);
+
+/* playing with magnitudes */
+int	mpmagcmp(mpint *b1, mpint *b2);
+void	mpmagadd(mpint *b1, mpint *b2, mpint *sum);	/* sum = b1+b2 */
+void	mpmagsub(mpint *b1, mpint *b2, mpint *sum);	/* sum = b1+b2 */
+
+/* chinese remainder theorem */
+typedef struct CRTpre	CRTpre;		/* precomputed values for converting */
+					/*  twixt residues and mpint */
+typedef struct CRTres	CRTres;		/* residue form of an mpint */
+
+struct CRTres
+{
+	int	n;		/* number of residues */
+	mpint	*r[1];		/* residues */
+};
+
+CRTpre*	crtpre(int, mpint**);			/* precompute conversion values */
+CRTres*	crtin(CRTpre*, mpint*);			/* convert mpint to residues */
+void	crtout(CRTpre*, CRTres*, mpint*);	/* convert residues to mpint */
+void	crtprefree(CRTpre*);
+void	crtresfree(CRTres*);
+
+
+#pragma	varargck	type	"B"	mpint*
+#pragma varargck	type	"U" mpint*
--- /dev/null
+++ b/include/nandecc.h
@@ -1,0 +1,12 @@
+#pragma src "/usr/inferno/libnandfs"
+
+typedef enum NandEccError {
+	NandEccErrorBad,
+	NandEccErrorGood,
+	NandEccErrorOneBit,
+	NandEccErrorOneBitInEcc,
+} NandEccError;
+
+ulong nandecc(uchar buf[256]);
+NandEccError nandecccorrect(uchar buf[256], ulong calcecc, ulong *storedecc, int reportbad);
+
--- /dev/null
+++ b/include/nandfs.h
@@ -1,0 +1,74 @@
+#pragma src "/usr/inferno/libnandfs"
+
+typedef struct Nandfs Nandfs;
+typedef struct NandfsTags NandfsTags;
+
+#pragma incomplete Nandfs
+
+enum {
+	NandfsL2PageSize = 9,
+	NandfsPageSize = 1 << NandfsL2PageSize,
+	NandfsAuxiliarySize = 16,
+	NandfsFullSize = NandfsPageSize + NandfsAuxiliarySize,
+	NandfsPathBits = 26,
+	NandfsPathMask = ((1 << NandfsPathBits) - 1),
+	NandfsNeraseBits = 18,
+	NandfsNeraseMask = ((1 << NandfsNeraseBits) - 1),
+};
+
+struct NandfsTags {
+	ulong path;	// 26 bits
+	ulong nerase;	// 18 bits
+	uchar tag;		// 8 bits
+	uchar magic;	// 8 bits
+};
+
+char *nandfsinit(void*, long, long, char *(*)(void*, void*, long, ulong),
+	char *(*)(void*, void*, long, ulong),
+	char *(*)(void*, long),
+	char *(*)(void*),
+	LogfsLowLevel **);
+void nandfsfree(Nandfs*);
+char *nandfsreadpageauxiliary(Nandfs*, NandfsTags*, long, int, int, LogfsLowLevelReadResult*);
+void nandfssetmagic(Nandfs*, void*);
+char *nandfswritepageauxiliary(Nandfs*, NandfsTags*, long, int);
+char *nandfsreadpage(Nandfs*, void*, NandfsTags*, long, int, int, LogfsLowLevelReadResult*);
+char *nandfsreadpagerange(Nandfs*, void*, long, int, int, int, LogfsLowLevelReadResult*);
+char *nandfsupdatepage(Nandfs*, void*, ulong, uchar, long, int);
+
+long nandfsgetnerase(Nandfs*, long);
+void nandfssetnerase(Nandfs*, long, ulong);
+void nandfssetpartial(Nandfs*, long, int);
+
+char *nandfsmarkabsblockbad(Nandfs*, long);
+
+/* low level interface functions */
+
+char *nandfsopen(Nandfs*, long, long, int, int, long*);
+short nandfsgettag(Nandfs*, long);
+void nandfssettag(Nandfs*, long, short);
+long nandfsgetpath(Nandfs*, long);
+void nandfssetpath(Nandfs*, long, ulong);
+int nandfsgetblockpartialformatstatus(Nandfs*, long);
+long nandfsfindfreeblock(Nandfs*, long*);
+char *nandfsreadblock(Nandfs*, void*, long, LogfsLowLevelReadResult*);
+char *nandfswriteblock(Nandfs*, void*, uchar, ulong, int, long*, long);
+char *nandfswritepage(Nandfs*, void*, long, int);
+char *nandfseraseblock(Nandfs*, long, void **, int*);
+char *nandfsformatblock(Nandfs*, long, uchar, ulong, long, long, int, long*, void*, int*);
+char *nandfsreformatblock(Nandfs*, long, uchar, ulong, int, long*, void*, int*);
+char *nandfsmarkblockbad(Nandfs*, long);
+int nandfsgetpagesize(Nandfs*);
+int nandfsgetpagesperblock(Nandfs*);
+long nandfsgetblocks(Nandfs*);
+long nandfsgetbaseblock(Nandfs*);
+int nandfsgetblocksize(Nandfs*);
+ulong nandfscalcrawaddress(Nandfs*, long, int);
+char *nandfsgetblockstatus(Nandfs*, long, int*, void **, LogfsLowLevelReadResult*);
+int nandfscalcformat(Nandfs*, long, long, long, long*, long*, long*);
+int nandfsgetopenstatus(Nandfs*);
+char *nandfssync(Nandfs*);
+
+/* defined in environment */
+void *nandfsrealloc(void*, ulong);
+void nandfsfreemem(void*);
--- /dev/null
+++ b/include/pool.h
@@ -1,0 +1,73 @@
+/* Inferno tree allocator */
+
+typedef struct Pool Pool;
+typedef struct Bhdr Bhdr;
+typedef struct Btail Btail;
+
+#pragma incomplete Pool
+
+enum
+{
+	MAGIC_A		= 0xa110c,		/* Allocated block */
+	MAGIC_F		= 0xbadc0c0a,		/* Free block */
+	MAGIC_E		= 0xdeadbabe,		/* End of arena */
+	MAGIC_I		= 0xabba		/* Block is immutable (hidden from gc) */
+};
+
+struct Bhdr
+{
+	ulong	magic;
+	ulong	size;
+	union {
+		uchar data[1];
+		struct {
+			Bhdr*	bhl;
+			Bhdr*	bhr;
+			Bhdr*	bhp;
+			Bhdr*	bhv;
+			Bhdr*	bhf;
+		} s;
+#define clink	u.l.link
+#define csize	u.l.size
+		struct {
+			Bhdr*	link;
+			int	size;
+		} l;
+	} u;
+};
+
+struct Btail
+{
+	/* ulong	pad; */
+	Bhdr*	hdr;
+};
+
+#define B2D(bp)		((void*)bp->u.data)
+#define D2B(b, dp)	b = ((Bhdr*)(((uchar*)dp)-(((Bhdr*)0)->u.data))); \
+			if(b->magic != MAGIC_A && b->magic != MAGIC_I)\
+				poolfault(dp, "alloc:D2B", getcallerpc(&dp));
+#define B2NB(b)		((Bhdr*)((uchar*)b + b->size))
+#define B2PT(b)		((Btail*)((uchar*)b - sizeof(Btail)))
+#define B2T(b)		((Btail*)(((uchar*)b)+b->size-sizeof(Btail)))
+
+#define B2LIMIT(b)	((Bhdr*)((uchar*)b + b->csize))
+
+#define BHDRSIZE	((int)(((Bhdr*)0)->u.data)+sizeof(Btail))
+
+extern	void	(*poolfault)(void *, char *, ulong);
+extern	void	poolinit(void);
+extern	void*	poolalloc(Pool*, ulong);
+extern	void	poolfree(Pool*, void*);
+extern	Bhdr*	poolchain(Pool*);
+extern	int	poolcompact(Pool*);
+extern	void	poolimmutable(void*);
+extern	ulong	poolmsize(Pool*, void*);
+extern	void	poolmutable(void*);
+extern	char*	poolname(Pool*);
+extern	int	poolread(char*, int, ulong);
+extern	void*	poolrealloc(Pool*, void*, ulong);
+extern	int	poolsetsize(char*, int);
+extern	void	poolsetcompact(Pool*, void (*)(void*, void*));
+extern	char*	poolaudit(char*(*)(int, Bhdr *));
+
+extern	void	(*poolmonitor)(int, ulong, Bhdr*, ulong);
--- /dev/null
+++ b/include/pooldefs.h
@@ -1,0 +1,5 @@
+#define left    u.s.bhl
+#define right   u.s.bhr
+#define fwd     u.s.bhf
+#define prev    u.s.bhv
+#define parent  u.s.bhp
--- /dev/null
+++ b/include/prefab.h
@@ -1,0 +1,103 @@
+#pragma src "/usr/inferno/libprefab"
+
+typedef struct PElement PElement;
+typedef struct PCompound PCompound;
+typedef struct Memimage Memimage;
+
+enum
+{
+	Dirty,
+	Clean
+};
+
+enum Elementtype	/* same as in prefab.m */
+{
+	EIcon,
+	EText,
+	ETitle,
+	EHorizontal,
+	EVertical,
+	ESeparator,
+	NEtypes
+};
+
+enum Adjust	/* same as in prefab.m */
+{
+	/* first arg: size of elements */
+	Adjpack = 10,	/* leave alone, pack tightly */
+	Adjequal = 11,	/* make equal */
+	Adjfill = 12,	/* make equal, filling available space */
+
+	/* second arg: position of element within space */
+	Adjleft = 20,
+	Adjup = 20,
+	Adjcenter = 21,
+	Adjright = 22,
+	Adjdown = 22
+};
+
+enum
+{
+	Maxchars = 128	/* maximum # chars in a word */
+};
+
+struct PElement
+{
+	Prefab_Element	e;
+	Point		drawpt;
+	Prefab_Compound*highlight;
+	List*		first;
+	List*		last;
+	List*		vfirst;
+	List*		vlast;
+	int		nkids;
+	int		newline;
+	int		pkind;	/* for error check against e.kind */
+};
+
+struct PCompound
+{
+	Prefab_Compound	c;
+	Display*	display;
+};
+
+extern Type*	TLayout;
+extern Type*	TElement;
+extern Type*	TCompound;
+
+PCompound*	iconbox(Prefab_Environ*, Draw_Point, String*, Draw_Image*, Draw_Image*);
+PCompound*	textbox(Prefab_Environ*, Draw_Rect, String*, String*);
+PCompound*	layoutbox(Prefab_Environ*, Draw_Rect, String*, List*);
+PCompound*	box(Prefab_Environ*, Draw_Point, Prefab_Element*, Prefab_Element*);
+
+PElement*	separatorelement(Prefab_Environ*, Draw_Rect, Draw_Image*, Draw_Image*);
+PElement*	iconelement(Prefab_Environ*, Draw_Rect, Draw_Image*, Draw_Image*);
+PElement*	textelement(Prefab_Environ*, String*, Draw_Rect, enum Elementtype);
+PElement*	layoutelement(Prefab_Environ*, List*, Draw_Rect, enum Elementtype);
+PElement*	elistelement(Prefab_Environ*, Prefab_Element*, enum Elementtype);
+PElement*	appendelist(Prefab_Element*, Prefab_Element*);
+
+void		drawcompound(Prefab_Compound*);
+void		redrawcompound(Image*, Rectangle, Prefab_Compound*);
+void		refreshcompound(Image*, Rectangle, void*);
+void		drawelement(Prefab_Element*, Image*, Rectangle, int, int);
+void		translateelement(Prefab_Element*, Point);
+void		adjustelement(Prefab_Element*, int, int);
+void		highlightelement(Prefab_Element*, Image*, Prefab_Compound*, int);
+void		clipelement(Prefab_Element*, Rectangle);
+void		scrollelement(Prefab_Element*, Point, int*);
+int		showelement(Prefab_Element*, Prefab_Element*);
+void		edge(Prefab_Environ*, Image*, Draw_Rect, Draw_Rect);
+int		fitrect(Rectangle*, Rectangle);
+Draw_Rect	edgerect(Prefab_Environ*, Draw_Point, Draw_Rect*);
+List*		prefabwrap(void*);
+List*		listoflayout(Prefab_Style*, String*, int);
+
+extern PElement*	lookupelement(Prefab_Element*);
+extern PCompound*	lookupcompound(Prefab_Compound*);
+extern PElement*	checkelement(Prefab_Element*);
+extern PCompound*	checkcompound(Prefab_Compound*);
+extern int		badenviron(Prefab_Environ*, int);
+extern PElement*	mkelement(Prefab_Environ*, enum Elementtype);
+extern Point		iconsize(Image*);
+extern void		localrefreshcompound(Memimage*, Rectangle, void*);
--- /dev/null
+++ b/include/raise.h
@@ -1,0 +1,26 @@
+/*
+ * Exceptions thrown by the interpreter
+ */	
+extern	char exAlt[];		/* alt send/recv on same chan */
+extern	char exBusy[];		/* channel busy */
+extern	char exModule[];	/* module not loaded */
+extern	char exCompile[];	/* compile failed */
+extern	char exCrange[];	/* constant range */
+extern	char exCctovflw[];	/* constant table overflow */
+extern	char exCphase[];	/* compiler phase error */
+extern	char exType[];		/* type not constructed correctly */
+extern	char exZdiv[];		/* zero divide */
+extern	char exHeap[];		/* out of memory: heap */
+extern	char	exImage[];	/* out of memory: image */
+extern	char exItype[];		/* inconsistent type */
+extern	char exMathia[];	/* invalid math argument */
+extern	char exBounds[];	/* array bounds error */
+extern	char exNegsize[];	/* negative array size */
+extern	char exNomem[];		/* out of memory: main */
+extern	char exSpawn[];		/* spawn a builtin module */
+extern	char exOp[];		/* illegal dis instruction */
+extern	char exTcheck[];	/* type check */
+extern	char exInval[];		/* invalid argument */
+extern	char exNilref[];	/* dereference of nil */
+extern	char exRange[];		/* value out of range */
+extern  char exLoadedmod[];     /* need newmod */
--- /dev/null
+++ b/include/rdbg.h
@@ -1,0 +1,35 @@
+/* Remote kernel debug protocol */
+enum
+{
+	Terr='0',	/* not sent */
+	Rerr,
+	Tmget,
+	Rmget,
+	Tmput,
+	Rmput,
+
+	Tspid,	/* obsolete */
+	Rspid,	/* obsolete */
+	Tproc,
+	Rproc,
+	Tstatus,
+	Rstatus,
+	Trnote,
+	Rrnote,
+
+	Tstartstop,
+	Rstartstop,
+	Twaitstop,
+	Rwaitstop,
+	Tstart,
+	Rstart,
+	Tstop,
+	Rstop,
+	Tkill,
+	Rkill,
+
+	Tcondbreak,
+	Rcondbreak,
+
+	RDBMSGLEN = 10	/* tag byte, 9 data bytes */
+};
--- /dev/null
+++ b/include/styx.h
@@ -1,0 +1,140 @@
+#pragma src "/usr/inferno/lib9"
+#pragma	lib	"libc.a"
+
+#define	VERSION9P	"9P2000"
+
+#define	MAXWELEM	16
+
+typedef
+struct	Fcall
+{
+	uchar	type;
+	u32int	fid;
+	ushort	tag;
+	/* union { */
+		/* struct { */
+			u32int	msize;		/* Tversion, Rversion */
+			char	*version;	/* Tversion, Rversion */
+		/* }; */
+		/* struct { */
+			ushort	oldtag;		/* Tflush */
+		/* }; */
+		/* struct { */
+			char	*ename;		/* Rerror */
+		/* }; */
+		/* struct { */
+			Qid	qid;		/* Rattach, Ropen, Rcreate */
+			u32int	iounit;		/* Ropen, Rcreate */
+		/* }; */
+		/* struct { */
+			Qid	aqid;		/* Rauth */
+		/* }; */
+		/* struct { */
+			u32int	afid;		/* Tauth, Tattach */
+			char	*uname;		/* Tauth, Tattach */
+			char	*aname;		/* Tauth, Tattach */
+		/* }; */
+		/* struct { */
+			u32int	perm;		/* Tcreate */ 
+			char	*name;		/* Tcreate */
+			uchar	mode;		/* Tcreate, Topen */
+		/* }; */
+		/* struct { */
+			u32int	newfid;		/* Twalk */
+			ushort	nwname;		/* Twalk */
+			char	*wname[MAXWELEM];	/* Twalk */
+		/* }; */
+		/* struct { */
+			ushort	nwqid;		/* Rwalk */
+			Qid	wqid[MAXWELEM];		/* Rwalk */
+		/* }; */
+		/* struct { */
+			vlong	offset;		/* Tread, Twrite */
+			u32int	count;		/* Tread, Twrite, Rread */
+			char	*data;		/* Twrite, Rread */
+		/* }; */
+		/* struct { */
+			ushort	nstat;		/* Twstat, Rstat */
+			uchar	*stat;		/* Twstat, Rstat */
+		/* }; */
+	/* }; */
+} Fcall;
+
+
+#define	GBIT8(p)	((p)[0])
+#define	GBIT16(p)	((p)[0]|((p)[1]<<8))
+#define	GBIT32(p)	((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24))
+#define	GBIT64(p)	((vlong)((p)[0]|((p)[1]<<8)|((p)[2]<<16)|((p)[3]<<24)) |\
+				((vlong)((p)[4]|((p)[5]<<8)|((p)[6]<<16)|((p)[7]<<24)) << 32))
+
+#define	PBIT8(p,v)	(p)[0]=(v)
+#define	PBIT16(p,v)	(p)[0]=(v);(p)[1]=(v)>>8
+#define	PBIT32(p,v)	(p)[0]=(v);(p)[1]=(v)>>8;(p)[2]=(v)>>16;(p)[3]=(v)>>24
+#define	PBIT64(p,v)	(p)[0]=(v);(p)[1]=(v)>>8;(p)[2]=(v)>>16;(p)[3]=(v)>>24;\
+			(p)[4]=(v)>>32;(p)[5]=(v)>>40;(p)[6]=(v)>>48;(p)[7]=(v)>>56
+
+#define	BIT8SZ		1
+#define	BIT16SZ		2
+#define	BIT32SZ		4
+#define	BIT64SZ		8
+#define	QIDSZ	(BIT8SZ+BIT32SZ+BIT64SZ)
+
+/* STATFIXLEN includes leading 16-bit count */
+/* The count, however, excludes itself; total size is BIT16SZ+count */
+#define STATFIXLEN	(BIT16SZ+QIDSZ+5*BIT16SZ+4*BIT32SZ+1*BIT64SZ)	/* amount of fixed length data in a stat buffer */
+
+#define	NOTAG		(ushort)~0U	/* Dummy tag */
+#define	NOFID		(u32int)~0U	/* Dummy fid */
+#define	IOHDRSZ		24	/* ample room for Twrite/Rread header (iounit) */
+
+enum
+{
+	Tversion =	100,
+	Rversion,
+	Tauth =	102,
+	Rauth,
+	Tattach =	104,
+	Rattach,
+	Terror =	106,	/* illegal */
+	Rerror,
+	Tflush =	108,
+	Rflush,
+	Twalk =		110,
+	Rwalk,
+	Topen =		112,
+	Ropen,
+	Tcreate =	114,
+	Rcreate,
+	Tread =		116,
+	Rread,
+	Twrite =	118,
+	Rwrite,
+	Tclunk =	120,
+	Rclunk,
+	Tremove =	122,
+	Rremove,
+	Tstat =		124,
+	Rstat,
+	Twstat =	126,
+	Rwstat,
+	Tmax,
+};
+
+uint	convM2S(uchar*, uint, Fcall*);
+uint	convS2M(Fcall*, uchar*, uint);
+uint	sizeS2M(Fcall*);
+
+int	statcheck(uchar *abuf, uint nbuf);
+uint	convM2D(uchar*, uint, Dir*, char*);
+uint	convD2M(Dir*, uchar*, uint);
+uint	sizeD2M(Dir*);
+
+int	fcallfmt(Fmt*);
+int	dirfmt(Fmt*);
+int	dirmodefmt(Fmt*);
+
+int	read9pmsg(int, void*, uint);
+
+#pragma	varargck	type	"F"	Fcall*
+#pragma	varargck	type	"M"	ulong
+#pragma	varargck	type	"D"	Dir*
--- /dev/null
+++ b/include/styxserver.h
@@ -1,0 +1,98 @@
+
+#define Qroot	0
+
+#define MSGMAX	((((8192+128)*2)+3) & ~3)
+
+extern char Enomem[];	/* out of memory */
+extern char Eperm[];		/* permission denied */
+extern char Enodev[];	/* no free devices */
+extern char Ehungup[];	/* i/o on hungup channel */
+extern char Eexist[];		/* file exists */
+extern char Enonexist[];	/* file does not exist */
+extern char Ebadcmd[];	/* bad command */
+extern char Ebadarg[];	/* bad arguments */
+
+typedef uvlong	Path;
+typedef struct Styxserver	Styxserver;
+typedef struct Styxops Styxops;
+typedef struct Styxfile Styxfile;
+typedef struct Client Client;
+typedef struct Fid Fid;
+
+struct Styxserver
+{
+	Styxops *ops;
+	Path qidgen;
+	int connfd;
+	int needfile;
+	Client *clients;
+	Client *curc;
+	Styxfile *root;
+	Styxfile **ftab;
+	void	*priv;	/* private */
+};
+
+struct Client
+{
+	Styxserver *server;
+	Client *next;
+	int		fd;
+	char	msg[MSGMAX];
+	uint		nread;		/* valid bytes in msg (including nc)*/
+	int		nc;			/* bytes consumed from front of msg by convM2S */
+	char	data[MSGMAX];	/* Tread/Rread data */
+	int		state;
+	Fid		*fids;
+	char		*uname;	/* uid */
+	char		*aname;	/* attach name */
+	void		*u;
+};
+
+struct Styxops
+{
+	char *(*newclient)(Client *c);
+	char *(*freeclient)(Client *c);
+
+	char *(*attach)(char *uname, char *aname);
+	char *(*walk)(Qid *qid, char *name);
+	char *(*open)(Qid *qid, int mode);
+	char *(*create)(Qid *qid, char *name, int perm, int mode);
+	char *(*read)(Qid qid, char *buf, ulong *n, vlong offset);
+	char *(*write)(Qid qid, char *buf, ulong *n, vlong offset);
+	char *(*close)(Qid qid, int mode);
+	char *(*remove)(Qid qid);
+	char *(*stat)(Qid qid, Dir *d);
+	char *(*wstat)(Qid qid, Dir *d);
+};
+
+struct Styxfile
+{
+	Dir	d;
+	Styxfile *parent;
+	Styxfile *child;
+	Styxfile *sibling;
+	Styxfile *next;
+	int ref;
+	int open;
+	void	*u;
+};
+
+char *styxinit(Styxserver *server, Styxops *ops, char *port, int perm, int needfile);
+char *styxwait(Styxserver *server);
+char *styxprocess(Styxserver *server);
+char *styxend(Styxserver *server);
+
+Client *styxclient(Styxserver *server);
+
+Styxfile *styxaddfile(Styxserver *server, Path pqid, Path qid, char *name, int mode, char *owner);
+Styxfile *styxadddir(Styxserver *server, Path pqid, Path qid, char *name, int mode, char *owner);
+int styxrmfile(Styxserver *server, Path qid);
+Styxfile *styxfindfile(Styxserver *server, Path qid);
+
+int	styxperm(Styxfile *file, char *uid, int mode);
+long styxreadstr(ulong off, char *buf, ulong n, char *str);
+Qid styxqid(int path, int isdir);
+void *styxmalloc(int n);
+void styxfree(void *p);
+void styxdebug(void);
+void styxsetowner(char*);
--- /dev/null
+++ b/include/tk.h
@@ -1,0 +1,853 @@
+/*
+ * Here are some conventions about  our Tk widgets.
+ *
+ * When a widget is packed, its act geom record is
+ * set so that act.{x,y} is the vector from the containing
+ * widget's origin to the position of this widget.  The position
+ * is the place just outside the top-left border.  The origin
+ * is the place just inside the top-left border.
+ * act.{width,height} gives the allocated dimensions inside
+ * the border --- it will be the requested width or height
+ * plus ipad{x,y} plus any filling done by the packer.
+ *
+ * The tkposn function returns the origin of its argument
+ * widget, expressed in absolute screen coordinates.
+ *
+ * The actual drawing contents of the widget should be
+ * drawn at an internal origin that is the widget's origin
+ * plus the ipad vector.
+ */
+
+/*
+ * event printing
+ */
+#pragma	varargck	type	"v"	int
+#pragma	varargck	argpos	tkwreq	2
+
+enum
+{
+	TKframe,		/* Widget type */
+	TKlabel,
+	TKcheckbutton,
+	TKbutton,
+	TKmenubutton,
+	TKmenu,
+	TKseparator,
+	TKcascade,
+	TKlistbox,
+	TKscrollbar,
+	TKtext,
+	TKcanvas,
+	TKentry,
+	TKradiobutton,
+	TKscale,
+	TKpanel,
+	TKchoicebutton,
+	TKwidgets,
+
+	TKsingle	= 0,	/* Select mode */
+	TKbrowse,
+	TKmultiple,
+	TKextended,
+
+	TKraised,		/* Relief */
+	TKsunken,
+	TKflat,
+	TKgroove,
+	TKridge,
+
+	TkArepl		= 0,	/* Bind options */
+	TkAadd,
+	TkAsub,
+
+	Tkvertical	= 0,	/* Scroll bar orientation */
+	Tkhorizontal,
+
+	Tkwrapnone	= 0,	/* Wrap mode */
+	Tkwrapword,
+	Tkwrapchar,
+
+	TkDdelivered	= 0,	/* Event Delivery results */
+	TkDbreak,
+	TkDnone,
+
+	TkLt = 0,		/* Comparison operators */
+	TkLte,
+	TkEq,
+	TkGte,
+	TkGt,
+	TkNeq,
+
+	
+	OPTdist		= 0,	/* Distance; aux is offset of TkEnv* */
+	OPTstab,		/* String->Constant table; aux is TkStab array */
+	OPTtext,		/* Text string */
+	OPTwinp,		/* Window Path to Tk ptr */
+	OPTflag,		/* Option sets bitmask; aux is TkStab array*/
+	OPTbmap,		/* Option specifies bitmap file */
+	OPTbool,		/* Set to one if option present */
+	OPTfont,		/* Env font */
+	OPTfrac,		/* list of fixed point distances (count in aux) */
+	OPTnnfrac,	/* non-negative fixed point distance */
+	OPTctag,		/* Tag list for canvas item */
+	OPTtabs,		/* Tab stops; aux is offset of TkEnv* */
+	OPTcolr,		/* Colors; aux is index into colour table */
+	OPTimag,		/* Image */
+	OPTsize,		/* width/height; aux is offset of TkEnv* */
+	OPTnndist,		/* Non-negative distance */
+	OPTact,		/* actx or acty */
+	OPTignore,	/* ignore this option */
+	OPTsticky,	/* sticky (any comb. of chars n, s, e, w) */
+	OPTlist,		/* list of text values */
+	OPTflags,		/* more than one OPTflag */
+
+	BoolX		= 0,
+	BoolT,
+	BoolF,
+
+	Tkmaxitem	= 128,
+	Tkminitem	= 32,
+	Tkcvstextins	= 1024,
+	Tkmaxdump	= 1024,
+	Tkentryins	= 128,
+	TkMaxmsgs	= 100,
+	Tkshdelta	= 0x40,	/* color intensity delta for shading */
+
+	Tkfpscalar	= 10000,	/* Fixed point scale factor */
+
+	Tkdpi		= 100,	/* pixels per inch on an average display */
+
+	Tksweep		= 64,	/* binds before a sweep */
+
+	TkColcachesize = 128,	/* colours cached per context (display) */
+
+	TkStatic	= 0,
+	TkDynamic	= 1,
+
+	TkRptclick		= 100,	/* granularity */
+	TkRptpause	= 300,	/* autorepeat inital delay */
+	TkRptinterval	= 100,	/* autorepeat interval */
+
+	TkBlinkinterval	= 500
+};
+
+#define TKSTRUCTALIGN	4
+#define TKI2F(i)	((i)*Tkfpscalar)
+extern	int TKF2I(int);
+/*#define TKF2I(f)	(((f) + Tkfpscalar/2)/Tkfpscalar)*/
+#define IAUX(i)		((void*)i)
+#define AUXI(i)		((int)i)
+#define TKKEY(i)	((i)&0xFFFF)
+
+typedef struct Tk Tk;
+typedef struct TkCol TkCol;
+typedef struct TkCtxt TkCtxt;
+typedef struct TkEnv TkEnv;
+typedef struct TkName TkName;
+typedef struct TkTtabstop TkTtabstop;
+typedef struct TkOptab TkOptab;
+typedef struct TkOption TkOption;
+typedef struct TkStab TkStab;
+typedef struct TkTop TkTop;
+typedef struct TkGeom TkGeom;
+typedef struct TkMethod TkMethod;
+typedef struct TkAction TkAction;
+typedef struct TkWin TkWin;
+typedef struct TkCmdtab TkCmdtab;
+typedef struct TkMemimage TkMemimage;
+typedef struct TkMouse TkMouse;
+typedef struct TkVar TkVar;
+typedef struct TkMsg TkMsg;
+typedef struct TkEbind TkEbind;
+typedef struct TkImg TkImg;
+typedef struct TkPanelimage TkPanelimage;
+typedef struct TkWinfo TkWinfo;
+typedef struct TkCursor TkCursor;
+typedef struct TkGrid TkGrid;
+typedef struct TkGridbeam TkGridbeam;
+typedef struct TkGridcell TkGridcell;
+
+#pragma incomplete TkCol
+
+struct TkImg
+{
+	TkTop*	top;
+	int	ref;
+	int	type;
+	int	w;
+	int	h;
+	TkEnv*	env;
+	Image*	img;
+	TkImg*	link;
+	TkName*	name;
+	char *cursor;
+};
+
+struct TkCursor
+{
+	int	def;
+	Point	p;
+	Image*	bit;
+	TkImg*	img;
+};
+
+struct TkEbind
+{
+	int	event;
+	char*	cmd;
+};
+
+struct TkMsg
+{
+	TkVar*	var;
+	TkMsg*	link;
+	char	msg[TKSTRUCTALIGN];
+};
+
+enum
+{
+	TkVchan		= 1,
+	TkVstring,
+};
+
+struct TkVar
+{
+	int	type;
+	TkVar*	link;
+	void*	value;
+	char	name[TKSTRUCTALIGN];
+};
+
+struct TkPanelimage
+{
+	void*		image;		/* Image paired with Draw_Image: see lookupimage in libinterp/draw.c */
+	int			ref;
+	TkPanelimage*	link;
+};
+
+struct TkMouse
+{
+	int		x;
+	int		y;
+	int		b;
+};
+
+struct TkMemimage
+{
+	Rectangle	r;
+	ulong	chans;
+	uchar*	data;
+};
+
+struct TkCmdtab
+{
+	char*		name;
+	char*		(*fn)(Tk*, char*, char**);
+};
+
+struct TkWinfo
+{
+	Tk*		w;
+	Rectangle	r;
+};
+
+struct TkAction
+{
+	int		event;
+	int		type;
+	char*		arg;
+	TkAction*	link;
+};
+
+struct TkStab
+{
+	char*		val;
+	int		con;
+};
+
+struct TkOption
+{
+	char*		o;
+	int		type;
+	int		offset;
+	void*		aux;
+};
+
+struct TkOptab
+{
+	void*		ptr;
+	TkOption*	optab;	
+};
+
+enum
+{
+	/* Widget Control Bits */
+	Tktop		= (1<<0),
+	Tkbottom	= (1<<1),
+	Tkleft		= (1<<2),
+	Tkright		= (1<<3),
+	Tkside		= Tktop|Tkbottom|Tkleft|Tkright,
+	Tkfillx		= (1<<4),
+	Tkfilly		= (1<<5),
+	Tkfill		= Tkfillx|Tkfilly,
+	Tkexpand	= (1<<6),
+	Tkrefresh	= (1<<7),
+	Tknoprop	= (1<<8),
+	Tkbaseline 	= (1<<10),
+	Tknumeric	= (1<<11),
+
+	Tknorth		= (1<<10),
+	Tkeast		= (1<<11),
+	Tksouth		= (1<<12),
+	Tkwest		= (1<<13),
+	Tkcenter		= 0,
+	Tkanchor	= Tknorth|Tkeast|Tksouth|Tkwest,
+	Tksuspended	= (1<<14),		/* window suspended pending resize */
+
+	Tkgridpack	= (1<<17),		/* temporary flag marking addition to grid */
+	Tkgridremove	= (1<<18),		/* marked for removal from grid */
+	Tktakefocus	= (1<<19),
+	Tktransparent		= (1<<20),	/* Doesn't entirely obscure its background */
+	Tkwindow	= (1<<21),	/* Top level window */
+	Tkactive		= (1<<22),	/* Pointer is over active object */
+	Tkactivated	= (1<<23),	/* Button pressed etc.. */
+	Tkdisabled	= (1<<24),	/* Button is not accepting events */
+	Tkmapped	= (1<<25),	/* Mapped onto display */
+	Tknograb		= (1<<26),
+	Tkdestroy		= (1<<27),	/* Marked for death */
+	Tksetwidth	= (1<<28),
+	Tksetheight	= (1<<29),
+	Tksubsub	= (1<<30),
+	Tkswept		= (1<<31),
+
+	/* Supported Event Types 		*/
+	/*
+	 * Bits 0-15 are keyboard characters
+	 * but duplicated by other events, as we can distinguish
+	 * key events from others with the TkKey bit.
+	 * N.B. make sure that this distinction *is* made;
+	 * i.e.
+	 *	if (event & TkButton1P)
+	 *   is no longer sufficient to test for button1 down.
+	 *
+	 * 	if (!(event & TkKey) && (event & TkButton1P))
+	 *   would be better.
+	 */
+	TkButton1P	= (1<<0),
+	TkButton1R	= (1<<1),
+	TkButton2P	= (1<<2),
+	TkButton2R	= (1<<3),
+	TkButton3P	= (1<<4),
+	TkButton3R	= (1<<5),
+	TkButton4P	= (1<<6),
+	TkButton4R	= (1<<7),
+	TkButton5P	= (1<<8),
+	TkButton5R	= (1<<9),
+	TkButton6P	= (1<<10),
+	TkButton6R	= (1<<11),
+	/*
+	 * 12-15 reserved for more buttons.
+	 */
+	TkExtn1		= (1<<16),
+	TkExtn2		= (1<<17),
+	TkTakefocus	= (1<<18),
+	/*
+	 * 19-20 currently free
+	 */
+	TkDestroy		= (1<< 21),
+	TkEnter		= (1<<22),
+	TkLeave		= (1<<23),
+	TkMotion	= (1<<24),
+	TkMap		= (1<<25),
+	TkUnmap		= (1<<26),
+	TkKey		= (1<<27),
+	TkFocusin	= (1<<28),
+	TkFocusout	= (1<<29),
+	TkConfigure	= (1<<30),
+	TkDouble	= (1<<31),
+	TkEmouse	= TkButton1P|TkButton1R|TkButton2P|TkButton2R|
+			TkButton3P|TkButton3R|
+			TkButton4P|TkButton4R|
+			TkButton5P|TkButton5R|
+			TkButton6P|TkButton6R|TkMotion,
+	TkEpress	= TkButton1P|TkButton2P|TkButton3P|
+			TkButton4P|TkButton5P|TkButton6P,
+	TkErelease	= TkButton1R|TkButton2R|TkButton3R|
+					TkButton4R|TkButton5R|TkButton6R,
+	TkExtns	= TkExtn1|TkExtn2,
+	TkAllEvents	= ~0,
+
+	TkCforegnd	= 0,
+	TkCbackgnd,			/* group of 3 */
+	TkCbackgndlght,
+	TkCbackgnddark,
+	TkCselect,
+	TkCselectbgnd,			/* group of 3 */
+	TkCselectbgndlght,
+	TkCselectbgnddark,
+	TkCselectfgnd,
+	TkCactivebgnd,		/* group of 3 */
+	TkCactivebgndlght,
+	TkCactivebgnddark,
+	TkCactivefgnd,
+	TkCdisablefgnd,
+	TkChighlightfgnd,
+	TkCfill,
+	TkCtransparent,
+
+	TkNcolor,
+
+	TkSameshade	= 0,		/* relative shade for tkgshade() and tkrgbashade()*/
+	TkLightshade,
+	TkDarkshade
+};
+
+
+struct TkEnv
+{
+	int		ref;
+	TkTop*		top;			/* Owner */
+	ulong		set;
+	ulong		colors[TkNcolor];	/* OPTcolr */
+	Font*		font;			/* Font description */
+	int		wzero;			/* Width of "0" in pixel */
+};
+
+struct TkGeom
+{
+	int		x;
+	int		y;
+	int		width;
+	int		height;
+};
+
+struct TkGridbeam
+{
+	int		equalise;
+	int		minsize;
+	int		maxsize;
+	int		weight;
+	int		pad;
+	int		act;
+	char*	name;
+};
+
+struct TkGridcell
+{
+	Tk*		tk;
+	Point		span;
+};
+
+struct TkGrid
+{
+	TkGridcell**	cells;		/* 2D array of cells, y major, x minor */
+	Point			dim;		/* dimensions of table */
+	TkGridbeam*	rows;
+	TkGridbeam*	cols;
+	Point			origin;	/* top left point grid was rendered at */
+};
+
+struct Tk
+{
+	int		type;		/* Widget type */
+	TkName*		name;		/* Hierarchy name */
+	Tk*		siblings;	/* Link to descendents */
+	Tk*		master;		/* Pack owner */
+	Tk*		slave;		/* Packer slaves */
+	Tk*		next;		/* Link for packer slaves */
+	Tk*		parent;		/* Window is sub of this canvas or text */
+	Tk*		depth;		/* Window depth when mapped */
+	void		(*geom)(Tk*, int, int, int, int);		/* Geometry change notify function */
+	void		(*destroyed)(Tk*);		/* Destroy notify function */
+	int		flag;		/* Misc flags. */
+	TkEnv*		env;		/* Colors & fonts */
+	TkAction*	binds;		/* Binding of current events */
+
+	TkGeom		req;		/* Requested size and position */
+	TkGeom		act;		/* Actual size and position */
+	int		relief;		/* 3D border type */
+	int		borderwidth;	/* 3D border size */
+	int		highlightwidth;
+	Point		pad;		/* outside frame padding */
+	Point		ipad;		/* inside frame padding */
+	Rectangle	dirty;	/* dirty rectangle, relative to widget */
+	TkGrid*	grid;		/* children are packed in a grid */
+
+	/* followed by widget-dependent data */
+};
+
+struct TkWin
+{
+	Image*	image;
+	Tk*		next;
+	Point		act;
+	Point		req;
+	void*	di;		/* !=H if it's been set externally */
+	int		changed;	/* requested rect has changed since request sent */
+	int		reqid;	/* id of request most recently sent out; replies to earlier requests are ignored */
+
+	/* menu specific members */
+	Tk*		slave;
+	char*		postcmd;
+	char*		cascade;
+	int			freeonunmap;
+	char			*cbname;		/* name of choicebutton that posted this */
+
+	Point			delta;
+	int			speed;
+	int			waiting;
+};
+
+struct TkMethod
+{
+	char*		name;
+	TkCmdtab*	cmd;
+	void		(*free)(Tk*);
+	char*	(*draw)(Tk*, Point);
+	void		(*geom)(Tk*);
+	void		(*getimgs)(Tk*, Image**, Image**);
+
+	void		(*focusorder)(Tk*);	/* add any focusable descendants to the focus order */
+	void		(*dirtychild)(Tk*);		/* Child notifies parent to redraw */
+	Point		(*relpos)(Tk*);
+	Tk*		(*deliver)(Tk*, int, void*);
+	void		(*see)(Tk*, Rectangle*, Point*);
+	Tk*		(*inwindow)(Tk*, Point*);
+	void		(*varchanged)(Tk*, char*, char*);
+	void		(*forgetsub)(Tk*, Tk*);
+	int		ncmd;
+};
+
+struct TkName
+{
+	TkName*		link;
+	void*		obj;		/* Name for ... */
+	union {
+		TkAction*	binds;
+	}prop;				/* Properties for ... */
+	int		ref;
+	char		name[TKSTRUCTALIGN];
+};
+
+struct TkTtabstop
+{
+	int		pos;
+	int		justify;
+	TkTtabstop*	next;
+};
+
+struct TkCtxt
+{
+	void*	lock;
+	Display*	display;
+	int		ncol;
+	TkCol*	chead;
+	TkCol*	ctail;
+	Image*	i;			/* temporary image for drawing buttons, etc */
+	Image*	ia;			/* as above, but with an alpha channel */
+	Tk*		tkkeygrab;
+
+	int		focused;
+	Tk*		mfocus;
+	Tk*		mgrab;
+	Tk*		entered;
+	TkMouse	mstate;
+
+	Tk*		tkmenu;
+	void*	extn;
+};
+
+struct TkTop
+{
+	void*	dd;	/* really Draw_Display */
+	void*	wreq;	/* really chan of string */
+	void*	di;		/* really Draw_Image* */
+	void*	wmctxt;	/* really Draw_Wmcontext */
+	Rectangle	screenr;	/* XXX sleazy equiv to Draw_Rect, but what else? */
+
+	/* Private from here on */
+	TkCtxt*		ctxt;
+	Display*	display;
+	Tk*		root;			/* list of all objects, linked by siblings; first object is "." */
+	Tk*		windows;
+	Tk**		focusorder;
+	int		nfocus;
+	TkEnv*		env;
+	TkTop*		link;
+	TkVar*		vars;
+	TkImg*		imgs;
+	TkPanelimage*	panelimages;
+	TkAction*	binds[TKwidgets];
+	int		debug;
+	int		execdepth;
+	char		focused;
+	char		dirty;
+	char		noupdate;
+	char*	err;
+	char		errcmd[32];
+	char		errx[32];
+};
+
+#define TKobj(t, p)	((t*)((p)+1))
+//#define TKobj(t, p)	((t*)(p->obj))
+#define OPTION(p, t, o)	(*(t*)((char*)p + o))
+
+/* Command entry points */
+extern	char*	tkbind(TkTop*, char*, char**);
+extern	char*	tkbutton(TkTop*, char*, char**);
+extern	char*	tkcanvas(TkTop*, char*, char**);
+extern	char*	tkcheckbutton(TkTop*, char*, char**);
+extern	char*	tkchoicebutton(TkTop*, char*, char**);
+extern	char*	tkcursorcmd(TkTop*, char*, char**);
+extern	char*	tkdestroy(TkTop*, char*, char**);
+extern	char*	tkentry(TkTop*, char*, char**);
+extern	char*	tkfocus(TkTop*, char*, char**);
+extern	char*	tkframe(TkTop*, char*, char**);
+extern	char*	tkgrab(TkTop*, char*, char**);
+extern	char*	tkgrid(TkTop*, char*, char**);
+extern	char*	tkimage(TkTop*, char*, char**);
+extern	char*	tklabel(TkTop*, char*, char**);
+extern	char*	tklistbox(TkTop*, char*, char**);
+extern	char*	tklower(TkTop*, char*, char**);
+extern	char*	tkmenu(TkTop*, char*, char**);
+extern	char*	tkmenubutton(TkTop*, char*, char**);
+extern	char*	tkpack(TkTop*, char*, char**);
+extern	char*	tkpanel(TkTop*, char*, char**);
+extern	char*	tkputs(TkTop*, char*, char**);
+extern	char*	tkradiobutton(TkTop*, char*, char**);
+extern	char*	tkraise(TkTop*, char*, char**);
+extern	char*	tkscale(TkTop*, char*, char**);
+extern	char*	tkscrollbar(TkTop*, char*, char**);
+extern	char*	tksend(TkTop*, char*, char**);
+extern	char*	tktext(TkTop*, char*, char**);
+extern	char*	tkupdatecmd(TkTop*, char*, char**);
+extern	char*	tkvariable(TkTop*, char*, char**);
+extern	char*	tkwinfo(TkTop*, char*, char**);
+
+extern	TkMethod	*tkmethod[];
+
+/* Errors - xdata.c*/
+extern	char	TkNomem[];
+extern	char 	TkBadop[];
+extern	char 	TkOparg[];
+extern	char 	TkBadvl[];
+extern	char 	TkBadwp[];
+extern	char 	TkNotop[];
+extern	char	TkDupli[];
+extern	char	TkNotpk[];
+extern	char	TkBadcm[];
+extern	char	TkIstop[];
+extern	char	TkBadbm[];
+extern	char	TkBadft[];
+extern	char	TkBadit[];
+extern	char	TkBadtg[];
+extern	char	TkFewpt[];
+extern	char	TkBadsq[];
+extern	char	TkBadix[];
+extern	char	TkNotwm[];
+extern	char	TkWpack[];
+extern	char	TkBadvr[];
+extern	char	TkNotvt[];
+extern	char	TkMovfw[];
+extern	char	TkBadsl[];
+extern	char	TkSyntx[];
+extern	char TkRecur[];
+extern	char TkDepth[];
+extern	char TkNomaster[];
+extern	char TkNotgrid[];
+extern	char TkIsgrid[];
+extern	char TkBadgridcell[];
+extern	char TkBadspan[];
+extern	char TkBadcursor[];
+
+/* Option tables - xdata.c */
+extern	TkStab	tkanchor[];
+extern	TkStab	tkbool[];
+extern	TkStab	tkcolortab[];
+extern	TkStab	tkjustify[];
+extern	TkStab	tkorient[];
+extern	TkStab	tkrelief[];
+extern	TkStab	tktabjust[];
+extern	TkStab	tkwrap[];
+extern	TkOption	tkgeneric[];
+extern	TkOption	tktop[];
+extern	TkOption	tktopdbg[];
+
+/* panel.c */
+extern	void		tkgetpanelimage(Tk*, Image**, Image**);
+extern	void		tksetpanelimage(Tk *tk, Image*, Image*);
+
+/* General - colrs.c */
+extern	void		tksetenvcolours(TkEnv*);
+
+/* General - ebind.c */
+extern	void		tkcmdbind(Tk*, int, char*, void*);
+extern	TkCtxt*		tkdeldepth(Tk*);
+extern	char*		tkdestroy(TkTop*, char*, char**);
+extern	char*		tkbindings(TkTop*, Tk*, TkEbind*, int);
+extern	int		tkseqparse(char*);
+extern	void		tksetkeyfocus(TkTop*, Tk*, int);
+extern	void		tksetglobalfocus(TkTop*, int);
+
+/* General - image.c */
+extern	TkImg*		tkname2img(TkTop*, char*);
+extern	void		tkimgput(TkImg*);
+extern	void		tksizeimage(Tk*, TkImg*);
+extern	TkImg*		tkauximage(TkTop*, char*, TkMemimage*, int);
+
+/* choicebuttons - menus.c */
+extern	Tk*		tkfindchoicemenu(Tk*);
+
+/* General - packr.c */
+extern	void		tkdelpack(Tk*);
+extern	void		tkappendpack(Tk*, Tk*, int);
+extern	void		tkpackqit(Tk*);
+extern	void		tkrunpack(TkTop*);
+extern	void		tksetslavereq(Tk*, TkGeom);
+extern	int		tkisslave(Tk*, Tk*);
+
+/* General - grids.c */
+extern	int		tkgridder(Tk*);
+extern	void		tkgriddelslave(Tk*);
+extern	char*	tkpropagate(TkTop*, char*);
+extern	void		tkfreegrid(TkGrid*);
+
+/* General - parse.c */
+extern	char*		tkconflist(TkOptab*, char**);
+extern	char*		tkskip(char*, char*);
+extern	char*		tkword(TkTop*, char*, char*, char*, int*);
+extern	char*		tkxyparse(Tk*, char**, Point*);
+extern	char*		tkparse(TkTop*, char*, TkOptab*, TkName**);
+extern	TkName*		tkmkname(char*);
+extern	char*		tkgencget(TkOptab*, char*, char**, TkTop*);
+extern	char*		tkparsecolor(char*, ulong*);
+
+/* General - utils.c */
+extern	Image*		tkgc(TkEnv*, int);
+extern	Image*		tkgshade(TkEnv*, int, int);
+extern	Image*		tkcolor(TkCtxt*, ulong);
+extern	Image*		tkcolormix(TkCtxt*, ulong, ulong);
+extern	Image*		tkgradient(TkCtxt*, Rectangle, int, ulong, ulong);
+extern	void			tkclear(Image*, Rectangle);
+extern	TkEnv*		tknewenv(TkTop*);
+extern	TkEnv*		tkdefaultenv(TkTop*);
+extern	void		tkputenv(TkEnv*);
+extern	TkEnv*		tkdupenv(TkEnv**);
+extern	Tk*		tknewobj(TkTop*, int, int);
+extern	Tk*		tkfindsub(Tk*);
+extern	void		tkfreebind(TkAction*);
+extern	void		tkfreename(TkName*);
+extern	void		tkfreeobj(Tk*);
+extern	char*		tkaddchild(TkTop*, Tk*, TkName**);
+extern	Tk*		tklook(TkTop*, char*, int);
+extern	void		tktextsdraw(Image*, Rectangle, TkEnv*, int);
+extern	void		tkbox(Image*, Rectangle, int, Image*);
+extern	void		tkbevel(Image*, Point, int, int, int, Image*, Image*);
+extern	void		tkdrawrelief(Image*, Tk*, Point, int, int);
+extern	Point		tkstringsize(Tk*, char*);
+extern	void		tkdrawstring(Tk*, Image*, Point, char*, int, Image *, int);
+extern	int		tkeventfmt(Fmt*);
+extern	Tk*		tkdeliver(Tk*, int, void*);
+extern	int		tksubdeliver(Tk*, TkAction*, int, void*, int);
+extern	void		tkcancel(TkAction**, int);
+extern	char*		tkaction(TkAction**, int, int, char*, int);
+extern	char*		tkitem(char*, char*);
+extern	Point		tkposn(Tk*);
+extern	Point		tkscrn2local(Tk*, Point);
+extern	int		tkvisiblerect(Tk *tk, Rectangle *rr);
+extern	Point		tkanchorpoint(Rectangle, Point, int);
+extern	char*		tkfrac(char**, int*, TkEnv*);
+extern	char*		tkfracword(TkTop*, char**, int*, TkEnv*);
+extern	char*		tkfprint(char*, int);
+extern	char*		tkvalue(char**, char*, ...);
+extern	void		tkdirty(Tk *);
+extern	void		tksorttable(void);
+extern	char*		tkexec(TkTop*, char*, char**);
+extern	int		tkeventfmt(Fmt*);
+extern	void		tkerr(TkTop*, char*);
+extern	char*	tkerrstr(TkTop*, char*);
+extern	char*	tkcursorswitch(TkTop*, Image*, TkImg*);
+extern	void		tkcursorset(TkTop*, Point);
+extern	char*	tksetmgrab(TkTop*, Tk*);
+extern	int 		tkinsidepoly(Point*, int, int, Point);
+extern	int		tklinehit(Point*, int, int, Point);
+extern	int		tkiswordchar(int);
+extern	int		tkhaskeyfocus(Tk*);
+extern	Rectangle	tkrect(Tk*, int);
+extern	int		tkchanhastype(ulong, int);
+extern	int		tkhasalpha(TkEnv*, int);
+extern	void		tksettransparent(Tk*, int);
+extern	ulong	tkrgba(int, int, int, int);
+extern	ulong	tkrgbashade(ulong, int);
+extern	void		tkrgbavals(ulong, int*, int*, int*, int*);
+extern	void		tkrepeat(Tk*, void(*)(Tk*, void*, int), void*, int, int);
+extern	void		tkcancelrepeat(Tk*);
+extern	void		tkblink(Tk*, void(*)(Tk*, int));
+extern	void		tkblinkreset(Tk*);
+extern	char*	tkname(Tk*);
+
+/* General - windw.c */
+extern	TkCtxt*		tknewctxt(Display*);
+extern	void		tkfreectxt(TkCtxt*);
+extern	void		tkfreecolcache(TkCtxt*);
+extern	Image*		tkitmp(TkEnv*, Point, int);
+extern	void		tkgeomchg(Tk*, TkGeom*, int);
+extern	Tk*		tkinwindow(Tk*, Point, int);
+extern	Tk*		tkfindfocus(TkTop*, int, int, int);
+extern	char*		tkdrawslaves(Tk*, Point, int*);
+extern	char*		tkupdate(TkTop*);
+extern	int		tkischild(Tk*, Tk*);
+extern	void		tksetbits(Tk*, int);
+extern	char*		tkmap(Tk*);
+extern	void		tkunmap(Tk*);
+extern	void		tkmoveresize(Tk*, int, int, int, int);
+extern	int		tkupdatewinsize(Tk*);
+extern	void		tkmovewin(Tk*, Point);
+extern	Image*		tkimageof(Tk*);
+extern	void		tktopopt(Tk*, char*);
+extern	void		tkdirtyfocusorder(TkTop*);
+extern	void		tkbuildfocusorder(TkTop*);
+extern	void		tksortfocusorder(TkWinfo*, int);
+extern	void		tkappendfocusorder(Tk*);
+extern	void		tksee(Tk*, Rectangle, Point);
+extern	char*	tkseecmd(TkTop*, char*, char**);
+
+/* Style specific extensions - extns.c */
+extern	int		tkextndeliver(Tk*, TkAction*, int, void*);
+extern	void		tkextnfreeobj(Tk*);
+extern	int		tkextnnewctxt(TkCtxt*);
+extern	void		tkextnfreectxt(TkCtxt*);
+extern	char*	tkextnparseseq(char*, char*, int*);
+
+/* Debugging */
+extern	void		tkdump(Tk*);
+extern	void		tktopdump(Tk*);
+extern	void		tkcvsdump(Tk*);
+
+/* External to libtk */
+extern	void		tkenterleave(TkTop*);
+extern	void		tksetwinimage(Tk*, Image*);
+extern	void		tkdestroywinimage(Tk*);
+extern	void		tkfreevar(TkTop*, char*, int);
+extern	TkVar*		tkmkvar(TkTop*, char*, int);
+extern	int		tktolimbo(void*, char*);
+extern	void		tkwreq(TkTop*, char*, ...);
+extern	void		tkdelpanelimage(TkTop*, Image*);
+
+extern	TkMethod		framemethod;
+extern	TkMethod		labelmethod;
+extern	TkMethod		checkbuttonmethod;
+extern	TkMethod		buttonmethod;
+extern	TkMethod		menubuttonmethod;
+extern	TkMethod		menumethod;
+extern	TkMethod		separatormethod;
+extern	TkMethod		cascademethod;
+extern	TkMethod		listboxmethod;
+extern	TkMethod		scrollbarmethod;
+extern	TkMethod		textmethod;
+extern	TkMethod		canvasmethod;
+extern	TkMethod		entrymethod;
+extern	TkMethod		radiobuttonmethod;
+extern	TkMethod		scalemethod;
+extern	TkMethod		panelmethod;
+extern	TkMethod		choicebuttonmethod;
--- /dev/null
+++ b/include/trace.h
@@ -1,0 +1,24 @@
+typedef enum Tevent {
+	SAdmit = 0,	/* Edf admit */
+	SRelease,	/* Edf release, waiting to be scheduled */
+	SEdf,		/* running under EDF */
+	SRun,		/* running best effort */
+	SReady,		/* runnable but not running  */
+	SSleep,		/* blocked */
+	SYield,		/* blocked waiting for release */
+	SSlice,		/* slice exhausted */
+	SDeadline,	/* proc's deadline */
+	SExpel,		/* Edf expel */
+	SDead,		/* proc dies */
+	SInts,		/* Interrupt start */
+	SInte,		/* Interrupt end */
+	SUser,		/* user event */
+	Nevent,
+} Tevent;
+
+typedef struct Traceevent	Traceevent;
+struct Traceevent {
+	ulong	pid;	
+	ulong	etype;		/* Event type */
+	vlong	time;		/* time stamp  */
+};
--- /dev/null
+++ b/include/version.h
@@ -1,0 +1,1 @@
+#define VERSION	"Fourth Edition (20151010)"
--- /dev/null
+++ b/include/vm.h
@@ -1,0 +1,8 @@
+/*
+ * All the virtual machine interfaces
+ */
+#include "/usr/inferno/include/interp.h"
+#include "/usr/inferno/include/isa.h"
+#include "/usr/inferno/libinterp/runt.h"
+
+int srvf2c(char*, char*, int, Sys_FileIO*);