text: /***************************************************************************/
  /*                                                                         */
  /*  otvmath.c                                                              */
  /*                                                                         */
  /*    OpenType MATH table validation (body).                               */
  /*                                                                         */
  /*  Copyright 2007 by                                                      */
  /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  /*                                                                         */
  /*  Written by George Williams.                                            */
  /*                                                                         */
  /*  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 "otvalid.h"
  #include "otvcommn.h"
  #include "otvgpos.h"
  
  
    /*************************************************************************/
    /*                                                                       */
    /* 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  trace_otvmath
  
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                  MATH TYPOGRAPHIC CONSTANTS                   *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
    static void
    otv_MathConstants_validate( FT_Bytes       table,
                                OTV_Validator  valid )
    {
      FT_Bytes  p = table;
      FT_UInt   i;
      FT_UInt   table_size;
  
      OTV_OPTIONAL_TABLE( DeviceTableOffset );
  
  
      OTV_NAME_ENTER( "MathConstants" );
  
      /* 56 constants, 51 have device tables */
      OTV_LIMIT_CHECK( 2 * ( 56 + 51 ) );
      table_size = 2 * ( 56 + 51 );
  
      p += 4 * 2;                 /* First 4 constants have no device tables */
      for ( i = 0; i < 51; ++i )
      {
        p += 2;                                            /* skip the value */
        OTV_OPTIONAL_OFFSET( DeviceTableOffset );
        OTV_SIZE_CHECK( DeviceTableOffset );
        if ( DeviceTableOffset )
          otv_Device_validate( table + DeviceTableOffset, valid );
      }
  
      OTV_EXIT;
    }
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                   MATH ITALICS CORRECTION                     *****/
    /*****                 MATH TOP ACCENT ATTACHMENT                    *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
    static void
    otv_MathItalicsCorrectionInfo_validate( FT_Bytes       table,
                                            OTV_Validator  valid,
                                            FT_Int         isItalic )
    {
      FT_Bytes  p = table;
      FT_UInt   i, cnt, table_size ;
  
      OTV_OPTIONAL_TABLE( Coverage );
      OTV_OPTIONAL_TABLE( DeviceTableOffset );
  
  
      OTV_NAME_ENTER( isItalic ? "MathItalicsCorrectionInfo"
                               : "MathTopAccentAttachment" );
  
      OTV_LIMIT_CHECK( 4 );
  
      OTV_OPTIONAL_OFFSET( Coverage );
      cnt = FT_NEXT_USHORT( p );
  
      OTV_LIMIT_CHECK( 4 * cnt );
      table_size = 4 + 4 * cnt;
  
      OTV_SIZE_CHECK( Coverage );
      otv_Coverage_validate( table + Coverage, valid, cnt );
  
      for ( i = 0; i < cnt; ++i )
      {
        p += 2;                                            /* Skip the value */
        OTV_OPTIONAL_OFFSET( DeviceTableOffset );
        OTV_SIZE_CHECK( DeviceTableOffset );
        if ( DeviceTableOffset )
          otv_Device_validate( table + DeviceTableOffset, valid );
      }
  
      OTV_EXIT;
    }
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                           MATH KERNING                        *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
    static void
    otv_MathKern_validate( FT_Bytes       table,
                           OTV_Validator  valid )
    {
      FT_Bytes  p = table;
      FT_UInt   i, cnt, table_size;
  
      OTV_OPTIONAL_TABLE( DeviceTableOffset );
  
  
      /* OTV_NAME_ENTER( "MathKern" );*/
  
      OTV_LIMIT_CHECK( 2 );
  
      cnt = FT_NEXT_USHORT( p );
  
      OTV_LIMIT_CHECK( 4 * cnt + 2 );
      table_size = 4 + 4 * cnt;
  
      /* Heights */
      for ( i = 0; i < cnt; ++i )
      {
        p += 2;                                            /* Skip the value */
        OTV_OPTIONAL_OFFSET( DeviceTableOffset );
        OTV_SIZE_CHECK( DeviceTableOffset );
        if ( DeviceTableOffset )
          otv_Device_validate( table + DeviceTableOffset, valid );
      }
  
      /* One more Kerning value */
      for ( i = 0; i < cnt + 1; ++i )
      {
        p += 2;                                            /* Skip the value */
        OTV_OPTIONAL_OFFSET( DeviceTableOffset );
        OTV_SIZE_CHECK( DeviceTableOffset );
        if ( DeviceTableOffset )
          otv_Device_validate( table + DeviceTableOffset, valid );
      }
  
      OTV_EXIT;
    }
  
  
    static void
    otv_MathKernInfo_validate( FT_Bytes       table,
                               OTV_Validator  valid )
    {
      FT_Bytes  p = table;
      FT_UInt   i, j, cnt, table_size;
  
      OTV_OPTIONAL_TABLE( Coverage );
      OTV_OPTIONAL_TABLE( MKRecordOffset );
  
  
      OTV_NAME_ENTER( "MathKernInfo" );
  
      OTV_LIMIT_CHECK( 4 );
  
      OTV_OPTIONAL_OFFSET( Coverage );
      cnt = FT_NEXT_USHORT( p );
  
      OTV_LIMIT_CHECK( 8 * cnt );
      table_size = 4 + 8 * cnt;
  
      OTV_SIZE_CHECK( Coverage );
      otv_Coverage_validate( table + Coverage, valid, cnt );
  
      for ( i = 0; i < cnt; ++i )
      {
        for ( j = 0; j < 4; ++j )
        {
          OTV_OPTIONAL_OFFSET( MKRecordOffset );
          OTV_SIZE_CHECK( MKRecordOffset );
          if ( MKRecordOffset )
            otv_MathKern_validate( table + MKRecordOffset, valid );
        }
      }
  
      OTV_EXIT;
    }
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                         MATH GLYPH INFO                       *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
    static void
    otv_MathGlyphInfo_validate( FT_Bytes       table,
                                OTV_Validator  valid )
    {
      FT_Bytes  p = table;
      FT_UInt   MathItalicsCorrectionInfo, MathTopAccentAttachment;
      FT_UInt   ExtendedShapeCoverage, MathKernInfo;
  
  
      OTV_NAME_ENTER( "MathGlyphInfo" );
  
      OTV_LIMIT_CHECK( 8 );
  
      MathItalicsCorrectionInfo = FT_NEXT_USHORT( p );
      MathTopAccentAttachment   = FT_NEXT_USHORT( p );
      ExtendedShapeCoverage     = FT_NEXT_USHORT( p );
      MathKernInfo              = FT_NEXT_USHORT( p );
  
      if ( MathItalicsCorrectionInfo )
        otv_MathItalicsCorrectionInfo_validate(
          table + MathItalicsCorrectionInfo, valid, TRUE );
  
      /* Italic correction and Top Accent Attachment have the same format */
      if ( MathTopAccentAttachment )
        otv_MathItalicsCorrectionInfo_validate(
          table + MathTopAccentAttachment, valid, FALSE );
  
      if ( ExtendedShapeCoverage ) {
        OTV_NAME_ENTER( "ExtendedShapeCoverage" );
        otv_Coverage_validate( table + ExtendedShapeCoverage, valid, -1 );
        OTV_EXIT;
      }
  
      if ( MathKernInfo )
        otv_MathKernInfo_validate( table + MathKernInfo, valid );
  
      OTV_EXIT;
    }
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                    MATH GLYPH CONSTRUCTION                    *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
    static void
    otv_GlyphAssembly_validate( FT_Bytes       table,
                                OTV_Validator  valid )
    {
      FT_Bytes  p = table;
      FT_UInt   pcnt, table_size;
      FT_UInt   i;
  
      OTV_OPTIONAL_TABLE( DeviceTableOffset );
  
  
      /* OTV_NAME_ENTER( "GlyphAssembly" ); */
  
      OTV_LIMIT_CHECK( 6 );
  
      p += 2;                           /* Skip the Italics Correction value */
      OTV_OPTIONAL_OFFSET( DeviceTableOffset );
      pcnt = FT_NEXT_USHORT( p );
  
      OTV_LIMIT_CHECK( 8 * pcnt );
      table_size = 6 + 8 * pcnt;
  
      OTV_SIZE_CHECK( DeviceTableOffset );
      if ( DeviceTableOffset )
        otv_Device_validate( table + DeviceTableOffset, valid );
  
      for ( i = 0; i < pcnt; ++i )
      {
        FT_UInt  gid;
  
  
        gid = FT_NEXT_USHORT( p );
        if ( gid >= valid->glyph_count )
          FT_INVALID_GLYPH_ID;
        p += 2*4;             /* skip the Start, End, Full, and Flags fields */
      }
  
      /* OTV_EXIT; */
    }
  
  
    static void
    otv_MathGlyphConstruction_validate( FT_Bytes       table,
                                        OTV_Validator  valid )
    {
      FT_Bytes  p = table;
      FT_UInt   vcnt, table_size;
      FT_UInt   i;
  
      OTV_OPTIONAL_TABLE( GlyphAssembly );
  
  
      /* OTV_NAME_ENTER( "MathGlyphConstruction" ); */
  
      OTV_LIMIT_CHECK( 4 );
  
      OTV_OPTIONAL_OFFSET( GlyphAssembly );
      vcnt = FT_NEXT_USHORT( p );
  
      OTV_LIMIT_CHECK( 4 * vcnt );
      table_size = 4 + 4 * vcnt;
  
      for ( i = 0; i < vcnt; ++i )
      {
        FT_UInt  gid;
  
  
        gid = FT_NEXT_USHORT( p );
        if ( gid >= valid->glyph_count )
          FT_INVALID_GLYPH_ID;
        p += 2;                          /* skip the size */
      }
  
      OTV_SIZE_CHECK( GlyphAssembly );
      if ( GlyphAssembly )
        otv_GlyphAssembly_validate( table+GlyphAssembly, valid );
  
      /* OTV_EXIT; */
    }
  
  
    static void
    otv_MathVariants_validate( FT_Bytes       table,
                               OTV_Validator  valid )
    {
      FT_Bytes  p = table;
      FT_UInt   vcnt, hcnt, i, table_size;
  
      OTV_OPTIONAL_TABLE( VCoverage );
      OTV_OPTIONAL_TABLE( HCoverage );
      OTV_OPTIONAL_TABLE( Offset );
  
  
      OTV_NAME_ENTER( "MathVariants" );
  
      OTV_LIMIT_CHECK( 10 );
  
      p += 2;                       /* Skip the MinConnectorOverlap constant */
      OTV_OPTIONAL_OFFSET( VCoverage );
      OTV_OPTIONAL_OFFSET( HCoverage );
      vcnt = FT_NEXT_USHORT( p );
      hcnt = FT_NEXT_USHORT( p );
  
      OTV_LIMIT_CHECK( 2 * vcnt + 2 * hcnt );
      table_size = 10 + 2 * vcnt + 2 * hcnt;
  
      OTV_SIZE_CHECK( VCoverage );
      if ( VCoverage )
        otv_Coverage_validate( table + VCoverage, valid, vcnt );
  
      OTV_SIZE_CHECK( HCoverage );
      if ( HCoverage )
        otv_Coverage_validate( table + HCoverage, valid, hcnt );
  
      for ( i = 0; i < vcnt; ++i )
      {
        OTV_OPTIONAL_OFFSET( Offset );
        OTV_SIZE_CHECK( Offset );
        otv_MathGlyphConstruction_validate( table + Offset, valid );
      }
  
      for ( i = 0; i < hcnt; ++i )
      {
        OTV_OPTIONAL_OFFSET( Offset );
        OTV_SIZE_CHECK( Offset );
        otv_MathGlyphConstruction_validate( table + Offset, valid );
      }
  
      OTV_EXIT;
    }
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                          MATH TABLE                           *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
    /* sets valid->glyph_count */
  
    FT_LOCAL_DEF( void )
    otv_MATH_validate( FT_Bytes      table,
                       FT_UInt       glyph_count,
                       FT_Validator  ftvalid )
    {
      OTV_ValidatorRec  validrec;
      OTV_Validator     valid = &validrec;
      FT_Bytes          p     = table;
      FT_UInt           MathConstants, MathGlyphInfo, MathVariants;
  
  
      valid->root = ftvalid;
  
      FT_TRACE3(( "validating MATH table\n" ));
      OTV_INIT;
  
      OTV_LIMIT_CHECK( 10 );
  
      if ( FT_NEXT_ULONG( p ) != 0x10000UL )      /* Version */
        FT_INVALID_FORMAT;
  
      MathConstants = FT_NEXT_USHORT( p );
      MathGlyphInfo = FT_NEXT_USHORT( p );
      MathVariants  = FT_NEXT_USHORT( p );
  
      valid->glyph_count = glyph_count;
  
      otv_MathConstants_validate( table + MathConstants,
                                  valid );
      otv_MathGlyphInfo_validate( table + MathGlyphInfo,
                                  valid );
      otv_MathVariants_validate ( table + MathVariants,
                                  valid );
  
      FT_TRACE4(( "\n" ));
    }
  
  
  /* END */
  