fnt2bdf.c

/************************************************
 *
 * Extract fonts from .fnt or Windows DLL files
 * and convert them to the .bdf format.
 *
 * Copyright 1994-1996 Kevin Carothers and Alex Korobka
 *
 * Modified for converting the Dina font
 * Copyright 2013 Joergen Ibsen
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#ifdef _WIN32
# include <windows.h>
#else
# include "config.h"
# include "wine/port.h"
#endif

#ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#include <fcntl.h>
#ifdef HAVE_IO_H
# include <io.h>
#endif

#ifndef _WIN32
# include "windef.h"
# include "wingdi.h"
#endif

enum data_types { dfChar, dfShort, dfLong, dfString };

#define ERROR_DATA  1
#define ERROR_VERSION   2
#define ERROR_SIZE  3
#define ERROR_MEMORY    4
#define ERROR_FILE  5

#include "pshpack1.h"

typedef struct {
	INT16 dfType;
	INT16 dfPoints;
	INT16 dfVertRes;
	INT16 dfHorizRes;
	INT16 dfAscent;
	INT16 dfInternalLeading;
	INT16 dfExternalLeading;
	BYTE dfItalic;
	BYTE dfUnderline;
	BYTE dfStrikeOut;
	INT16 dfWeight;
	BYTE dfCharSet;
	INT16 dfPixWidth;
	INT16 dfPixHeight;
	BYTE dfPitchAndFamily;
	INT16 dfAvgWidth;
	INT16 dfMaxWidth;
	BYTE dfFirstChar;
	BYTE dfLastChar;
	BYTE dfDefaultChar;
	BYTE dfBreakChar;
	INT16 dfWidthBytes;
	LONG dfDevice;
	LONG dfFace;
	LONG dfBitsPointer;
	LONG dfBitsOffset;
	BYTE dfReserved;
	LONG dfFlags;
	INT16 dfAspace;
	INT16 dfBspace;
	INT16 dfCspace;
	LONG dfColorPointer;
	LONG dfReserved1[4];
} FONTINFO16;

typedef struct {
	WORD offset;
	WORD length;
	WORD flags;
	WORD id;
	WORD handle;
	WORD usage;
} NE_NAMEINFO;

typedef struct {
	WORD type_id;
	WORD count;
	DWORD resloader;
} NE_TYPEINFO;

#define NE_FFLAGS_SINGLEDATA    0x0001
#define NE_FFLAGS_MULTIPLEDATA  0x0002
#define NE_FFLAGS_WIN32         0x0010
#define NE_FFLAGS_FRAMEBUF      0x0100
#define NE_FFLAGS_CONSOLE       0x0200
#define NE_FFLAGS_GUI           0x0300
#define NE_FFLAGS_SELFLOAD      0x0800
#define NE_FFLAGS_LINKERROR     0x2000
#define NE_FFLAGS_CALLWEP       0x4000
#define NE_FFLAGS_LIBMODULE     0x8000

#define NE_OSFLAGS_WINDOWS      0x02

#define NE_RSCTYPE_FONTDIR            0x8007
#define NE_RSCTYPE_FONT               0x8008
#define NE_RSCTYPE_SCALABLE_FONTPATH  0x80cc

#define NE_SEGFLAGS_DATA        0x0001
#define NE_SEGFLAGS_ALLOCATED   0x0002
#define NE_SEGFLAGS_LOADED      0x0004
#define NE_SEGFLAGS_ITERATED    0x0008
#define NE_SEGFLAGS_MOVEABLE    0x0010
#define NE_SEGFLAGS_SHAREABLE   0x0020
#define NE_SEGFLAGS_PRELOAD     0x0040
#define NE_SEGFLAGS_EXECUTEONLY 0x0080
#define NE_SEGFLAGS_READONLY    0x0080
#define NE_SEGFLAGS_RELOC_DATA  0x0100
#define NE_SEGFLAGS_SELFLOAD    0x0800
#define NE_SEGFLAGS_DISCARDABLE 0x1000
#define NE_SEGFLAGS_32BIT       0x2000

typedef struct tagFontHeader {
	SHORT dfVersion;        /* Version */
	LONG dfSize;        /* Total File Size */
	char dfCopyright[60];   /* Copyright notice */
	FONTINFO16 fi;      /* FONTINFO structure */
} fnt_hdrS;

