?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- start assigning custom VK codes from VK_OEM_8 since this code
[wine.git] / tools / fnt2bdf.c
blob4a6bd16ae3d5a4060b128cfe562b19924f81b8f8
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23 #include "config.h"
24
25 #ifdef HAVE_SYS_PARAM_H
26 # include <sys/param.h>
27 #endif
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #ifdef HAVE_UNISTD_H
34 # include <unistd.h>
35 #endif
36 #include <fcntl.h>
37 #ifdef HAVE_IO_H
38 # include <io.h>
39 #endif
40
41 #ifndef O_BINARY
42 # define O_BINARY 0
43 #endif
44
45 #include "fnt2bdf.h"
46
47 #define FILE_ERROR 0
48 #define FILE_DLL 1
49 #define FILE_FNT 2
50
51 /* global options */
52
53 int dump_bdf( fnt_fontS* cpe_font_struct, unsigned char* file_buffer);
54 int dump_bdf_hdr(FILE* fs, fnt_fontS* cpe_font_struct, unsigned char* file_buffer);
55
56 char* g_lpstrFileName = NULL;
57 char* g_lpstrCharSet = NULL;
58 char* g_lpstrInputFile = NULL;
59 int g_outputPoints = 0;
60
61 static const char* errorDLLRead = "Unable to read Windows DLL.\n";
62 static const char* errorFNTRead = "Unable to read .FNT file.\n";
63 static const char* errorOpenFile = "Unable to open file.\n";
64 static const char* errorMemory = "Memory allocation error.\n";
65 static const char* errorFile = "Corrupt or invalid file.\n";
66 static const char* errorFontData = "Unable to parse font data: Error ";
67 static const char* errorEmpty = "No fonts found.\n";
68
69 /* info */
70
71 void usage(void)
72 {
73 printf("Usage: fnt2bdf [-t] [-c charset] [-o basename] [input file]\n");
74 printf(" -c charset\tcharset name for OEM_CHARSET fonts\n");
75 printf(" -f basename\tbasic output filename\n");
76 printf(" -t \t\toutput files by point size instead of pixel height\n");
77 printf(" input file\tMSWindows .fon, .fnt, .dll, or .exe file.\n");
78 printf("\nExample:\n fnt2bdf -c winsys vgasys.fnt\n\n");
79 exit(-1);
80 }
81
82 /* convert little-endian value to the local format */
83
84 int return_data_value(enum data_types dtype, void * pChr)
85 {
86 int ret_val = 0;
87
88 switch(dtype) {
89 case (dfChar):
90 ret_val = (int) *(unsigned char *)pChr;
91 break;
92
93 case(dfShort):
94 ret_val = *(unsigned char *)pChr;
95 ret_val += (*((unsigned char *)pChr + 1) << 8);
96 break;
97
98 case(dfLong): {
99 int i;
100
101 for(i=3; i >= 0; i--) {
102 ret_val += *((unsigned char *)pChr + i) << (8*i);
103 }
104 break;
105 }
106 case(dfString):
107 break;
108 }
109 return ret_val;
110 }
111
112 int make_bdf_filename(char* name, fnt_fontS* cpe_font_struct, unsigned char* file_buffer)
113 {
114 long l_nameoffset = return_data_value(dfLong, &cpe_font_struct->hdr.fi.dfFace);
115 char* lpChar;
116
117 if( !g_lpstrFileName )
118 {
119 if( !l_nameoffset ||
120 l_nameoffset > return_data_value(dfLong, &cpe_font_struct->hdr.dfSize) + 1 )
121 return ERROR_DATA;
122 lpChar = (char*)(file_buffer + l_nameoffset);
123 }
124 else lpChar = g_lpstrFileName;
125
126 strcpy( name, lpChar );
127
128 while( (lpChar = strchr( name, ' ')) )
129 *lpChar = '-';
130
131 /* construct a filename from the font typeface, slant, weight, and size */
132
133 if( cpe_font_struct->hdr.fi.dfItalic ) strcat(name, "_i" );
134 else strcat(name, "_r" );
135
136 lpChar = name + strlen( name );
137 sprintf(lpChar, "%d-%d.bdf", return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfWeight),
138 (g_outputPoints) ? return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPoints)
139 : return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixHeight) );
140 return 0;
141 }
142
143 /* parse FONT resource and write .bdf file */
144
145 int parse_fnt_data(unsigned char* file_buffer, int length)
146 {
147 fnt_fontS cpe_font_struct;
148 int ic=0, t;
149
150 memcpy((char *) &cpe_font_struct.hdr, file_buffer, sizeof(fnt_hdrS));
151
152 /* check font header */
153
154 t = return_data_value(dfShort, &cpe_font_struct.hdr.dfVersion);
155 if( t != 0x300 && t != 0x200) return ERROR_VERSION;
156
157 t = return_data_value(dfShort, &cpe_font_struct.hdr.fi.dfType);
158 if (t & 1)
159 {
160 fprintf(stderr, "Vector fonts not supported\n");
161 return ERROR_DATA;
162 }
163
164 t = return_data_value(dfLong, &cpe_font_struct.hdr.dfSize);
165 if( t > length ) return ERROR_SIZE;
166 else
167 {
168 /* set up the charWidth/charOffset structure pairs (dfCharTable)... */
169
170 int l_fchar = return_data_value(dfChar, &cpe_font_struct.hdr.fi.dfFirstChar),
171 l_lchar = return_data_value(dfChar, &cpe_font_struct.hdr.fi.dfLastChar);
172 int l_len = l_lchar - l_fchar + 1;
173 int l_ptr = sizeof(fnt_hdrS);
174
175 /* some fields were introduced for Windows 3.x fonts */
176 if( return_data_value(dfShort, &cpe_font_struct.hdr.dfVersion) == 0x200 )
177 l_ptr -= 30;
178
179 /* malloc size = (# chars) * sizeof(WinCharS) */
180
181 if((cpe_font_struct.dfCharTable = (WinCharS *) calloc(sizeof(WinCharS), l_len)) == NULL)
182 return ERROR_MEMORY;
183
184 /* NOW, convert them all to UNIX (lton) notation... */
185
186 for(ic=0; ic < l_len; ic++) {
187 cpe_font_struct.dfCharTable[ic].charWidth = return_data_value(dfShort, &file_buffer[l_ptr]);
188 l_ptr += 2; /* bump by sizeof(short) */
189
190
191 if( return_data_value(dfShort, &cpe_font_struct.hdr.dfVersion) == 0x200) {
192 cpe_font_struct.dfCharTable[ic].charOffset =
193 return_data_value(dfShort, &file_buffer[l_ptr]);
194 l_ptr += 2; /* bump by sizeof(short) */
195 }
196 else { /* Windows Version 3.0 type font */
197 cpe_font_struct.dfCharTable[ic].charOffset =
198 return_data_value(dfLong, &file_buffer[l_ptr]);
199 l_ptr += 4; /* bump by sizeof(long) */
200 }
201 }
202 t = dump_bdf(&cpe_font_struct, file_buffer);
203 free( cpe_font_struct.dfCharTable );
204 }
205 return t;
206 }
207
208 int dump_bdf( fnt_fontS* cpe_font_struct, unsigned char* file_buffer)
209 {
210 FILE* fp;
211 int ic;
212 int l_fchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfFirstChar),
213 l_lchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfLastChar);
214
215 int l_len = l_lchar-l_fchar + 1,
216 l_hgt = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfPixHeight);
217 int l_ascent = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfAscent);
218 char l_filename[256];
219
220 if( (ic = make_bdf_filename(l_filename, cpe_font_struct, file_buffer)) )
221 return ic;
222
223 if((fp = fopen(l_filename, "w")) == (FILE *) 0)
224 {
225 fprintf(stderr, "Couldn't open \"%s\" for output.\n", l_filename);
226 return ERROR_FILE;
227 }
228
229 ic = dump_bdf_hdr(fp, cpe_font_struct, file_buffer);
230 if (ic) return (ic);
231
232 /* NOW, convert all chars to UNIX (lton) notation... */
233
234 for(ic=0; ic < l_len; ic++) {
235 int rowidx, l_span, /* how many char-cols wide is char? */
236 l_idx = cpe_font_struct->dfCharTable[ic].charOffset;
237
238 l_span = (int) (cpe_font_struct->dfCharTable[ic].charWidth-1)/8;
239
240 fprintf(fp, "STARTCHAR %d \n", ic);
241 fprintf(fp, "ENCODING %d\n", l_fchar);
242 fprintf(fp, "SWIDTH %d %d \n",
243 cpe_font_struct->dfCharTable[ic].charWidth*1000,
244 0);
245
246 fprintf(fp, "DWIDTH %d %d \n",
247 cpe_font_struct->dfCharTable[ic].charWidth, 0);
248
249 fprintf(fp, "BBX %d %d %d %d\n",
250 cpe_font_struct->dfCharTable[ic].charWidth, l_hgt, 0,
251 l_ascent - l_hgt);
252
253 fprintf(fp, "BITMAP\n");
254 for(rowidx=0; rowidx < l_hgt; rowidx++) {
255 switch(l_span) {
256 case(0): /* 1-7 pixels wide font */
257 {
258 fprintf(fp, "%02X\n", (int) file_buffer[l_idx+rowidx]);
259 break;
260 }
261
262 case(1): /* 8-15 pixels wide font */
263 {
264 fprintf(fp, "%02X%02X",
265 (int) file_buffer[l_idx+rowidx], file_buffer[l_idx+l_hgt+rowidx]);
266 fprintf(fp, "\n");
267 break;
268 }
269
270 case(2): /* 16-23 pixels wide font */
271 {
272 fprintf(fp, "%02X%02X%02X",
273 file_buffer[l_idx+rowidx],
274 file_buffer[l_idx+l_hgt+rowidx],
275 file_buffer[l_idx+(2*l_hgt)+rowidx]);
276 fprintf(fp, "\n");
277 break;
278 }
279
280 case(3): /* 24-31 pixels wide font */
281 {
282 fprintf(fp, "%02X%02X%02X%02X",
283 file_buffer[l_idx+rowidx],
284 file_buffer[l_idx+l_hgt+rowidx],
285 file_buffer[l_idx+(2*l_hgt)+rowidx],
286 file_buffer[l_idx+(3*l_hgt)+rowidx]);
287 fprintf(fp, "\n");
288 break;
289 }
290 case(4): /* 32-39 */
291 {
292 fprintf(fp, "%02X%02X%02X%02X%02X",
293 file_buffer[l_idx+rowidx],
294 file_buffer[l_idx+l_hgt+rowidx],
295 file_buffer[l_idx+(2*l_hgt)+rowidx],
296 file_buffer[l_idx+(3*l_hgt)+rowidx],
297 file_buffer[l_idx+(4*l_hgt)+rowidx]);
298 fprintf(fp, "\n");
299 break;
300 }
301 default:
302 fclose(fp);
303 unlink(l_filename);
304 return ERROR_DATA;
305 }
306 }
307 fprintf(fp, "ENDCHAR\n");
308
309 l_fchar++; /* Go to next one */
310 }
311 fprintf(fp, "ENDFONT\n");
312 fclose(fp);
313 return 0;
314 }
315
316
317 int dump_bdf_hdr(FILE* fs, fnt_fontS* cpe_font_struct, unsigned char* file_buffer)
318 {
319 int l_fchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfFirstChar),
320 l_lchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfLastChar);
321 int l_len = l_lchar - l_fchar + 1;
322 long l_nameoffset = return_data_value(dfLong, &cpe_font_struct->hdr.fi.dfFace);
323 int l_cellheight = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixHeight);
324 int l_ascent = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfAscent);
325
326 fprintf(fs, "STARTFONT 2.1\n");
327
328 /* Compose font name */
329
330 if( l_nameoffset &&
331 l_nameoffset < return_data_value(dfLong, &cpe_font_struct->hdr.dfSize) )
332 {
333 int dpi, point_size;
334 char* lpFace = (char*)(file_buffer + l_nameoffset), *lpChar;
335 short tmWeight = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfWeight);
336
337 while((lpChar = strchr(lpFace, '-')) )
338 *lpChar = ' ';
339
340 fprintf(fs, "FONT -windows-%s-", lpFace );
341
342 if( tmWeight == 0 ) /* weight */
343 fputs("medium-", fs);
344 else if( tmWeight <= FW_LIGHT )
345 fputs("light-", fs);
346 else if( tmWeight <= FW_MEDIUM )
347 fputs("medium-", fs);
348 else if( tmWeight <= FW_DEMIBOLD )
349 fputs("demibold-", fs);
350 else if( tmWeight <= FW_BOLD )
351 fputs("bold-", fs);
352 else fputs("black-", fs);
353
354 if( cpe_font_struct->hdr.fi.dfItalic ) /* slant */
355 fputs("i-", fs);
356 else fputs("r-", fs);
357
358 /* style */
359
360 if( (cpe_font_struct->hdr.fi.dfPitchAndFamily & 0xF0) == FF_SWISS )
361 fputs("normal-sans-", fs);
362 else fputs("normal--", fs); /* still can be -sans */
363
364 /* y extents */
365
366 point_size = 10 * return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPoints );
367 dpi = (l_cellheight * 720) / point_size;
368
369 fprintf(fs, "%d-%d-%d-%d-",l_cellheight, point_size,
370 return_data_value (dfShort, &cpe_font_struct->hdr.fi.dfHorizRes),
371 return_data_value (dfShort, &cpe_font_struct->hdr.fi.dfVertRes));
372
373 /* spacing */
374
375 if( return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixWidth) ) fputs("c-", fs);
376 else fputs("p-", fs);
377
378 /* average width */
379
380 fprintf( fs, "%d-", 10 * return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfAvgWidth) );
381
382 /* charset */
383
384 if( g_lpstrCharSet ) fprintf(fs, "%s\n", g_lpstrCharSet);
385 else
386 switch( cpe_font_struct->hdr.fi.dfCharSet )
387 {
388 /* Microsoft just had to invent its own charsets! */
389
390 case ANSI_CHARSET: fputs("microsoft-cp1252\n", fs); break;
391 case GREEK_CHARSET: fputs("microsoft-cp1253\n", fs); break;
392 case TURKISH_CHARSET: fputs("microsoft-cp1254\n", fs); break;
393 case HEBREW_CHARSET: fputs("microsoft-cp1255\n", fs); break;
394 case ARABIC_CHARSET: fputs("microsoft-cp1256\n", fs); break;
395 case BALTIC_CHARSET: fputs("microsoft-cp1257\n", fs); break;
396 case RUSSIAN_CHARSET: fputs("microsoft-cp1251\n", fs); break;
397 case EE_CHARSET: fputs("microsoft-cp1250\n", fs); break;
398 case SYMBOL_CHARSET: fputs("microsoft-symbol\n", fs); break;
399 case SHIFTJIS_CHARSET: fputs("jisx0208.1983-0\n", fs); break;
400 case DEFAULT_CHARSET: fputs("iso8859-1\n", fs); break;
401
402 default:
403 case OEM_CHARSET:
404 fputs("Undefined charset, use -c option.\n", stderr);
405 return ERROR_DATA;
406 }
407 }
408 else return ERROR_DATA;
409
410 fprintf(fs, "SIZE %d %d %d\n",
411 return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPoints ),
412 return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfHorizRes),
413 return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfVertRes)); /* dfVertRes[2] */
414
415 fprintf(fs, "FONTBOUNDINGBOX %d %d %d %d\n",
416 return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfMaxWidth),
417 return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfPixHeight),
418 0, l_ascent - l_cellheight );
419
420 fprintf(fs, "STARTPROPERTIES 4\n");
421
422 fprintf(fs, "FONT_ASCENT %d\n", l_ascent ); /* dfAscent[2] */
423 fprintf(fs, "FONT_DESCENT %d\n", l_cellheight - l_ascent );
424 fprintf(fs, "CAP_HEIGHT %d\n", l_ascent -
425 return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfInternalLeading));
426 fprintf(fs, "DEFAULT_CHAR %d\n", return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfDefaultChar));
427
428 fprintf(fs, "ENDPROPERTIES\n");
429
430 fprintf(fs, "CHARS %d\n", l_len);
431 return 0;
432 }
433
434
435
436 void parse_options(int argc, char **argv)
437 {
438 int i;
439
440 switch( argc )
441 {
442 case 2:
443 g_lpstrInputFile = argv[1];
444 break;
445
446 case 3:
447 case 4:
448 case 5:
449 case 6:
450 case 7:
451 case 8:
452 for( i = 1; i < argc - 1; i++ )
453 {
454 if( argv[i][0] != '-' ||
455 strlen(argv[i]) != 2 ) break;
456
457 if( argv[i][1] == 'c' )
458 g_lpstrCharSet = argv[i+1];
459 else
460 if( argv[i][1] == 'f' )
461 g_lpstrFileName = argv[i+1];
462 else
463 if( argv[i][1] == 't' )
464 {
465 g_outputPoints = 1;
466 continue;
467 }
468 else
469 usage();
470
471 i++;
472 }
473 if( i == argc - 1 )
474 {
475 g_lpstrInputFile = argv[i];
476 break;
477 }
478 default: usage();
479 }
480
481 }
482
483 /* read file data and return file type */
484
485 int get_resource_table(int fd, unsigned char** lpdata, int fsize)
486 {
487 IMAGE_DOS_HEADER mz_header;
488 IMAGE_OS2_HEADER ne_header;
489 long s, offset, size;
490 int retval;
491
492 lseek( fd, 0, SEEK_SET );
493
494 if( read(fd, &mz_header, sizeof(mz_header)) != sizeof(mz_header) )
495 return FILE_ERROR;
496
497 s = return_data_value(dfShort, &mz_header.e_magic);
498
499 if( s == IMAGE_DOS_SIGNATURE) /* looks like .dll file so far... */
500 {
501 s = return_data_value(dfShort, &mz_header.e_lfanew);
502 lseek( fd, s, SEEK_SET );
503
504 if( read(fd, &ne_header, sizeof(ne_header)) != sizeof(ne_header) )
505 return FILE_ERROR;
506
507 s = return_data_value(dfShort, &ne_header.ne_magic);
508
509 if( s == IMAGE_NT_SIGNATURE)
510 {
511 fprintf( stderr, "Do not know how to handle 32-bit Windows DLLs.\n");
512 return FILE_ERROR;
513 }
514 else if ( s != IMAGE_OS2_SIGNATURE) return FILE_ERROR;
515
516 s = return_data_value(dfShort, &ne_header.ne_rsrctab);
517 size = return_data_value(dfShort, &ne_header.ne_restab);
518
519 if( size > fsize ) return FILE_ERROR;
520
521 size -= s;
522 offset = s + return_data_value(dfShort, &mz_header.e_lfanew);
523
524 if( size <= sizeof(NE_TYPEINFO) ) return FILE_ERROR;
525 retval = FILE_DLL;
526 }
527 else if( s == 0x300 || s == 0x200 ) /* maybe .fnt ? */
528 {
529 size = return_data_value(dfLong, &((fnt_hdrS *)&mz_header)->dfSize);
530
531 if( size != fsize ) return FILE_ERROR;
532 offset = 0;
533 retval = FILE_FNT;
534 }
535 else return FILE_ERROR;
536
537 *lpdata = (unsigned char*)malloc(size);
538
539 if( *lpdata )
540 {
541 lseek( fd, offset, SEEK_SET );
542 if( read(fd, *lpdata, size) != size )
543 { free( *lpdata ); *lpdata = NULL; }
544 }
545 return retval;
546 }
547
548
549 /* entry point */
550
551 int main(int argc, char **argv)
552 {
553 unsigned char* lpdata = NULL;
554 int fd;
555
556 parse_options( argc, argv);
557
558 if( (fd = open( g_lpstrInputFile, O_RDONLY | O_BINARY)) )
559 {
560 int i;
561 struct stat file_stat;
562
563 fstat( fd, &file_stat);
564 i = get_resource_table( fd, &lpdata, file_stat.st_size );
565
566 switch(i)
567 {
568 case FILE_DLL:
569 if( lpdata )
570 {
571 int j, count = 0;
572 NE_TYPEINFO* pTInfo = (NE_TYPEINFO*)(lpdata + 2);
573 NE_NAMEINFO* pFontStorage = NULL;
574
575 while( (i = return_data_value(dfShort, &pTInfo->type_id)) )
576 {
577 j = return_data_value(dfShort, &pTInfo->count);
578 if( i == NE_RSCTYPE_FONT )
579 {
580 count = j;
581 pFontStorage = (NE_NAMEINFO*)(pTInfo + 1);
582 break; /* found one */
583 }
584
585 pTInfo = (NE_TYPEINFO *)((char*)(pTInfo+1) + j*sizeof(NE_NAMEINFO));
586 }
587 if( pFontStorage && count )
588 {
589 unsigned short size_shift = return_data_value(dfShort, lpdata);
590 unsigned char* lpfont = NULL;
591 unsigned offset;
592 int length;
593
594 for( j = 0; j < count; j++, pFontStorage++ )
595 {
596 length = return_data_value(dfShort, &pFontStorage->length) << size_shift;
597 offset = return_data_value(dfShort, &pFontStorage->offset) << size_shift;
598
599 if( !(lpfont = (unsigned char*) realloc( lpfont, length )) )
600 {
601 fprintf(stderr, errorMemory );
602 exit(1);
603 }
604
605 lseek( fd, offset, SEEK_SET );
606 if( read(fd, lpfont, length) != length )
607 {
608 fprintf(stderr, errorDLLRead );
609 exit(1);
610 }
611
612 if( (i = parse_fnt_data( lpfont, length )) )
613 {
614 fprintf(stderr, "%s%d\n", errorFontData, i );
615 exit(1);
616 }
617 }
618 free(lpfont); free(lpdata);
619 exit(0);
620 }
621 else
622 {
623 fprintf(stderr, errorEmpty );
624 exit(1);
625 }
626 free( lpdata );
627 }
628 else
629 {
630 fprintf(stderr, errorDLLRead);
631 exit(1);
632 }
633 break;
634
635 case FILE_FNT:
636 if( lpdata )
637 {
638 if( (i = parse_fnt_data( lpdata, file_stat.st_size )) )
639 {
640 fprintf(stderr, "%s%d\n", errorFontData, i );
641 exit(1);
642 }
643 free( lpdata );
644 }
645 else
646 {
647 fprintf(stderr, errorFNTRead);
648 exit(1);
649 }
650 break;
651
652 case FILE_ERROR:
653 fprintf(stderr, errorFile );
654 exit(1);
655 }
656 close(fd);
657 exit(0);
658 }
659 else
660 {
661 fprintf(stderr, errorOpenFile );
662 exit(1);
663 }
664 }
Windows API implementation