shithub: purgatorio

ref: a8083462e62459b2ae8a243dc4ba88416eba03b1

View raw version
#include "otlgsub.h"
#include "otlcommn.h"

 /************************************************************************/
 /************************************************************************/
 /*****                                                              *****/
 /*****                 GSUB LOOKUP TYPE 1                           *****/
 /*****                                                              *****/
 /************************************************************************/
 /************************************************************************/

 /*
  *  1: Single Substitution - Table format(s)
  *
  *  This table is used to substiture individual glyph indices
  *  with another one. There are only two sub-formats:
  *
  *   Name         Offset    Size       Description
  *   ------------------------------------------
  *   format       0         2          sub-table format (1)
  *   offset       2         2          offset to coverage table
  *   delta        4         2          16-bit delta to apply on all
  *                                     covered glyph indices
  *
  *   Name         Offset    Size       Description
  *   ------------------------------------------
  *   format       0         2          sub-table format (2)
  *   offset       2         2          offset to coverage table
  *   count        4         2          coverage table count
  *   substs[]     6         2*count    substituted glyph indices,
  *
  */

  static void
  otl_gsub_lookup1_validate( OTL_Bytes      table,
                             OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   format;

    OTL_CHECK( 2 );
    format = OTL_NEXT_USHORT( p );
    switch ( format )
    {
      case 1:
        {
          OTL_UInt  coverage;

          OTL_CHECK( 4 );
          coverage = OTL_NEXT_USHORT( p );

          otl_coverage_validate( table + coverage, valid );
        }
        break;

      case 2:
        {
          OTL_UInt  coverage, count;

          OTL_CHECK( 4 );
          coverage = OTL_NEXT_USHORT( p );
          count    = OTL_NEXT_USHORT( p );

          otl_coverage_validate( table + coverage, valid );

          OTL_CHECK( 2*count );

          /* NB: we don't check that there are at most 'count'   */
          /*     elements in the coverage table. This is delayed */
          /*     to the lookup function...                       */
        }
        break;

      default:
        OTL_INVALID_DATA;
    }
  }


  static OTL_Bool
  otl_gsub_lookup1_apply( OTL_Bytes   table,
                          OTL_Parser  parser )
  {
    OTL_Bytes  p = table;
    OTL_Bytes  coverage;
    OTL_UInt   format, gindex, property;
    OTL_Int    index;
    OTL_Bool   subst = 0;

    if ( parser->context_len != 0xFFFF && parser->context_len < 1 )
      goto Exit;

    gindex = otl_parser_get_gindex( parser );

    if ( !otl_parser_check_property( parser, gindex, &property ) )
      goto Exit;

    format   = OTL_NEXT_USHORT(p);
    coverage = table + OTL_NEXT_USHORT(p);
    index    = otl_coverage_lookup( coverage, gindex );

    if ( index >= 0 )
    {
      switch ( format )
      {
        case 1:
          {
            OTL_Int  delta = OTL_NEXT_SHORT(p);

            gindex = ( gindex + delta ) & 0xFFFF;
            otl_parser_replace_1( parser, gindex );
            subst = 1;
          }
          break;

        case 2:
          {
            OTL_UInt  count = OTL_NEXT_USHORT(p);

            if ( (OTL_UInt) index < count )
            {
              p += index*2;
              otl_parser_replace_1( parser, OTL_PEEK_USHORT(p) );
              subst = 1;
            }
          }
          break;

        default:
          ;
      }
    }
  Exit:
    return subst;
  }

 /************************************************************************/
 /************************************************************************/
 /*****                                                              *****/
 /*****                 GSUB LOOKUP TYPE 2                           *****/
 /*****                                                              *****/
 /************************************************************************/
 /************************************************************************/

 /*
  *  2: Multiple Substitution - Table format(s)
  *
  *  Replaces a single glyph with one or more glyphs.
  *
  *   Name         Offset    Size       Description
  *   -----------------------------------------------------------
  *   format       0         2          sub-table format (1)
  *   offset       2         2          offset to coverage table
  *   count        4         2          coverage table count
  *   sequencess[] 6         2*count    offsets to sequence items
  *
  *   each sequence item has the following format:
  *
  *   Name         Offset    Size       Description
  *   -----------------------------------------------------------
  *   count        0         2          number of replacement glyphs
  *   gindices[]   2         2*count    string of glyph indices
  */

  static void
  otl_seq_validate( OTL_Bytes      table,
                    OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   count;

    OTL_CHECK( 2 );
    count = OTL_NEXT_USHORT( p );

    /* XXX: according to the spec, 'count' should be > 0     */
    /*      we can deal with these cases pretty well however */

    OTL_CHECK( 2*count );
    /* check glyph indices */
  }


  static void
  otl_gsub_lookup2_validate( OTL_Bytes      table,
                             OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   format, coverage;

    OTL_CHECK( 2 );
    format = OTL_NEXT_USHORT( p );
    switch ( format )
    {
      case 1:
        {
          OTL_UInt  coverage, seq_count;

          OTL_CHECK( 4 );
          coverage  = OTL_NEXT_USHORT( p );
          seq_count = OTL_NEXT_USHORT( p );

          otl_coverage_validate( table + coverage, valid );

          OTL_CHECK( seq_count*2 );
          for ( ; seq_count > 0; seq_count-- )
            otl_seq_validate( table + OTL_NEXT_USHORT( p ), valid );
        }
        break;

      default:
        OTL_INVALID_DATA;
    }
  }


  static OTL_Bool
  otl_gsub_lookup2_apply( OTL_Bytes    table,
                          OTL_Parser   parser )
  {
    OTL_Bytes  p = table;
    OTL_Bytes  coverage, sequence;
    OTL_UInt   format, gindex, index, property;
    OTL_Int    index;
    OTL_Bool   subst = 0;

    if ( context_len != 0xFFFF && context_len < 1 )
      goto Exit;

    gindex = otl_parser_get_gindex( parser );

    if ( !otl_parser_check_property( parser, gindex, &property ) )
      goto Exit;

    p        += 2;  /* skip format */
    coverage  = table + OTL_NEXT_USHORT(p);
    seq_count = OTL_NEXT_USHORT(p);
    index     = otl_coverage_lookup( coverage, gindex );

    if ( (OTL_UInt) index >= seq_count )
      goto Exit;

    p       += index*2;
    sequence = table + OTL_PEEK_USHORT(p);
    p        = sequence;
    count    = OTL_NEXT_USHORT(p);

    otl_parser_replace_n( parser, count, p );
    subst = 1;

   Exit:
    return subst;
  }

 /************************************************************************/
 /************************************************************************/
 /*****                                                              *****/
 /*****                 GSUB LOOKUP TYPE 3                           *****/
 /*****                                                              *****/
 /************************************************************************/
 /************************************************************************/

 /*
  *  3: Alternate Substitution - Table format(s)
  *
  *  Replaces a single glyph by another one taken liberally
  *  in a list of alternatives
  *
  *   Name         Offset    Size       Description
  *   -----------------------------------------------------------
  *   format       0         2          sub-table format (1)
  *   offset       2         2          offset to coverage table
  *   count        4         2          coverage table count
  *   alternates[] 6         2*count    offsets to alternate items
  *
  *   each alternate item has the following format:
  *
  *   Name         Offset    Size       Description
  *   -----------------------------------------------------------
  *   count        0         2          number of replacement glyphs
  *   gindices[]   2         2*count    string of glyph indices, each one
  *                                     is a valid alternative
  */

  static void
  otl_alternate_set_validate( OTL_Bytes      table,
                              OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   count;

    OTL_CHECK( 2 );
    count = OTL_NEXT_USHORT( p );

    OTL_CHECK( 2*count );
    /* XXX: check glyph indices */
  }


  static void
  otl_gsub_lookup3_validate( OTL_Bytes      table,
                             OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   format, coverage;

    OTL_CHECK( 2 );
    format = OTL_NEXT_USHORT( p );
    switch ( format )
    {
      case 1:
        {
          OTL_UInt  coverage, count;

          OTL_CHECK( 4 );
          coverage = OTL_NEXT_USHORT( p );
          count    = OTL_NEXT_USHORT( p );

          otl_coverage_validate( table + coverage, valid );

          OTL_CHECK( 2*count );
          for ( ; count > 0; count-- )
            otl_alternate_set_validate( table + OTL_NEXT_USHORT( p ), valid );
        }
        break;

      default:
        OTL_INVALID_DATA;
    }
  }


  static OTL_Bool
  otl_gsub_lookup3_apply( OTL_Bytes    table,
                          OTL_Parser   parser )
  {
    OTL_Bytes  p = table;
    OTL_Bytes  coverage, alternates;
    OTL_UInt   format, gindex, index, property;
    OTL_Int    index;
    OTL_Bool   subst = 0;

    OTL_GSUB_Alternate  alternate = parser->alternate;

    if ( context_len != 0xFFFF && context_len < 1 )
      goto Exit;

    if ( alternate == NULL )
      goto Exit;

    gindex = otl_parser_get_gindex( parser );

    if ( !otl_parser_check_property( parser, gindex, &property ) )
      goto Exit;

    p        += 2;  /* skip format */
    coverage  = table + OTL_NEXT_USHORT(p);
    seq_count = OTL_NEXT_USHORT(p);
    index     = otl_coverage_lookup( coverage, gindex );

    if ( (OTL_UInt) index >= seq_count )
      goto Exit;

    p         += index*2;
    alternates = table + OTL_PEEK_USHORT(p);
    p          = alternates;
    count      = OTL_NEXT_USHORT(p);

    gindex = alternate->handler_func(
                 gindex, count, p, alternate->handler_data );

    otl_parser_replace_1( parser, gindex );
    subst = 1;

   Exit:
    return subst;
  }

 /************************************************************************/
 /************************************************************************/
 /*****                                                              *****/
 /*****                 GSUB LOOKUP TYPE 4                           *****/
 /*****                                                              *****/
 /************************************************************************/
 /************************************************************************/

  static void
  otl_ligature_validate( OTL_Bytes      table,
                         OTL_Validator  valid )
  {
    OTL_UInt  glyph_id, count;

    OTL_CHECK( 4 );
    glyph_id = OTL_NEXT_USHORT( p );
    count    = OTL_NEXT_USHORT( p );

    if ( count == 0 )
      OTL_INVALID_DATA;

    OTL_CHECK( 2*(count-1) );
    /* XXX: check glyph indices */
  }


  static void
  otl_ligature_set_validate( OTL_Bytes      table,
                             OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   count;

    OTL_CHECK( 2 );
    count = OTL_NEXT_USHORT( p );

    OTL_CHECK( 2*count );
    for ( ; count > 0; count-- )
      otl_ligature_validate( table + OTL_NEXT_USHORT( p ), valid );
  }


  static void
  otl_gsub_lookup4_validate( OTL_Bytes      table,
                             OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   format, coverage;

    OTL_CHECK( 2 );
    format = OTL_NEXT_USHORT( p );
    switch ( format )
    {
      case 1:
        {
          OTL_UInt  coverage, count;

          OTL_CHECK( 4 );
          coverage = OTL_NEXT_USHORT( p );
          count    = OTL_NEXT_USHORT( p );

          otl_coverage_validate( table + coverage, valid );

          OTL_CHECK( 2*count );
          for ( ; count > 0; count-- )
            otl_ligature_set_validate( table + OTL_NEXT_USHORT( p ), valid );
        }
        break;

      default:
        OTL_INVALID_DATA;
    }
  }


 /************************************************************************/
 /************************************************************************/
 /*****                                                              *****/
 /*****                 GSUB LOOKUP TYPE 5                           *****/
 /*****                                                              *****/
 /************************************************************************/
 /************************************************************************/


  static void
  otl_sub_rule_validate( OTL_Bytes      table,
                         OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   glyph_count, subst_count;

    OTL_CHECK( 4 );
    glyph_count = OTL_NEXT_USHORT( p );
    subst_count = OTL_NEXT_USHORT( p );

    if ( glyph_count == 0 )
      OTL_INVALID_DATA;

    OTL_CHECK( (glyph_count-1)*2 + substcount*4 );

    /* XXX: check glyph indices and subst lookups */
  }


  static void
  otl_sub_rule_set_validate( OTL_Bytes      table,
                             OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   count;

    OTL_CHECK( 2 );
    count = OTL_NEXT_USHORT( p );

    OTL_CHECK( 2*count );
    for ( ; count > 0; count-- )
      otl_sub_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
  }


  static void
  otl_sub_class_rule_validate( OTL_Bytes      table,
                               OTL_Validator  valid )
  {
    OTL_UInt  glyph_count, subst_count;

    OTL_CHECK( 4 );
    glyph_count = OTL_NEXT_USHORT( p );
    subst_count = OTL_NEXT_USHORT( p );

    if ( glyph_count == 0 )
      OTL_INVALID_DATA;

    OTL_CHECK( (glyph_count-1)*2 + substcount*4 );

    /* XXX: check glyph indices and subst lookups */
  }


  static void
  otl_sub_class_rule_set_validate( OTL_Bytes      table,
                                   OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   count;

    OTL_CHECK( 2 );
    count = OTL_NEXT_USHORT( p );

    OTL_CHECK( 2*count );
    for ( ; count > 0; count-- )
      otl_sub_class_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
  }


  static void
  otl_gsub_lookup5_validate( OTL_Bytes      table,
                             OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   format, coverage;

    OTL_CHECK( 2 );
    format = OTL_NEXT_USHORT( p );
    switch ( format )
    {
      case 1:
        {
          OTL_UInt  coverage, count;

          OTL_CHECK( 4 );
          coverage = OTL_NEXT_USHORT( p );
          count    = OTL_NEXT_USHORT( p );

          otl_coverage_validate( table + coverage, valid );

          OTL_CHECK( 2*count );
          for ( ; count > 0; count-- )
            otl_sub_rule_set_validate( table + coverage, valid );
        }
        break;

      case 2:
        {
          OTL_UInt  coverage, class_def, count;

          OTL_CHECK( 6 );
          coverage  = OTL_NEXT_USHORT( p );
          class_def = OTL_NEXT_USHORT( p );
          count     = OTL_NEXT_USHORT( p );

          otl_coverage_validate        ( table + coverage, valid );
          otl_class_definition_validate( table + class_def, valid );

          OTL_CHECK( 2*count );
          for ( ; count > 0; count-- )
            otl_sub_class_rule_set_validate( table + coveragen valid );
        }
        break;

      case 3:
        {
          OTL_UInt  glyph_count, subst_count, count;

          OTL_CHECK( 4 );
          glyph_count = OTL_NEXT_USHORT( p );
          subst_count = OTL_NEXT_USHORT( p );

          OTL_CHECK( 2*glyph_count + 4*subst_count );
          for ( count = glyph_count; count > 0; count-- )
            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
        }
        break;

      default:
        OTL_INVALID_DATA;
    }
  }


 /************************************************************************/
 /************************************************************************/
 /*****                                                              *****/
 /*****                 GSUB LOOKUP TYPE 6                           *****/
 /*****                                                              *****/
 /************************************************************************/
 /************************************************************************/


  static void
  otl_chain_sub_rule_validate( OTL_Bytes      table,
                               OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   back_count, input_count, ahead_count, subst_count, count;

    OTL_CHECK( 2 );
    back_count = OTL_NEXT_USHORT( p );

    OTL_CHECK( 2*back_count+2 );
    p += 2*back_count;

    input_count = OTL_NEXT_USHORT( p );
    if ( input_count == 0 )
      OTL_INVALID_DATA;

    OTL_CHECK( 2*input_count );
    p += 2*(input_count-1);

    ahead_count = OTL_NEXT_USHORT( p );
    OTL_CHECK( 2*ahead_count + 2 );
    p += 2*ahead_count;

    count = OTL_NEXT_USHORT( p );
    OTL_CHECK( 4*count );

    /* XXX: check glyph indices and subst lookups */
  }


  static void
  otl_chain_sub_rule_set_validate( OTL_Bytes      table,
                                   OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   count;

    OTL_CHECK( 2 );
    count = OTL_NEXT_USHORT( p );

    OTL_CHECK( 2*count );
    for ( ; count > 0; count-- )
      otl_chain_sub_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
  }


  static void
  otl_chain_sub_class_rule_validate( OTL_Bytes      table,
                                     OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   back_count, input_count, ahead_count, subst_count, count;

    OTL_CHECK( 2 );
    back_count = OTL_NEXT_USHORT( p );

    OTL_CHECK( 2*back_count+2 );
    p += 2*back_count;

    input_count = OTL_NEXT_USHORT( p );
    if ( input_count == 0 )
      OTL_INVALID_DATA;

    OTL_CHECK( 2*input_count );
    p += 2*(input_count-1);

    ahead_count = OTL_NEXT_USHORT( p );
    OTL_CHECK( 2*ahead_count + 2 );
    p += 2*ahead_count;

    count = OTL_NEXT_USHORT( p );
    OTL_CHECK( 4*count );

    /* XXX: check class indices and subst lookups */
  }



  static void
  otl_chain_sub_class_set_validate( OTL_Bytes      table,
                                    OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   count;

    OTL_CHECK( 2 );
    count = OTL_NEXT_USHORT( p );

    OTL_CHECK( 2*count );
    for ( ; count > 0; count-- )
      otl_chain_sub_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
  }


  static void
  otl_gsub_lookup6_validate( OTL_Bytes      table,
                             OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   format, coverage;

    OTL_CHECK( 2 );
    format = OTL_NEXT_USHORT( p );
    switch ( format )
    {
      case 1:
        {
          OTL_UInt  coverage, count;

          OTL_CHECK( 4 );
          coverage = OTL_NEXT_USHORT( p );
          count    = OTL_NEXT_USHORT( p );

          otl_coverage_validate( table + coverage, valid );

          OTL_CHECK( 2*count );
          for ( ; count > 0; count-- )
            otl_chain_sub_rule_set_validate( table + coverage, valid );
        }
        break;

      case 2:
        {
          OTL_UInt  coverage, back_class, input_class, ahead_class, count;

          OTL_CHECK( 10 );
          coverage    = OTL_NEXT_USHORT( p );
          back_class  = OTL_NEXT_USHORT( p );
          input_class = OTL_NEXT_USHORT( p );
          ahead_class = OTL_NEXT_USHORT( p );
          count       = OTL_NEXT_USHORT( p );

          otl_coverage_validate( table + coverage, valid );

          otl_class_definition_validate( table + back_class,  valid );
          otl_class_definition_validate( table + input_class, valid );
          otl_class_definition_validate( table + ahead_class, valid );

          OTL_CHECK( 2*count );
          for ( ; count > 0; count-- )
            otl_chain_sub_class_set( table + OTL_NEXT_USHORT( p ), valid );
        }
        break;

      case 3:
        {
          OTL_UInt  back_count, input_count, ahead_count, subst_count, count;

          OTL_CHECK( 2 );
          back_count = OTL_NEXT_USHORT( p );

          OTL_CHECK( 2*back_count+2 );
          for ( count = back_count; count > 0; count-- )
            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );

          input_count = OTL_NEXT_USHORT( p );

          OTL_CHECK( 2*input_count+2 );
          for ( count = input_count; count > 0; count-- )
            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );

          ahead_count = OTL_NEXT_USHORT( p );

          OTL_CHECK( 2*ahead_count+2 );
          for ( count = ahead_count; count > 0; count-- )
            otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );

          subst_count = OTL_NEXT_USHORT( p );
          OTL_CHECK( subst_count*4 );
        }
        break;

      default:
        OTL_INVALID_DATA;
    }
  }

 /************************************************************************/
 /************************************************************************/
 /*****                                                              *****/
 /*****                 GSUB LOOKUP TYPE 6                           *****/
 /*****                                                              *****/
 /************************************************************************/
 /************************************************************************/

  static void
  otl_gsub_lookup7_validate( OTL_Bytes      table,
                             OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   format, coverage;

    OTL_CHECK( 2 );
    format = OTL_NEXT_USHORT( p );
    switch ( format )
    {
      case 1:
        {
          OTL_UInt          lookup_type, lookup_offset;
          OTL_ValidateFunc  validate;

          OTL_CHECK( 6 );
          lookup_type   = OTL_NEXT_USHORT( p );
          lookup_offset = OTL_NEXT_ULONG( p );

          if ( lookup_type == 0 || lookup_type >= 7 )
            OTL_INVALID_DATA;

          validate = otl_gsub_validate_funcs[ lookup_type-1 ];
          validate( table + lookup_offset, valid );
        }
        break;

      default:
        OTL_INVALID_DATA;
    }
  }


  static const OTL_ValidateFunc  otl_gsub_validate_funcs[ 7 ] =
  {
    otl_gsub_lookup1_validate,
    otl_gsub_lookup2_validate,
    otl_gsub_lookup3_validate,
    otl_gsub_lookup4_validate,
    otl_gsub_lookup5_validate,
    otl_gsub_lookup6_validate
  };

 /************************************************************************/
 /************************************************************************/
 /*****                                                              *****/
 /*****                         GSUB TABLE                           *****/
 /*****                                                              *****/
 /************************************************************************/
 /************************************************************************/


  OTL_LOCALDEF( void )
  otl_gsub_validate( OTL_Bytes      table,
                     OTL_Validator  valid )
  {
    OTL_Bytes  p = table;
    OTL_UInt   scripts, features, lookups;

    OTL_CHECK( 10 );

    if ( OTL_NEXT_USHORT( p ) != 0x10000UL )
      OTL_INVALID_DATA;

    scripts  = OTL_NEXT_USHORT( p );
    features = OTL_NEXT_USHORT( p );
    lookups  = OTL_NEXT_USHORT( p );

    otl_script_list_validate ( table + scripts, valid );
    otl_feature_list_validate( table + features, valid );

    otl_lookup_list_validate( table + lookups, 7, otl_gsub_validate_funcs,
                              valid );
  }