typedef struct WinCharStruct {
	unsigned int charWidth;
	long charOffset;
} WinCharS;

typedef struct fntFontStruct {
	fnt_hdrS hdr;
	WinCharS *dfCharTable;
	unsigned char *dfDeviceP;
	unsigned char *dfFaceP;
	unsigned char *dfBitsPointerP;
	unsigned char *dfBitsOffsetP;
	short *dfColorTableP;
} fnt_fontS;

#include "poppack.h"

#define FILE_ERROR  0
#define FILE_DLL    1
#define FILE_FNT    2

/* global options */

static int dump_bdf(fnt_fontS *cpe_font_struct, unsigned char *file_buffer);
static int dump_bdf_hdr(FILE *fs, fnt_fontS *cpe_font_struct, unsigned char *file_buffer);

static char *g_lpstrFileName = NULL;
static char *g_lpstrCharSet = NULL;
static char *g_lpstrInputFile = NULL;
static int g_outputPoints = 0;

/* info */

static void usage(void)
{
	printf("Usage: fnt2bdf [-t] [-c charset] [-f basename] [input file]\n");
	printf("  -c charset\tcharset name for OEM_CHARSET fonts\n");
	printf("  -f basename\tbasic output filename\n");
	printf("  -t \t\toutput files by point size instead of pixel height\n");
	printf("  input file\tMSWindows .fon, .fnt, .dll, or .exe file.\n");
	printf("\nExample:\n  fnt2bdf -c winsys vgasys.fnt\n\n");
	exit(-1);
}

/* convert little-endian value to the local format */

static int return_data_value(enum data_types dtype, void *pChr)
{
	int ret_val = 0;

	switch (dtype) {
	case (dfChar):
		ret_val = (int) *(unsigned char *) pChr;
		break;

	case (dfShort):
		ret_val = *(unsigned char *) pChr;
		ret_val += (*((unsigned char *) pChr + 1) << 8);
		break;

	case (dfLong): {
			int i;

			for (i = 3; i >= 0; i--) {
				ret_val += *((unsigned char *) pChr + i) << (8 * i);
			}
			break;
		}
	case (dfString):
		break;
	}
	return ret_val;
}

static int make_bdf_filename(char *name, fnt_fontS *cpe_font_struct, unsigned char *file_buffer)
{
	long l_nameoffset = return_data_value(dfLong, &cpe_font_struct->hdr.fi.dfFace);
	char *lpChar;

	if (!g_lpstrFileName) {
		if (!l_nameoffset ||
		    l_nameoffset > return_data_value(dfLong, &cpe_font_struct->hdr.dfSize) + 1) {
			return ERROR_DATA;
		}
		lpChar = (char *) (file_buffer + l_nameoffset);
	}
	else {
		lpChar = g_lpstrFileName;
	}

	strcpy(name, lpChar);

	while ((lpChar = strchr(name, ' '))) {
		*lpChar = '-';
	}

	/* construct a filename from the font typeface, slant, weight, and size */

	if (cpe_font_struct->hdr.fi.dfItalic) {
		strcat(name, "_i");
	}
	else {
		strcat(name, "_r");
	}

	lpChar = name + strlen(name);
	sprintf(lpChar, "%d-%d.bdf", return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfWeight),
	        (g_outputPoints) ? return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPoints)
			: return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixHeight));
	return 0;
}

/* parse FONT resource and write .bdf file */

