← Back to branch summary

~ubuntu-branches/ubuntu/wily/hedgewars/wily

« back to all changes in this revision

Viewing changes to misc/libfreetype/src/tools/ftrandom/ftrandom.c

  • Committer: Package Import Robot
  • Author(s): Dmitry E. Oboukhov
  • Date: 2011-09-23 10:16:55 UTC
  • mfrom: (1.2.11 upstream)
  • Revision ID: package-import@ubuntu.com-20110923101655-3977th2gc5n0a3pv
Tags: 0.9.16-1
* New upstream version.
 + Downloadable content! Simply click to install any content.
   New voices, hats, maps, themes, translations, music, scripts...
   Hedgewars is now more customisable than ever before! As time goes
   by we will be soliciting community content to feature on this page,
   so remember to check it from time to time. If you decide you want
   to go back to standard Hedgewars, just remove the Data directory
   from your Hedgewars config directory.
 + 3-D rendering! Diorama-like rendering of the game in a variety
   of 3D modes. Let us know which ones work best for you, we didn't
   really have the equipment to test them all.
 + Resizable game window.
 + New utilities! The Time Box will remove one of your hedgehogs
   from the game for a while, protecting from attack until it returns,
   somewhere else on the map. Land spray will allow you to build bridges,
   seal up holes, or just make life unpleasant for your enemies.
 + New single player: Bamboo Thicket, That Sinking Feeling, Newton and
   the Tree and multi-player: The Specialists, Space Invaders,
   Racer - scripts! And a ton more script hooks for scripters
 + New twists on old weapons. Drill strike, seduction and fire have
   been adjusted. Defective mines have been added, rope can attach to
   hogs/crates/barrels again, grenades now have variable bounce (use
   precise key + 1-5). Portal gun is now more usable in flight and
   all game actions are a lot faster.
 + New theme - Golf, dozens of new community hats and a new
   localised Default voice, Ukranian.

Show diffs side-by-side

added added

removed removed

Lines of Context:
misc/libfreetype/src/tools/ftrandom/ftrandom.c
 
1
/* Copyright (C) 2005, 2007, 2008 by George Williams */
 
2
/*
 
3
 * Redistribution and use in source and binary forms, with or without
 
4
 * modification, are permitted provided that the following conditions are met:
 
5
 
 
6
 * Redistributions of source code must retain the above copyright notice, this
 
7
 * list of conditions and the following disclaimer.
 
8
 
 
9
 * Redistributions in binary form must reproduce the above copyright notice,
 
10
 * this list of conditions and the following disclaimer in the documentation
 
11
 * and/or other materials provided with the distribution.
 
12
 
 
13
 * The name of the author may not be used to endorse or promote products
 
14
 * derived from this software without specific prior written permission.
 
15
 
 
16
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
 
17
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 
18
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
 
19
 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
20
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 
21
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 
22
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 
23
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 
24
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 
25
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
26
 */
 
27
 
 
28
/* modified by Werner Lemberg <wl@gnu.org>       */
 
29
/* This file is now part of the FreeType library */
 
30
 
 
31
 
 
32
#include <stdio.h>
 
33
#include <stdlib.h>
 
34
#include <string.h>
 
35
#include <strings.h>
 
36
#include <sys/types.h>
 
37
#include <sys/stat.h>
 
38
#include <sys/wait.h>
 
39
#include <unistd.h>
 
40
#include <dirent.h>
 
41
#include <math.h>
 
42
#include <signal.h>
 
43
#include <time.h>
 
44
 
 
45
#include <ft2build.h>
 
46
#include FT_FREETYPE_H
 
47
#include FT_OUTLINE_H
 
48
 
 
49
#define true     1
 
50
#define false    0
 
51
#define forever  for (;;)
 
52
 
 
53
 
 
54
  static int    check_outlines = false;
 
55
  static int    nohints        = false;
 
56
  static int    rasterize      = false;
 
57
  static char*  results_dir    = "results";
 
58
 
 
59
#define GOOD_FONTS_DIR  "/home/wl/freetype-testfonts"
 
60
 
 
61
  static char*  default_dir_list[] =
 
62
  {
 
63
    GOOD_FONTS_DIR,
 
64
    NULL
 
65
  };
 
66
 
 
67
  static char*  default_ext_list[] =
 
