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