kc3-lang/freetype/src/sfnt/ttbdf.c

Branch - branch -v2.13

• Show log

  Commit

• Hash : e245951c
  Author :
  Date : 2023-05-06T23:59:25
  

  * src/sfnt/sfdriver.c, src/sfnt/ttbdf.c: Clean up interface. Ensure that all driver functions use the signature of the service or driver. This avoids pointer mismatches, which are technically undefined behaviour. Recent compilers are more picky in catching them as part of Control Flow Integrity tests. * src/sfnt/sfdriver.c (sfnt_load_table): New wrapper function. (sfnt_service_sfnt_table): Use it.

Download

• src/sfnt/ttbdf.c

• /****************************************************************************
   *
   * ttbdf.c
   *
   *   TrueType and OpenType embedded BDF properties (body).
   *
   * Copyright (C) 2005-2023 by
   * David Turner, Robert Wilhelm, and Werner Lemberg.
   *
   * This file is part of the FreeType project, and may only be used,
   * modified, and distributed under the terms of the FreeType project
   * license, LICENSE.TXT.  By continuing to use, modify, or distribute
   * this file you indicate that you have read the license and
   * understand and accept it fully.
   *
   */
  
  
  #include <freetype/internal/ftdebug.h>
  #include <freetype/internal/ftstream.h>
  #include <freetype/tttags.h>
  #include "ttbdf.h"
  
  #include "sferrors.h"
  
  
  #ifdef TT_CONFIG_OPTION_BDF
  
    /**************************************************************************
     *
     * The macro FT_COMPONENT is used in trace mode.  It is an implicit
     * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
     * messages during execution.
     */
  #undef  FT_COMPONENT
  #define FT_COMPONENT  ttbdf
  
  
    FT_LOCAL_DEF( void )
    tt_face_free_bdf_props( TT_Face  face )
    {
      TT_BDF  bdf = &face->bdf;
  
  
      if ( bdf->loaded )
      {
        FT_Stream  stream = FT_FACE( face )->stream;
  
  
        if ( bdf->table )
          FT_FRAME_RELEASE( bdf->table );
  
        bdf->table_end    = NULL;
        bdf->strings      = NULL;
        bdf->strings_size = 0;
      }
    }
  
  
    static FT_Error
    tt_face_load_bdf_props( TT_Face    face,
                            FT_Stream  stream )
    {
      TT_BDF    bdf = &face->bdf;
      FT_ULong  length;
      FT_Error  error;
  
  
      FT_ZERO( bdf );
  
      error = tt_face_goto_table( face, TTAG_BDF, stream, &length );
      if ( error                                  ||
           length < 8                             ||
           FT_FRAME_EXTRACT( length, bdf->table ) )
      {
        error = FT_THROW( Invalid_Table );
        goto Exit;
      }
  
      bdf->table_end = bdf->table + length;
  
      {
        FT_Byte*   p           = bdf->table;
        FT_UInt    version     = FT_NEXT_USHORT( p );
        FT_UInt    num_strikes = FT_NEXT_USHORT( p );
        FT_ULong   strings     = FT_NEXT_ULONG ( p );
        FT_UInt    count;
        FT_Byte*   strike;
  
  
        if ( version != 0x0001                 ||
             strings < 8                       ||
             ( strings - 8 ) / 4 < num_strikes ||
             strings + 1 > length              )
        {
          goto BadTable;
        }
  
        bdf->num_strikes  = num_strikes;
        bdf->strings      = bdf->table + strings;
        bdf->strings_size = length - strings;
  
        count  = bdf->num_strikes;
        p      = bdf->table + 8;
        strike = p + count * 4;
  
  
        for ( ; count > 0; count-- )
        {
          FT_UInt  num_items = FT_PEEK_USHORT( p + 2 );
  
          /*
           * We don't need to check the value sets themselves, since this
           * is done later.
           */
          strike += 10 * num_items;
  
          p += 4;
        }
  
        if ( strike > bdf->strings )
          goto BadTable;
      }
  
      bdf->loaded = 1;
  
    Exit:
      return error;
  
    BadTable:
      FT_FRAME_RELEASE( bdf->table );
      FT_ZERO( bdf );
      error = FT_THROW( Invalid_Table );
      goto Exit;
    }
  
  
    FT_LOCAL_DEF( FT_Error )
    tt_face_find_bdf_prop( FT_Face           face,          /* TT_Face */
                           const char*       property_name,
                           BDF_PropertyRec  *aprop )
    {
      TT_Face    ttface = (TT_Face)face;
      TT_BDF     bdf    = &ttface->bdf;
      FT_Size    size   = FT_FACE_SIZE( face );
      FT_Error   error  = FT_Err_Ok;
      FT_Byte*   p;
      FT_UInt    count;
      FT_Byte*   strike;
      FT_Offset  property_len;
  
  
      aprop->type = BDF_PROPERTY_TYPE_NONE;
  
      if ( bdf->loaded == 0 )
      {
        error = tt_face_load_bdf_props( ttface, FT_FACE_STREAM( face ) );
        if ( error )
          goto Exit;
      }
  
      count  = bdf->num_strikes;
      p      = bdf->table + 8;
      strike = p + 4 * count;
  
      error = FT_ERR( Invalid_Argument );
  
      if ( !size || !property_name )
        goto Exit;
  
      property_len = ft_strlen( property_name );
      if ( property_len == 0 )
        goto Exit;
  
      for ( ; count > 0; count-- )
      {
        FT_UInt  _ppem  = FT_NEXT_USHORT( p );
        FT_UInt  _count = FT_NEXT_USHORT( p );
  
  
        if ( _ppem == size->metrics.y_ppem )
        {
          count = _count;
          goto FoundStrike;
        }
  
        strike += 10 * _count;
      }
      goto Exit;
  
    FoundStrike:
      p = strike;
      for ( ; count > 0; count-- )
      {
        FT_UInt  type = FT_PEEK_USHORT( p + 4 );
  
  
        if ( ( type & 0x10 ) != 0 )
        {
          FT_UInt32  name_offset = FT_PEEK_ULONG( p     );
          FT_UInt32  value       = FT_PEEK_ULONG( p + 6 );
  
          /* be a bit paranoid for invalid entries here */
          if ( name_offset < bdf->strings_size                    &&
               property_len < bdf->strings_size - name_offset     &&
               ft_strncmp( property_name,
                           (const char*)bdf->strings + name_offset,
                           bdf->strings_size - name_offset ) == 0 )
          {
            switch ( type & 0x0F )
            {
            case 0x00:  /* string */
            case 0x01:  /* atoms */
              /* check that the content is really 0-terminated */
              if ( value < bdf->strings_size &&
                   ft_memchr( bdf->strings + value, 0, bdf->strings_size ) )
              {
                aprop->type   = BDF_PROPERTY_TYPE_ATOM;
                aprop->u.atom = (const char*)bdf->strings + value;
                error         = FT_Err_Ok;
                goto Exit;
              }
              break;
  
            case 0x02:
              aprop->type      = BDF_PROPERTY_TYPE_INTEGER;
              aprop->u.integer = (FT_Int32)value;
              error            = FT_Err_Ok;
              goto Exit;
  
            case 0x03:
              aprop->type       = BDF_PROPERTY_TYPE_CARDINAL;
              aprop->u.cardinal = value;
              error             = FT_Err_Ok;
              goto Exit;
  
            default:
              ;
            }
          }
        }
        p += 10;
      }
  
    Exit:
      return error;
    }
  
  #else /* !TT_CONFIG_OPTION_BDF */
  
    /* ANSI C doesn't like empty source files */
    typedef int  tt_bdf_dummy_;
  
  #endif /* !TT_CONFIG_OPTION_BDF */
  
  
  /* END */
  

Download