Logo Search packages:      
Sourcecode: wine-unstable version File versions  Download package

fnt2bdf.c

/************************************************
 *
 * Extract fonts from .fnt or Windows DLL files
 * and convert them to the .bdf format.
 *
 * Copyright 1994-1996 Kevin Carothers and Alex Korobka
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#include "config.h"
#include "wine/port.h"

#ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#include <fcntl.h>
#ifdef HAVE_IO_H
# include <io.h>
#endif

#include "windef.h"
#include "wingdi.h"

enum data_types {dfChar, dfShort, dfLong, dfString};

#define ERROR_DATA      1
#define ERROR_VERSION   2
#define ERROR_SIZE      3
#define ERROR_MEMORY    4
#define ERROR_FILE      5

#include "pshpack1.h"

typedef struct
{
    INT16 dfType;
    INT16 dfPoints;
    INT16 dfVertRes;
    INT16 dfHorizRes;
    INT16 dfAscent;
    INT16 dfInternalLeading;
    INT16 dfExternalLeading;
    BYTE  dfItalic;
    BYTE  dfUnderline;
    BYTE  dfStrikeOut;
    INT16 dfWeight;
    BYTE  dfCharSet;
    INT16 dfPixWidth;
    INT16 dfPixHeight;
    BYTE  dfPitchAndFamily;
    INT16 dfAvgWidth;
    INT16 dfMaxWidth;
    BYTE  dfFirstChar;
    BYTE  dfLastChar;
    BYTE  dfDefaultChar;
    BYTE  dfBreakChar;
    INT16 dfWidthBytes;
    LONG  dfDevice;
    LONG  dfFace;
    LONG  dfBitsPointer;
    LONG  dfBitsOffset;
    BYTE  dfReserved;
    LONG  dfFlags;
    INT16 dfAspace;
    INT16 dfBspace;
    INT16 dfCspace;
    LONG  dfColorPointer;
    LONG  dfReserved1[4];
} FONTINFO16;

typedef struct
{
    WORD  offset;
    WORD  length;
    WORD  flags;
    WORD  id;
    WORD  handle;
    WORD  usage;
} NE_NAMEINFO;

typedef struct
{
    WORD  type_id;
    WORD  count;
    DWORD resloader;
} NE_TYPEINFO;

#define NE_FFLAGS_SINGLEDATA    0x0001
#define NE_FFLAGS_MULTIPLEDATA  0x0002
#define NE_FFLAGS_WIN32         0x0010
#define NE_FFLAGS_FRAMEBUF      0x0100
#define NE_FFLAGS_CONSOLE       0x0200
#define NE_FFLAGS_GUI           0x0300
#define NE_FFLAGS_SELFLOAD      0x0800
#define NE_FFLAGS_LINKERROR     0x2000
#define NE_FFLAGS_CALLWEP       0x4000
#define NE_FFLAGS_LIBMODULE     0x8000

#define NE_OSFLAGS_WINDOWS      0x02

#define NE_RSCTYPE_FONTDIR            0x8007
#define NE_RSCTYPE_FONT               0x8008
#define NE_RSCTYPE_SCALABLE_FONTPATH  0x80cc

#define NE_SEGFLAGS_DATA        0x0001
#define NE_SEGFLAGS_ALLOCATED   0x0002
#define NE_SEGFLAGS_LOADED      0x0004
#define NE_SEGFLAGS_ITERATED    0x0008
#define NE_SEGFLAGS_MOVEABLE    0x0010
#define NE_SEGFLAGS_SHAREABLE   0x0020
#define NE_SEGFLAGS_PRELOAD     0x0040
#define NE_SEGFLAGS_EXECUTEONLY 0x0080
#define NE_SEGFLAGS_READONLY    0x0080
#define NE_SEGFLAGS_RELOC_DATA  0x0100
#define NE_SEGFLAGS_SELFLOAD    0x0800
#define NE_SEGFLAGS_DISCARDABLE 0x1000
#define NE_SEGFLAGS_32BIT       0x2000

typedef struct tagFontHeader
{
    SHORT dfVersion;          /* Version */
    LONG dfSize;        /* Total File Size */
    char dfCopyright[60];     /* Copyright notice */
    FONTINFO16 fi;            /* FONTINFO structure */
} fnt_hdrS;

