{            FT_TRACE6(( "encoding end\n" ));            cur += 3;            break;          }        }        if ( *cur == ']' )        {          FT_TRACE6(( "encoding end\n" ));          cur++;          break;        }        /* check whether we've found an entry */        if ( ft_isdigit( *cur ) || only_immediates )        {          FT_Int  charcode;          if ( only_immediates )            charcode = n;          else          {            charcode = (FT_Int)T1_ToInt( parser );            T1_Skip_Spaces( parser );          }          cur = parser->root.cursor;          if ( *cur == '/' && cur + 2 < limit && n < count )          {            FT_PtrDist  len;            cur++;            parser->root.cursor = cur;            T1_Skip_PS_Token( parser );            if ( parser->root.error )              return;            len = parser->root.cursor - cur;            parser->root.error = T1_Add_Table( char_table, charcode,                                               cur, len + 1 );            if ( parser->root.error )              return;            char_table->elements[charcode][len] = '\0';            n++;          }        }        else          T1_Skip_PS_Token( parser );        T1_Skip_Spaces( parser );      }      face->type1.encoding_type  = T1_ENCODING_TYPE_ARRAY;      parser->root.cursor        = cur;    }    /* Otherwise, we should have either `StandardEncoding', */    /* `ExpertEncoding', or `ISOLatin1Encoding'             */    else    {      if ( cur + 17 < limit                                            &&           ft_strncmp( (const char*)cur, "StandardEncoding", 16 ) == 0 )        face->type1.encoding_type = T1_ENCODING_TYPE_STANDARD;      else if ( cur + 15 < limit                                          &&                ft_strncmp( (const char*)cur, "ExpertEncoding", 14 ) == 0 )        face->type1.encoding_type = T1_ENCODING_TYPE_EXPERT;      else if ( cur + 18 < limit                                             &&                ft_strncmp( (const char*)cur, "ISOLatin1Encoding", 17 ) == 0 )        face->type1.encoding_type = T1_ENCODING_TYPE_ISOLATIN1;      else      {        FT_ERROR(( "t42_parse_encoding: invalid token!\n" ));        parser->root.error = T42_Err_Invalid_File_Format;      }    }  }  typedef enum  {    BEFORE_START,    BEFORE_TABLE_DIR,    OTHER_TABLES  } T42_Load_Status;  static void  t42_parse_sfnts( T42_Face    face,                   T42_Loader  loader )  {    T42_Parser  parser = &loader->parser;    FT_Memory   memory = parser->root.memory;    FT_Byte*    cur;    FT_Byte*    limit  = parser->root.limit;    FT_Error    error;    FT_Int      num_tables = 0;    FT_ULong    count, ttf_size = 0;    FT_Long     n, string_size, old_string_size, real_size;    FT_Byte*    string_buf = NULL;    FT_Bool     alloc      = 0;    T42_Load_Status  status;    /* The format is                                */    /*                                              */    /*   /sfnts [ <hexstring> <hexstring> ... ] def */    /*                                              */    /* or                                           */    /*                                              */    /*   /sfnts [                                   */    /*      <num_bin_bytes> RD <binary data>        */    /*      <num_bin_bytes> RD <binary data>        */    /*      ...                                     */    /*   ] def                                      */    /*                                              */    /* with exactly one space after the `RD' token. */    T1_Skip_Spaces( parser );    if ( parser->root.cursor >= limit || *parser->root.cursor++ != '[' )    {      FT_ERROR(( "t42_parse_sfnts: can't find begin of sfnts vector!\n" ));      error = T42_Err_Invalid_File_Format;      goto Fail;    }    T1_Skip_Spaces( parser );    status          = BEFORE_START;    string_size     = 0;    old_string_size = 0;    count           = 0;    while ( parser->root.cursor < limit )    {      cur = parser->root.cursor;      if ( *cur == ']' )      {        parser->root.cursor++;        goto Exit;      }      else if ( *cur == '<' )      {        T1_Skip_PS_Token( parser );        if ( parser->root.error )          goto Exit;        /* don't include delimiters */        string_size = (FT_Long)( ( parser->root.cursor - cur - 2 + 1 ) / 2 );        if ( FT_REALLOC( string_buf, old_string_size, string_size ) )          goto Fail;        alloc = 1;        parser->root.cursor = cur;        (void)T1_ToBytes( parser, string_buf, string_size, &real_size, 1 );        old_string_size = string_size;        string_size = real_size;      }      else if ( ft_isdigit( *cur ) )      {        string_size = T1_ToInt( parser );        T1_Skip_PS_Token( parser );             /* `RD' */        if ( parser->root.error )          return;        string_buf = parser->root.cursor + 1;   /* one space after `RD' */        parser->root.cursor += string_size + 1;        if ( parser->root.cursor >= limit )        {          FT_ERROR(( "t42_parse_sfnts: too many binary data!\n" ));          error = T42_Err_Invalid_File_Format;          goto Fail;        }      }      /* A string can have a trailing zero byte for padding.  Ignore it. */      if ( string_buf[string_size - 1] == 0 && ( string_size % 2 == 1 ) )        string_size--;      for ( n = 0; n < string_size; n++ )      {        switch ( status )        {        case BEFORE_START:          /* load offset table, 12 bytes */          if ( count < 12 )          {            face->ttf_data[count++] = string_buf[n];            continue;          }          else          {            num_tables = 16 * face->ttf_data[4] + face->ttf_data[5];            status     = BEFORE_TABLE_DIR;            ttf_size   = 12 + 16 * num_tables;            if ( FT_REALLOC( face->ttf_data, 12, ttf_size ) )              goto Fail;          }          /* fall through */        case BEFORE_TABLE_DIR:          /* the offset table is read; read the table directory */          if ( count < ttf_size )          {            face->ttf_data[count++] = string_buf[n];            continue;          }          else          {            int       i;            FT_ULong  len;            for ( i = 0; i < num_tables; i++ )            {              FT_Byte*  p = face->ttf_data + 12 + 16 * i + 12;              len = FT_PEEK_ULONG( p );              /* Pad to a 4-byte boundary length */              ttf_size += ( len + 3 ) & ~3;            }            status         = OTHER_TABLES;            face->ttf_size = ttf_size;            /* there are no more than 256 tables, so no size check here */            if ( FT_REALLOC( face->ttf_data, 12 + 16 * num_tables,                             ttf_size + 1 ) )              goto Fail;          }          /* fall through */        case OTHER_TABLES:          /* all other tables are just copied */          if ( count >= ttf_size )          {            FT_ERROR(( "t42_parse_sfnts: too many binary data!\n" ));            error = T42_Err_Invalid_File_Format;            goto Fail;          }          face->ttf_data[count++] = string_buf[n];        }      }      T1_Skip_Spaces( parser );    }    /* if control reaches this point, the format was not valid */    error = T42_Err_Invalid_File_Format;  Fail:    parser->root.error = error;  Exit:    if ( alloc )      FT_FREE( string_buf );  }  static void  t42_parse_charstrings( T42_Face    face,                         T42_Loader  loader )  {    T42_Parser     parser       = &loader->parser;    PS_Table       code_table   = &loader->charstrings;    PS_Table       name_table   = &loader->glyph_names;    PS_Table       swap_table   = &loader->swap_table;    FT_Memory      memory       = parser->root.memory;    FT_Error       error;    PSAux_Service  psaux        = (PSAux_Service)face->psaux;    FT_Byte*       cur;    FT_Byte*       limit        = parser->root.limit;    FT_UInt        n;    FT_UInt        notdef_index = 0;    FT_Byte        notdef_found = 0;    T1_Skip_Spaces( parser );    if ( parser->root.cursor >= limit )    {      FT_ERROR(( "t42_parse_charstrings: out of bounds!\n" ));      error = T42_Err_Invalid_File_Format;      goto Fail;    }    if ( ft_isdigit( *parser->root.cursor ) )    {      loader->num_glyphs = (FT_UInt)T1_ToInt( parser );      if ( parser->root.error )        return;    }    else if ( *parser->root.cursor == '<' )    {      /* We have `<< ... >>'.  Count the number of `/' in the dictionary */      /* to get its size.                                                */      FT_UInt  count = 0;      T1_Skip_PS_Token( parser );      if ( parser->root.error )        return;      T1_Skip_Spaces( parser );      cur = parser->root.cursor;      while ( parser->root.cursor < limit )      {        if ( *parser->root.cursor == '/' )          count++;        else if ( *parser->root.cursor == '>' )        {          loader->num_glyphs  = count;          parser->root.cursor = cur;        /* rewind */          break;        }        T1_Skip_PS_Token( parser );        if ( parser->root.error )          return;        T1_Skip_Spaces( parser );      }    }    else    {      FT_ERROR(( "t42_parse_charstrings: invalid token!\n" ));      error = T42_Err_Invalid_File_Format;      goto Fail;    }    if ( parser->root.cursor >= limit )    {      FT_ERROR(( "t42_parse_charstrings: out of bounds!\n" ));      error = T42_Err_Invalid_File_Format;      goto Fail;    }    /* initialize tables */    error = psaux->ps_table_funcs->init( code_table,                                         loader->num_glyphs,                                         memory );    if ( error )      goto Fail;    error = psaux->ps_table_funcs->init( name_table,                                         loader->num_glyphs,                                         memory );    if ( error )      goto Fail;    /* Initialize table for swapping index notdef_index and */    /* index 0 names and codes (if necessary).              */    error = psaux->ps_table_funcs->init( swap_table, 4, memory );    if ( error )      goto Fail;    n = 0;