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