typedef struct WinCharStruct
{
    unsigned int charWidth;
    long charOffset;
} WinCharS;

typedef struct fntFontStruct
{
    fnt_hdrS            hdr;
    WinCharS            *dfCharTable;
    unsigned char *dfDeviceP;
    unsigned char       *dfFaceP;
    unsigned char       *dfBitsPointerP;
    unsigned char       *dfBitsOffsetP;
    short         *dfColorTableP;
} fnt_fontS;

#include "poppack.h"

#define FILE_ERROR      0
#define FILE_DLL  1
#define FILE_FNT  2

/* global options */

static int dump_bdf( fnt_fontS* cpe_font_struct, unsigned char* file_buffer);
static int dump_bdf_hdr(FILE* fs, fnt_fontS* cpe_font_struct, unsigned char* file_buffer);

static char* g_lpstrFileName = NULL;
static char* g_lpstrCharSet = NULL;
static char* g_lpstrInputFile = NULL;
static int   g_outputPoints = 0;

/* info */

static void usage(void)
{
    printf("Usage: fnt2bdf [-t] [-c charset] [-o basename] [input file]\n");
    printf("  -c charset\tcharset name for OEM_CHARSET fonts\n");
    printf("  -f basename\tbasic output filename\n");
    printf("  -t \t\toutput files by point size instead of pixel height\n");
    printf("  input file\tMSWindows .fon, .fnt, .dll, or .exe file.\n");
    printf("\nExample:\n  fnt2bdf -c winsys vgasys.fnt\n\n");
    exit(-1);
}

/* convert little-endian value to the local format */

static int return_data_value(enum data_types dtype, void * pChr)
{
int   ret_val = 0;

    switch(dtype) {
        case (dfChar):
            ret_val = (int) *(unsigned char *)pChr;
            break;

        case(dfShort):
            ret_val = *(unsigned char *)pChr;
            ret_val += (*((unsigned char *)pChr + 1) << 8);
            break;

        case(dfLong): {
            int  i;

            for(i=3; i >= 0; i--)  {
                ret_val += *((unsigned char *)pChr + i) << (8*i);
                }
            break;
            }
            case(dfString):
                  break;
        }
    return ret_val;
}

static int make_bdf_filename(char* name, fnt_fontS* cpe_font_struct, unsigned char* file_buffer)
{
long  l_nameoffset = return_data_value(dfLong, &cpe_font_struct->hdr.fi.dfFace);
char*   lpChar;

  if( !g_lpstrFileName )
  {
    if( !l_nameoffset ||
         l_nameoffset > return_data_value(dfLong, &cpe_font_struct->hdr.dfSize) + 1 )
         return ERROR_DATA;
    lpChar =  (char*)(file_buffer + l_nameoffset);
  }
    else lpChar = g_lpstrFileName;

  strcpy( name, lpChar );

  while( (lpChar = strchr( name, ' ')) )
         *lpChar = '-';

  /* construct a filename from the font typeface, slant, weight, and size */

  if( cpe_font_struct->hdr.fi.dfItalic ) strcat(name, "_i" );
  else strcat(name, "_r" );

  lpChar = name + strlen( name );
  sprintf(lpChar, "%d-%d.bdf", return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfWeight),
          (g_outputPoints) ? return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPoints)
                     : return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixHeight) );
  return 0;
}

/* parse FONT resource and write .bdf file */