static int parse_fnt_data(unsigned char *file_buffer, int length)
{
	fnt_fontS cpe_font_struct;
	int ic = 0, t;

	memcpy((char *) &cpe_font_struct.hdr, file_buffer, sizeof(fnt_hdrS));

	/* check font header */

	t = return_data_value(dfShort, &cpe_font_struct.hdr.dfVersion);
	if (t != 0x300 && t != 0x200) {
		return ERROR_VERSION;
	}

	t = return_data_value(dfShort, &cpe_font_struct.hdr.fi.dfType);
	if (t & 1) {
		fprintf(stderr, "Vector fonts not supported\n");
		return ERROR_DATA;
	}

	t = return_data_value(dfLong, &cpe_font_struct.hdr.dfSize);
	if (t > length) {
		return ERROR_SIZE;
	}
	else {
		/* set up the charWidth/charOffset  structure pairs (dfCharTable)... */

		int l_fchar = return_data_value(dfChar, &cpe_font_struct.hdr.fi.dfFirstChar),
		    l_lchar = return_data_value(dfChar, &cpe_font_struct.hdr.fi.dfLastChar);
		int l_len = l_lchar - l_fchar + 1;
		int l_ptr = sizeof(fnt_hdrS);

		/* some fields were introduced for Windows 3.x fonts */
		if (return_data_value(dfShort, &cpe_font_struct.hdr.dfVersion) == 0x200) {
			l_ptr -= 30;
		}

		/* malloc size = (# chars) * sizeof(WinCharS) */

		if ((cpe_font_struct.dfCharTable = calloc(sizeof(WinCharS), l_len)) == NULL) {
			return ERROR_MEMORY;
		}

		/* NOW, convert them all to UNIX (lton) notation... */

		for (ic = 0; ic < l_len; ic++) {
			cpe_font_struct.dfCharTable[ic].charWidth = return_data_value(dfShort, &file_buffer[l_ptr]);
			l_ptr += 2; /* bump by sizeof(short) */


			if (return_data_value(dfShort, &cpe_font_struct.hdr.dfVersion) == 0x200) {
				cpe_font_struct.dfCharTable[ic].charOffset =
				    return_data_value(dfShort, &file_buffer[l_ptr]);
				l_ptr += 2; /* bump by sizeof(short) */
			}
			else { /*  Windows Version 3.0 type font */
				cpe_font_struct.dfCharTable[ic].charOffset =
				    return_data_value(dfLong, &file_buffer[l_ptr]);
				l_ptr += 4; /* bump by sizeof(long) */
			}
		}
		t = dump_bdf(&cpe_font_struct, file_buffer);
		free(cpe_font_struct.dfCharTable);
	}
	return t;
}