68
  {
 
69
    "ttf",
 
70
    "otf",
 
71
    "ttc",
 
72
    "cid",
 
73
    "pfb",
 
74
    "pfa",
 
75
    "bdf",
 
76
    "pcf",
 
77
    "pfr",
 
78
    "fon",
 
79
    "otb",
 
80
    "cff",
 
81
    NULL
 
82
  };
 
83
 
 
84
  static int  error_count    = 1;
 
85
  static int  error_fraction = 0;
 
86
 
 
87
  static FT_F26Dot6  font_size = 12 * 64;
 
88
 
 
89
  static struct fontlist
 
90
  {
 
91
    char*         name;
 
92
    int           len;
 
93
    unsigned int  isbinary: 1;
 
94
    unsigned int  isascii: 1;
 
95
    unsigned int  ishex: 1;
 
96
 
 
97
  } *fontlist;
 
98
 
 
99
  static int  fcnt;
 
100
 
 
101
 
 
102
  static int
 
103
  FT_MoveTo( const FT_Vector  *to,
 
104
             void             *user )
 
105
  {
 
106
    return 0;
 
107
  }
 
108
 
 
109
 
 
110
  static int
 
111
  FT_LineTo( const FT_Vector  *to,
 
112
             void             *user )
 
113
  {
 
114
    return 0;
 
115
  }
 
116
 
 
117
 
 
118
  static int
 
119
  FT_ConicTo( const FT_Vector  *_cp,
 
120
              const FT_Vector  *to,
 
121
              void             *user )
 
122
  {
 
123
    return 0;
 
124
  }
 
125
 
 
126
 
 
127
  static int
 
128
  FT_CubicTo( const FT_Vector  *cp1,
 
129
              const FT_Vector  *cp2,
 
130
              const FT_Vector  *to,
 
131
              void             *user )
 
132
  {
 
133
    return 0;
 
134
  }
 
135
 
 
136
 
 
137
  static FT_Outline_Funcs outlinefuncs =
 
138
  {
 
139
    FT_MoveTo,
 
140
    FT_LineTo,
 
141
    FT_ConicTo,
 
142
    FT_CubicTo,
 
143
    0, 0          /* No shift, no delta */
 
144
  };
 
145
 
 
146
 
 
147
  static void
 
148
  TestFace( FT_Face  face )
 
149
  {
 
150
    int  gid;
 
151
    int  load_flags = FT_LOAD_DEFAULT;
 
152
 
 
153
 
 
154
    if ( check_outlines         &&
 
155
         FT_IS_SCALABLE( face ) )
 
156
      load_flags = FT_LOAD_NO_BITMAP;
 
157
 
 
158
    if ( nohints )
 
159
      load_flags |= FT_LOAD_NO_HINTING;
 
160
 
 
161
    FT_Set_Char_Size( face, 0, font_size, 72, 72 );
 
162
 
 
163
    for ( gid = 0; gid < face->num_glyphs; ++gid )
 
164
    {
 
165
      if ( check_outlines         &&
 
166
           FT_IS_SCALABLE( face ) )
 
167
      {
 
168
        if ( !FT_Load_Glyph( face, gid, load_flags ) )
 
169
          FT_Outline_Decompose( &face->glyph->outline, &outlinefuncs, NULL );
 
170
      }
 
171
      else
 
172
        FT_Load_Glyph( face, gid, load_flags );
 
173
 
 
174
      if ( rasterize )
 
175
        FT_Render_Glyph( face->glyph, ft_render_mode_normal );
 
176
    }
 
177
 
 
178
    FT_Done_Face( face );
 
179
  }
 
180
 
 
181
 
 
182
  static void
 
183
  ExecuteTest( char*  testfont )
 
184
  {
 
185
    FT_Library  context;
 
186
    FT_Face     face;
 
187
    int         i, num;
 
188
 
 
189
 
 
190
    if ( FT_Init_FreeType( &context ) )
 
191
    {
 
192
      fprintf( stderr, "Can't initialize FreeType.\n" );
 
193
      exit( 1 );
 
194
    }
 
195
 
 
196
    if ( FT_New_Face( context, testfont, 0, &face ) )
 
197
    {
 
198
      /* The font is erroneous, so if this fails that's ok. */
 
199
      exit( 0 );
 
200
    }
 
201
 
 
202
    if ( face->num_faces == 1 )
 
203
      TestFace( face );
 
204
    else
 
205
    {
 
206
      num = face->num_faces;
 
207
      FT_Done_Face( face );
 
208
 
 
209
      for ( i = 0; i < num; ++i )
 
210
      {
 
211
        if ( !FT_New_Face( context, testfont, i, &face ) )
 
212
          TestFace( face );
 
213
      }
 
214
    }
 
215
 
 
216
    exit( 0 );
 
217
  }
 