static int parse_fnt_data(unsigned char* file_buffer, int length)
{
  fnt_fontS cpe_font_struct;
  int       ic=0, t;

  memcpy((char *) &cpe_font_struct.hdr, file_buffer, sizeof(fnt_hdrS));

  /* check font header */

  t = return_data_value(dfShort, &cpe_font_struct.hdr.dfVersion);
  if( t != 0x300 && t != 0x200) return ERROR_VERSION;

  t = return_data_value(dfShort, &cpe_font_struct.hdr.fi.dfType);
  if (t & 1)
  {
    fprintf(stderr, "Vector fonts not supported\n");
    return ERROR_DATA;
  }

  t = return_data_value(dfLong, &cpe_font_struct.hdr.dfSize);
  if( t > length ) return ERROR_SIZE;
  else
  {
    /* set up the charWidth/charOffset  structure pairs (dfCharTable)... */

    int l_fchar = return_data_value(dfChar, &cpe_font_struct.hdr.fi.dfFirstChar),
      l_lchar = return_data_value(dfChar, &cpe_font_struct.hdr.fi.dfLastChar);
    int l_len   = l_lchar - l_fchar + 1;
    int l_ptr = sizeof(fnt_hdrS);

    /* some fields were introduced for Windows 3.x fonts */
    if( return_data_value(dfShort, &cpe_font_struct.hdr.dfVersion) == 0x200 )
      l_ptr -= 30;

    /* malloc size = (# chars) * sizeof(WinCharS) */

    if((cpe_font_struct.dfCharTable = (WinCharS *) calloc(sizeof(WinCharS), l_len)) == NULL)
      return ERROR_MEMORY;

    /* NOW, convert them all to UNIX (lton) notation... */

    for(ic=0; ic < l_len; ic++) {
      cpe_font_struct.dfCharTable[ic].charWidth = return_data_value(dfShort, &file_buffer[l_ptr]);
      l_ptr += 2; /* bump by sizeof(short) */


      if( return_data_value(dfShort, &cpe_font_struct.hdr.dfVersion) == 0x200) {
          cpe_font_struct.dfCharTable[ic].charOffset =
                  return_data_value(dfShort, &file_buffer[l_ptr]);
          l_ptr += 2;   /* bump by sizeof(short) */
          }
      else {      /*  Windows Version 3.0 type font */
          cpe_font_struct.dfCharTable[ic].charOffset =
                  return_data_value(dfLong, &file_buffer[l_ptr]);
          l_ptr += 4;   /* bump by sizeof(long) */
          }
      }
    t = dump_bdf(&cpe_font_struct, file_buffer);
    free( cpe_font_struct.dfCharTable );
  }
  return t;
}

static int dump_bdf( fnt_fontS* cpe_font_struct, unsigned char* file_buffer)
{
  FILE*   fp;
  int   ic;
  int   l_fchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfFirstChar),
        l_lchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfLastChar);

  int     l_len = l_lchar-l_fchar + 1,
        l_hgt = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfPixHeight);
  int   l_ascent = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfAscent);
  char    l_filename[256];

    if( (ic = make_bdf_filename(l_filename, cpe_font_struct, file_buffer)) )
      return ic;

    if((fp = fopen(l_filename, "w")) == NULL)
    {
      fprintf(stderr, "Couldn't open \"%s\" for output.\n", l_filename);
      return ERROR_FILE;
    }

    ic = dump_bdf_hdr(fp, cpe_font_struct, file_buffer);
    if (ic) {
      fclose(fp);
      return (ic);
    }

    /* NOW, convert all chars to UNIX (lton) notation... */

    for(ic=0; ic < l_len; ic++) {
      int rowidx, l_span,           /* how many char-cols wide is char? */
          l_idx = cpe_font_struct->dfCharTable[ic].charOffset;

      l_span = (int) (cpe_font_struct->dfCharTable[ic].charWidth-1)/8;

      fprintf(fp, "STARTCHAR %d\n", ic);
      fprintf(fp, "ENCODING %d\n",   l_fchar);
      fprintf(fp, "SWIDTH    %d    %d\n",
            cpe_font_struct->dfCharTable[ic].charWidth*1000,
            0);

      fprintf(fp, "DWIDTH    %d    %d\n",
            cpe_font_struct->dfCharTable[ic].charWidth, 0);

      fprintf(fp, "BBX  %d  %d  %d   %d\n",
            cpe_font_struct->dfCharTable[ic].charWidth, l_hgt, 0,
            l_ascent - l_hgt);

      fprintf(fp, "BITMAP\n");
      for(rowidx=0; rowidx < l_hgt; rowidx++) {
          switch(l_span) {
            case(0):    /* 1-7 pixels wide font */
                {
                fprintf(fp, "%02X\n", (int) file_buffer[l_idx+rowidx]);
                break;
                }

            case(1):    /* 8-15 pixels wide font */
                {
                fprintf(fp, "%02X%02X",
                  (int) file_buffer[l_idx+rowidx], file_buffer[l_idx+l_hgt+rowidx]);
                fprintf(fp, "\n");
                break;
                }

            case(2):    /* 16-23 pixels wide font */
                {
                fprintf(fp, "%02X%02X%02X",
                  file_buffer[l_idx+rowidx],
                    file_buffer[l_idx+l_hgt+rowidx],
                    file_buffer[l_idx+(2*l_hgt)+rowidx]);
                fprintf(fp, "\n");
                break;
                }

            case(3):    /* 24-31 pixels wide font */
                {
                fprintf(fp, "%02X%02X%02X%02X",
                  file_buffer[l_idx+rowidx],
                  file_buffer[l_idx+l_hgt+rowidx],
                  file_buffer[l_idx+(2*l_hgt)+rowidx],
                  file_buffer[l_idx+(3*l_hgt)+rowidx]);
                fprintf(fp, "\n");
                break;
                }
            case(4):    /* 32-39 */
                {
                fprintf(fp, "%02X%02X%02X%02X%02X",
                  file_buffer[l_idx+rowidx],
                  file_buffer[l_idx+l_hgt+rowidx],
                        file_buffer[l_idx+(2*l_hgt)+rowidx],
                        file_buffer[l_idx+(3*l_hgt)+rowidx],
                  file_buffer[l_idx+(4*l_hgt)+rowidx]);
                fprintf(fp, "\n");
                    break;
                    }
            default:
                fclose(fp);
                unlink(l_filename);
                return ERROR_DATA;
            }
          }
      fprintf(fp, "ENDCHAR\n");

      l_fchar++;  /* Go to next one */
      }
