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