static int dump_bdf(fnt_fontS *cpe_font_struct, unsigned char *file_buffer)
{
	FILE *fp;
	int ic;
	int l_fchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfFirstChar),
	    l_lchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfLastChar);

	int l_len = l_lchar - l_fchar + 1,
	    l_hgt = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfPixHeight);
	int l_ascent = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfAscent);
	char l_filename[256];

	if ((ic = make_bdf_filename(l_filename, cpe_font_struct, file_buffer))) {
		return ic;
	}

	if ((fp = fopen(l_filename, "w")) == NULL) {
		fprintf(stderr, "Couldn't open \"%s\" for output.\n", l_filename);
		return ERROR_FILE;
	}

	ic = dump_bdf_hdr(fp, cpe_font_struct, file_buffer);
	if (ic) {
		fclose(fp);
		return ic;
	}

	/* NOW, convert all chars to UNIX (lton) notation... */

	for (ic = 0; ic < l_len; ic++) {
		int rowidx, l_span, /* how many char-cols wide is char? */
		    l_idx = cpe_font_struct->dfCharTable[ic].charOffset;

		l_span = (int) (cpe_font_struct->dfCharTable[ic].charWidth - 1) / 8;

		fprintf(fp, "STARTCHAR %d\n", ic);
		fprintf(fp, "ENCODING %d\n", l_fchar);
		/* Since dwith = swidth * (point_size / 1000) * (resolution_x / 72),
		   we can approximate swidth using this computation */
		fprintf(fp, "SWIDTH %d %d\n",
		        (cpe_font_struct->dfCharTable[ic].charWidth * 1000 * 72) /
		        ((unsigned int) cpe_font_struct->hdr.fi.dfPoints * cpe_font_struct->hdr.fi.dfHorizRes),
		        0);

		fprintf(fp, "DWIDTH %d %d\n",
		        cpe_font_struct->dfCharTable[ic].charWidth, 0);

		fprintf(fp, "BBX %d %d %d %d\n",
		        cpe_font_struct->dfCharTable[ic].charWidth, l_hgt, 0,
		        l_ascent - l_hgt);

		fprintf(fp, "BITMAP\n");
		for (rowidx = 0; rowidx < l_hgt; rowidx++) {
			switch (l_span) {
			case (0): /* 1-7 pixels wide font */
				{
					fprintf(fp, "%02X\n", (int) file_buffer[l_idx + rowidx]);
					break;
				}

			case (1): /* 8-15 pixels wide font */
				{
					fprintf(fp, "%02X%02X",
					        (int) file_buffer[l_idx + rowidx], file_buffer[l_idx + l_hgt + rowidx]);
					fprintf(fp, "\n");
					break;
				}

			case (2): /* 16-23 pixels wide font */
				{
					fprintf(fp, "%02X%02X%02X",
					        file_buffer[l_idx + rowidx],
					        file_buffer[l_idx + l_hgt + rowidx],
					        file_buffer[l_idx + (2 * l_hgt) + rowidx]);
					fprintf(fp, "\n");
					break;
				}

			case (3): /* 24-31 pixels wide font */
				{
					fprintf(fp, "%02X%02X%02X%02X",
					        file_buffer[l_idx + rowidx],
					        file_buffer[l_idx + l_hgt + rowidx],
					        file_buffer[l_idx + (2 * l_hgt) + rowidx],
					        file_buffer[l_idx + (3 * l_hgt) + rowidx]);
					fprintf(fp, "\n");
					break;
				}
			case (4): /* 32-39 */
				{
					fprintf(fp, "%02X%02X%02X%02X%02X",
					        file_buffer[l_idx + rowidx],
					        file_buffer[l_idx + l_hgt + rowidx],
					        file_buffer[l_idx + (2 * l_hgt) + rowidx],
					        file_buffer[l_idx + (3 * l_hgt) + rowidx],
					        file_buffer[l_idx + (4 * l_hgt) + rowidx]);
					fprintf(fp, "\n");
					break;
				}
			default:
				fclose(fp);
				unlink(l_filename);
				return ERROR_DATA;
			}
		}
		fprintf(fp, "ENDCHAR\n");

		l_fchar++; /* Go to next one */
	}
	fprintf(fp, "ENDFONT\n");
	fclose(fp);
	return 0;
}


