?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dplayx: System players are the ones who must not be listed
[wine/gsoc_dplay.git] / tools / fnt2bdf.c
blob5534ff9647d4784a0d61bbc291a2f9c767ab24b5
1 /************************************************
2 *
3 * Extract fonts from .fnt or Windows DLL files
4 * and convert them to the .bdf format.
5 *
6 * Copyright 1994-1996 Kevin Carothers and Alex Korobka
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #ifdef HAVE_SYS_PARAM_H
27 # include <sys/param.h>
28 #endif
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #ifdef HAVE_UNISTD_H
35 # include <unistd.h>
36 #endif
37 #include <fcntl.h>
38 #ifdef HAVE_IO_H
39 # include <io.h>
40 #endif
41
42 #include "windef.h"
43 #include "wingdi.h"
44
45 enum data_types {dfChar, dfShort, dfLong, dfString};
46
47 #define ERROR_DATA 1
48 #define ERROR_VERSION 2
49 #define ERROR_SIZE 3
50 #define ERROR_MEMORY 4
51 #define ERROR_FILE 5
52
53 #include "pshpack1.h"
54
55 typedef struct
56 {
57 INT16 dfType;
58 INT16 dfPoints;
59 INT16 dfVertRes;
60 INT16 dfHorizRes;
61 INT16 dfAscent;
62 INT16 dfInternalLeading;
63 INT16 dfExternalLeading;
64 BYTE dfItalic;
65 BYTE dfUnderline;
66 BYTE dfStrikeOut;
67 INT16 dfWeight;
68 BYTE dfCharSet;
69 INT16 dfPixWidth;
70 INT16 dfPixHeight;
71 BYTE dfPitchAndFamily;
72 INT16 dfAvgWidth;
73 INT16 dfMaxWidth;
74 BYTE dfFirstChar;
75 BYTE dfLastChar;
76 BYTE dfDefaultChar;
77 BYTE dfBreakChar;
78 INT16 dfWidthBytes;
79 LONG dfDevice;
80 LONG dfFace;
81 LONG dfBitsPointer;
82 LONG dfBitsOffset;
83 BYTE dfReserved;
84 LONG dfFlags;
85 INT16 dfAspace;
86 INT16 dfBspace;
87 INT16 dfCspace;
88 LONG dfColorPointer;
89 LONG dfReserved1[4];
90 } FONTINFO16;
91
92 typedef struct
93 {
94 WORD offset;
95 WORD length;
96 WORD flags;
97 WORD id;
98 WORD handle;
99 WORD usage;
100 } NE_NAMEINFO;
101
102 typedef struct
103 {
104 WORD type_id;
105 WORD count;
106 DWORD resloader;
107 } NE_TYPEINFO;
108
109 #define NE_FFLAGS_SINGLEDATA 0x0001
110 #define NE_FFLAGS_MULTIPLEDATA 0x0002
111 #define NE_FFLAGS_WIN32 0x0010
112 #define NE_FFLAGS_FRAMEBUF 0x0100
113 #define NE_FFLAGS_CONSOLE 0x0200
114 #define NE_FFLAGS_GUI 0x0300
115 #define NE_FFLAGS_SELFLOAD 0x0800
116 #define NE_FFLAGS_LINKERROR 0x2000
117 #define NE_FFLAGS_CALLWEP 0x4000
118 #define NE_FFLAGS_LIBMODULE 0x8000
119
120 #define NE_OSFLAGS_WINDOWS 0x02
121
122 #define NE_RSCTYPE_FONTDIR 0x8007
123 #define NE_RSCTYPE_FONT 0x8008
124 #define NE_RSCTYPE_SCALABLE_FONTPATH 0x80cc
125
126 #define NE_SEGFLAGS_DATA 0x0001
127 #define NE_SEGFLAGS_ALLOCATED 0x0002
128 #define NE_SEGFLAGS_LOADED 0x0004
129 #define NE_SEGFLAGS_ITERATED 0x0008
130 #define NE_SEGFLAGS_MOVEABLE 0x0010
131 #define NE_SEGFLAGS_SHAREABLE 0x0020
132 #define NE_SEGFLAGS_PRELOAD 0x0040
133 #define NE_SEGFLAGS_EXECUTEONLY 0x0080
134 #define NE_SEGFLAGS_READONLY 0x0080
135 #define NE_SEGFLAGS_RELOC_DATA 0x0100
136 #define NE_SEGFLAGS_SELFLOAD 0x0800
137 #define NE_SEGFLAGS_DISCARDABLE 0x1000
138 #define NE_SEGFLAGS_32BIT 0x2000
139
140 typedef struct tagFontHeader
141 {
142 SHORT dfVersion; /* Version */
143 LONG dfSize; /* Total File Size */
144 char dfCopyright[60]; /* Copyright notice */
145 FONTINFO16 fi; /* FONTINFO structure */
146 } fnt_hdrS;
147
148 typedef struct WinCharStruct
149 {
150 unsigned int charWidth;
151 long charOffset;
152 } WinCharS;
153
154 typedef struct fntFontStruct
155 {
156 fnt_hdrS hdr;
157 WinCharS *dfCharTable;
158 unsigned char *dfDeviceP;
159 unsigned char *dfFaceP;
160 unsigned char *dfBitsPointerP;
161 unsigned char *dfBitsOffsetP;
162 short *dfColorTableP;
163 } fnt_fontS;
164
165 #include "poppack.h"
166
167 #define FILE_ERROR 0
168 #define FILE_DLL 1
169 #define FILE_FNT 2
170
171 /* global options */
172
173 static int dump_bdf( fnt_fontS* cpe_font_struct, unsigned char* file_buffer);
174 static int dump_bdf_hdr(FILE* fs, fnt_fontS* cpe_font_struct, unsigned char* file_buffer);
175
176 static char* g_lpstrFileName = NULL;
177 static char* g_lpstrCharSet = NULL;
178 static char* g_lpstrInputFile = NULL;
179 static int g_outputPoints = 0;
180
181 /* info */
182
183 static void usage(void)
184 {
185 printf("Usage: fnt2bdf [-t] [-c charset] [-o basename] [input file]\n");
186 printf(" -c charset\tcharset name for OEM_CHARSET fonts\n");
187 printf(" -f basename\tbasic output filename\n");
188 printf(" -t \t\toutput files by point size instead of pixel height\n");
189 printf(" input file\tMSWindows .fon, .fnt, .dll, or .exe file.\n");
190 printf("\nExample:\n fnt2bdf -c winsys vgasys.fnt\n\n");
191 exit(-1);
192 }
193
194 /* convert little-endian value to the local format */
195
196 static int return_data_value(enum data_types dtype, void * pChr)
197 {
198 int ret_val = 0;
199
200 switch(dtype) {
201 case (dfChar):
202 ret_val = (int) *(unsigned char *)pChr;
203 break;
204
205 case(dfShort):
206 ret_val = *(unsigned char *)pChr;
207 ret_val += (*((unsigned char *)pChr + 1) << 8);
208 break;
209
210 case(dfLong): {
211 int i;
212
213 for(i=3; i >= 0; i--) {
214 ret_val += *((unsigned char *)pChr + i) << (8*i);
215 }
216 break;
217 }
218 case(dfString):
219 break;
220 }
221 return ret_val;
222 }
223
224 static int make_bdf_filename(char* name, fnt_fontS* cpe_font_struct, unsigned char* file_buffer)
225 {
226 long l_nameoffset = return_data_value(dfLong, &cpe_font_struct->hdr.fi.dfFace);
227 char* lpChar;
228
229 if( !g_lpstrFileName )
230 {
231 if( !l_nameoffset ||
232 l_nameoffset > return_data_value(dfLong, &cpe_font_struct->hdr.dfSize) + 1 )
233 return ERROR_DATA;
234 lpChar = (char*)(file_buffer + l_nameoffset);
235 }
236 else lpChar = g_lpstrFileName;
237
238 strcpy( name, lpChar );
239
240 while( (lpChar = strchr( name, ' ')) )
241 *lpChar = '-';
242
243 /* construct a filename from the font typeface, slant, weight, and size */
244
245 if( cpe_font_struct->hdr.fi.dfItalic ) strcat(name, "_i" );
246 else strcat(name, "_r" );
247
248 lpChar = name + strlen( name );
249 sprintf(lpChar, "%d-%d.bdf", return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfWeight),
250 (g_outputPoints) ? return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPoints)
251 : return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixHeight) );
252 return 0;
253 }
254
255 /* parse FONT resource and write .bdf file */
256
257 static int parse_fnt_data(unsigned char* file_buffer, int length)
258 {
259 fnt_fontS cpe_font_struct;
260 int ic=0, t;
261
262 memcpy((char *) &cpe_font_struct.hdr, file_buffer, sizeof(fnt_hdrS));
263
264 /* check font header */
265
266 t = return_data_value(dfShort, &cpe_font_struct.hdr.dfVersion);
267 if( t != 0x300 && t != 0x200) return ERROR_VERSION;
268
269 t = return_data_value(dfShort, &cpe_font_struct.hdr.fi.dfType);
270 if (t & 1)
271 {
272 fprintf(stderr, "Vector fonts not supported\n");
273 return ERROR_DATA;
274 }
275
276 t = return_data_value(dfLong, &cpe_font_struct.hdr.dfSize);
277 if( t > length ) return ERROR_SIZE;
278 else
279 {
280 /* set up the charWidth/charOffset structure pairs (dfCharTable)... */
281
282 int l_fchar = return_data_value(dfChar, &cpe_font_struct.hdr.fi.dfFirstChar),
283 l_lchar = return_data_value(dfChar, &cpe_font_struct.hdr.fi.dfLastChar);
284 int l_len = l_lchar - l_fchar + 1;
285 int l_ptr = sizeof(fnt_hdrS);
286
287 /* some fields were introduced for Windows 3.x fonts */
288 if( return_data_value(dfShort, &cpe_font_struct.hdr.dfVersion) == 0x200 )
289 l_ptr -= 30;
290
291 /* malloc size = (# chars) * sizeof(WinCharS) */
292
293 if((cpe_font_struct.dfCharTable = (WinCharS *) calloc(sizeof(WinCharS), l_len)) == NULL)
294 return ERROR_MEMORY;
295
296 /* NOW, convert them all to UNIX (lton) notation... */
297
298 for(ic=0; ic < l_len; ic++) {
299 cpe_font_struct.dfCharTable[ic].charWidth = return_data_value(dfShort, &file_buffer[l_ptr]);
300 l_ptr += 2; /* bump by sizeof(short) */
301
302
303 if( return_data_value(dfShort, &cpe_font_struct.hdr.dfVersion) == 0x200) {
304 cpe_font_struct.dfCharTable[ic].charOffset =
305 return_data_value(dfShort, &file_buffer[l_ptr]);
306 l_ptr += 2; /* bump by sizeof(short) */
307 }
308 else { /* Windows Version 3.0 type font */
309 cpe_font_struct.dfCharTable[ic].charOffset =
310 return_data_value(dfLong, &file_buffer[l_ptr]);
311 l_ptr += 4; /* bump by sizeof(long) */
312 }
313 }
314 t = dump_bdf(&cpe_font_struct, file_buffer);
315 free( cpe_font_struct.dfCharTable );
316 }
317 return t;
318 }
319
320 static int dump_bdf( fnt_fontS* cpe_font_struct, unsigned char* file_buffer)
321 {
322 FILE* fp;
323 int ic;
324 int l_fchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfFirstChar),
325 l_lchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfLastChar);
326
327 int l_len = l_lchar-l_fchar + 1,
328 l_hgt = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfPixHeight);
329 int l_ascent = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfAscent);
330 char l_filename[256];
331
332 if( (ic = make_bdf_filename(l_filename, cpe_font_struct, file_buffer)) )
333 return ic;
334
335 if((fp = fopen(l_filename, "w")) == NULL)
336 {
337 fprintf(stderr, "Couldn't open \"%s\" for output.\n", l_filename);
338 return ERROR_FILE;
339 }
340
341 ic = dump_bdf_hdr(fp, cpe_font_struct, file_buffer);
342 if (ic) {
343 fclose(fp);
344 return (ic);
345 }
346
347 /* NOW, convert all chars to UNIX (lton) notation... */
348
349 for(ic=0; ic < l_len; ic++) {
350 int rowidx, l_span, /* how many char-cols wide is char? */
351 l_idx = cpe_font_struct->dfCharTable[ic].charOffset;
352
353 l_span = (int) (cpe_font_struct->dfCharTable[ic].charWidth-1)/8;
354
355 fprintf(fp, "STARTCHAR %d\n", ic);
356 fprintf(fp, "ENCODING %d\n", l_fchar);
357 fprintf(fp, "SWIDTH %d %d\n",
358 cpe_font_struct->dfCharTable[ic].charWidth*1000,
359 0);
360
361 fprintf(fp, "DWIDTH %d %d\n",
362 cpe_font_struct->dfCharTable[ic].charWidth, 0);
363
364 fprintf(fp, "BBX %d %d %d %d\n",
365 cpe_font_struct->dfCharTable[ic].charWidth, l_hgt, 0,
366 l_ascent - l_hgt);
367
368 fprintf(fp, "BITMAP\n");
369 for(rowidx=0; rowidx < l_hgt; rowidx++) {
370 switch(l_span) {
371 case(0): /* 1-7 pixels wide font */
372 {
373 fprintf(fp, "%02X\n", (int) file_buffer[l_idx+rowidx]);
374 break;
375 }
376
377 case(1): /* 8-15 pixels wide font */
378 {
379 fprintf(fp, "%02X%02X",
380 (int) file_buffer[l_idx+rowidx], file_buffer[l_idx+l_hgt+rowidx]);
381 fprintf(fp, "\n");
382 break;
383 }
384
385 case(2): /* 16-23 pixels wide font */
386 {
387 fprintf(fp, "%02X%02X%02X",
388 file_buffer[l_idx+rowidx],
389 file_buffer[l_idx+l_hgt+rowidx],
390 file_buffer[l_idx+(2*l_hgt)+rowidx]);
391 fprintf(fp, "\n");
392 break;
393 }
394
395 case(3): /* 24-31 pixels wide font */
396 {
397 fprintf(fp, "%02X%02X%02X%02X",
398 file_buffer[l_idx+rowidx],
399 file_buffer[l_idx+l_hgt+rowidx],
400 file_buffer[l_idx+(2*l_hgt)+rowidx],
401 file_buffer[l_idx+(3*l_hgt)+rowidx]);
402 fprintf(fp, "\n");
403 break;
404 }
405 case(4): /* 32-39 */
406 {
407 fprintf(fp, "%02X%02X%02X%02X%02X",
408 file_buffer[l_idx+rowidx],
409 file_buffer[l_idx+l_hgt+rowidx],
410 file_buffer[l_idx+(2*l_hgt)+rowidx],
411 file_buffer[l_idx+(3*l_hgt)+rowidx],
412 file_buffer[l_idx+(4*l_hgt)+rowidx]);
413 fprintf(fp, "\n");
414 break;
415 }
416 default:
417 fclose(fp);
418 unlink(l_filename);
419 return ERROR_DATA;
420 }
421 }
422 fprintf(fp, "ENDCHAR\n");
423
424 l_fchar++; /* Go to next one */
425 }
426 fprintf(fp, "ENDFONT\n");
427 fclose(fp);
428 return 0;
429 }
430
431
432 static int dump_bdf_hdr(FILE* fs, fnt_fontS* cpe_font_struct, unsigned char* file_buffer)
433 {
434 int l_fchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfFirstChar),
435 l_lchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfLastChar);
436 int l_len = l_lchar - l_fchar + 1;
437 long l_nameoffset = return_data_value(dfLong, &cpe_font_struct->hdr.fi.dfFace);
438 int l_cellheight = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixHeight);
439 int l_ascent = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfAscent);
440
441 fprintf(fs, "STARTFONT 2.1\n");
442
443 /* Compose font name */
444
445 if( l_nameoffset &&
446 l_nameoffset < return_data_value(dfLong, &cpe_font_struct->hdr.dfSize) )
447 {
448 int dpi, point_size;
449 char* lpFace = (char*)(file_buffer + l_nameoffset), *lpChar;
450 short tmWeight = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfWeight);
451
452 while((lpChar = strchr(lpFace, '-')) )
453 *lpChar = ' ';
454
455 fprintf(fs, "FONT -windows-%s-", lpFace );
456
457 if( tmWeight == 0 ) /* weight */
458 fputs("medium-", fs);
459 else if( tmWeight <= FW_LIGHT )
460 fputs("light-", fs);
461 else if( tmWeight <= FW_MEDIUM )
462 fputs("medium-", fs);
463 else if( tmWeight <= FW_DEMIBOLD )
464 fputs("demibold-", fs);
465 else if( tmWeight <= FW_BOLD )
466 fputs("bold-", fs);
467 else fputs("black-", fs);
468
469 if( cpe_font_struct->hdr.fi.dfItalic ) /* slant */
470 fputs("i-", fs);
471 else fputs("r-", fs);
472
473 /* style */
474
475 if( (cpe_font_struct->hdr.fi.dfPitchAndFamily & 0xF0) == FF_SWISS )
476 fputs("normal-sans-", fs);
477 else fputs("normal--", fs); /* still can be -sans */
478
479 /* y extents */
480
481 point_size = 10 * return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPoints );
482 dpi = (l_cellheight * 720) / point_size;
483
484 fprintf(fs, "%d-%d-%d-%d-",l_cellheight, point_size,
485 return_data_value (dfShort, &cpe_font_struct->hdr.fi.dfHorizRes),
486 return_data_value (dfShort, &cpe_font_struct->hdr.fi.dfVertRes));
487
488 /* spacing */
489
490 if( return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixWidth) ) fputs("c-", fs);
491 else fputs("p-", fs);
492
493 /* average width */
494
495 fprintf( fs, "%d-", 10 * return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfAvgWidth) );
496
497 /* charset */
498
499 if( g_lpstrCharSet ) fprintf(fs, "%s\n", g_lpstrCharSet);
500 else
501 switch( cpe_font_struct->hdr.fi.dfCharSet )
502 {
503 /* Microsoft just had to invent its own charsets! */
504
505 case ANSI_CHARSET: fputs("microsoft-cp1252\n", fs); break;
506 case GREEK_CHARSET: fputs("microsoft-cp1253\n", fs); break;
507 case TURKISH_CHARSET: fputs("microsoft-cp1254\n", fs); break;
508 case HEBREW_CHARSET: fputs("microsoft-cp1255\n", fs); break;
509 case ARABIC_CHARSET: fputs("microsoft-cp1256\n", fs); break;
510 case BALTIC_CHARSET: fputs("microsoft-cp1257\n", fs); break;
511 case RUSSIAN_CHARSET: fputs("microsoft-cp1251\n", fs); break;
512 case EE_CHARSET: fputs("microsoft-cp1250\n", fs); break;
513 case SYMBOL_CHARSET: fputs("microsoft-symbol\n", fs); break;
514 case SHIFTJIS_CHARSET: fputs("jisx0208.1983-0\n", fs); break;
515 case DEFAULT_CHARSET: fputs("iso8859-1\n", fs); break;
516
517 default:
518 case OEM_CHARSET:
519 fputs("Undefined charset, use -c option.\n", stderr);
520 return ERROR_DATA;
521 }
522 }
523 else return ERROR_DATA;
524
525 fprintf(fs, "SIZE %d %d %d\n",
526 return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPoints ),
527 return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfHorizRes),
528 return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfVertRes)); /* dfVertRes[2] */
529
530 fprintf(fs, "FONTBOUNDINGBOX %d %d %d %d\n",
531 return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfMaxWidth),
532 return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfPixHeight),
533 0, l_ascent - l_cellheight );
534
535 fprintf(fs, "STARTPROPERTIES 4\n");
536
537 fprintf(fs, "FONT_ASCENT %d\n", l_ascent ); /* dfAscent[2] */
538 fprintf(fs, "FONT_DESCENT %d\n", l_cellheight - l_ascent );
539 fprintf(fs, "CAP_HEIGHT %d\n", l_ascent -
540 return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfInternalLeading));
541 fprintf(fs, "DEFAULT_CHAR %d\n", return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfDefaultChar));
542
543 fprintf(fs, "ENDPROPERTIES\n");
544
545 fprintf(fs, "CHARS %d\n", l_len);
546 return 0;
547 }
548
549
550
551 static void parse_options(int argc, char **argv)
552 {
553 int i;
554
555 switch( argc )
556 {
557 case 2:
558 g_lpstrInputFile = argv[1];
559 break;
560
561 case 3:
562 case 4:
563 case 5:
564 case 6:
565 case 7:
566 case 8:
567 for( i = 1; i < argc - 1; i++ )
568 {
569 if( argv[i][0] != '-' ||
570 strlen(argv[i]) != 2 ) break;
571
572 if( argv[i][1] == 'c' )
573 g_lpstrCharSet = argv[i+1];
574 else
575 if( argv[i][1] == 'f' )
576 g_lpstrFileName = argv[i+1];
577 else
578 if( argv[i][1] == 't' )
579 {
580 g_outputPoints = 1;
581 continue;
582 }
583 else
584 usage();
585
586 i++;
587 }
588 if( i == argc - 1 )
589 {
590 g_lpstrInputFile = argv[i];
591 break;
592 }
593 default: usage();
594 }
595
596 }
597
598 /* read file data and return file type */
599
600 static int get_resource_table(int fd, unsigned char** lpdata, int fsize)
601 {
602 IMAGE_DOS_HEADER mz_header;
603 IMAGE_OS2_HEADER ne_header;
604 long s, offset, size;
605 int retval;
606
607 lseek( fd, 0, SEEK_SET );
608
609 if( read(fd, &mz_header, sizeof(mz_header)) != sizeof(mz_header) )
610 return FILE_ERROR;
611
612 s = return_data_value(dfShort, &mz_header.e_magic);
613
614 if( s == IMAGE_DOS_SIGNATURE) /* looks like .dll file so far... */
615 {
616 s = return_data_value(dfShort, &mz_header.e_lfanew);
617 lseek( fd, s, SEEK_SET );
618
619 if( read(fd, &ne_header, sizeof(ne_header)) != sizeof(ne_header) )
620 return FILE_ERROR;
621
622 s = return_data_value(dfShort, &ne_header.ne_magic);
623
624 if( s == IMAGE_NT_SIGNATURE)
625 {
626 fprintf( stderr, "Do not know how to handle 32-bit Windows DLLs.\n");
627 return FILE_ERROR;
628 }
629 else if ( s != IMAGE_OS2_SIGNATURE) return FILE_ERROR;
630
631 s = return_data_value(dfShort, &ne_header.ne_rsrctab);
632 size = return_data_value(dfShort, &ne_header.ne_restab);
633
634 if( size > fsize ) return FILE_ERROR;
635
636 size -= s;
637 offset = s + return_data_value(dfShort, &mz_header.e_lfanew);
638
639 if( size <= sizeof(NE_TYPEINFO) ) return FILE_ERROR;
640 retval = FILE_DLL;
641 }
642 else if( s == 0x300 || s == 0x200 ) /* maybe .fnt ? */
643 {
644 size = return_data_value(dfLong, &((fnt_hdrS *)&mz_header)->dfSize);
645
646 if( size != fsize ) return FILE_ERROR;
647 offset = 0;
648 retval = FILE_FNT;
649 }
650 else return FILE_ERROR;
651
652 *lpdata = (unsigned char*)malloc(size);
653
654 if( *lpdata )
655 {
656 lseek( fd, offset, SEEK_SET );
657 if( read(fd, *lpdata, size) != size )
658 { free( *lpdata ); *lpdata = NULL; }
659 }
660 return retval;
661 }
662
663
664 /* entry point */
665
666 int main(int argc, char **argv)
667 {
668 unsigned char* lpdata = NULL;
669 int fd;
670
671 parse_options( argc, argv);
672
673 if( (fd = open( g_lpstrInputFile, O_RDONLY | O_BINARY)) != -1 )
674 {
675 int i;
676 struct stat file_stat;
677
678 fstat( fd, &file_stat);
679 i = get_resource_table( fd, &lpdata, file_stat.st_size );
680
681 switch(i)
682 {
683 case FILE_DLL:
684 if( lpdata )
685 {
686 int j, count = 0;
687 NE_TYPEINFO* pTInfo = (NE_TYPEINFO*)(lpdata + 2);
688 NE_NAMEINFO* pFontStorage = NULL;
689
690 while( (i = return_data_value(dfShort, &pTInfo->type_id)) )
691 {
692 j = return_data_value(dfShort, &pTInfo->count);
693 if( i == NE_RSCTYPE_FONT )
694 {
695 count = j;
696 pFontStorage = (NE_NAMEINFO*)(pTInfo + 1);
697 break; /* found one */
698 }
699
700 pTInfo = (NE_TYPEINFO *)((char*)(pTInfo+1) + j*sizeof(NE_NAMEINFO));
701 }
702 if( pFontStorage && count )
703 {
704 unsigned short size_shift = return_data_value(dfShort, lpdata);
705 unsigned char* lpfont = NULL;
706 unsigned offset;
707 int length;
708
709 for( j = 0; j < count; j++, pFontStorage++ )
710 {
711 length = return_data_value(dfShort, &pFontStorage->length) << size_shift;
712 offset = return_data_value(dfShort, &pFontStorage->offset) << size_shift;
713
714 if( !(lpfont = (unsigned char*) realloc( lpfont, length )) )
715 {
716 fprintf(stderr, "Memory allocation error.\n" );
717 exit(1);
718 }
719
720 lseek( fd, offset, SEEK_SET );
721 if( read(fd, lpfont, length) != length )
722 {
723 fprintf(stderr, "Unable to read Windows DLL.\n" );
724 exit(1);
725 }
726
727 if( (i = parse_fnt_data( lpfont, length )) )
728 {
729 fprintf(stderr, "Unable to parse font data: Error %d\n", i );
730 exit(1);
731 }
732 }
733 free(lpfont); free(lpdata);
734 exit(0);
735 }
736 else
737 {
738 fprintf(stderr, "No fonts found.\n" );
739 exit(1);
740 }
741 free( lpdata );
742 }
743 else
744 {
745 fprintf(stderr, "Unable to read Windows DLL.\n" );
746 exit(1);
747 }
748 break;
749
750 case FILE_FNT:
751 if( lpdata )
752 {
753 if( (i = parse_fnt_data( lpdata, file_stat.st_size )) )
754 {
755 fprintf(stderr, "Unable to parse font data: Error %d\n", i );
756 exit(1);
757 }
758 free( lpdata );
759 }
760 else
761 {
762 fprintf(stderr, "Unable to read .FNT file.\n" );
763 exit(1);
764 }
765 break;
766
767 case FILE_ERROR:
768 fprintf(stderr, "Corrupt or invalid file.\n" );
769 exit(1);
770 }
771 close(fd);
772 exit(0);
773 }
774 else
775 {
776 fprintf(stderr, "Unable to open '%s'.\n", g_lpstrInputFile );
777 exit(1);
778 }
779 }
DirectPlay implementation for GSoC