218
 
 
219
 
 
220
  static int
 
221
  extmatch( char*   filename,
 
222
            char**  extensions )
 
223
  {
 
224
    int    i;
 
225
    char*  pt;
 
226
 
 
227
 
 
228
    if ( extensions == NULL )
 
229
      return true;
 
230
 
 
231
    pt = strrchr( filename, '.' );
 
232
    if ( pt == NULL )
 
233
      return false;
 
234
    if ( pt < strrchr( filename, '/' ) )
 
235
      return false;
 
236
 
 
237
    for ( i = 0; extensions[i] != NULL; ++i )
 
238
      if ( strcasecmp( pt + 1, extensions[i] ) == 0 ||
 
239
           strcasecmp( pt,     extensions[i] ) == 0 )
 
240
        return true;
 
241
 
 
242
    return false;
 
243
  }
 
244
 
 
245
 
 
246
  static void
 
247
  figurefiletype( struct fontlist*  item )
 
248
  {
 
249
    FILE*  foo;
 
250
 
 
251
 
 
252
    item->isbinary = item->isascii = item->ishex = false;
 
253
 
 
254
    foo = fopen( item->name, "rb" );
 
255
    if ( foo != NULL )
 
256
    {
 
257
      /* Try to guess the file type from the first few characters... */
 
258
      int  ch1 = getc( foo );
 
259
      int  ch2 = getc( foo );
 
260
      int  ch3 = getc( foo );
 
261
      int  ch4 = getc( foo );
 
262
 
 
263
 
 
264
      fclose( foo );
 
265
 
 
266
      if ( ( ch1 == 0   && ch2 == 1   && ch3 == 0   && ch4 == 0   ) ||
 
267
           ( ch1 == 'O' && ch2 == 'T' && ch3 == 'T' && ch4 == 'O' ) ||
 
268
           ( ch1 == 't' && ch2 == 'r' && ch3 == 'u' && ch4 == 'e' ) ||
 
269
           ( ch1 == 't' && ch2 == 't' && ch3 == 'c' && ch4 == 'f' ) )
 
270
      {
 
271
        /* ttf, otf, ttc files */
 
272
        item->isbinary = true;
 
273
      }
 
274
      else if ( ch1 == 0x80 && ch2 == '\01' )
 
275
      {
 
276
        /* PFB header */
 
277
        item->isbinary = true;
 
278
      }
 
279
      else if ( ch1 == '%' && ch2 == '!' )
 
280
      {
 
281
        /* Random PostScript */
 
282
        if ( strstr( item->name, ".pfa" ) != NULL ||
 
283
             strstr( item->name, ".PFA" ) != NULL )
 
284
          item->ishex = true;
 
285
        else
 
286
          item->isascii = true;
 
287
      }
 
288
      else if ( ch1 == 1 && ch2 == 0 && ch3 == 4 )
 
289
      {
 
290
        /* Bare CFF */
 
291
        item->isbinary = true;
 
292
      }
 
293
      else if ( ch1 == 'S' && ch2 == 'T' && ch3 == 'A' && ch4 == 'R' )
 
294
      {
 
295
        /* BDF */
 
296
        item->ishex = true;
 
297
      }
 
298
      else if ( ch1 == 'P' && ch2 == 'F' && ch3 == 'R' && ch4 == '0' )
 
299
      {
 
300
        /* PFR */
 
301
        item->isbinary = true;
 
302
      }
 
303
      else if ( ( ch1 == '\1' && ch2 == 'f' && ch3 == 'c' && ch4 == 'p' ) ||
 
304
                ( ch1 == 'M'  && ch2 == 'Z' )                             )
 
305
      {
 
306
        /* Windows FON */
 
307
        item->isbinary = true;
 
308
      }
 
309
      else
 
310
      {
 
311
        fprintf( stderr,
 
312
                 "Can't recognize file type of `%s', assuming binary\n",
 
313
                 item->name );
 
314
        item->isbinary = true;
 
315
      }
 
316
    }
 
317
    else
 
318
    {
 
319
      fprintf( stderr, "Can't open `%s' for typing the file.\n",
 
320
               item->name );
 
321
      item->isbinary = true;
 
322
    }
 
323
  }
 
