winex11.drv: Empty clipboard cache on process unload to avoid false positives being...
[wine] / tools / fnt2bdf.c
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 }