static int dump_bdf_hdr(FILE *fs, fnt_fontS *cpe_font_struct, unsigned char *file_buffer)
{
	int l_fchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfFirstChar),
	    l_lchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfLastChar);
	int l_len = l_lchar - l_fchar + 1;
	long l_nameoffset = return_data_value(dfLong, &cpe_font_struct->hdr.fi.dfFace);
	int l_cellheight = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixHeight);
	int l_ascent = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfAscent);
	int point_size = 10 * return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPoints);
	char *lpFace = (char *) (file_buffer + l_nameoffset);
	short tmWeight = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfWeight);

	fprintf(fs, "STARTFONT 2.1\n");

	/* Compose font name */

	if (l_nameoffset &&
	    l_nameoffset < return_data_value(dfLong, &cpe_font_struct->hdr.dfSize)) {
		char *lpChar;

		while ((lpChar = strchr(lpFace, '-'))) {
			*lpChar = ' ';
		}

		fprintf(fs, "FONT -windows-%s-", lpFace);

		if (tmWeight == 0) {        /* weight */
			fputs("medium-", fs);
		}
		else if (tmWeight <= FW_LIGHT) {
			fputs("light-", fs);
		}
		else if (tmWeight <= FW_MEDIUM) {
			fputs("medium-", fs);
		}
		else if (tmWeight <= FW_DEMIBOLD) {
			fputs("demibold-", fs);
		}
		else if (tmWeight <= FW_BOLD) {
			fputs("bold-", fs);
		}
		else {
			fputs("black-", fs);
		}

		if (cpe_font_struct->hdr.fi.dfItalic) { /* slant */
			fputs("i-", fs);
		}
		else {
			fputs("r-", fs);
		}

		/* style */

		if ((cpe_font_struct->hdr.fi.dfPitchAndFamily & 0xF0) == FF_SWISS) {
			fputs("normal-sans-", fs);
		}
		else {
			fputs("normal--", fs);  /* still can be -sans */
		}
		/* y extents */

		fprintf(fs, "%d-%d-%d-%d-", l_cellheight -
		        return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfInternalLeading),
		        point_size,
		        return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfHorizRes),
		        return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfVertRes));

		/* spacing */

		if (return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixWidth)) {
			fputs("c-", fs);
		}
		else {
			fputs("p-", fs);
		}

		/* average width */

		fprintf(fs, "%d-", 10 * return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfAvgWidth));

		/* charset */

		if (g_lpstrCharSet) {
			fprintf(fs, "%s\n", g_lpstrCharSet);
		}
		else {
			switch (cpe_font_struct->hdr.fi.dfCharSet) {
			/* Microsoft just had to invent its own charsets! */

			case ANSI_CHARSET:  fputs("microsoft-cp1252\n", fs);
				break;
			case GREEK_CHARSET:     fputs("microsoft-cp1253\n", fs);
				break;
			case TURKISH_CHARSET:   fputs("microsoft-cp1254\n", fs);
				break;
			case HEBREW_CHARSET:    fputs("microsoft-cp1255\n", fs);
				break;
			case ARABIC_CHARSET:    fputs("microsoft-cp1256\n", fs);
				break;
			case BALTIC_CHARSET:    fputs("microsoft-cp1257\n", fs);
				break;
			case RUSSIAN_CHARSET:   fputs("microsoft-cp1251\n", fs);
				break;
			case EASTEUROPE_CHARSET:    fputs("microsoft-cp1250\n", fs);
				break;
			case SYMBOL_CHARSET:    fputs("microsoft-symbol\n", fs);
				break;
			case SHIFTJIS_CHARSET:  fputs("jisx0208.1983-0\n", fs);
				break;
			case DEFAULT_CHARSET:   fputs("iso8859-1\n", fs);
				break;

			default:
			case OEM_CHARSET:
				fputs("Undefined charset, use -c option.\n", stderr);
				return ERROR_DATA;
			}
		}
	}
	else {
		return ERROR_DATA;
	}

	fprintf(fs, "SIZE %d %d %d\n",
	        return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPoints),
	        return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfHorizRes),
	        return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfVertRes)); /* dfVertRes[2] */

	fprintf(fs, "FONTBOUNDINGBOX %d %d %d %d\n",
	        return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfMaxWidth),
	        return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfPixHeight),
	        0, l_ascent - l_cellheight);

	fprintf(fs, "STARTPROPERTIES 16\n");

	fprintf(fs, "FACE_NAME \"%s\"\n", lpFace);
	fprintf(fs, "FAMILY_NAME \"%s\"\n", lpFace);
	fputs("WEIGHT_NAME \"", fs);
	if (tmWeight == 0) {
		fputs("Medium", fs);
	}
	else if (tmWeight <= FW_LIGHT) {
		fputs("Light", fs);
	}
	else if (tmWeight <= FW_MEDIUM) {
		fputs("Medium", fs);
	}
	else if (tmWeight <= FW_DEMIBOLD) {
		fputs("Demibold", fs);
	}
	else if (tmWeight <= FW_BOLD) {
		fputs("Bold", fs);
	}
	else {
		fputs("Black", fs);
	}
	fputs("\"\n", fs);

	fprintf(fs, "SLANT \"%c\"\n", cpe_font_struct->hdr.fi.dfItalic ? 'I' : 'R');
	fprintf(fs, "PIXEL_SIZE %d\n", l_cellheight -
	        return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfInternalLeading));
	fprintf(fs, "POINT_SIZE %d\n", point_size);
	fprintf(fs, "RESOLUTION_X %d\n", return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfHorizRes));
	fprintf(fs, "RESOLUTION_Y %d\n", return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfVertRes));

	if (return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixWidth)) {
		fprintf(fs, "SPACING \"C\"\n");
	}
	else {
		fprintf(fs, "SPACING \"P\"\n");
	}

	/* these are hardcoded, since they do not corespond to the actual encoding */
	fputs("CHARSET_REGISTRY \"ISO8859\"\n", fs);
	fputs("CHARSET_ENCODING \"1\"\n", fs);

	fprintf(fs, "FONT_ASCENT %d\n", l_ascent);
	fprintf(fs, "FONT_DESCENT %d\n", l_cellheight - l_ascent);
	fprintf(fs, "CAP_HEIGHT %d\n", l_ascent -
	        return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfInternalLeading));
	fprintf(fs, "DEFAULT_CHAR %d\n", return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfDefaultChar));

	{
		char *p = cpe_font_struct->hdr.dfCopyright;
		size_t i;

		/* strip trailing spaces */
		for (i = strlen(p); i && p[i - 1] == ' '; --i) {
			p[i - 1] = '\0';
		}
	}
	fprintf(fs, "COPYRIGHT \"%s\"\n", cpe_font_struct->hdr.dfCopyright);

	fprintf(fs, "ENDPROPERTIES\n");

	fprintf(fs, "CHARS %d\n", l_len);
	return 0;
}