324
 
 
325
 
 
326
  static void
 
327
  FindFonts( char**  fontdirs,
 
328
             char**  extensions )
 
329
  {
 
330
    DIR*            examples;
 
331
    struct dirent*  ent;
 
332
 
 
333
    int             i, max;
 
334
    char            buffer[1025];
 
335
    struct stat     statb;
 
336
 
 
337
 
 
338
    max  = 0;
 
339
    fcnt = 0;
 
340
 
 
341
    for ( i = 0; fontdirs[i] != NULL; ++i )
 
342
    {
 
343
      examples = opendir( fontdirs[i] );
 
344
      if ( examples == NULL )
 
345
      {
 
346
        fprintf( stderr,
 
347
                 "Can't open example font directory `%s'\n",
 
348
                 fontdirs[i] );
 
349
        exit( 1 );
 
350
      }
 
351
 
 
352
      while ( ( ent = readdir( examples ) ) != NULL )
 
353
      {
 
354
        snprintf( buffer, sizeof ( buffer ),
 
355
                  "%s/%s", fontdirs[i], ent->d_name );
 
356
        if ( stat( buffer, &statb ) == -1 || S_ISDIR( statb.st_mode ) )
 
357
          continue;
 
358
        if ( extensions == NULL || extmatch( buffer, extensions ) )
 
359
        {
 
360
          if ( fcnt >= max )
 
361
          {
 
362
            max += 100;
 
363
            fontlist = realloc( fontlist, max * sizeof ( struct fontlist ) );
 
364
            if ( fontlist == NULL )
 
365
            {
 
366
              fprintf( stderr, "Can't allocate memory\n" );
 
367
              exit( 1 );
 
368
            }
 
369
          }
 
370
 
 
371
          fontlist[fcnt].name = strdup( buffer );
 
372
          fontlist[fcnt].len  = statb.st_size;
 
373
 
 
374
          figurefiletype( &fontlist[fcnt] );
 
375
          ++fcnt;
 
376
        }
 
377
      }
 
378
 
 
379
      closedir( examples );
 
380
    }
 
381
 
 
382
    if ( fcnt == 0 )
 
383
    {
 
384
      fprintf( stderr, "Can't find matching font files.\n" );
 
385
      exit( 1 );
 
386
    }
 
387
 
 
388
    fontlist[fcnt].name = NULL;
 
389
  }
 
390
 
 
391
 
 
392
  static int
 
393
  getErrorCnt( struct fontlist*  item )
 
394
  {
 
395
    if ( error_count == 0 && error_fraction == 0 )
 
396
      return 0;
 
397
 
 
398
    return error_count + ceil( error_fraction * item->len );
 
399
  }
 
400
 
 
401
 
 
402
  static int
 
403
  getRandom( int  low,
 
404
             int  high )
 
405
  {
 
406
    if ( low - high < 0x10000L )
 
407
      return low + ( ( random() >> 8 ) % ( high + 1 - low ) );
 
408
 
 
409
    return low + ( random() % ( high + 1 - low ) );
 
410
  }
 
411
 
 
412
 
 
413
  static int
 
414
  copyfont( struct fontlist*  item,
 
415
            char*             newfont )
 
