X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fttf.cpp;h=799f0321ffc288aad01c42836e19b991d961d0c7;hb=0c01fa32c7e0629ae61992e0419f03724fc18487;hp=ce312a8d6dfc2ddd70265dfc0f9265f4a13028ae;hpb=3ef71393f70213eb53db552605ae3c93f1303ee9;p=ttedit

diff --git a/src/ttf.cpp b/src/ttf.cpp
index ce312a8..799f032 100755
--- a/src/ttf.cpp
+++ b/src/ttf.cpp
@@ -20,7 +20,7 @@
 // - Eliminate ALL references to BYTE, WORD, SBYTE, SWORD, etc.
 //
 
-#include <stdio.h>								// For file handling, etc.												//
+#include <stdio.h>								// For file handling, etc.
 #include <stdlib.h>
 #include <string.h>
 #include "charnames.h"
@@ -35,7 +35,7 @@
 #define NUMTABS  24                   // Number of distinct tables
 
 
-/*void fskip(HANDLE file, uint32 bytesToSkip)
+/*void fskip(HANDLE file, uint32_t bytesToSkip)
 {
 	SetFilePointer(file, (LONG)bytesToSkip, NULL, FILE_CURRENT);
 }*/
@@ -43,9 +43,9 @@
 //
 // Get a BYTE from the current file...
 //
-uint8 ReadByte(FILE * file)
+uint8_t ReadByte(FILE * file)
 {
-	return (uint8)fgetc(file);
+	return (uint8_t)fgetc(file);
 }
 
 // The following routines get and put WORDs and DWORDs in little endian
@@ -55,10 +55,10 @@ uint8 ReadByte(FILE * file)
 //
 // Get a WORD from the current file...
 //
-uint16 ReadWord(FILE * file)
+uint16_t ReadWord(FILE * file)
 {
-	uint16 word = (uint16)fgetc(file) << 8;
-	word |= (uint16)fgetc(file);
+	uint16_t word = (uint16_t)fgetc(file) << 8;
+	word |= (uint16_t)fgetc(file);
 
 	return word;
 }
@@ -66,14 +66,14 @@ uint16 ReadWord(FILE * file)
 //
 // Get a double WORD from the current file...
 //
