goto Exit;    /* check the face index */    if ( face_index != 0 )    {      FT_ERROR(( "T1_Face_Init: invalid face index\n" ));      error = T1_Err_Invalid_Argument;      goto Exit;    }    /* Now, load the font program into the face object */    /* Init the face object fields */    /* Now set up root face fields */    {      FT_Face  root = (FT_Face)&face->root;      root->num_glyphs = face->type1.num_glyphs;      root->face_index = face_index;      root->face_flags = FT_FACE_FLAG_SCALABLE;      root->face_flags |= FT_FACE_FLAG_HORIZONTAL;      root->face_flags |= FT_FACE_FLAG_GLYPH_NAMES;      if ( face->type1.font_info.is_fixed_pitch )        root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;      if ( face->blend )        root->face_flags |= FT_FACE_FLAG_MULTIPLE_MASTERS;      /* XXX: TODO -- add kerning with .afm support */      /* get style name -- be careful, some broken fonts only */      /* have a `/FontName' dictionary entry!                 */      root->family_name = face->type1.font_info.family_name;      if ( root->family_name )      {        char*  full   = face->type1.font_info.full_name;        char*  family = root->family_name;        if ( full )        {          while ( *family && *full == *family )          {            family++;            full++;          }          root->style_name = ( *full == ' ' ? full + 1                                            : (char *)"Regular" );        }        else          root->style_name = (char *)"Regular";      }      else      {        /* do we have a `/FontName'? */        if ( face->type1.font_name )        {          root->family_name = face->type1.font_name;          root->style_name  = (char *)"Regular";        }      }      /* compute style flags */      root->style_flags = 0;      if ( face->type1.font_info.italic_angle )        root->style_flags |= FT_STYLE_FLAG_ITALIC;      if ( face->type1.font_info.weight )      {        if ( !ft_strcmp( face->type1.font_info.weight, "Bold"  ) ||             !ft_strcmp( face->type1.font_info.weight, "Black" ) )          root->style_flags |= FT_STYLE_FLAG_BOLD;      }      /* no embedded bitmap support */      root->num_fixed_sizes = 0;      root->available_sizes = 0;      root->bbox.xMin =   face->type1.font_bbox.xMin             >> 16;      root->bbox.yMin =   face->type1.font_bbox.yMin             >> 16;      root->bbox.xMax = ( face->type1.font_bbox.xMax + 0xFFFFU ) >> 16;      root->bbox.yMax = ( face->type1.font_bbox.yMax + 0xFFFFU ) >> 16;      /* Set units_per_EM if we didn't set it in parse_font_matrix. */      if ( !root->units_per_EM )        root->units_per_EM = 1000;      root->ascender  = (FT_Short)( root->bbox.yMax );      root->descender = (FT_Short)( root->bbox.yMin );      root->height    = (FT_Short)(                          ( ( root->ascender - root->descender ) * 12 ) / 10 );      /* now compute the maximum advance width */      root->max_advance_width =        (FT_Short)( root->bbox.xMax );      {        FT_Int  max_advance;        error = T1_Compute_Max_Advance( face, &max_advance );        /* in case of error, keep the standard width */        if ( !error )          root->max_advance_width = (FT_Short)max_advance;        else          error = 0;   /* clear error */      }      root->max_advance_height = root->height;      root->underline_position  = face->type1.font_info.underline_position;      root->underline_thickness = face->type1.font_info.underline_thickness;      root->internal->max_points   = 0;      root->internal->max_contours = 0;    }#ifdef FT_CONFIG_OPTION_USE_CMAPS    {      FT_Face  root = &face->root;      if ( psnames && psaux )      {        FT_CharMapRec    charmap;        T1_CMap_Classes  cmap_classes = psaux->t1_cmap_classes;        FT_CMap_Class    clazz;        charmap.face = root;        /* first of all, try to synthetize a Unicode charmap */        charmap.platform_id = 3;        charmap.encoding_id = 1;        charmap.encoding    = ft_encoding_unicode;        FT_CMap_New( cmap_classes->unicode, NULL, &charmap, NULL );        /* now, generate an Adobe Standard encoding when appropriate */        charmap.platform_id = 7;        clazz               = NULL;        switch ( face->type1.encoding_type )        {        case T1_ENCODING_TYPE_STANDARD:          charmap.encoding    = ft_encoding_adobe_standard;          charmap.encoding_id = 0;          clazz               = cmap_classes->standard;          break;        case T1_ENCODING_TYPE_EXPERT:          charmap.encoding    = ft_encoding_adobe_expert;          charmap.encoding_id = 1;          clazz               = cmap_classes->expert;          break;        case T1_ENCODING_TYPE_ARRAY:          charmap.encoding    = ft_encoding_adobe_custom;          charmap.encoding_id = 2;          clazz               = cmap_classes->custom;          break;        case T1_ENCODING_TYPE_ISOLATIN1:          charmap.encoding    = ft_encoding_latin_1;          charmap.encoding_id = 3;          clazz               = cmap_classes->unicode;          break;        default:          ;        }        if ( clazz )          FT_CMap_New( clazz, NULL, &charmap, NULL );        /* Select default charmap */        if (root->num_charmaps)          root->charmap = root->charmaps[0];      }    }#else /* !FT_CONFIG_OPTION_USE_CMAPS */    /* charmap support -- synthetize unicode charmap if possible */    {      FT_Face     root    = &face->root;      FT_CharMap  charmap = face->charmaprecs;      /* synthesize a Unicode charmap if there is support in the `PSNames' */      /* module                                                            */      if ( psnames )      {        if ( psnames->unicode_value )        {          error = psnames->build_unicodes(                    root->memory,                    face->type1.num_glyphs,                    (const char**)face->type1.glyph_names,                    &face->unicode_map );          if ( !error )          {            root->charmap        = charmap;            charmap->face        = (FT_Face)face;            charmap->encoding    = ft_encoding_unicode;            charmap->platform_id = 3;            charmap->encoding_id = 1;            charmap++;          }          /* simply clear the error in case of failure (which really) */          /* means that out of memory or no unicode glyph names       */          error = T1_Err_Ok;        }      }      /* now, support either the standard, expert, or custom encoding */      charmap->face        = (FT_Face)face;      charmap->platform_id = 7;  /* a new platform id for Adobe fonts? */      switch ( face->type1.encoding_type )      {      case T1_ENCODING_TYPE_STANDARD:        charmap->encoding    = ft_encoding_adobe_standard;        charmap->encoding_id = 0;        break;      case T1_ENCODING_TYPE_EXPERT:        charmap->encoding    = ft_encoding_adobe_expert;        charmap->encoding_id = 1;        break;      case T1_ENCODING_TYPE_ARRAY:        charmap->encoding    = ft_encoding_adobe_custom;        charmap->encoding_id = 2;        break;      case T1_ENCODING_TYPE_ISOLATIN1:        charmap->encoding    = ft_encoding_latin_1;        charmap->encoding_id = 3;        break;      default:        FT_ERROR(( "T1_Face_Init: invalid encoding\n" ));        error = T1_Err_Invalid_File_Format;        goto Exit;      }      root->charmaps     = face->charmaps;      root->num_charmaps = charmap - face->charmaprecs + 1;      face->charmaps[0]  = &face->charmaprecs[0];      face->charmaps[1]  = &face->charmaprecs[1];    }#endif /* !FT_CONFIG_OPTION_USE_CMAPS */  Exit:    return error;  }  /*************************************************************************/  /*                                                                       */  /* <Function>                                                            */  /*    T1_Driver_Init                                                     */  /*                                                                       */  /* <Description>                                                         */  /*    Initializes a given Type 1 driver object.                          */  /*                                                                       */  /* <Input>                                                               */  /*    driver :: A handle to the target driver object.                    */  /*                                                                       */  /* <Return>                                                              */  /*    FreeType error code.  0 means success.                             */  /*                                                                       */  FT_LOCAL_DEF( FT_Error )  T1_Driver_Init( T1_Driver  driver )  {    FT_UNUSED( driver );    return T1_Err_Ok;  }  /*************************************************************************/  /*                                                                       */  /* <Function>                                                            */  /*    T1_Driver_Done                                                     */  /*                                                                       */  /* <Description>                                                         */  /*    Finalizes a given Type 1 driver.                                   */  /*                                                                       */  /* <Input>                                                               */  /*    driver :: A handle to the target Type 1 driver.                    */  /*                                                                       */  FT_LOCAL_DEF( void )  T1_Driver_Done( T1_Driver  driver )  {    FT_UNUSED( driver );  }/* END */