static void parse_options(int argc, char **argv)
{
	int i;

	switch (argc) {
	case 2:
		g_lpstrInputFile = argv[1];
		break;

	case 3:
	case 4:
	case 5:
	case 6:
	case 7:
	case 8:
		for (i = 1; i < argc - 1; i++) {
			if (argv[i][0] != '-' ||
			    strlen(argv[i]) != 2) {
				break;
			}

			if (argv[i][1] == 'c') {
				g_lpstrCharSet = argv[i + 1];
			}
			else if (argv[i][1] == 'f') {
				g_lpstrFileName = argv[i + 1];
			}
			else if (argv[i][1] == 't') {
				g_outputPoints = 1;
				continue;
			}
			else {
				usage();
			}

			i++;
		}
		if (i == argc - 1) {
			g_lpstrInputFile = argv[i];
			break;
		}
	default: usage();
	}
}

/* read file data and return file type */

static int get_resource_table(int fd, unsigned char **lpdata, int fsize)
{
	IMAGE_DOS_HEADER mz_header;
	IMAGE_OS2_HEADER ne_header;
	long s, offset, size;
	int retval;

	lseek(fd, 0, SEEK_SET);

	if (read(fd, &mz_header, sizeof(mz_header)) != sizeof(mz_header)) {
		return FILE_ERROR;
	}

	s = return_data_value(dfShort, &mz_header.e_magic);

	if (s == IMAGE_DOS_SIGNATURE) { /* looks like .dll file so far... */
		s = return_data_value(dfShort, &mz_header.e_lfanew);
		lseek(fd, s, SEEK_SET);

		if (read(fd, &ne_header, sizeof(ne_header)) != sizeof(ne_header)) {
			return FILE_ERROR;
		}

		s = return_data_value(dfShort, &ne_header.ne_magic);

		if (s == IMAGE_NT_SIGNATURE) {
			fprintf(stderr, "Do not know how to handle 32-bit Windows DLLs.\n");
			return FILE_ERROR;
		}
		else if (s != IMAGE_OS2_SIGNATURE) {
			return FILE_ERROR;
		}

		s = return_data_value(dfShort, &ne_header.ne_rsrctab);
		size = return_data_value(dfShort, &ne_header.ne_restab);

		if (size > fsize) {
			return FILE_ERROR;
		}

		size -= s;
		offset = s + return_data_value(dfShort, &mz_header.e_lfanew);

		if (size <= sizeof(NE_TYPEINFO)) {
			return FILE_ERROR;
		}
		retval = FILE_DLL;
	}
	else if (s == 0x300 || s == 0x200) {    /* maybe .fnt ? */
		size = return_data_value(dfLong, &((fnt_hdrS *) &mz_header)->dfSize);

		if (size != fsize) {
			return FILE_ERROR;
		}
		offset = 0;
		retval = FILE_FNT;
	}
	else {
		return FILE_ERROR;
	}

	*lpdata = malloc(size);

	if (*lpdata) {
		lseek(fd, offset, SEEK_SET);
		if (read(fd, *lpdata, size) != size) {
			free(*lpdata);
			*lpdata = NULL;
		}
	}
	return retval;
}


