ReactOS Fundraising Campaign 2012
 
€ 4,410 / € 30,000

Information | Donate

Home | Info | Community | Development | myReactOS | Contact Us

  1. Home
  2. Community
  3. Development
  4. myReactOS
  5. Fundraiser 2012

  1. Main Page
  2. Alphabetical List
  3. Data Structures
  4. Directories
  5. File List
  6. Data Fields
  7. Globals
  8. Related Pages

ReactOS Development > Doxygen

otvmath.c
Go to the documentation of this file.
00001 /***************************************************************************/
00002 /*                                                                         */
00003 /*  otvmath.c                                                              */
00004 /*                                                                         */
00005 /*    OpenType MATH table validation (body).                               */
00006 /*                                                                         */
00007 /*  Copyright 2007, 2008 by                                                */
00008 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
00009 /*                                                                         */
00010 /*  Written by George Williams.                                            */
00011 /*                                                                         */
00012 /*  This file is part of the FreeType project, and may only be used,       */
00013 /*  modified, and distributed under the terms of the FreeType project      */
00014 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
00015 /*  this file you indicate that you have read the license and              */
00016 /*  understand and accept it fully.                                        */
00017 /*                                                                         */
00018 /***************************************************************************/
00019 
00020 
00021 #include "otvalid.h"
00022 #include "otvcommn.h"
00023 #include "otvgpos.h"
00024 
00025 
00026   /*************************************************************************/
00027   /*                                                                       */
00028   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
00029   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
00030   /* messages during execution.                                            */
00031   /*                                                                       */
00032 #undef  FT_COMPONENT
00033 #define FT_COMPONENT  trace_otvmath
00034 
00035 
00036 
00037   /*************************************************************************/
00038   /*************************************************************************/
00039   /*****                                                               *****/
00040   /*****                  MATH TYPOGRAPHIC CONSTANTS                   *****/
00041   /*****                                                               *****/
00042   /*************************************************************************/
00043   /*************************************************************************/
00044 
00045   static void
00046   otv_MathConstants_validate( FT_Bytes       table,
00047                               OTV_Validator  valid )
00048   {
00049     FT_Bytes  p = table;
00050     FT_UInt   i;
00051     FT_UInt   table_size;
00052 
00053     OTV_OPTIONAL_TABLE( DeviceTableOffset );
00054 
00055 
00056     OTV_NAME_ENTER( "MathConstants" );
00057 
00058     /* 56 constants, 51 have device tables */
00059     OTV_LIMIT_CHECK( 2 * ( 56 + 51 ) );
00060     table_size = 2 * ( 56 + 51 );
00061 
00062     p += 4 * 2;                 /* First 4 constants have no device tables */
00063     for ( i = 0; i < 51; ++i )
00064     {
00065       p += 2;                                            /* skip the value */
00066       OTV_OPTIONAL_OFFSET( DeviceTableOffset );
00067       OTV_SIZE_CHECK( DeviceTableOffset );
00068       if ( DeviceTableOffset )
00069         otv_Device_validate( table + DeviceTableOffset, valid );
00070     }
00071 
00072     OTV_EXIT;
00073   }
00074 
00075 
00076   /*************************************************************************/
00077   /*************************************************************************/
00078   /*****                                                               *****/
00079   /*****                   MATH ITALICS CORRECTION                     *****/
00080   /*****                 MATH TOP ACCENT ATTACHMENT                    *****/
00081   /*****                                                               *****/
00082   /*************************************************************************/
00083   /*************************************************************************/
00084 
00085   static void
00086   otv_MathItalicsCorrectionInfo_validate( FT_Bytes       table,
00087                                           OTV_Validator  valid,
00088                                           FT_Int         isItalic )
00089   {
00090     FT_Bytes  p = table;
00091     FT_UInt   i, cnt, table_size ;
00092 
00093     OTV_OPTIONAL_TABLE( Coverage );
00094     OTV_OPTIONAL_TABLE( DeviceTableOffset );
00095 
00096     FT_UNUSED( isItalic );  /* only used if tracing is active */
00097 
00098 
00099     OTV_NAME_ENTER( isItalic ? "MathItalicsCorrectionInfo"
00100                              : "MathTopAccentAttachment" );
00101 
00102     OTV_LIMIT_CHECK( 4 );
00103 
00104     OTV_OPTIONAL_OFFSET( Coverage );
00105     cnt = FT_NEXT_USHORT( p );
00106 
00107     OTV_LIMIT_CHECK( 4 * cnt );
00108     table_size = 4 + 4 * cnt;
00109 
00110     OTV_SIZE_CHECK( Coverage );
00111     otv_Coverage_validate( table + Coverage, valid, cnt );
00112 
00113     for ( i = 0; i < cnt; ++i )
00114     {
00115       p += 2;                                            /* Skip the value */
00116       OTV_OPTIONAL_OFFSET( DeviceTableOffset );
00117       OTV_SIZE_CHECK( DeviceTableOffset );
00118       if ( DeviceTableOffset )
00119         otv_Device_validate( table + DeviceTableOffset, valid );
00120     }
00121 
00122     OTV_EXIT;
00123   }
00124 
00125 
00126   /*************************************************************************/
00127   /*************************************************************************/
00128   /*****                                                               *****/
00129   /*****                           MATH KERNING                        *****/
00130   /*****                                                               *****/
00131   /*************************************************************************/
00132   /*************************************************************************/
00133 
00134   static void
00135   otv_MathKern_validate( FT_Bytes       table,
00136                          OTV_Validator  valid )
00137   {
00138     FT_Bytes  p = table;
00139     FT_UInt   i, cnt, table_size;
00140 
00141     OTV_OPTIONAL_TABLE( DeviceTableOffset );
00142 
00143 
00144     /* OTV_NAME_ENTER( "MathKern" );*/
00145 
00146     OTV_LIMIT_CHECK( 2 );
00147 
00148     cnt = FT_NEXT_USHORT( p );
00149 
00150     OTV_LIMIT_CHECK( 4 * cnt + 2 );
00151     table_size = 4 + 4 * cnt;
00152 
00153     /* Heights */
00154     for ( i = 0; i < cnt; ++i )
00155     {
00156       p += 2;                                            /* Skip the value */
00157       OTV_OPTIONAL_OFFSET( DeviceTableOffset );
00158       OTV_SIZE_CHECK( DeviceTableOffset );
00159       if ( DeviceTableOffset )
00160         otv_Device_validate( table + DeviceTableOffset, valid );
00161     }
00162 
00163     /* One more Kerning value */
00164     for ( i = 0; i < cnt + 1; ++i )
00165     {
00166       p += 2;                                            /* Skip the value */
00167       OTV_OPTIONAL_OFFSET( DeviceTableOffset );
00168       OTV_SIZE_CHECK( DeviceTableOffset );
00169       if ( DeviceTableOffset )
00170         otv_Device_validate( table + DeviceTableOffset, valid );
00171     }
00172 
00173     OTV_EXIT;
00174   }
00175 
00176 
00177   static void
00178   otv_MathKernInfo_validate( FT_Bytes       table,
00179                              OTV_Validator  valid )
00180   {
00181     FT_Bytes  p = table;
00182     FT_UInt   i, j, cnt, table_size;
00183 
00184     OTV_OPTIONAL_TABLE( Coverage );
00185     OTV_OPTIONAL_TABLE( MKRecordOffset );
00186 
00187 
00188     OTV_NAME_ENTER( "MathKernInfo" );
00189 
00190     OTV_LIMIT_CHECK( 4 );
00191 
00192     OTV_OPTIONAL_OFFSET( Coverage );
00193     cnt = FT_NEXT_USHORT( p );
00194 
00195     OTV_LIMIT_CHECK( 8 * cnt );
00196     table_size = 4 + 8 * cnt;
00197 
00198     OTV_SIZE_CHECK( Coverage );
00199     otv_Coverage_validate( table + Coverage, valid, cnt );
00200 
00201     for ( i = 0; i < cnt; ++i )
00202     {
00203       for ( j = 0; j < 4; ++j )
00204       {
00205         OTV_OPTIONAL_OFFSET( MKRecordOffset );
00206         OTV_SIZE_CHECK( MKRecordOffset );
00207         if ( MKRecordOffset )
00208           otv_MathKern_validate( table + MKRecordOffset, valid );
00209       }
00210     }
00211 
00212     OTV_EXIT;
00213   }
00214 
00215 
00216   /*************************************************************************/
00217   /*************************************************************************/
00218   /*****                                                               *****/
00219   /*****                         MATH GLYPH INFO                       *****/
00220   /*****                                                               *****/
00221   /*************************************************************************/
00222   /*************************************************************************/
00223 
00224   static void
00225   otv_MathGlyphInfo_validate( FT_Bytes       table,
00226                               OTV_Validator  valid )
00227   {
00228     FT_Bytes  p = table;
00229     FT_UInt   MathItalicsCorrectionInfo, MathTopAccentAttachment;
00230     FT_UInt   ExtendedShapeCoverage, MathKernInfo;
00231 
00232 
00233     OTV_NAME_ENTER( "MathGlyphInfo" );
00234 
00235     OTV_LIMIT_CHECK( 8 );
00236 
00237     MathItalicsCorrectionInfo = FT_NEXT_USHORT( p );
00238     MathTopAccentAttachment   = FT_NEXT_USHORT( p );
00239     ExtendedShapeCoverage     = FT_NEXT_USHORT( p );
00240     MathKernInfo              = FT_NEXT_USHORT( p );
00241 
00242     if ( MathItalicsCorrectionInfo )
00243       otv_MathItalicsCorrectionInfo_validate(
00244         table + MathItalicsCorrectionInfo, valid, TRUE );
00245 
00246     /* Italic correction and Top Accent Attachment have the same format */
00247     if ( MathTopAccentAttachment )
00248       otv_MathItalicsCorrectionInfo_validate(
00249         table + MathTopAccentAttachment, valid, FALSE );
00250 
00251     if ( ExtendedShapeCoverage )
00252     {
00253       OTV_NAME_ENTER( "ExtendedShapeCoverage" );
00254       otv_Coverage_validate( table + ExtendedShapeCoverage, valid, -1 );
00255       OTV_EXIT;
00256     }
00257 
00258     if ( MathKernInfo )
00259       otv_MathKernInfo_validate( table + MathKernInfo, valid );
00260 
00261     OTV_EXIT;
00262   }
00263 
00264 
00265   /*************************************************************************/
00266   /*************************************************************************/
00267   /*****                                                               *****/
00268   /*****                    MATH GLYPH CONSTRUCTION                    *****/
00269   /*****                                                               *****/
00270   /*************************************************************************/
00271   /*************************************************************************/
00272 
00273   static void
00274   otv_GlyphAssembly_validate( FT_Bytes       table,
00275                               OTV_Validator  valid )
00276   {
00277     FT_Bytes  p = table;
00278     FT_UInt   pcnt, table_size;
00279     FT_UInt   i;
00280 
00281     OTV_OPTIONAL_TABLE( DeviceTableOffset );
00282 
00283 
00284     /* OTV_NAME_ENTER( "GlyphAssembly" ); */
00285 
00286     OTV_LIMIT_CHECK( 6 );
00287 
00288     p += 2;                           /* Skip the Italics Correction value */
00289     OTV_OPTIONAL_OFFSET( DeviceTableOffset );
00290     pcnt = FT_NEXT_USHORT( p );
00291 
00292     OTV_LIMIT_CHECK( 8 * pcnt );
00293     table_size = 6 + 8 * pcnt;
00294 
00295     OTV_SIZE_CHECK( DeviceTableOffset );
00296     if ( DeviceTableOffset )
00297       otv_Device_validate( table + DeviceTableOffset, valid );
00298 
00299     for ( i = 0; i < pcnt; ++i )
00300     {
00301       FT_UInt  gid;
00302 
00303 
00304       gid = FT_NEXT_USHORT( p );
00305       if ( gid >= valid->glyph_count )
00306         FT_INVALID_GLYPH_ID;
00307       p += 2*4;             /* skip the Start, End, Full, and Flags fields */
00308     }
00309 
00310     /* OTV_EXIT; */
00311   }
00312 
00313 
00314   static void
00315   otv_MathGlyphConstruction_validate( FT_Bytes       table,
00316                                       OTV_Validator  valid )
00317   {
00318     FT_Bytes  p = table;
00319     FT_UInt   vcnt, table_size;
00320     FT_UInt   i;
00321 
00322     OTV_OPTIONAL_TABLE( GlyphAssembly );
00323 
00324 
00325     /* OTV_NAME_ENTER( "MathGlyphConstruction" ); */
00326 
00327     OTV_LIMIT_CHECK( 4 );
00328 
00329     OTV_OPTIONAL_OFFSET( GlyphAssembly );
00330     vcnt = FT_NEXT_USHORT( p );
00331 
00332     OTV_LIMIT_CHECK( 4 * vcnt );
00333     table_size = 4 + 4 * vcnt;
00334 
00335     for ( i = 0; i < vcnt; ++i )
00336     {
00337       FT_UInt  gid;
00338 
00339 
00340       gid = FT_NEXT_USHORT( p );
00341       if ( gid >= valid->glyph_count )
00342         FT_INVALID_GLYPH_ID;
00343       p += 2;                          /* skip the size */
00344     }
00345 
00346     OTV_SIZE_CHECK( GlyphAssembly );
00347     if ( GlyphAssembly )
00348       otv_GlyphAssembly_validate( table+GlyphAssembly, valid );
00349 
00350     /* OTV_EXIT; */
00351   }
00352 
00353 
00354   static void
00355   otv_MathVariants_validate( FT_Bytes       table,
00356                              OTV_Validator  valid )
00357   {
00358     FT_Bytes  p = table;
00359     FT_UInt   vcnt, hcnt, i, table_size;
00360 
00361     OTV_OPTIONAL_TABLE( VCoverage );
00362     OTV_OPTIONAL_TABLE( HCoverage );
00363     OTV_OPTIONAL_TABLE( Offset );
00364 
00365 
00366     OTV_NAME_ENTER( "MathVariants" );
00367 
00368     OTV_LIMIT_CHECK( 10 );
00369 
00370     p += 2;                       /* Skip the MinConnectorOverlap constant */
00371     OTV_OPTIONAL_OFFSET( VCoverage );
00372     OTV_OPTIONAL_OFFSET( HCoverage );
00373     vcnt = FT_NEXT_USHORT( p );
00374     hcnt = FT_NEXT_USHORT( p );
00375 
00376     OTV_LIMIT_CHECK( 2 * vcnt + 2 * hcnt );
00377     table_size = 10 + 2 * vcnt + 2 * hcnt;
00378 
00379     OTV_SIZE_CHECK( VCoverage );
00380     if ( VCoverage )
00381       otv_Coverage_validate( table + VCoverage, valid, vcnt );
00382 
00383     OTV_SIZE_CHECK( HCoverage );
00384     if ( HCoverage )
00385       otv_Coverage_validate( table + HCoverage, valid, hcnt );
00386 
00387     for ( i = 0; i < vcnt; ++i )
00388     {
00389       OTV_OPTIONAL_OFFSET( Offset );
00390       OTV_SIZE_CHECK( Offset );
00391       otv_MathGlyphConstruction_validate( table + Offset, valid );
00392     }
00393 
00394     for ( i = 0; i < hcnt; ++i )
00395     {
00396       OTV_OPTIONAL_OFFSET( Offset );
00397       OTV_SIZE_CHECK( Offset );
00398       otv_MathGlyphConstruction_validate( table + Offset, valid );
00399     }
00400 
00401     OTV_EXIT;
00402   }
00403 
00404 
00405   /*************************************************************************/
00406   /*************************************************************************/
00407   /*****                                                               *****/
00408   /*****                          MATH TABLE                           *****/
00409   /*****                                                               *****/
00410   /*************************************************************************/
00411   /*************************************************************************/
00412 
00413   /* sets valid->glyph_count */
00414 
00415   FT_LOCAL_DEF( void )
00416   otv_MATH_validate( FT_Bytes      table,
00417                      FT_UInt       glyph_count,
00418                      FT_Validator  ftvalid )
00419   {
00420     OTV_ValidatorRec  validrec;
00421     OTV_Validator     valid = &validrec;
00422     FT_Bytes          p     = table;
00423     FT_UInt           MathConstants, MathGlyphInfo, MathVariants;
00424 
00425 
00426     valid->root = ftvalid;
00427 
00428     FT_TRACE3(( "validating MATH table\n" ));
00429     OTV_INIT;
00430 
00431     OTV_LIMIT_CHECK( 10 );
00432 
00433     if ( FT_NEXT_ULONG( p ) != 0x10000UL )      /* Version */
00434       FT_INVALID_FORMAT;
00435 
00436     MathConstants = FT_NEXT_USHORT( p );
00437     MathGlyphInfo = FT_NEXT_USHORT( p );
00438     MathVariants  = FT_NEXT_USHORT( p );
00439 
00440     valid->glyph_count = glyph_count;
00441 
00442     otv_MathConstants_validate( table + MathConstants,
00443                                 valid );
00444     otv_MathGlyphInfo_validate( table + MathGlyphInfo,
00445                                 valid );
00446     otv_MathVariants_validate ( table + MathVariants,
00447                                 valid );
00448 
00449     FT_TRACE4(( "\n" ));
00450   }
00451 
00452 
00453 /* END */

Generated on Sun May 27 2012 04:33:52 for ReactOS by doxygen 1.7.6.1

ReactOS is a registered trademark or a trademark of ReactOS Foundation in the United States and other countries.