fprintf(fp, "ENDFONT\n");
fclose(fp);
return 0;
}


static int dump_bdf_hdr(FILE* fs, fnt_fontS* cpe_font_struct, unsigned char* file_buffer)
{
int   l_fchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfFirstChar),
      l_lchar = return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfLastChar);
int     l_len = l_lchar - l_fchar + 1;
long  l_nameoffset = return_data_value(dfLong, &cpe_font_struct->hdr.fi.dfFace);
int   l_cellheight = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixHeight);
int   l_ascent = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfAscent);

    fprintf(fs, "STARTFONT   2.1\n");

    /* Compose font name */

    if( l_nameoffset &&
      l_nameoffset < return_data_value(dfLong, &cpe_font_struct->hdr.dfSize) )
    {
      int     dpi, point_size;
      char*   lpFace = (char*)(file_buffer + l_nameoffset), *lpChar;
      short   tmWeight = return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfWeight);

      while((lpChar = strchr(lpFace, '-')) )
          *lpChar = ' ';

      fprintf(fs, "FONT -windows-%s-", lpFace );

      if( tmWeight == 0 )                 /* weight */
        fputs("medium-", fs);
      else if( tmWeight <= FW_LIGHT )
        fputs("light-", fs);
      else if( tmWeight <= FW_MEDIUM )
        fputs("medium-", fs);
      else if( tmWeight <= FW_DEMIBOLD )
        fputs("demibold-", fs);
      else if( tmWeight <= FW_BOLD )
        fputs("bold-", fs);
      else fputs("black-", fs);

      if( cpe_font_struct->hdr.fi.dfItalic )    /* slant */
        fputs("i-", fs);
      else fputs("r-", fs);

      /* style */

      if( (cpe_font_struct->hdr.fi.dfPitchAndFamily & 0xF0) == FF_SWISS )
        fputs("normal-sans-", fs);
      else fputs("normal--", fs);   /* still can be -sans */

      /* y extents */

      point_size = 10 * return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPoints );
      dpi = (l_cellheight * 720) / point_size;

      fprintf(fs, "%d-%d-%d-%d-",l_cellheight, point_size,
            return_data_value (dfShort, &cpe_font_struct->hdr.fi.dfHorizRes),
            return_data_value (dfShort, &cpe_font_struct->hdr.fi.dfVertRes));

      /* spacing */

      if( return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPixWidth) ) fputs("c-", fs);
      else fputs("p-", fs);

      /* average width */

      fprintf( fs, "%d-", 10 * return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfAvgWidth) );

      /* charset */

     if( g_lpstrCharSet ) fprintf(fs, "%s\n", g_lpstrCharSet);
     else
      switch( cpe_font_struct->hdr.fi.dfCharSet )
      {
      /* Microsoft just had to invent its own charsets! */

      case ANSI_CHARSET:      fputs("microsoft-cp1252\n", fs); break;
      case GREEK_CHARSET:     fputs("microsoft-cp1253\n", fs); break;
      case TURKISH_CHARSET:   fputs("microsoft-cp1254\n", fs); break;
      case HEBREW_CHARSET:    fputs("microsoft-cp1255\n", fs); break;
      case ARABIC_CHARSET:    fputs("microsoft-cp1256\n", fs); break;
      case BALTIC_CHARSET:    fputs("microsoft-cp1257\n", fs); break;
      case RUSSIAN_CHARSET:   fputs("microsoft-cp1251\n", fs); break;
      case EE_CHARSET:  fputs("microsoft-cp1250\n", fs); break;
      case SYMBOL_CHARSET:    fputs("microsoft-symbol\n", fs); break;
      case SHIFTJIS_CHARSET:  fputs("jisx0208.1983-0\n", fs); break;
      case DEFAULT_CHARSET:   fputs("iso8859-1\n", fs); break;

      default:
      case OEM_CHARSET:
                fputs("Undefined charset, use -c option.\n", stderr);
                return ERROR_DATA;
      }
    }
    else return ERROR_DATA;

    fprintf(fs, "SIZE  %d  %d   %d\n",
        return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfPoints ),
      return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfHorizRes),
      return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfVertRes));   /* dfVertRes[2] */

    fprintf(fs, "FONTBOUNDINGBOX %d  %d  %d  %d\n",
      return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfMaxWidth),
      return_data_value(dfChar, &cpe_font_struct->hdr.fi.dfPixHeight),
      0, l_ascent - l_cellheight );

    fprintf(fs, "STARTPROPERTIES  4\n");

    fprintf(fs, "FONT_ASCENT %d\n", l_ascent );                       /*  dfAscent[2] */
    fprintf(fs, "FONT_DESCENT %d\n", l_cellheight - l_ascent );
    fprintf(fs, "CAP_HEIGHT %d\n", l_ascent -
                                   return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfInternalLeading));
    fprintf(fs, "DEFAULT_CHAR %d\n", return_data_value(dfShort, &cpe_font_struct->hdr.fi.dfDefaultChar));

    fprintf(fs, "ENDPROPERTIES\n");

    fprintf(fs, "CHARS  %d\n",  l_len);
    return 0;
}