/* entry point */

int main(int argc, char **argv)
{
	unsigned char *lpdata = NULL;
	int fd;

	parse_options(argc, argv);

	if ((fd = open(g_lpstrInputFile, O_RDONLY | O_BINARY)) != -1) {
		int i;
		struct stat file_stat;

		fstat(fd, &file_stat);
		i = get_resource_table(fd, &lpdata, file_stat.st_size);

		switch (i) {
		case FILE_DLL:
			if (lpdata) {
				int j, count = 0;
				NE_TYPEINFO *pTInfo = (NE_TYPEINFO *) (lpdata + 2);
				NE_NAMEINFO *pFontStorage = NULL;

				while ((i = return_data_value(dfShort, &pTInfo->type_id))) {
					j = return_data_value(dfShort, &pTInfo->count);
					if (i == NE_RSCTYPE_FONT) {
						count = j;
						pFontStorage = (NE_NAMEINFO *) (pTInfo + 1);
						break; /* found one */
					}

					pTInfo = (NE_TYPEINFO *) ((char *) (pTInfo + 1) + j * sizeof(NE_NAMEINFO));
				}
				if (pFontStorage && count) {
					unsigned short size_shift = return_data_value(dfShort, lpdata);
					unsigned char *lpfont = NULL;
					unsigned offset;
					int length;

					for (j = 0; j < count; j++, pFontStorage++) {
						length = return_data_value(dfShort, &pFontStorage->length) << size_shift;
						offset = return_data_value(dfShort, &pFontStorage->offset) << size_shift;

						if (!(lpfont = realloc(lpfont, length))) {
							fprintf(stderr, "Memory allocation error.\n");
							exit(1);
						}

						lseek(fd, offset, SEEK_SET);
						if (read(fd, lpfont, length) != length) {
							fprintf(stderr, "Unable to read Windows DLL.\n");
							exit(1);
						}

						if ((i = parse_fnt_data(lpfont, length))) {
							fprintf(stderr, "Unable to parse font data: Error %d\n", i);
							exit(1);
						}
					}
					free(lpfont);
					free(lpdata);
					exit(0);
				}
				else {
					fprintf(stderr, "No fonts found.\n");
					exit(1);
				}
				free(lpdata);
			}
			else {
				fprintf(stderr, "Unable to read Windows DLL.\n");
				exit(1);
			}
			break;

		case FILE_FNT:
			if (lpdata) {
				if ((i = parse_fnt_data(lpdata, file_stat.st_size))) {
					fprintf(stderr, "Unable to parse font data: Error %d\n", i);
					exit(1);
				}
				free(lpdata);
			}
			else {
				fprintf(stderr, "Unable to read .FNT file.\n");
				exit(1);
			}
			break;

		case FILE_ERROR:
			fprintf(stderr, "Corrupt or invalid file.\n");
			exit(1);
		}
		close(fd);
		exit(0);
	}
	else {
		fprintf(stderr, "Unable to open '%s'.\n", g_lpstrInputFile);
		exit(1);
	}
}