416
  {
 
417
    static char  buffer[8096];
 
418
    FILE         *good, *new;
 
419
    int          len;
 
420
    int          i, err_cnt;
 
421
 
 
422
 
 
423
    good = fopen( item->name, "r" );
 
424
    if ( good == NULL )
 
425
    {
 
426
      fprintf( stderr, "Can't open `%s'\n", item->name );
 
427
      return false;
 
428
    }
 
429
 
 
430
    new = fopen( newfont, "w+" );
 
431
    if ( new == NULL )
 
432
    {
 
433
      fprintf( stderr, "Can't create temporary output file `%s'\n",
 
434
               newfont );
 
435
      exit( 1 );
 
436
    }
 
437
 
 
438
    while ( ( len = fread( buffer, 1, sizeof ( buffer ), good ) ) > 0 )
 
439
      fwrite( buffer, 1, len, new );
 
440
 
 
441
    fclose( good );
 
442
 
 
443
    err_cnt = getErrorCnt( item );
 
444
    for ( i = 0; i < err_cnt; ++i )
 
445
    {
 
446
      fseek( new, getRandom( 0, item->len - 1 ), SEEK_SET );
 
447
 
 
448
      if ( item->isbinary )
 
449
        putc( getRandom( 0, 0xff ), new );
 
450
      else if ( item->isascii )
 
451
        putc( getRandom( 0x20, 0x7e ), new );
 
452
      else
 
453
      {
 
454
        int  hex = getRandom( 0, 15 );
 
455
 
 
456
 
 
457
        if ( hex < 10 )
 
458
          hex += '0';
 
459
        else
 
460
          hex += 'A' - 10;
 
461
 
 
462
        putc( hex, new );
 
463
      }
 
464
    }
 
465
 
 
466
    if ( ferror( new ) )
 
467
    {
 
468
      fclose( new );
 
469
      unlink( newfont );
 
470
      return false;
 
471
    }
 
472
 
 
473
    fclose( new );
 
474
 
 
475
    return true;
 
476
  }
 
477
 
 
478
 
 
479
  static int  child_pid;
 
480
 
 
481
  static void
 
482
  abort_test( int  sig )
 
483
  {
 
484
    /* If a time-out happens, then kill the child */
 
485
    kill( child_pid, SIGFPE );
 
486
    write( 2, "Timeout... ", 11 );
 
487
  }
 
488
 
 
489
 
 
490
  static void
 
491
  do_test( void )
 
492
  {
 
493
    int         i        = getRandom( 0, fcnt - 1 );
 
494
    static int  test_num = 0;
 
495
    char        buffer[1024];
 
496
 
 
497
 
 
498
    sprintf( buffer, "%s/test%d", results_dir, test_num++ );
 
499
 
 
500
    if ( copyfont ( &fontlist[i], buffer ) )
 
501
    {
 
502
      signal( SIGALRM, abort_test );
 
503
      /* Anything that takes more than 20 seconds */
 
504
      /* to parse and/or rasterize is an error.   */
 
505
      alarm( 20 );
 
506
      if ( ( child_pid = fork() ) == 0 )
 
507
        ExecuteTest( buffer );
 
508
      else if ( child_pid != -1 )
 
509
      {
 
510
        int  status;
 
511
 
 
512
 
 
513
        waitpid( child_pid, &status, 0 );
 
514
        alarm( 0 );
 
515
        if ( WIFSIGNALED ( status ) )
 
516
          printf( "Error found in file `%s'\n", buffer );
 
517
        else
 
518
          unlink( buffer );
 
519
      }
 
520
      else
 
521
      {
 
522
        fprintf( stderr, "Can't fork test case.\n" );
 
523
        exit( 1 );
 
524
      }
 
525
      alarm( 0 );
 
526
    }
 
527
  }
 
528
 
 
529
 
 
530
  static void
 
531
  usage( FILE*  out,
 
532
         char*  name )
 
533
  {
 
534
    fprintf( out, "%s [options] -- Generate random erroneous fonts\n"
 
535
                  "  and attempt to parse them with FreeType.\n\n", name );
 
536
 
 
537
    fprintf( out, "  --all                    All non-directory files are assumed to be fonts.\n" );
 
538
    fprintf( out, "  --check-outlines         Make sure we can parse the outlines of each glyph.\n" );
 
539
    fprintf( out, "  --dir <path>             Append <path> to list of font search directories.\n" );
 
540
    fprintf( out, "  --error-count <cnt>      Introduce <cnt> single byte errors into each font.\n" );
 
541
    fprintf( out, "  --error-fraction <frac>  Introduce <frac>*filesize single byte errors\n"
 
542
                  "                           into each font.\n" );
 
543
    fprintf( out, "  --ext <ext>              Add <ext> to list of extensions indicating fonts.\n" );
 
544
    fprintf( out, "  --help                   Print this.\n" );
 
545
    fprintf( out, "  --nohints                Turn off hinting.\n" );
 
546
    fprintf( out, "  --rasterize              Attempt to rasterize each glyph.\n" );
 
547
    fprintf( out, "  --results <dir>          Directory in which to place the test fonts.\n" );
 
548
    fprintf( out, "  --size <float>           Use the given font size for the tests.\n" );
 
549
    fprintf( out, "  --test <file>            Run a single test on an already existing file.\n" );
 
550
  }
 
