ftvalid.c

Demo for Free type 2.2.1

    printf( "-------------------------------------------------------------------\n" );
  }


  static void
  report_result( FT_Bytes            data[],
                 FT_UInt             validation_flags,
                 const TableSpecRec  spec[],
                 int                 spec_count )
  {
    int  i;
    int  n_passes;
    

    for ( i = 0, n_passes = 0; i < spec_count; i++ )
    {
      if ( ( spec[i].validation_flag & validation_flags ) &&
             data[i] != NULL                              )
      {
        printf( "[%s:%s] ", execname, validator_symbols[validator] );
        print_tag( stdout, spec[i].tag );
        printf( "...pass\n" );
        n_passes++;
      }
    }

    if ( n_passes == 0 )
    {
      printf( "[%s:%s] layout tables are invalid.\n",
              execname, validator_symbols[validator] );
      printf( "[%s:%s] set FT2_DEBUG environment variable to \n",
              execname, validator_symbols[validator] );
      printf( "[%s:%s] know the validation detail. \n",
              execname, validator_symbols[validator] );
    }
  }


  /* 
   * OpenType related funtions
   */
  static int
  run_ot_validator( FT_Face      face,
                    const char*  tables,
                    int          validation_level )
  {
    FT_UInt       validation_flags;
    FT_Error      error;
    FT_Bytes      data[N_OT_TABLE_SPEC];
    unsigned int  i;
    

    validation_flags  = validation_level;
    validation_flags |= make_table_specs( face, tables, ot_table_spec,
                                          N_OT_TABLE_SPEC );

    for ( i = 0; i < N_OT_TABLE_SPEC; i++ )
      data[i] = NULL;

    report_header( validation_flags, ot_table_spec, N_OT_TABLE_SPEC );

    error = FT_OpenType_Validate(
              face, 
              validation_flags, 
              &data[0], &data[1], &data[2], &data[3], &data[4] );
      
    report_result( data, validation_flags, ot_table_spec, N_OT_TABLE_SPEC );

    for ( i = 0; i < N_OT_TABLE_SPEC; i++ )
      FT_OpenType_Free( face, data[i] );

    return (int)error;
  }


  static int
  list_ot_tables( FT_Face  face )
  {
    FT_UInt  validation_flags;


    validation_flags = list_face_tables( face, ot_table_spec,
                                         N_OT_TABLE_SPEC );
    return print_tables( stdout, validation_flags, ot_table_spec,
                         N_OT_TABLE_SPEC );
  }


  /* 
   * TrueTypeGX related funtions
   */
  static int
  run_gx_validator( FT_Face      face, 
                    const char*  tables, 
                    int          validation_level )
  {
    FT_UInt       validation_flags;
    FT_Error      error;
    FT_Bytes      data[N_GX_TABLE_SPEC];
    unsigned int  i;
    
    validation_flags  = validation_level;
    validation_flags |= make_table_specs( face, tables, gx_table_spec,
                                          N_GX_TABLE_SPEC );
    
    for ( i = 0; i < N_GX_TABLE_SPEC; i++ )
      data[i] = NULL;

    report_header( validation_flags, gx_table_spec, N_GX_TABLE_SPEC );

    error = FT_TrueTypeGX_Validate( 
              face, 
              validation_flags, 
              data,
              N_GX_TABLE_SPEC );
      
    report_result( data, validation_flags, gx_table_spec, N_GX_TABLE_SPEC );

    for ( i = 0; i < N_GX_TABLE_SPEC; i++ )
      FT_TrueTypeGX_Free( face, data[i] );

    return (int)error;
  }


  static int
  list_gx_tables ( FT_Face  face )
  {
    FT_UInt  validation_flags;

    validation_flags = list_face_tables( face, gx_table_spec,
                                         N_GX_TABLE_SPEC );
    return print_tables( stdout, validation_flags, gx_table_spec,
                         N_GX_TABLE_SPEC );
  }
  

  /*
   * Classic kern related funtions
   */
  static int
  run_ckern_validator( FT_Face      face, 
                       const char*  dialect_request, 
                       int          validation_level )
  {
    FT_UInt    validation_flags;
    FT_Error   error;
    FT_Bytes   data;  

    
    if ( dialect_request == NULL )
      dialect_request = "ms:apple";

    
    validation_flags  = validation_level;
    
    if ( strcmp( dialect_request, "ms:apple" ) == 0 ||  
         strcmp( dialect_request, "apple:ms" ) == 0 )
      validation_flags |= FT_VALIDATE_MS | FT_VALIDATE_APPLE;
    else if ( strcmp( dialect_request, "ms" ) == 0 )
      validation_flags |= FT_VALIDATE_MS;
    else if ( strcmp( dialect_request, "apple" ) == 0 )
      validation_flags |= FT_VALIDATE_APPLE;
    else
    {
      fprintf( stderr, "Wrong classic kern dialect: %s\n", dialect_request );
      print_usage();
    }

    printf( "[%s:%s] validation targets: %s...", 
            execname, validator_symbols[validator], dialect_request );


    error = FT_ClassicKern_Validate(
              face,
              validation_flags,
              &data );


    if ( data )
      printf( "pass\n" );
    else if ( data == NULL && error )
      printf( "fail\n" );
    else
      printf( "no kern\n" );
    
    FT_ClassicKern_Free( face, data );
              
    return (int)error;
  }

  static int
  list_ckern_tables ( FT_Face  face )
  {
    FT_Error  error;

    error = try_load( face, TTAG_kern );
    if ( error == 0 )
      printf( "ms:apple\n" );
    return 0;
  }  
  
  /*
   * Main driver
   */

  int
  main( int     argc, 
        char**  argv )
  {
    char*  fontfile;
    int    option;
    int    status;

    char*  tables;
    int    dump_table_list;

    FT_ValidationLevel  validation_level;
#if 0
    int  trace_level;
#endif  /* 0 */
    
    execname = ft_basename( argv[0] );

    /*
     * Parsing options
     */
    validator        = OT_VALIDATE;
    tables           = NULL;
    dump_table_list  = 0;
    validation_level = FT_VALIDATE_DEFAULT;
#if 0
    trace_level      = 0;
#endif  /* 0 */

    while ( 1 )
    {
      option = getopt( argc, argv, "t:T:Lv:l:" );

      if ( option == -1 )
        break;
    
      switch ( option )
      {
      case 't':
        {
          int i;
          

          for ( i = 0; /* No condition here */; i++ )
          {
            if ( validator_symbols[i] == NULL )
            {
              fprintf( stderr, "*** Unknown validator name: %s\n", optarg );
              print_usage();
            }
            
            if ( strcmp( optarg, validator_symbols[i] ) == 0 )
            {
              validator = (ValidatorType)i;
              break;
            }
          }
        }
        break;

      case 'T':
        tables = optarg;
        break;

      case 'L':
        dump_table_list = 1;
        break;

      case 'v':
        validation_level = (FT_ValidationLevel)atoi( optarg );
        if ( validation_level > FT_VALIDATE_PARANOID )
        {
          fprintf( stderr, "*** Validation level is out of range: %d\n",
                           validation_level );
          print_usage();
        }
        break;

      default:
        print_usage();
        break;
      }
    }

    argc -= optind;
    argv += optind;

    if ( argc == 0 )
    {
      fprintf(stderr, "*** Font file is not specified.\n");
      print_usage();
    }
    else if ( argc > 1 )
    {
      fprintf(stderr, "*** Too many font files.\n");
      print_usage();
    }

    fontfile = argv[0];

#if 0
    printf( "fontfile: %s\n",
            fontfile );
    printf( "validator type: " );
    printf( "%s\n", validator_symbols[validator] );
    printf( "tables: %s\n",
            ( tables != NULL ) ? tables : "unspecified" );
    printf( "action: %s\n",
            ( dump_table_list == 1 ) ? "list" : "validate" );
    printf( "validation level: %d\n",
            validation_level );
#if 0
    printf( "trace level: %d\n", trace_level );
#endif /* 0 */
#endif /* 0 */


    /*
     * Run a validator
     */
    {
      FT_Library  library;
      FT_Face     face;
      FT_Error    error;


      status = 0;

      error = FT_Init_FreeType( &library );
      if ( error )
        panic ( error, "Could not initialize FreeType library" );

      /* TODO: Multiple faces in a font file? */
      error = FT_New_Face( library, fontfile, 0, &face );
      if ( error )
        panic( error, "Could not open face." );
      
      switch ( validator )
      {
      case OT_VALIDATE:
        if ( dump_table_list == 0 )
          status = run_ot_validator( face, tables, validation_level );
        else
          status = list_ot_tables  ( face );
        break;
      case GX_VALIDATE:
        if ( dump_table_list == 0 )
          status = run_gx_validator( face, tables, validation_level );
        else
          status = list_gx_tables( face );
        break;
      case CKERN_VALIDATE:
        if ( dump_table_list == 0 )
          status = run_ckern_validator( face, tables, validation_level );
        else
          status = list_ckern_tables( face );
        break;
      }
      
      FT_Done_Face( face );
      FT_Done_FreeType( library );
    }

    return status;
  }


/* End */