t1load.c

a very goog book

  parse_blend_design_positions( T1_Face    face,
                                T1_Loader  loader )
  {
    T1_TokenRec  design_tokens[ T1_MAX_MM_DESIGNS ];
    FT_Int       num_designs;
    FT_Int       num_axis;
    T1_Parser    parser = &loader->parser;

    FT_Error     error = 0;
    PS_Blend     blend;


    /* get the array of design tokens - compute number of designs */
    T1_ToTokenArray( parser, design_tokens, T1_MAX_MM_DESIGNS, &num_designs );
    if ( num_designs <= 0 || num_designs > T1_MAX_MM_DESIGNS )
    {
      FT_ERROR(( "parse_blend_design_positions:" ));
      FT_ERROR(( " incorrect number of designs: %d\n",
                 num_designs ));
      error = T1_Err_Invalid_File_Format;
      goto Exit;
    }

    {
      FT_Byte*  old_cursor = parser->root.cursor;
      FT_Byte*  old_limit  = parser->root.limit;
      FT_UInt   n;


      blend    = face->blend;
      num_axis = 0;  /* make compiler happy */

      for ( n = 0; n < (FT_UInt)num_designs; n++ )
      {
        T1_TokenRec  axis_tokens[ T1_MAX_MM_DESIGNS ];
        T1_Token     token;
        FT_Int       axis, n_axis;


        /* read axis/coordinates tokens */
        token = design_tokens + n;
        parser->root.cursor = token->start - 1;
        parser->root.limit  = token->limit + 1;
        T1_ToTokenArray( parser, axis_tokens, T1_MAX_MM_AXIS, &n_axis );

        if ( n == 0 )
        {
          num_axis = n_axis;
          error = t1_allocate_blend( face, num_designs, num_axis );
          if ( error )
            goto Exit;
          blend = face->blend;
        }
        else if ( n_axis != num_axis )
        {
          FT_ERROR(( "parse_blend_design_positions: incorrect table\n" ));
          error = T1_Err_Invalid_File_Format;
          goto Exit;
        }

        /* now, read each axis token into the design position */
        for ( axis = 0; axis < n_axis; axis++ )
        {
          T1_Token  token2 = axis_tokens + axis;


          parser->root.cursor = token2->start;
          parser->root.limit  = token2->limit;
          blend->design_pos[n][axis] = T1_ToFixed( parser, 0 );
        }
      }

      loader->parser.root.cursor = old_cursor;
      loader->parser.root.limit  = old_limit;
    }

  Exit:
    loader->parser.root.error = error;
  }


  static void
  parse_blend_design_map( T1_Face    face,
                          T1_Loader  loader )
  {
    FT_Error     error  = 0;
    T1_Parser    parser = &loader->parser;
    PS_Blend     blend;
    T1_TokenRec  axis_tokens[T1_MAX_MM_AXIS];
    FT_Int       n, num_axis;
    FT_Byte*     old_cursor;
    FT_Byte*     old_limit;
    FT_Memory    memory = face->root.memory;


    T1_ToTokenArray( parser, axis_tokens, T1_MAX_MM_AXIS, &num_axis );
    if ( num_axis <= 0 || num_axis > T1_MAX_MM_AXIS )
    {
      FT_ERROR(( "parse_blend_design_map: incorrect number of axes: %d\n",
                 num_axis ));
      error = T1_Err_Invalid_File_Format;
      goto Exit;
    }
    old_cursor = parser->root.cursor;
    old_limit  = parser->root.limit;

    error = t1_allocate_blend( face, 0, num_axis );
    if ( error )
      goto Exit;
    blend = face->blend;

    /* now, read each axis design map */
    for ( n = 0; n < num_axis; n++ )
    {
      PS_DesignMap  map = blend->design_map + n;
      T1_Token      token;
      FT_Int        p, num_points;


      token = axis_tokens + n;
      parser->root.cursor = token->start;
      parser->root.limit  = token->limit;

      /* count the number of map points */
      {
        FT_Byte*  ptr   = token->start;
        FT_Byte*  limit = token->limit;


        num_points = 0;
        for ( ; ptr < limit; ptr++ )
          if ( ptr[0] == '[' )
            num_points++;
      }
      if ( num_points <= 0 || num_points > T1_MAX_MM_MAP_POINTS )
      {
        FT_ERROR(( "parse_blend_design_map: incorrect table\n" ));
        error = T1_Err_Invalid_File_Format;
        goto Exit;
      }

      /* allocate design map data */
      if ( FT_NEW_ARRAY( map->design_points, num_points * 2 ) )
        goto Exit;
      map->blend_points = map->design_points + num_points;
      map->num_points   = (FT_Byte)num_points;

      for ( p = 0; p < num_points; p++ )
      {
        map->design_points[p] = T1_ToInt( parser );
        map->blend_points [p] = T1_ToFixed( parser, 0 );
      }
    }

    parser->root.cursor = old_cursor;
    parser->root.limit  = old_limit;

  Exit:
    parser->root.error = error;
  }


  static void
  parse_weight_vector( T1_Face    face,
                       T1_Loader  loader )
  {
    FT_Error     error  = 0;
    T1_Parser    parser = &loader->parser;
    PS_Blend     blend  = face->blend;
    T1_TokenRec  master;
    FT_UInt      n;
    FT_Byte*     old_cursor;
    FT_Byte*     old_limit;


    if ( !blend || blend->num_designs == 0 )
    {
      FT_ERROR(( "parse_weight_vector: too early!\n" ));
      error = T1_Err_Invalid_File_Format;
      goto Exit;
    }

    T1_ToToken( parser, &master );
    if ( master.type != T1_TOKEN_TYPE_ARRAY )
    {
      FT_ERROR(( "parse_weight_vector: incorrect format!\n" ));
      error = T1_Err_Invalid_File_Format;
      goto Exit;
    }

    old_cursor = parser->root.cursor;
    old_limit  = parser->root.limit;

    parser->root.cursor = master.start;
    parser->root.limit  = master.limit;

    for ( n = 0; n < blend->num_designs; n++ )
    {
      blend->default_weight_vector[n] =
      blend->weight_vector[n]         = T1_ToFixed( parser, 0 );
    }

    parser->root.cursor = old_cursor;
    parser->root.limit  = old_limit;

  Exit:
    parser->root.error = error;
  }


  /* the keyword `/shareddict' appears in some multiple master fonts   */
  /* with a lot of Postscript garbage behind it (that's completely out */
  /* of spec!); we detect it and terminate the parsing                 */
  /*                                                                   */
  static void
  parse_shared_dict( T1_Face    face,
                     T1_Loader  loader )
  {
    T1_Parser  parser = &loader->parser;

    FT_UNUSED( face );


    parser->root.cursor = parser->root.limit;
    parser->root.error  = 0;
  }

