kc3-lang/freetype/src/otlayout/otlgpos.c

• Show log

  Commit

• Hash : 8cd89073
  Author :
  Date : 2002-05-04T18:02:59
  

  * src/truetype/ttgload.c (TT_Load_Glyph): finally fixing the last bug that prevented FreeType 2.x and FreeType 1.x to produce bit-by-bit identical monochrome glyph bitmaps with native TrueType hinting. The culprit was a single-bit flag that wasn't set correctly by the TrueType glyph loader !! * src/otlayout/otlayout.h, src/otlayout/otlbase.c, src/otlayout/otlbase.h, src/otlayout/otlconf.h, src/otlayout/otlgdef.c, src/otlayout/otlgdef.h, src/otlayout/otlgpos.c, src/otlayout/otlgpos.h, src/otlayout/otlgsub.c, src/otlayout/otlgsub.h, src/otlayout/otljstf.c, src/otlayout/otljstf.h, src/otlayout/otltable.c, src/otlayout/otltable.h, src/otlayout/otltags.h: adding OpenType Layout source files. Module is still incomplete

Download

• src/otlayout/otlgpos.c

• #include "otlgpos.h"
  #include "otlcommn.h"
  
   /* forward declaration */
    static OTL_ValidateFunc  otl_gpos_validate_funcs[];
  
  
   /************************************************************************/
   /************************************************************************/
   /*****                                                              *****/
   /*****                         VALUE RECORDS                        *****/
   /*****                                                              *****/
   /************************************************************************/
   /************************************************************************/
  
    static OTL_UInt
    otl_value_length( OTL_UInt  format )
    {
      FT_UInt  count;
  
      count = (( format & 0xAA ) >> 1) + ( format & 0x55 );
      count = (( count  & 0xCC ) >> 2) + ( count  & 0x33 );
      count = (( count  & 0xF0 ) >> 4) + ( count  & 0x0F );
  
      return count;
    }
  
  
    static void
    otl_value_validate( OTL_Bytes      table,
                        OTL_Bytes      pos_table,
                        OTL_UInt       format,
                        OTL_Validator  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   count, device;
  
      if ( format >= 0x100U )
        OTL_INVALID_DATA;
  
      for ( count = 4; count > 0; count-- )
      {
        if ( format & 1 )
        {
          OTL_CHECK( 2 );
          p += 2;
        }
  
        format >>= 1;
      }
  
      for ( count = 4; count > 0; count-- )
      {
        if ( format & 1 )
        {
          OTL_CHECK( 2 );
          device = OTL_NEXT_USHORT( p );
          if ( device )
            otl_device_table_validate( pos_table + device, valid );
        }
        format >>= 1;
      }
    }
  
  
   /************************************************************************/
   /************************************************************************/
   /*****                                                              *****/
   /*****                          ANCHORS                             *****/
   /*****                                                              *****/
   /************************************************************************/
   /************************************************************************/
  
    static void
    otl_anchor_validate( OTL_Bytes      table,
                         OTL_Validator  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   format;
  
      OTL_CHECK( 6 );
      format = OTL_NEXT_USHORT( p );
      p += 4;
  
      switch ( format )
      {
        case 1:
          break;
  
        case 2:
          OTL_CHECK( 2 );  /* anchor point */
          break;
  
        case 3:
          {
            OTL_UInt  x_device, y_device;
  
            OTL_CHECK( 4 );
            x_device = OTL_NEXT_USHORT( p );
            y_device = OTL_NEXT_USHORT( p );
  
            if ( x_device )
              otl_device_table_validate( table + x_device, valid );
  
            if ( y_device )
              otl_device_table_validate( table + y_device, valid );
          }
          break;
  
        default:
          OTL_INVALID_DATA;
      }
    }
  
  
   /************************************************************************/
   /************************************************************************/
   /*****                                                              *****/
   /*****                           MARK ARRAY                         *****/
   /*****                                                              *****/
   /************************************************************************/
   /************************************************************************/
  
    static void
    otl_mark_array_validate( OTL_Bytes      table,
                             OTL_Validator  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   count;
  
      OTL_CHECK( 2 );
  
      count = OTL_NEXT_USHORT( p );
      OTL_CHECK( count * 4 );
      for ( ; count > 0; count-- )
      {
        p += 2;  /* ignore class index */
        otl_anchor_validate( table + OTL_NEXT_USHORT( p ), valid );
      }
    }
  
  
   /************************************************************************/
   /************************************************************************/
   /*****                                                              *****/
   /*****                 GPOS LOOKUP TYPE 1                           *****/
   /*****                                                              *****/
   /************************************************************************/
   /************************************************************************/
  
    static void
    otl_gpos_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:
          {
            FT_UInt  coverage, value_format;
  
            OTL_CHECK( 4 );
            coverage     = OTL_NEXT_USHORT( p );
            value_format = OTL_NEXT_USHORT( p );
  
            otl_coverage_validate( table + coverage, valid );
            otl_value_validate( p, table, value_format, valid );
          }
          break;
  
        case 2:
          {
            FT_UInt  coverage, value_format, count, len;
  
            OTL_CHECK( 6 );
            coverage     = OTL_NEXT_USHORT( p );
            value_format = OTL_NEXT_USHORT( p );
            count        = OTL_NEXT_USHORT( p );
            len          = otl_value_length( value_format );
  
            otl_coverage_validate( table + coverage, valid );
  
            OTL_CHECK( count * len );
            for ( ; count > 0; count-- )
            {
              otl_value_validate( p, table, value_format, valid );
              p += len;
            }
          }
          break;
  
        default:
          OTL_INVALID_DATA;
      }
    }
  
  
   /************************************************************************/
   /************************************************************************/
   /*****                                                              *****/
   /*****                 GPOS LOOKUP TYPE 2                           *****/
   /*****                                                              *****/
   /************************************************************************/
   /************************************************************************/
  
    static otl_gpos_pairset_validate( OTL_Bytes      table,
                                      OTL_Bytes      pos_table,
                                      OTL_UInt       format1,
                                      OTL_UInt       format2,
                                      OTL_Validator  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   len1, len2, count;
  
      OTL_CHECK( 2 );
      count = OTL_NEXT_USHORT( p );
      len1  = otl_value_length( format1 );
      len2  = otl_value_length( format2 );
  
      OTL_CHECK( count * (len1+len2+2) );
      for ( ; count > 0; count-- )
      {
        p += 2;  /* ignore glyph id */
        otl_value_validate( p, pos_table, format1, valid );
        p += len1;
  
        otl_value_validate( p, pos_table, format2, valid );
        p += len2;
      }
    }
  
    static void
    otl_gpos_lookup2_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, value1, value2, count;
  
            OTL_CHECK( 8 );
            coverage = OTL_NEXT_USHORT( p );
            value1   = OTL_NEXT_USHORT( p );
            value2   = OTL_NEXT_USHORT( p );
            count    = OTL_NEXT_USHORT( p );
  
            otl_coverage_validate( table + coverage, valid );
  
            OTL_CHECK( count*2 );
            for ( ; count > 0; count-- )
            {
              otl_gpos_pairset_validate( table + OTL_NEXT_USHORT( p ),
                                         table, value1, value2, valid );
            }
          }
          break;
  
        case 2:
          {
            OTL_UInt  coverage, value1, value2, class1, class2, count1, count2;
            OTL_UInt  len1, len2;
  
            OTL_CHECK( 14 );
            coverage = OTL_NEXT_USHORT( p );
            value1   = OTL_NEXT_USHORT( p );
            value2   = OTL_NEXT_USHORT( p );
            class1   = OTL_NEXT_USHORT( p );
            class2   = OTL_NEXT_USHORT( p );
            count1   = OTL_NEXT_USHORT( p );
            count2   = OTL_NEXT_USHORT( p );
  
            len1 = otl_value_length( value1 );
            len2 = otl_value_length( value2 );
  
            otl_coverage_validate( table + coverage, valid );
  
            OTL_CHECK( count1*count2*(len1+len2) );
            for ( ; count1 > 0; count1-- )
            {
              for ( ; count2 > 0; count2-- )
              {
                otl_value_validate( p, table, value1, valid );
                p += len1;
  
                otl_value_validate( p, table, value2, valid );
                p += len2;
              }
            }
          }
          break;
  
        default:
          OTL_INVALID_DATA;
      }
    }
  
  
   /************************************************************************/
   /************************************************************************/
   /*****                                                              *****/
   /*****                 GPOS LOOKUP TYPE 3                           *****/
   /*****                                                              *****/
   /************************************************************************/
   /************************************************************************/
  
    static void
    otl_gpos_lookup3_validate( OTL_Bytes  table,
                               OTL_Valid  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   format;
  
      OTL_CHECK( 2 );
      format = OTL_NEXT_USHORT( p );
      switch (format)
      {
        case 1:
          {
            OTL_UInt  coverage, count, anchor1, anchor2;
  
            OTL_CHECK( 4 );
            coverage = OTL_NEXT_USHORT( p );
            count    = OTL_NEXT_USHORT( p );
  
            otl_coverage_validate( table + coverage, valid );
  
            OTL_CHECK( count*4 );
            for ( ; count > 0; count-- )
            {
              anchor1 = OTL_NEXT_USHORT( p );
              anchor2 = OTL_NEXT_USHORT( p );
  
              if ( anchor1 )
                otl_anchor_validate( table + anchor1, valid );
  
              if ( anchor2 )
                otl_anchor_validate( table + anchor2, valid );
            }
          }
          break;
  
        default:
          OTL_INVALID_DATA;
      }
    }
  
  
   /************************************************************************/
   /************************************************************************/
   /*****                                                              *****/
   /*****                 GPOS LOOKUP TYPE 4                           *****/
   /*****                                                              *****/
   /************************************************************************/
   /************************************************************************/
  
    static void
    otl_base_array_validate( OTL_Bytes      table,
                             OTL_UInt       class_count,
                             OTL_Validator  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   count, count2;
  
      OTL_CHECK( 2 );
      count = OTL_NEXT_USHORT( p );
  
      OTL_CHECK( count*class_count*2 );
      for ( ; count > 0; count-- )
        for ( count2 = class_count; count2 > 0; count2-- )
          otl_anchor_validate( table + OTL_NEXT_USHORT( p ) );
    }
  
  
    static void
    otl_gpos_lookup4_validate( OTL_Bytes  table,
                               OTL_Valid  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   format;
  
      OTL_CHECK( 2 );
      format = OTL_NEXT_USHORT( p );
      switch (format)
      {
        case 1:
          {
            OTL_UInt  mark_coverage, base_coverage, class_count;
            OTL_UInt  mark_array, base_array;
  
            OTL_CHECK( 10 );
            mark_coverage = OTL_NEXT_USHORT( p );
            base_coverage = OTL_NEXT_USHORT( p );
            class_count   = OTL_NEXT_USHORT( p );
            mark_array    = OTL_NEXT_USHORT( p );
            base_array    = OTL_NEXT_USHORT( p );
  
            otl_coverage_validate( table + mark_coverage, valid );
            otl_coverage_validate( table + base_coverage, valid );
  
            otl_mark_array_validate( table + mark_array, valid );
            otl_base_array_validate( table, class_count, valid );
          }
          break;
  
        default:
          OTL_INVALID_DATA;
      }
    }
  
   /************************************************************************/
   /************************************************************************/
   /*****                                                              *****/
   /*****                 GPOS LOOKUP TYPE 5                           *****/
   /*****                                                              *****/
   /************************************************************************/
   /************************************************************************/
  
    static void
    otl_liga_attach_validate( OTL_Bytes      table,
                              OTL_UInt       class_count,
                              OTL_Validator  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   count, count2;
  
      OTL_CHECK( 2 );
      count = OTL_NEXT_USHORT( p );
  
      OTL_CHECK( count*class_count*2 );
      for ( ; count > 0; count-- )
        for ( count2 = class_count; class_count > 0; class_count-- )
          otl_anchor_validate( table + OTL_NEXT_USHORT( p ), valid );
    }
  
  
    static void
    otl_liga_array_validate( OTL_Bytes      table,
                             OTL_UInt       class_count,
                             OTL_Validator  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   count, count2;
  
      OTL_CHECK( 2 );
      count = OTL_NEXT_USHORT( p );
  
      OTL_CHECK( count*2 );
      for ( ; count > 0; count-- )
        otl_liga_attach_validate( table + OTL_NEXT_USHORT( p ), valid );
    }
  
  
    static void
    otl_gpos_lookup5_validate( OTL_Bytes  table,
                               OTL_Valid  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   format;
  
      OTL_CHECK( 2 );
      format = OTL_NEXT_USHORT( p );
      switch (format)
      {
        case 1:
          {
            OTL_UInt  mark_coverage, lig_coverage, class_count;
            OTL_UInt  mar_array, lig_array;
  
            OTL_CHECK( 10 );
            mark_coverage = OTL_NEXT_USHORT( p );
            liga_coverage = OTL_NEXT_USHORT( p );
            class_count   = OTL_NEXT_USHORT( p );
            mark_array    = OTL_NEXT_USHORT( p );
            liga_array    = OTL_NEXT_USHORT( p );
  
            otl_coverage_validate( table + mark_coverage, valid );
            otl_coverage_validate( table + liga_coverage, valid );
  
            otl_mark_array_validate( table + mark_array, valid );
            otl_liga_array_validate( table + liga_array, class_count, valid );
          }
          break;
  
        default:
          OTL_INVALID_DATA;
      }
    }
  
   /************************************************************************/
   /************************************************************************/
   /*****                                                              *****/
   /*****                 GPOS LOOKUP TYPE 6                           *****/
   /*****                                                              *****/
   /************************************************************************/
   /************************************************************************/
  
  
    static void
    otl_mark2_array_validate( OTL_Bytes      table,
                              OTL_UInt       class_count,
                              OTL_Validator  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   count, count2;
  
      OTL_CHECK( 2 );
      count = OTL_NEXT_USHORT( p );
  
      OTL_CHECK( count*class_count*2 );
      for ( ; count > 0; count-- )
        for ( count2 = class_count; class_count > 0; class_count-- )
          otl_anchor_validate( table + OTL_NEXT_USHORT( p ), valid );
    }
  
  
    static void
    otl_gpos_lookup6_validate( OTL_Bytes  table,
                               OTL_Valid  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   format;
  
      OTL_CHECK( 2 );
      format = OTL_NEXT_USHORT( p );
      switch (format)
      {
        case 1:
          {
            OTL_UInt  coverage1, coverage2, class_count, array1, array2;
  
            OTL_CHECK( 10 );
            coverage1   = OTL_NEXT_USHORT( p );
            coverage2   = OTL_NEXT_USHORT( p );
            class_count = OTL_NEXT_USHORT( p );
            array1      = OTL_NEXT_USHORT( p );
            array2      = OTL_NEXT_USHORT( p );
  
            otl_coverage_validate( table + coverage1, valid );
            otl_coverage_validate( table + coverage2, valid );
  
            otl_mark_array_validate( table + array1, valid );
            otl_mark2_array_validate( table + array2, valid );
          }
          break;
  
        default:
          OTL_INVALID_DATA;
      }
    }
  
  
   /************************************************************************/
   /************************************************************************/
   /*****                                                              *****/
   /*****                 GPOS LOOKUP TYPE 7                           *****/
   /*****                                                              *****/
   /************************************************************************/
   /************************************************************************/
  
    static void
    otl_pos_rule_validate( OTL_Bytes      table,
                           OTL_Validator  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   glyph_count, pos_count;
  
      OTL_CHECK( 4 );
      glyph_count = OTL_NEXT_USHORT( p );
      pos_count   = OTL_NEXT_USHORT( p );
  
      if ( glyph_count == 0 )
        OTL_INVALID_DATA;
  
      OTL_CHECK( (glyph_count-1)*2 + pos_count*4 );
  
      /* XXX: check glyph indices and pos lookups */
    }
  
  
    static void
    otl_pos_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( count*2 );
      for ( ; count > 0; count-- )
        otl_pos_rule_validate( table + OTL_NEXT_USHORT(p), valid );
    }
  
  
  
    static void
    otl_pos_class_rule_validate( OTL_Bytes      table,
                                 OTL_Validator  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   glyph_count, pos_count;
  
      OTL_CHECK( 4 );
      glyph_count = OTL_NEXT_USHORT( p );
      pos_count   = OTL_NEXT_USHORT( p );
  
      if ( glyph_count == 0 )
        OTL_INVALID_DATA;
  
      OTL_CHECK( (glyph_count-1)*2 + pos_count*4 );
  
      /* XXX: check glyph indices and pos lookups */
    }
  
  
    static void
    otl_pos_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( count*2 );
      for ( ; count > 0; count-- )
        otl_pos_rule_validate( table + OTL_NEXT_USHORT(p), valid );
    }
  
  
    static void
    otl_gpos_lookup7_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, count;
  
            OTL_CHECK( 4 );
            coverage = OTL_NEXT_USHORT( p );
            count    = OTL_NEXT_USHORT( p );
  
            otl_coverage_validate( table + coverage, valid );
  
            OTL_CHECK( count*2 );
            for ( ; count > 0; count-- )
              otl_pos_rule_set_validate( table + OTL_NEXT_USHORT( p ), 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( count*2 );
            for ( ; count > 0; count-- )
              otl_
          }
          break;
  
        case 3:
          {
            OTL_UInt  glyph_count, pos_count;
  
            OTL_CHECK( 4 );
            glyph_count = OTL_NEXT_USHORT( p );
            pos_count   = OTL_NEXT_USHORT( p );
  
            OTL_CHECK( glyph_count*2 + pos_count*4 );
            for ( ; glyph_count > 0; glyph_count )
              otl_coverage_validate( table + OTL_NEXT_USHORT( p ), valid );
  
            /* XXX: check pos lookups */
          }
          break;
  
        default:
          OTL_INVALID_DATA;
      }
    }
  
  
   /************************************************************************/
   /************************************************************************/
   /*****                                                              *****/
   /*****                 GPOS LOOKUP TYPE 8                           *****/
   /*****                                                              *****/
   /************************************************************************/
   /************************************************************************/
  
    static void
    otl_chain_pos_rule_validate( OTL_Bytes      table,
                                 OTL_Validator  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   back_count, input_count, ahead_count, pos_count;
  
      OTL_CHECK( 2 );
      back_count = OTL_NEXT_USHORT( p );
  
      OTL_CHECK( back_count*2 + 2 );
      p += back_count*2;
  
      input_count = OTL_NEXT_USHORT( p );
      if ( input_count == 0 )
        OTL_INVALID_DATA;
  
      OTL_CHECK( input_count*2 );
      p += (input_count-1)*2;
  
      ahead_count = OTL_NEXT_USHORT( p );
      OTL_CHECK( ahead_count*2 + 2 );
      p += ahead_count*2;
  
      pos_count = OTL_NEXT_USHORT( p );
      OTL_CHECK( pos_count*4 );
    }
  
  
    static void
    otl_chain_pos_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_pos_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
    }
  
  
  
    static void
    otl_chain_pos_class_rule_validate( OTL_Bytes      table,
                                       OTL_Validator  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   back_count, input_count, ahead_count, pos_count;
  
      OTL_CHECK( 2 );
      back_count = OTL_NEXT_USHORT( p );
  
      OTL_CHECK( back_count*2 + 2 );
      p += back_count*2;
  
      input_count = OTL_NEXT_USHORT( p );
      if ( input_count == 0 )
        OTL_INVALID_DATA;
  
      OTL_CHECK( input_count*2 );
      p += (input_count-1)*2;
  
      ahead_count = OTL_NEXT_USHORT( p );
      OTL_CHECK( ahead_count*2 + 2 );
      p += ahead_count*2;
  
      pos_count = OTL_NEXT_USHORT( p );
      OTL_CHECK( pos_count*4 );
    }
  
  
    static void
    otl_chain_pos_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_pos_class_rule_validate( table + OTL_NEXT_USHORT( p ), valid );
    }
  
  
    static void
    otl_gpos_lookup8_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, count;
  
            OTL_CHECK( 4 );
            coverage = OTL_NEXT_USHORT( p );
            count    = OTL_NEXT_USHORT( p );
  
            otl_coverage_validate( table + coverage, valid );
  
            OTL_CHECK( count*2 );
            for ( ; count > 0; count-- )
              otl_chain_pos_rule_set_validate( table + OTL_NEXT_USHORT( p ),
                                               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( count*2 );
            for ( ; count > 0; count-- )
              otl_chain_pos_class_set_validate( table + OTL_NEXT_USHORT( p ),
                                                valid );
          }
          break;
  
        case 3:
          {
            OTL_UInt  back_count, input_count, ahead_count, pos_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 );
  
            pos_count = OTL_NEXT_USHORT( p );
            OTL_CHECK( pos_count*4 );
          }
          break;
  
        default:
          OTL_INVALID_DATA;
      }
    }
  
   /************************************************************************/
   /************************************************************************/
   /*****                                                              *****/
   /*****                 GPOS LOOKUP TYPE 9                           *****/
   /*****                                                              *****/
   /************************************************************************/
   /************************************************************************/
  
    static void
    otl_gpos_lookup9_validate( OTL_Bytes  table,
                               OTL_Valid  valid )
    {
      OTL_Bytes  p = table;
      OTL_UInt   format;
  
      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 >= 9 )
              OTL_INVALID_DATA;
  
            validate = otl_gpos_validate_funcs[ lookup_type-1 ];
            validate( table + lookup_offset, valid );
          }
          break;
  
        default:
          OTL_INVALID_DATA;
      }
    }
  
    static OTL_ValidateFunc  otl_gpos_validate_funcs[ 9 ] =
    {
      otl_gpos_lookup1_validate,
      otl_gpos_lookup2_validate,
      otl_gpos_lookup3_validate,
      otl_gpos_lookup4_validate,
      otl_gpos_lookup5_validate,
      otl_gpos_lookup6_validate,
      otl_gpos_lookup7_validate,
      otl_gpos_lookup8_validate,
      otl_gpos_lookup9_validate,
    };
  
  
   /************************************************************************/
   /************************************************************************/
   /*****                                                              *****/
   /*****                         GPOS TABLE                           *****/
   /*****                                                              *****/
   /************************************************************************/
   /************************************************************************/
  
  
    OTL_LOCALDEF( void )
    otl_gpos_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, 9, otl_gpos_validate_funcs,
                                valid );
    }
    

Download