551
 
 
552
 
 
553
  int
 
554
  main( int     argc,
 
555
        char**  argv )
 
556
  {
 
557
    char    **dirs, **exts;
 
558
    char    *pt, *end;
 
559
    int     dcnt = 0, ecnt = 0, rset = false, allexts = false;
 
560
    int     i;
 
561
    time_t  now;
 
562
    char*   testfile = NULL;
 
563
 
 
564
 
 
565
    dirs = calloc( argc + 1, sizeof ( char ** ) );
 
566
    exts = calloc( argc + 1, sizeof ( char ** ) );
 
567
 
 
568
    for ( i = 1; i < argc; ++i )
 
569
    {
 
570
      pt = argv[i];
 
571
      if ( pt[0] == '-' && pt[1] == '-' )
 
572
        ++pt;
 
573
 
 
574
      if ( strcmp( pt, "-all" ) == 0 )
 
575
        allexts = true;
 
576
      else if ( strcmp( pt, "-check-outlines" ) == 0 )
 
577
        check_outlines = true;
 
578
      else if ( strcmp( pt, "-dir" ) == 0 )
 
579
        dirs[dcnt++] = argv[++i];
 
580
      else if ( strcmp( pt, "-error-count" ) == 0 )
 
581
      {
 
582
        if ( !rset )
 
583
          error_fraction = 0;
 
584
        rset = true;
 
585
        error_count = strtol( argv[++i], &end, 10 );
 
586
        if ( *end != '\0' )
 
587
        {
 
588
          fprintf( stderr, "Bad value for error-count: %s\n", argv[i] );
 
589
          exit( 1 );
 
590
        }
 
591
      }
 
592
      else if ( strcmp( pt, "-error-fraction" ) == 0 )
 
593
      {
 
594
        if ( !rset )
 
595
          error_count = 0;
 
596
        rset = true;
 
597
        error_fraction = strtod( argv[++i], &end );
 
598
        if ( *end != '\0' )
 
599
        {
 
600
          fprintf( stderr, "Bad value for error-fraction: %s\n", argv[i] );
 
601
          exit( 1 );
 
602
        }
 
603
      }
 
604
      else if ( strcmp( pt, "-ext" ) == 0 )
 
605
        exts[ecnt++] = argv[++i];
 
606
      else if ( strcmp( pt, "-help" ) == 0 )
 
607
      {
 
608
        usage( stdout, argv[0] );
 
609
        exit( 0 );
 
610
      }
 
611
      else if ( strcmp( pt, "-nohints" ) == 0 )
 
612
        nohints = true;
 
613
      else if ( strcmp( pt, "-rasterize" ) == 0 )
 
614
        rasterize = true;
 
615
      else if ( strcmp( pt, "-results" ) == 0 )
 
616
        results_dir = argv[++i];
 
617
      else if ( strcmp( pt, "-size" ) == 0 )
 
618
      {
 
619
        font_size = (FT_F26Dot6)( strtod( argv[++i], &end ) * 64 );
 
620
        if ( *end != '\0' || font_size < 64 )
 
621
        {
 
622
          fprintf( stderr, "Bad value for size: %s\n", argv[i] );
 
623
          exit( 1 );
 
624
        }
 
625
      }
 
626
      else if ( strcmp( pt, "-test" ) == 0 )
 
627
        testfile = argv[++i];
 
628
      else
 
629
      {
 
630
        usage( stderr, argv[0] );
 
631
        exit( 1 );
 
632
      }
 
633
    }
 
634
 
 
635
    if ( allexts )
 
636
      exts = NULL;
 
637
    else if ( ecnt == 0 )
 
638
      exts = default_ext_list;
 
639
 
 
640
    if ( dcnt == 0 )
 
641
      dirs = default_dir_list;
 
642
 
 
643
    if ( testfile != NULL )
 
644
      ExecuteTest( testfile );         /* This should never return */
 
645
 
 
646
    time( &now );
 
647
    srandom( now );
 
648
 
 
649
    FindFonts( dirs, exts );
 
650
    mkdir( results_dir, 0755 );
 
651
 
 
652
    forever
 
653
      do_test();
 
654
 
 
655
    return 0;
 
656
  }
 
657
 
 
658
 
 
659
/* EOF */