static void parse_options(int argc, char **argv)
{
  int i;

  switch( argc )
  {
    case 2:
       g_lpstrInputFile = argv[1];
       break;

    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
       for( i = 1; i < argc - 1; i++ )
       {
         if( argv[i][0] != '-' ||
             strlen(argv[i]) != 2 ) break;

         if( argv[i][1] == 'c' )
             g_lpstrCharSet = argv[i+1];
         else
         if( argv[i][1] == 'f' )
             g_lpstrFileName = argv[i+1];
         else
         if( argv[i][1] == 't' )
         {
            g_outputPoints = 1;
            continue;
         }
         else
         usage();

         i++;
       }
       if( i == argc - 1 )
       {
         g_lpstrInputFile = argv[i];
         break;
       }
    default: usage();
  }

}

/* read file data and return file type */

static int get_resource_table(int fd, unsigned char** lpdata, int fsize)
{
  IMAGE_DOS_HEADER mz_header;
  IMAGE_OS2_HEADER ne_header;
  long s, offset, size;
  int retval;

  lseek( fd, 0, SEEK_SET );

  if( read(fd, &mz_header, sizeof(mz_header)) != sizeof(mz_header) )
      return FILE_ERROR;

  s = return_data_value(dfShort, &mz_header.e_magic);

  if( s == IMAGE_DOS_SIGNATURE)           /* looks like .dll file so far... */
  {
    s = return_data_value(dfShort, &mz_header.e_lfanew);
    lseek( fd, s, SEEK_SET );

    if( read(fd, &ne_header, sizeof(ne_header)) != sizeof(ne_header) )
      return FILE_ERROR;

    s = return_data_value(dfShort, &ne_header.ne_magic);

    if( s == IMAGE_NT_SIGNATURE)
    {
       fprintf( stderr, "Do not know how to handle 32-bit Windows DLLs.\n");
       return FILE_ERROR;
    }
    else if ( s != IMAGE_OS2_SIGNATURE) return FILE_ERROR;

    s = return_data_value(dfShort, &ne_header.ne_rsrctab);
    size = return_data_value(dfShort, &ne_header.ne_restab);

    if( size > fsize ) return FILE_ERROR;

    size -= s;
    offset = s + return_data_value(dfShort, &mz_header.e_lfanew);

    if( size <= sizeof(NE_TYPEINFO) ) return FILE_ERROR;
    retval = FILE_DLL;
  }
  else if( s == 0x300 || s == 0x200 )           /* maybe .fnt ? */
  {
    size = return_data_value(dfLong, &((fnt_hdrS *)&mz_header)->dfSize);

    if( size != fsize ) return FILE_ERROR;
    offset  = 0;
    retval = FILE_FNT;
  }
  else return FILE_ERROR;

  *lpdata = (unsigned char*)malloc(size);

  if( *lpdata )
  {
    lseek( fd, offset, SEEK_SET );
    if( read(fd, *lpdata, size) != size )
           { free( *lpdata ); *lpdata = NULL; }
  }
  return retval;
}