-uint32 ReadDWord(FILE * file)
+uint32_t ReadDWord(FILE * file)
 {
-	uint32 dword = 0;
+	uint32_t dword = 0;
 
 	for(int i=0; i<4; i++)
 	{
 		dword <<= 8;
-		dword |= (uint8)fgetc(file);
+		dword |= (uint8_t)fgetc(file);
 	}
 
 	return dword;
@@ -82,7 +82,7 @@ uint32 ReadDWord(FILE * file)
 //
 // Write a WORD to the current file...
 //
-void WriteWord(FILE * file, uint16 word)
+void WriteWord(FILE * file, uint16_t word)
 {
 	fputc(word >> 8, file);						// Hi byte
 	fputc(word & 0xFF, file);					// Lo byte
@@ -91,7 +91,7 @@ void WriteWord(FILE * file, uint16 word)
 //
 // Write a double WORD to the current file...
 //
-void WriteDWord(FILE * file, uint32 dword)
+void WriteDWord(FILE * file, uint32_t dword)
 {
 	for(int i=0; i<4; i++)
 	{
@@ -107,7 +107,7 @@ void WriteDWord(FILE * file, uint32 dword)
 //
 // Return a BYTE from a BYTE based table
 //
-uint8 GetByte(uint8 * table, uint32 &ptr)
+uint8_t GetByte(uint8_t * table, uint32_t &ptr)
 {
 	return table[ptr++];
 }
@@ -115,25 +115,25 @@ uint8 GetByte(uint8 * table, uint32 &ptr)
 //
 // Return a WORD from a BYTE based table
 //
-uint16 GetWord(uint8 * table, uint32 &ptr)
+uint16_t GetWord(uint8_t * table, uint32_t &ptr)
 {
-	uint16 hi = table[ptr++];
-	uint16 lo = table[ptr++];
+	uint16_t hi = table[ptr++];
+	uint16_t lo = table[ptr++];
 
-	return (uint16)((hi<<8) | lo);
+	return (uint16_t)((hi<<8) | lo);
 }
 
 //
 // Return a double WORD from a BYTE based table
 //
-uint32 GetDWord(uint8 * table, uint32 &ptr)
+uint32_t GetDWord(uint8_t * table, uint32_t &ptr)
 {
-	uint32 hi1 = table[ptr++];
-	uint32 lo1 = table[ptr++];
-	uint32 hi2 = table[ptr++];
-	uint32 lo2 = table[ptr++];
+	uint32_t hi1 = table[ptr++];
+	uint32_t lo1 = table[ptr++];
+	uint32_t hi2 = table[ptr++];
+	uint32_t lo2 = table[ptr++];
 
-	return (uint32)((hi1 << 24) | (lo1 << 16) | (hi2 << 8) | lo2);
+	return (uint32_t)((hi1 << 24) | (lo1 << 16) | (hi2 << 8) | lo2);
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ -143,7 +143,7 @@ uint32 GetDWord(uint8 * table, uint32 &ptr)
 //
 // Store a BYTE in a BYTE based table
 //
-void SetByte(uint8 * table, uint32 &ptr, uint8 data)
+void SetByte(uint8_t * table, uint32_t &ptr, uint8_t data)
 {
 	table[ptr++] = data;
 }
@@ -151,7 +151,7 @@ void SetByte(uint8 * table, uint32 &ptr, uint8 data)
 //
 // Store a WORD in a BYTE based table
 //
-void SetWord(uint8 * table, uint32 &ptr, uint16 data)
+void SetWord(uint8_t * table, uint32_t &ptr, uint16_t data)
 {
 	table[ptr++] = data>>8;  table[ptr++] = data&0xFF;
 }
@@ -159,16 +159,16 @@ void SetWord(uint8 * table, uint32 &ptr, uint16 data)
 //
 // Store a DWORD in a BYTE based table
 //
-void SetDWord(uint8 * table, uint32 &ptr, uint32 data)
+void SetDWord(uint8_t * table, uint32_t &ptr, uint32_t data)
 {
-	table[ptr++] = (uint8)(data >> 24); table[ptr++] = (uint8)(data >> 16);
-	table[ptr++] = (uint8)(data >> 8);  table[ptr++] = (uint8)(data & 0xFF);
+	table[ptr++] = (uint8_t)(data >> 24); table[ptr++] = (uint8_t)(data >> 16);
+	table[ptr++] = (uint8_t)(data >> 8);  table[ptr++] = (uint8_t)(data & 0xFF);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Fixed point to float (& vice versa) conversions
 /////////////////////////////////////////////////////////////////////////////
-float FixedToFloat(int16 fixed)
+float FixedToFloat(int16_t fixed)
 {
 	return (float)fixed / 16384.0f;
 }
@@ -201,10 +201,10 @@ TTF::TTF(void)
 	larray[18] = &maxp_len; larray[19] = &name_len; larray[20] = &post_len;
 	larray[21] = &prep_len; larray[22] = &vhea_len; larray[23] = &vmtx_len;
 
-	for(uint32 i=0; i<NUMTABS; i++)
+	for(uint32_t i=0; i<NUMTABS; i++)
 		*parray[i] = NULL;						// Init pointers...
 
-	for(uint32 i=0; i<MAXGLYPHS; i++)
+	for(uint32_t i=0; i<MAXGLYPHS; i++)
 		glyph[i] = NULL;
 }
 
@@ -232,7 +232,7 @@ void TTF::Init(void)
 /////////////////////////////////////////////////////////////////////////////
 void TTF::ClearTables(void)
 {
-	for(uint32 i=0; i<NUMTABS; i++)
+	for(uint32_t i=0; i<NUMTABS; i++)
 	{
 		if ((*parray[i]) != NULL)
 		{
@@ -242,7 +242,7 @@ void TTF::ClearTables(void)
 		}
 	}  
 
-	for(uint32 i=0; i<MAXGLYPHS; i++)
+	for(uint32_t i=0; i<MAXGLYPHS; i++)
 	{
 		if (glyph[i] != NULL)
 		{
@@ -262,7 +262,7 @@ bool TTF::Load(const char * filename)
 {
 //	unsigned char ch;							// Temp variable
 //	UINT num_tabs;								// Number of tables
-	uint32 offset[NUMTABS], length[NUMTABS];	// Temporary storage...
+	uint32_t offset[NUMTABS], length[NUMTABS];	// Temporary storage...
 	char names[NUMTABS][5];
 	char narray[NUMTABS][5] = { "EBDT", "EBLC", "EBSC", "LTSH", "OS/2", "PCLT",
 		"VDMX", "cmap", "cvt ", "fpgm", "gasp", "glyf", "hdmx", "head", "hhea",
@@ -292,7 +292,7 @@ WriteLogMsg("File was NOT a TTF file!\n");
 }
 #endif
 
-	uint32 num_tabs = ReadWord(file);			// Get # of tables
+	uint32_t num_tabs = ReadWord(file);			// Get # of tables
 #ifdef TTFDEBUG
 WriteLogMsg("Number of tables is %u...\n", num_tabs);
 #endif
@@ -302,7 +302,7 @@ WriteLogMsg("Number of tables is %u...\n", num_tabs);
 #ifdef TTFDEBUG
 WriteLogMsg("Reading names of tables...\n");
 #endif
-	for(uint32 i=0; i<num_tabs; i++)
+	for(uint32_t i=0; i<num_tabs; i++)
 	{
 //		ReadFile(file, names[i], 4, &bytesRead, NULL);
 		fread(names[i], 1, 4, file);
@@ -316,14 +316,14 @@ WriteLogMsg("Reading names of tables...\n");
 #ifdef TTFDEBUG
 WriteLogMsg("Reading tables...\n");
 #endif
-	for(uint32 i=0; i<num_tabs; i++)
+	for(uint32_t i=0; i<num_tabs; i++)
 	{
-		for(uint32 j=0; j<NUMTABS; j++)
+		for(uint32_t j=0; j<NUMTABS; j++)
 		{
 			if ((strcmp(names[i], narray[j])) == 0)	// Found a match...
 			{
-//				*parray[j] = (uint8 *)GlobalAlloc(GMEM_FIXED, length[i]);	// Allocate space
-				*parray[j] = (uint8 *)malloc(length[i]); // Alloc space
+//				*parray[j] = (uint8_t *)GlobalAlloc(GMEM_FIXED, length[i]);	// Allocate space
+				*parray[j] = (uint8_t *)malloc(length[i]); // Alloc space
 
 				if (*parray[j] == NULL)
 					return false;				// Bail out if nothing allocated
@@ -358,7 +358,7 @@ bool TTF::Save(const char * filename)
 {
 //  fstream file;
 //	ULONG offset = 12;
-	uint32 numtabs = 0;
+	uint32_t numtabs = 0;
 	char padding[3] = { 0, 0, 0 };
 	// Convert this to a table of ULONGs to decrease complexity...
 //wouldn't be endian safe then...
@@ -371,11 +371,11 @@ bool TTF::Save(const char * filename)
 
 	BuildTables();								// Ignore return value...  
 
-	for(uint32 i=0; i<NUMTABS; i++)				// Figure out how many tables there are
+	for(uint32_t i=0; i<NUMTABS; i++)				// Figure out how many tables there are
 		if ((*parray[i]) != NULL)
 			numtabs++;
 
-	uint32 offset = 12 + (numtabs * 16);		// Calc correct offset to start of data
+	uint32_t offset = 12 + (numtabs * 16);		// Calc correct offset to start of data
 
 //	HANDLE file = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
 //		NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
@@ -387,7 +387,7 @@ bool TTF::Save(const char * filename)
 	WriteWord(file, 0);							// entrySelector Log2(max power of 2 <= numTables).
 	WriteWord(file, 0);							// NumTables x 16 - searchRange.
 
-	for(uint32 i=0; i<NUMTABS; i++)					// Write out table directory...
+	for(uint32_t i=0; i<NUMTABS; i++)					// Write out table directory...
 	{
 		if ((*parray[i]) != NULL)
 		{
@@ -400,20 +400,20 @@ bool TTF::Save(const char * filename)
 			WriteDWord(file, offset);			// Offset
 			WriteDWord(file, (*larray[i]));		// Length
 
-			offset += (((*larray[i]) + 3) & ~3);	// Pad out to 4-uint8 boundary...
+			offset += (((*larray[i]) + 3) & ~3);	// Pad out to 4-uint8_t boundary...
 		}
 	}
 
-	for(uint32 i=0; i<NUMTABS; i++)					// Write out the tables...
+	for(uint32_t i=0; i<NUMTABS; i++)					// Write out the tables...
 	{
 		if ((*parray[i]) != NULL)
 		{
-//			for(uint32 j=0; j<(*larray[i]); j++)
+//			for(uint32_t j=0; j<(*larray[i]); j++)
 //				file.put((*parray[i])[j]);
 //			WriteFile(file, *parray[i], *larray[i], &bytesWritten, NULL);
 			fwrite(*parray[i], 1, *larray[i], file);
 
-			uint32 remainder = ((*larray[i]) & 0x3);
+			uint32_t remainder = ((*larray[i]) & 0x3);
 			if (remainder)               // i.e., it's not evenly div by 4
 //				for(j=remainder; j<4; j++)
 //					file.put((char)0);       // pad it!
@@ -432,18 +432,18 @@ bool TTF::Save(const char * filename)
 //
 // This function encodes the glyph data and stores it to the 'glyf' table.
 /////////////////////////////////////////////////////////////////////////////
-bool TTF::EncodeGlyph(uint16 glyphnum)
+bool TTF::EncodeGlyph(uint16_t glyphnum)
 {
 	bool retval = false;						// Assume failure
-	uint8 flag, xbuf[4000], ybuf[4000], fbuf[2000];
-	uint32 xp = 0, yp = 0, fp = 0;				// Table pointers
+	uint8_t flag, xbuf[4000], ybuf[4000], fbuf[2000];
+	uint32_t xp = 0, yp = 0, fp = 0;				// Table pointers
 
 	if (glyphnum < myMaxp.numGlyphs)  // numofgls is 1 based ind, glyph# 0 based
 	{
 		// need to add composite encoding...
 		int lastx = 0, lasty = 0;
 
-		for(uint32 i=0; i<numberOfPoints; i++)
+		for(uint32_t i=0; i<numberOfPoints; i++)
 		{
 			flag = 0;
 			int curx = gx[i] - lastx, cury = gy[i] - lasty;
@@ -453,7 +453,7 @@ bool TTF::EncodeGlyph(uint16 glyphnum)
 
 			if (curx)
 			{
-				if ((curx > 255) || (curx < -255)) // I.e., it's 2 uint8 value
+				if ((curx > 255) || (curx < -255)) // I.e., it's 2 uint8_t value
 					SetWord(xbuf, xp, curx);
 				else
 				{
@@ -473,7 +473,7 @@ bool TTF::EncodeGlyph(uint16 glyphnum)
   
 			if (cury)
 			{
-				if ((cury > 255) || (cury < -255)) // I.e., it's 2 uint8 value
+				if ((cury > 255) || (cury < -255)) // I.e., it's 2 uint8_t value
 					SetWord(ybuf, yp, cury);
 				else
 				{
@@ -502,7 +502,7 @@ bool TTF::EncodeGlyph(uint16 glyphnum)
     {
       if (fbuf[i] == fbuf[i+1])  // 
       {
-        uint8 count = 0;  // Sentinel takes care of check for end of flags...
+        uint8_t count = 0;  // Sentinel takes care of check for end of flags...
         while (fbuf[i] == fbuf[++i])  count++; // Count number of repeats
         i--;
         fbuf[fp++] = fbuf[i] | 0x08; // Set repeat flag
@@ -514,35 +514,35 @@ bool TTF::EncodeGlyph(uint16 glyphnum)
 		fp = numberOfPoints;
 		// Find length of glyph and reallocate space if necessary
 
-		uint32 newLength = 12 + numberOfPolys*2 + numberOfHints + fp + xp + yp;
+		uint32_t newLength = 12 + numberOfPolys*2 + numberOfHints + fp + xp + yp;
 
 		if (newLength & 0x03)
 			newLength += (4 - newLength & 0x03);
 
 		if (glyphLen[glyphnum] != newLength)
 		{
-			glyph[glyphnum] = (uint8 *)realloc(glyph[glyphnum], newLength);
+			glyph[glyphnum] = (uint8_t *)realloc(glyph[glyphnum], newLength);
 			glyphLen[glyphnum] = newLength;
 		}
 
 		// And finally, store it!
 
-		uint32 gp = 0;							// Glyph pointer...
+		uint32_t gp = 0;							// Glyph pointer...
 		SetWord(glyph[glyphnum], gp, numberOfPolys);
 		SetWord(glyph[glyphnum], gp, llx);
 		SetWord(glyph[glyphnum], gp, lly);
 		SetWord(glyph[glyphnum], gp, urx);
 		SetWord(glyph[glyphnum], gp, ury);
-		for(uint32 i=0; i<numberOfPolys; i++)
+		for(uint32_t i=0; i<numberOfPolys; i++)
 			SetWord(glyph[glyphnum], gp, poly[i]);
 		SetWord(glyph[glyphnum], gp, numberOfHints);
-		for(uint32 i=0; i<numberOfHints; i++)
+		for(uint32_t i=0; i<numberOfHints; i++)
 			SetByte(glyph[glyphnum], gp, hint[i]);
-		for(uint32 i=0; i<fp; i++)
+		for(uint32_t i=0; i<fp; i++)
 			SetByte(glyph[glyphnum], gp, fbuf[i]);
-		for(uint32 i=0; i<xp; i++)
+		for(uint32_t i=0; i<xp; i++)
 			SetByte(glyph[glyphnum], gp, xbuf[i]);
-		for(uint32 i=0; i<yp; i++)
+		for(uint32_t i=0; i<yp; i++)
 			SetByte(glyph[glyphnum], gp, ybuf[i]);
 
 		retval = true;							// Successfully encoded!
@@ -557,10 +557,10 @@ bool TTF::EncodeGlyph(uint16 glyphnum)
 // This function decodes the glyph data and stores it to the object's
 // internal array.
 /////////////////////////////////////////////////////////////////////////////
-bool TTF::DecodeGlyph(uint16 glyphnum)
+bool TTF::DecodeGlyph(uint16_t glyphnum)
 {
 	bool retval = false;
-	uint32 i, dp;
+	uint32_t i, dp;
 
 	// glyphnum is 0 based index, while numGlyphs is 1 based
 	if (glyphnum >= myMaxp.numGlyphs)
@@ -578,10 +578,10 @@ bool TTF::DecodeGlyph(uint16 glyphnum)
 	isCompositeGlyph = false;   // Default is no
 	numberOfPolys = GetWord(glyph[glyphnum], dp);  // # of polygons
 
-	llx = (int16)GetWord(glyph[glyphnum], dp);           // Lower left X
-	lly = (int16)GetWord(glyph[glyphnum], dp);           // Lower left Y
-	urx = (int16)GetWord(glyph[glyphnum], dp);           // Upper right X
-	ury = (int16)GetWord(glyph[glyphnum], dp);           // Upper right Y
+	llx = (int16_t)GetWord(glyph[glyphnum], dp);           // Lower left X
+	lly = (int16_t)GetWord(glyph[glyphnum], dp);           // Lower left Y
+	urx = (int16_t)GetWord(glyph[glyphnum], dp);           // Upper right X
+	ury = (int16_t)GetWord(glyph[glyphnum], dp);           // Upper right Y
 
 	// Need to handle composite glyphs better here.  The ways things
 	// are set now is a recipe for disaster...
@@ -600,19 +600,19 @@ bool TTF::DecodeGlyph(uint16 glyphnum)
 		{
 			cmpst.flags = GetWord(glyph[glyphnum], dp);
 			cmpst.glyphIndex = GetWord(glyph[glyphnum], dp);
-			cmpst.arg1 = (cmpst.flags & 0x01 ? (int16)GetWord(glyph[glyphnum], dp) : (int8)GetByte(glyph[glyphnum], dp));
-			cmpst.arg2 = (cmpst.flags & 0x01 ? (int16)GetWord(glyph[glyphnum], dp) : (int8)GetByte(glyph[glyphnum], dp));
+			cmpst.arg1 = (cmpst.flags & 0x01 ? (int16_t)GetWord(glyph[glyphnum], dp) : (int8_t)GetByte(glyph[glyphnum], dp));
+			cmpst.arg2 = (cmpst.flags & 0x01 ? (int16_t)GetWord(glyph[glyphnum], dp) : (int8_t)GetByte(glyph[glyphnum], dp));
 
 			if (cmpst.flags & 0x08)
-				cmpst.xScale = cmpst.yScale = FixedToFloat((int16)GetWord(glyph[glyphnum], dp));
+				cmpst.xScale = cmpst.yScale = FixedToFloat((int16_t)GetWord(glyph[glyphnum], dp));
 			else if (cmpst.flags & 0x40)
-				cmpst.xScale = FixedToFloat((int16)GetWord(glyph[glyphnum], dp)),
-				cmpst.yScale = FixedToFloat((int16)GetWord(glyph[glyphnum], dp));
+				cmpst.xScale = FixedToFloat((int16_t)GetWord(glyph[glyphnum], dp)),
+				cmpst.yScale = FixedToFloat((int16_t)GetWord(glyph[glyphnum], dp));
 			else if (cmpst.flags & 0x80)
-				cmpst.xScale = FixedToFloat((int16)GetWord(glyph[glyphnum], dp)),
-				cmpst.scale01 = FixedToFloat((int16)GetWord(glyph[glyphnum], dp)),
-				cmpst.scale10 = FixedToFloat((int16)GetWord(glyph[glyphnum], dp)),
-				cmpst.yScale = FixedToFloat((int16)GetWord(glyph[glyphnum], dp));
+				cmpst.xScale = FixedToFloat((int16_t)GetWord(glyph[glyphnum], dp)),
+				cmpst.scale01 = FixedToFloat((int16_t)GetWord(glyph[glyphnum], dp)),
+				cmpst.scale10 = FixedToFloat((int16_t)GetWord(glyph[glyphnum], dp)),
+				cmpst.yScale = FixedToFloat((int16_t)GetWord(glyph[glyphnum], dp));
 
 			compositeList.AddAtRear(cmpst);
 		}
@@ -624,9 +624,9 @@ bool TTF::DecodeGlyph(uint16 glyphnum)
 //do {
 //	USHORT flags;
 //	USHORT glyphIndex;
-//	if ( flags & ARG_1_AND_2_ARE_uint16S) {
-//	(SHORT or Fuint16) argument1;
-//	(SHORT or Fuint16) argument2;
+//	if ( flags & ARG_1_AND_2_ARE_uint16_tS) {
+//	(SHORT or Fuint16_t) argument1;
+//	(SHORT or Fuint16_t) argument2;
 //	} else {
 //		USHORT arg1and2; /* (arg1 << 8) | arg2 */
 //	}
@@ -644,11 +644,11 @@ bool TTF::DecodeGlyph(uint16 glyphnum)
 //} while ( flags & MORE_COMPONENTS ) 
 //if (flags & WE_HAVE_INSTR){
 //	USHORT numInstr
-//	uint8 instr[numInstr]
+//	uint8_t instr[numInstr]
 //
 //Flags                    Bit     Description 
-//ARG_1_AND_2_ARE_uint16S    0       If this is set, the arguments are uint16s;
-//                                 otherwise, they are uint8s.
+//ARG_1_AND_2_ARE_uint16_tS    0       If this is set, the arguments are uint16_ts;
+//                                 otherwise, they are uint8_ts.
 //ARGS_ARE_XY_VALUES       1       If this is set, the arguments are xy values;
 //                                 otherwise, they are points.
 //ROUND_XY_TO_GRID         2       For the xy values if the preceding is true.
@@ -678,20 +678,20 @@ bool TTF::DecodeGlyph(uint16 glyphnum)
 
 	// Decode the dots...
 
-	uint32 num_pts = poly[numberOfPolys-1] + 1;
+	uint32_t num_pts = poly[numberOfPolys-1] + 1;
 	numberOfPoints = num_pts; // necessary??
-	uint32 xptr, yptr;        // pointers to beginning of coord data
-	uint32 numXs = 0;
+	uint32_t xptr, yptr;        // pointers to beginning of coord data
+	uint32_t numXs = 0;
 	int xx = 0, yy = 0, repeat;
-	uint32 numTokens = num_pts, k, numRep;
+	uint32_t numTokens = num_pts, k, numRep;
 
 	// We make an educated guess that num_pts = num_tokens; but if there
 	// is repeated data in the tokens, then we need to adjust the # of
 	// tokens down appropriately.
 
-	for(uint32 i=0; i<numTokens; i++)
+	for(uint32_t i=0; i<numTokens; i++)
 	{
-		uint8 token = glyph[glyphnum][dp+i];  uint32 rpts = 1;
+		uint8_t token = glyph[glyphnum][dp+i];  uint32_t rpts = 1;
 
 		if (token & 0x08)      // Repeated token?
 		{
@@ -706,7 +706,7 @@ bool TTF::DecodeGlyph(uint16 glyphnum)
 			numTokens -= (numRep - 1); // Yes, adjust.
 		}
 
-		// 10 = same x(0uint8s), 00 = 2uint8s, 02&12 = 1uint8
+		// 10 = same x(0uint8_ts), 00 = 2uint8_ts, 02&12 = 1uint8_t
 		if ((token & 0x02) == 0x02)
 			numXs += rpts;
 
@@ -721,9 +721,9 @@ bool TTF::DecodeGlyph(uint16 glyphnum)
 
 	k = 0;                               // Index to the point array
 
-	for(uint32 i=0; i<numTokens; i++)
+	for(uint32_t i=0; i<numTokens; i++)
 	{
-		uint8 token = glyph[glyphnum][dp+i];
+		uint8_t token = glyph[glyphnum][dp+i];
 		repeat = 1;
 
 		if (token & 0x08)
@@ -741,7 +741,7 @@ bool TTF::DecodeGlyph(uint16 glyphnum)
 				xx -= GetByte(glyph[glyphnum], xptr);
 
 			if ((token & 0x12) == 0x00)
-				xx += (int16)GetWord(glyph[glyphnum], xptr);
+				xx += (int16_t)GetWord(glyph[glyphnum], xptr);
 
 			gx[k] = xx;                      // Store x-coordinate
 
@@ -752,7 +752,7 @@ bool TTF::DecodeGlyph(uint16 glyphnum)
 				yy -= GetByte(glyph[glyphnum], yptr);
 
 			if ((token & 0x24) == 0x00)
-				yy += (int16)GetWord(glyph[glyphnum], yptr);
+				yy += (int16_t)GetWord(glyph[glyphnum], yptr);
 
 			gy[k] = yy;                      // Store y-coordinate
 
@@ -774,7 +774,7 @@ bool TTF::DecodeGlyph(uint16 glyphnum)
  This function decodes the 'glyf' data for a non-composite (atomic) glyph and
  returns it as a GlyphPoints object. Helper function.
  *****************************************************************************/
-GlyphPoints TTF::GetGlyphPoints(uint16 glyphNum)
+GlyphPoints TTF::GetGlyphPoints(uint16_t glyphNum)
 {
 	if (DecodeGlyph(glyphNum))
 		return GlyphPoints(numberOfPoints, numberOfPolys, gx, gy, onCurve, poly);
@@ -788,7 +788,7 @@ GlyphPoints TTF::GetGlyphPoints(uint16 glyphNum)
  This function decodes the 'glyf' data for a composite glyph and returns
  it as a GlyphPoints object.
  *****************************************************************************/
-GlyphPoints TTF::GetAllCompositePoints(uint16 glyphNum)
+GlyphPoints TTF::GetAllCompositePoints(uint16_t glyphNum)
 {
 //  int tmpGlyph = currentGlyph;
   
@@ -835,11 +835,11 @@ GlyphPoints TTF::GetAllCompositePoints(uint16 glyphNum)
 }
 
 /////////////////////////////////////////////////////////////////////////////
-// Member function: void GetCharName(int cNum, uint8 * buf)
+// Member function: void GetCharName(int cNum, uint8_t * buf)
 //
 // This function returns the character name of the glyph number passed in.
 /////////////////////////////////////////////////////////////////////////////
-void TTF::GetCharName(int cNum, uint8 * buf)
+void TTF::GetCharName(int cNum, uint8_t * buf)
 {
 	buf[0] = 0;									// Set failure as default condition
   
@@ -849,10 +849,10 @@ void TTF::GetCharName(int cNum, uint8 * buf)
 	if (post[1] != 0x02 || post[2] != 0x00)		// i.e., it's NOT a V2.0 table
 		return;
 
-	uint8 * pTab = NULL;
-	uint32 tabOff = 34, numGlyphs = (uint32)((post[32] << 8) | post[33]);
-	uint32 index = (uint32)((post[tabOff + cNum * 2] << 8) | post[tabOff + cNum * 2 + 1]);
-	uint32 nInd2;
+	uint8_t * pTab = NULL;
+	uint32_t tabOff = 34, numGlyphs = (uint32_t)((post[32] << 8) | post[33]);
+	uint32_t index = (uint32_t)((post[tabOff + cNum * 2] << 8) | post[tabOff + cNum * 2 + 1]);
+	uint32_t nInd2;
 
 	if (index > 257)
 	{
@@ -866,13 +866,13 @@ void TTF::GetCharName(int cNum, uint8 * buf)
 		pTab = macStdNames;
 	}
 
-	for(uint32 i=0; i<index; i++)
-		nInd2 = nInd2 + pTab[nInd2] + 1; // 1st uint8 is length of string + that uint8
+	for(uint32_t i=0; i<index; i++)
+		nInd2 = nInd2 + pTab[nInd2] + 1; // 1st uint8_t is length of string + that uint8_t
 
-	uint8 len = pTab[nInd2];
+	uint8_t len = pTab[nInd2];
 	nInd2++;
 
-	for(uint8 i=0; i<len; i++)
+	for(uint8_t i=0; i<len; i++)
 		buf[i] = pTab[nInd2 + i];
 
 	buf[len] = 0;
@@ -894,7 +894,7 @@ WriteLogMsg("Bad HEAD header: Expected 54, found %u...\n", head_len);
 		return false;							// Corrupt data?
 	}
 
-	uint32 tp = 0;
+	uint32_t tp = 0;
 	myHead.version            = GetDWord(head, tp);
 	myHead.fontRevision       = GetDWord(head, tp);
 	myHead.checkSumAdjustment = GetDWord(head, tp);
@@ -911,9 +911,9 @@ WriteLogMsg("Bad HEAD header: Expected 54, found %u...\n", head_len);
 	myHead.yMax               = GetWord(head, tp);
 	myHead.macStyle           = GetWord(head, tp);
 	myHead.lowestRecPPEM      = GetWord(head, tp);
-	myHead.fontDirectionHint  = (int16)GetWord(head, tp);
-	myHead.indexToLocFormat   = (int16)GetWord(head, tp);
-	myHead.glyphDataFormat    = (int16)GetWord(head, tp);
+	myHead.fontDirectionHint  = (int16_t)GetWord(head, tp);
+	myHead.indexToLocFormat   = (int16_t)GetWord(head, tp);
+	myHead.glyphDataFormat    = (int16_t)GetWord(head, tp);
 
 	if (maxp_len != 32)
 	{
@@ -941,17 +941,17 @@ WriteLogMsg("Bad MAXP header: Expected 32, found %u...\n", maxp_len);
 	myMaxp.maxComponentDepth     = GetWord(maxp, tp);
 
 	tp = 0;										// Reset table pointer
-	uint32 start = (myHead.indexToLocFormat ? GetDWord(loca, tp) : GetWord(loca, tp) << 1);
+	uint32_t start = (myHead.indexToLocFormat ? GetDWord(loca, tp) : GetWord(loca, tp) << 1);
 
-	for(uint32 i=0; i<myMaxp.numGlyphs; i++)
+	for(uint32_t i=0; i<myMaxp.numGlyphs; i++)
 	{
-		uint32 end = (myHead.indexToLocFormat ? GetDWord(loca, tp) : GetWord(loca, tp) << 1);
-		uint32 length = end - start;
+		uint32_t end = (myHead.indexToLocFormat ? GetDWord(loca, tp) : GetWord(loca, tp) << 1);
+		uint32_t length = end - start;
 		glyphLen[i] = length;					// Lengths are saved 'cause malloc is sloppy
 
 		if (length)     // loca+start? pointer arithmetic?
 		{
-			glyph[i] = (uint8 *)malloc(length);	// Allocate space,
+			glyph[i] = (uint8_t *)malloc(length);	// Allocate space,
 			memcpy(glyph[i], glyf+start, length);	// and move it!
 		}
 		else
@@ -971,9 +971,9 @@ WriteLogMsg("Bad MAXP header: Expected 32, found %u...\n", maxp_len);
 /////////////////////////////////////////////////////////////////////////////
 bool TTF::BuildTables(void)
 {
-	uint32 i, tp, start;
+	uint32_t i, tp, start;
 
-	myHead.indexToLocFormat = 1;				// We don't bother with [uint16s*2] format...
+	myHead.indexToLocFormat = 1;				// We don't bother with [uint16_ts*2] format...
 
 	// Build HEAD table
 
@@ -994,9 +994,9 @@ bool TTF::BuildTables(void)
 	SetWord(head, tp, myHead.yMax);//               = GetWord(head, tp);
 	SetWord(head, tp, myHead.macStyle);//           = GetWord(head, tp);
 	SetWord(head, tp, myHead.lowestRecPPEM);//      = GetWord(head, tp);
-	SetWord(head, tp, myHead.fontDirectionHint);//  = (int16)GetWord(head, tp);
-	SetWord(head, tp, myHead.indexToLocFormat);//   = (int16)GetWord(head, tp);
-	SetWord(head, tp, myHead.glyphDataFormat);//    = (int16)GetWord(head, tp);
+	SetWord(head, tp, myHead.fontDirectionHint);//  = (int16_t)GetWord(head, tp);
+	SetWord(head, tp, myHead.indexToLocFormat);//   = (int16_t)GetWord(head, tp);
+	SetWord(head, tp, myHead.glyphDataFormat);//    = (int16_t)GetWord(head, tp);
 
 	// Build MAXP table
 
@@ -1024,7 +1024,7 @@ bool TTF::BuildTables(void)
 	if (loca)
 		free(loca);								// And create/reallocate it...
 
-	loca = (uint8 *) malloc(loca_len);
+	loca = (uint8_t *) malloc(loca_len);
 
 	glyf_len = 0;								// Refigure glyf table length
 
@@ -1034,7 +1034,7 @@ bool TTF::BuildTables(void)
 	if (glyf)
 		free(glyf);
 
-	glyf = (uint8 *) malloc(glyf_len);
+	glyf = (uint8_t *) malloc(glyf_len);
 
 	start = tp = 0;								// Reset table pointer
 
@@ -1060,7 +1060,7 @@ bool TTF::BuildTables(void)
 // internal array.  If the flag isDirty is set, it also encodes the internal
 // array and stores it to the 'glyf' table.
 /////////////////////////////////////////////////////////////////////////////
-bool TTF::SetGlyph(uint16 glyphnum)
+bool TTF::SetGlyph(uint16_t glyphnum)
 {
 	bool retval = false;						// Set failure as default
 
@@ -1086,7 +1086,7 @@ bool TTF::SetGlyph(uint16 glyphnum)
 // is greater than the number of glyphs, glyph is added at end of list. This
 // glyph then becomes the current glyph.
 /////////////////////////////////////////////////////////////////////////////
-bool TTF::AddGlyph(uint16 glyphnum)
+bool TTF::AddGlyph(uint16_t glyphnum)
 {
 	// incomplete: JLH
 	bool retval = false;
@@ -1105,7 +1105,7 @@ bool TTF::AddGlyph(uint16 glyphnum)
 // This function deletes the glyph at position glyphnum.  All glyphs after
 // this glyph are moved down in position.
 /////////////////////////////////////////////////////////////////////////////
-bool TTF::DeleteGlyph(uint16 glyphnum)
+bool TTF::DeleteGlyph(uint16_t glyphnum)
 {
 	// incomplete: JLH
 	bool retval = false;
@@ -1124,7 +1124,7 @@ Box TTF::GetBoundingBox(void)
 	return Box(llx, lly, urx, ury);
 }
 
-GlyphPt TTF::GetPoint(uint16 pointno)
+GlyphPt TTF::GetPoint(uint16_t pointno)
 {
 	GlyphPt p;
 
@@ -1135,12 +1135,12 @@ GlyphPt TTF::GetPoint(uint16 pointno)
 	return p;
 }
 
-uint16 TTF::GetNumberOfPolys(void)
+uint16_t TTF::GetNumberOfPolys(void)
 {
 	return numberOfPolys;
 }
 
-uint16 TTF::GetPolyEnd(uint16 polynum)
+uint16_t TTF::GetPolyEnd(uint16_t polynum)
 {
 	if (polynum >= numberOfPolys)
 		return 0;
@@ -1148,7 +1148,7 @@ uint16 TTF::GetPolyEnd(uint16 polynum)
 	return poly[polynum];
 }
 
-int TTF::GetPointX(uint16 pointno)
+int TTF::GetPointX(uint16_t pointno)
 {
 	if (pointno >= MAXPOINTS)
 		return 0;
@@ -1156,7 +1156,7 @@ int TTF::GetPointX(uint16 pointno)
 	return gx[pointno];
 }
 
-int TTF::GetPointY(uint16 pointno)
+int TTF::GetPointY(uint16_t pointno)
 {
 	if (pointno >= MAXPOINTS)
 		return 0;
@@ -1164,7 +1164,7 @@ int TTF::GetPointY(uint16 pointno)
 	return gy[pointno];
 }
 
-bool TTF::GetOnCurve(uint16 pointno)
+bool TTF::GetOnCurve(uint16_t pointno)
 {
 	if (pointno >= MAXPOINTS)
 		return true;
@@ -1172,7 +1172,7 @@ bool TTF::GetOnCurve(uint16 pointno)
 	return onCurve[pointno];
 }
 
-bool TTF::SetOnCurve(uint16 pointno, bool state)
+bool TTF::SetOnCurve(uint16_t pointno, bool state)
 {
 	if (pointno >= numberOfPoints)
 		return false;
@@ -1183,7 +1183,7 @@ bool TTF::SetOnCurve(uint16 pointno, bool state)
 	return true;
 }
 
-bool TTF::MovePoint(uint16 pointno, int x, int y)
+bool TTF::MovePoint(uint16_t pointno, int x, int y)
 {
 	if (pointno >= numberOfPoints)
 		return false;
@@ -1194,7 +1194,7 @@ bool TTF::MovePoint(uint16 pointno, int x, int y)
 	return true;
 }
 
-bool TTF::MovePoint(uint16 pointno, GlyphPt p)
+bool TTF::MovePoint(uint16_t pointno, GlyphPt p)
 {
 	if (pointno >= numberOfPoints)
 		return false;