#endif /* T1_CONFIG_OPTION_NO_MM_SUPPORT */


  /*************************************************************************/
  /*************************************************************************/
  /*****                                                               *****/
  /*****                      TYPE 1 SYMBOL PARSING                    *****/
  /*****                                                               *****/
  /*************************************************************************/
  /*************************************************************************/


  /*************************************************************************/
  /*                                                                       */
  /* First of all, define the token field static variables.  This is a set */
  /* of T1_FieldRec variables used later.                                  */
  /*                                                                       */
  /*************************************************************************/


  static FT_Error
  t1_load_keyword( T1_Face    face,
                   T1_Loader  loader,
                   T1_Field   field )
  {
    FT_Error  error;
    void*     dummy_object;
    void**    objects;
    FT_UInt   max_objects;
    PS_Blend  blend = face->blend;


    /* if the keyword has a dedicated callback, call it */
    if ( field->type == T1_FIELD_TYPE_CALLBACK )
    {
      field->reader( (FT_Face)face, loader );
      error = loader->parser.root.error;
      goto Exit;
    }

    /* now, the keyword is either a simple field, or a table of fields; */
    /* we are now going to take care of it                              */
    switch ( field->location )
    {
    case T1_FIELD_LOCATION_FONT_INFO:
      dummy_object = &face->type1.font_info;
      objects      = &dummy_object;
      max_objects  = 0;

      if ( blend )
      {
        objects     = (void**)blend->font_infos;
        max_objects = blend->num_designs;
      }
      break;

    case T1_FIELD_LOCATION_PRIVATE:
      dummy_object = &face->type1.private_dict;
      objects      = &dummy_object;
      max_objects  = 0;

      if ( blend )
      {
        objects     = (void**)blend->privates;
        max_objects = blend->num_designs;
      }
      break;

    default:
      dummy_object = &face->type1;
      objects      = &dummy_object;
      max_objects  = 0;
    }

    if ( field->type == T1_FIELD_TYPE_INTEGER_ARRAY ||
         field->type == T1_FIELD_TYPE_FIXED_ARRAY   )
      error = T1_Load_Field_Table( &loader->parser, field,
                                   objects, max_objects, 0 );
    else
      error = T1_Load_Field( &loader->parser, field,
                             objects, max_objects, 0 );

  Exit:
    return error;
  }


  static int
  is_space( FT_Byte  c )
  {
    return ( c == ' ' || c == '\t' || c == '\r' || c == '\n' );
  }


  static int
  is_alpha( FT_Byte  c )
  {
    /* Note: we must accept "+" as a valid character, as it is used in */
    /*       embedded type1 fonts in PDF documents.                    */
    /*                                                                 */
    return ( ft_isalnum( c ) ||
             c == '.'        ||
             c == '_'        ||
             c == '-'        ||
             c == '+'        );
  }


  static int
  read_binary_data( T1_Parser  parser,
                    FT_Int*    size,
                    FT_Byte**  base )
  {
    FT_Byte*  cur;
    FT_Byte*  limit = parser->root.limit;


    /* the binary data has the following format */
    /*                                          */
    /* `size' [white*] RD white ....... ND      */
    /*                                          */

    T1_Skip_Spaces( parser );
    cur = parser->root.cursor;

    if ( cur < limit && (FT_Byte)( *cur - '0' ) < 10 )
    {
      *size = T1_ToInt( parser );

      T1_Skip_Spaces( parser );
      T1_Skip_Alpha ( parser );  /* `RD' or `-|' or something else */

      /* there is only one whitespace char after the */
      /* `RD' or `-|' token                          */
      *base = parser->root.cursor + 1;

      parser->root.cursor += *size + 1;
      return 1;
    }

    FT_ERROR(( "read_binary_data: invalid size field\n" ));
    parser->root.error = T1_Err_Invalid_File_Format;
    return 0;
  }


  /* we will now define the routines used to handle */
  /* the `/Encoding', `/Subrs', and `/CharStrings'  */
  /* dictionaries                                   */

  static void
  parse_font_name( T1_Face    face,
                   T1_Loader  loader )
  {
    T1_Parser  parser = &loader->parser;
    FT_Error   error;
    FT_Memory  memory = parser->root.memory;
    FT_Int     len;
    FT_Byte*   cur;
    FT_Byte*   cur2;
    FT_Byte*   limit;


    if ( face->type1.font_name )
      /*  with synthetic fonts, it's possible we get here twice  */
      return;

    T1_Skip_Spaces( parser );

    cur   = parser->root.cursor;
    limit = parser->root.limit;

    if ( cur >= limit - 1 || *cur != '/' )
      return;

    cur++;
    cur2 = cur;
    while ( cur2 < limit && is_alpha( *cur2 ) )
      cur2++;

    len = (FT_Int)( cur2 - cur );
    if ( len > 0 )
    {
      if ( FT_ALLOC( face->type1.font_name, len + 1 ) )
      {
        parser->root.error = error;
        return;
      }

      FT_MEM_COPY( face->type1.font_name, cur, len );
      face->type1.font_name[len] = '\0';
    }
    parser->root.cursor = cur2;
  }


  static void
  parse_font_bbox( T1_Face    face,
                   T1_Loader  loader )
  {
    T1_Parser  parser = &loader->parser;
    FT_Fixed   temp[4];
    FT_BBox*   bbox   = &face->type1.font_bbox;


    (void)T1_ToFixedArray( parser, 4, temp, 0 );
    bbox->xMin = FT_RoundFix( temp[0] );
    bbox->yMin = FT_RoundFix( temp[1] );
    bbox->xMax = FT_RoundFix( temp[2] );
    bbox->yMax = FT_RoundFix( temp[3] );
  }


  static void
  parse_font_matrix( T1_Face    face,