/* entry point */

int main(int argc, char **argv)
{
  unsigned char* lpdata = NULL;
  int              fd;

  parse_options( argc, argv);

  if( (fd = open( g_lpstrInputFile, O_RDONLY | O_BINARY)) != -1 )
  {
    int    i;
    struct stat file_stat;

    fstat( fd, &file_stat);
    i = get_resource_table( fd, &lpdata, file_stat.st_size );

    switch(i)
    {
      case FILE_DLL:
           if( lpdata )
           {
             int      j, count = 0;
             NE_TYPEINFO* pTInfo = (NE_TYPEINFO*)(lpdata + 2);
             NE_NAMEINFO* pFontStorage = NULL;

             while( (i = return_data_value(dfShort, &pTInfo->type_id)) )
             {
              j = return_data_value(dfShort, &pTInfo->count);
              if( i == NE_RSCTYPE_FONT )
              {
                count = j;
                pFontStorage = (NE_NAMEINFO*)(pTInfo + 1);
                break; /* found one */
              }

              pTInfo = (NE_TYPEINFO *)((char*)(pTInfo+1) + j*sizeof(NE_NAMEINFO));
             }
             if( pFontStorage && count )
             {
             unsigned short         size_shift = return_data_value(dfShort, lpdata);
             unsigned char*         lpfont = NULL;
             unsigned         offset;
             int              length;

             for( j = 0; j < count; j++, pFontStorage++ )
             {
                length = return_data_value(dfShort, &pFontStorage->length) << size_shift;
                offset = return_data_value(dfShort, &pFontStorage->offset) << size_shift;

                if( !(lpfont = (unsigned char*) realloc( lpfont, length )) )
                {
                  fprintf(stderr, "Memory allocation error.\n" );
                  exit(1);
                }

                lseek( fd, offset, SEEK_SET );
                if( read(fd, lpfont, length) != length )
                {
                  fprintf(stderr, "Unable to read Windows DLL.\n" );
                  exit(1);
                }

                if( (i = parse_fnt_data( lpfont, length )) )
                {
                  fprintf(stderr, "Unable to parse font data: Error %d\n", i );
                  exit(1);
                }
             }
             free(lpfont); free(lpdata);
             exit(0);
             }
             else
             {
                 fprintf(stderr, "No fonts found.\n" );
             exit(1);
             }
             free( lpdata );
           }
           else
           {
               fprintf(stderr, "Unable to read Windows DLL.\n" );
             exit(1);
           }
           break;

      case FILE_FNT:
           if( lpdata )
           {
             if( (i = parse_fnt_data( lpdata, file_stat.st_size )) )
             {
                   fprintf(stderr, "Unable to parse font data: Error %d\n", i );
               exit(1);
             }
             free( lpdata );
           }
           else
           {
               fprintf(stderr, "Unable to read .FNT file.\n" );
             exit(1);
           }
           break;

      case FILE_ERROR:
             fprintf(stderr, "Corrupt or invalid file.\n" );
           exit(1);
    }
    close(fd);
    exit(0);
  }
  else
  {
    fprintf(stderr, "Unable to open '%s'.\n", g_lpstrInputFile );
    exit(1);
  }
}

Generated by  Doxygen 1.6.0   Back to index