← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/freetype/src/otvalid/otvmath.c

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/freetype/src/otvalid/otvmath.c
 
1
/***************************************************************************/
 
2
/*                                                                         */
 
3
/*  otvmath.c                                                              */
 
4
/*                                                                         */
 
5
/*    OpenType MATH table validation (body).                               */
 
6
/*                                                                         */
 
7
/*  Copyright 2007, 2008 by                                                */
 
8
/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 
9
/*                                                                         */
 
10
/*  Written by George Williams.                                            */
 
11
/*                                                                         */
 
12
/*  This file is part of the FreeType project, and may only be used,       */
 
13
/*  modified, and distributed under the terms of the FreeType project      */
 
14
/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
 
15
/*  this file you indicate that you have read the license and              */
 
16
/*  understand and accept it fully.                                        */
 
17
/*                                                                         */
 
18
/***************************************************************************/
 
19
 
 
20
 
 
21
#include "otvalid.h"
 
22
#include "otvcommn.h"
 
23
#include "otvgpos.h"
 
24
 
 
25
 
 
26
  /*************************************************************************/
 
27
  /*                                                                       */
 
28
  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
 
29
  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
 
30
  /* messages during execution.                                            */
 
31
  /*                                                                       */
 
32
#undef  FT_COMPONENT
 
33
#define FT_COMPONENT  trace_otvmath
 
34
 
 
35
 
 
36
 
 
37
  /*************************************************************************/
 
38
  /*************************************************************************/
 
39
  /*****                                                               *****/
 
40
  /*****                  MATH TYPOGRAPHIC CONSTANTS                   *****/
 
41
  /*****                                                               *****/
 
42
  /*************************************************************************/
 
43
  /*************************************************************************/
 
44
 
 
45
  static void
 
46
  otv_MathConstants_validate( FT_Bytes       table,
 
47
                              OTV_Validator  valid )
 
48
  {
 
49
    FT_Bytes  p = table;
 
50
    FT_UInt   i;
 
51
    FT_UInt   table_size;
 
52
 
 
53
    OTV_OPTIONAL_TABLE( DeviceTableOffset );
 
54
 
 
55
 
 
56
    OTV_NAME_ENTER( "MathConstants" );
 
57
 
 
58
    /* 56 constants, 51 have device tables */
 
59
    OTV_LIMIT_CHECK( 2 * ( 56 + 51 ) );
 
60
    table_size = 2 * ( 56 + 51 );
 
61
 
 
62
    p += 4 * 2;                 /* First 4 constants have no device tables */
 
63
    for ( i = 0; i < 51; ++i )
 
64
    {
 
65
      p += 2;                                            /* skip the value */
 
66
      OTV_OPTIONAL_OFFSET( DeviceTableOffset );
 
67
      OTV_SIZE_CHECK( DeviceTableOffset );
 
68
      if ( DeviceTableOffset )
 
69
        otv_Device_validate( table + DeviceTableOffset, valid );
 
70
    }
 
71
 
 
72
    OTV_EXIT;
 
73
  }
 
74
 
 
75
 
 
76
  /*************************************************************************/
 
77
  /*************************************************************************/
 
78
  /*****                                                               *****/
 
79
  /*****                   MATH ITALICS CORRECTION                     *****/
 
80
  /*****                 MATH TOP ACCENT ATTACHMENT                    *****/
 
81
  /*****                                                               *****/
 
82
  /*************************************************************************/
 
83
  /*************************************************************************/
 
84
 
 
85
  static void
 
86
  otv_MathItalicsCorrectionInfo_validate( FT_Bytes       table,
 
87
                                          OTV_Validator  valid,
 
88
                                          FT_Int         isItalic )
 
89
  {
 
90
    FT_Bytes  p = table;
 
91
    FT_UInt   i, cnt, table_size ;
 
92
 
 
93
    OTV_OPTIONAL_TABLE( Coverage );
 
94
    OTV_OPTIONAL_TABLE( DeviceTableOffset );
 
95
 
 
96
    FT_UNUSED( isItalic );  /* only used if tracing is active */
 
97
 
 
98
 
 
99
    OTV_NAME_ENTER( isItalic ? "MathItalicsCorrectionInfo"
 
100
                             : "MathTopAccentAttachment" );
 
101
 
 
102
    OTV_LIMIT_CHECK( 4 );
 
103
 
 
104
    OTV_OPTIONAL_OFFSET( Coverage );
 
105
    cnt = FT_NEXT_USHORT( p );
 
106
 
 
107
    OTV_LIMIT_CHECK( 4 * cnt );
 
108
    table_size = 4 + 4 * cnt;
 
109
 
 
110
    OTV_SIZE_CHECK( Coverage );
 
111
    otv_Coverage_validate( table + Coverage, valid, cnt );
 
112
 
 
113
    for ( i = 0; i < cnt; ++i )
 
114
    {
 
115
      p += 2;                                            /* Skip the value */
 
116
      OTV_OPTIONAL_OFFSET( DeviceTableOffset );
 
117
      OTV_SIZE_CHECK( DeviceTableOffset );
 
118
      if ( DeviceTableOffset )
 
119
        otv_Device_validate( table + DeviceTableOffset, valid );
 
120
    }
 
121
 
 
122
    OTV_EXIT;
 
123
  }
 
124
 
 
125
 
 
126
  /*************************************************************************/
 
127
  /*************************************************************************/
 
128
  /*****                                                               *****/
 
129
  /*****                           MATH KERNING                        *****/
 
130
  /*****                                                               *****/
 
131
  /*************************************************************************/
 
132
  /*************************************************************************/
 
133
 
 
134
  static void
 
135
  otv_MathKern_validate( FT_Bytes       table,
 
136
                         OTV_Validator  valid )
 
137
  {
 
138
    FT_Bytes  p = table;
 
139
    FT_UInt   i, cnt, table_size;
 
140
 
 
141
    OTV_OPTIONAL_TABLE( DeviceTableOffset );
 
142
 
 
143
 
 
144
    /* OTV_NAME_ENTER( "MathKern" );*/
 
145
 
 
146
    OTV_LIMIT_CHECK( 2 );
 
147
 
 
148
    cnt = FT_NEXT_USHORT( p );
 
149
 
 
150
    OTV_LIMIT_CHECK( 4 * cnt + 2 );
 
151
    table_size = 4 + 4 * cnt;
 
152
 
 
153
    /* Heights */
 
154
    for ( i = 0; i < cnt; ++i )
 
155
    {
 
156
      p += 2;                                            /* Skip the value */
 
157
      OTV_OPTIONAL_OFFSET( DeviceTableOffset );
 
158
      OTV_SIZE_CHECK( DeviceTableOffset );
 
159
      if ( DeviceTableOffset )
 
160
        otv_Device_validate( table + DeviceTableOffset, valid );
 
161
    }
 
162
 
 
163
    /* One more Kerning value */
 
164
    for ( i = 0; i < cnt + 1; ++i )
 
165
    {
 
166
      p += 2;                                            /* Skip the value */
 
167
      OTV_OPTIONAL_OFFSET( DeviceTableOffset );
 
168
      OTV_SIZE_CHECK( DeviceTableOffset );
 
169
      if ( DeviceTableOffset )
 
170
        otv_Device_validate( table + DeviceTableOffset, valid );
 
171
    }
 
172
 
 
173
    OTV_EXIT;
 
174
  }
 
175
 
 
176
 
 
177
  static void
 
178
  otv_MathKernInfo_validate( FT_Bytes       table,
 
179
                             OTV_Validator  valid )
 
180
  {
 
181
    FT_Bytes  p = table;
 
182
    FT_UInt   i, j, cnt, table_size;
 
183
 
 
184
    OTV_OPTIONAL_TABLE( Coverage );
 
185
    OTV_OPTIONAL_TABLE( MKRecordOffset );
 
186
 
 
187
 
 
188
    OTV_NAME_ENTER( "MathKernInfo" );
 
189
 
 
190
    OTV_LIMIT_CHECK( 4 );
 
191
 
 
192
    OTV_OPTIONAL_OFFSET( Coverage );
 
193
    cnt = FT_NEXT_USHORT( p );
 
194
 
 
195
    OTV_LIMIT_CHECK( 8 * cnt );
 
196
    table_size = 4 + 8 * cnt;
 
197
 
 
198
    OTV_SIZE_CHECK( Coverage );
 
199
    otv_Coverage_validate( table + Coverage, valid, cnt );
 
200
 
 
201
    for ( i = 0; i < cnt; ++i )
 
202
    {
 
203
      for ( j = 0; j < 4; ++j )
 
204
      {
 
205
        OTV_OPTIONAL_OFFSET( MKRecordOffset );
 
206
        OTV_SIZE_CHECK( MKRecordOffset );
 
207
        if ( MKRecordOffset )
 
208
          otv_MathKern_validate( table + MKRecordOffset, valid );
 
209
      }
 
210
    }
 
211
 
 
212
    OTV_EXIT;
 
213
  }
 
214
 
 
215
 
 
216
  /*************************************************************************/
 
217
  /*************************************************************************/
 
218
  /*****                                                               *****/
 
219
  /*****                         MATH GLYPH INFO                       *****/
 
220
  /*****                                                               *****/
 
221
  /*************************************************************************/
 
222
  /*************************************************************************/
 
223
 
 
224
  static void
 
225
  otv_MathGlyphInfo_validate( FT_Bytes       table,
 
226
                              OTV_Validator  valid )
 
227
  {
 
228
    FT_Bytes  p = table;
 
229
    FT_UInt   MathItalicsCorrectionInfo, MathTopAccentAttachment;
 
230
    FT_UInt   ExtendedShapeCoverage, MathKernInfo;
 
231
 
 
232
 
 
233
    OTV_NAME_ENTER( "MathGlyphInfo" );
 
234
 
 
235
    OTV_LIMIT_CHECK( 8 );
 
236
 
 
237
    MathItalicsCorrectionInfo = FT_NEXT_USHORT( p );
 
238
    MathTopAccentAttachment   = FT_NEXT_USHORT( p );
 
239
    ExtendedShapeCoverage     = FT_NEXT_USHORT( p );
 
240
    MathKernInfo              = FT_NEXT_USHORT( p );
 
241
 
 
242
    if ( MathItalicsCorrectionInfo )
 
243
      otv_MathItalicsCorrectionInfo_validate(
 
244
        table + MathItalicsCorrectionInfo, valid, TRUE );
 
245
 
 
246
    /* Italic correction and Top Accent Attachment have the same format */
 
247
    if ( MathTopAccentAttachment )
 
248
      otv_MathItalicsCorrectionInfo_validate(
 
249
        table + MathTopAccentAttachment, valid, FALSE );
 
250
 
 
251
    if ( ExtendedShapeCoverage )
 
252
    {
 
253
      OTV_NAME_ENTER( "ExtendedShapeCoverage" );
 
254
      otv_Coverage_validate( table + ExtendedShapeCoverage, valid, -1 );
 
255
      OTV_EXIT;
 
256
    }
 
257
 
 
258
    if ( MathKernInfo )
 
259
      otv_MathKernInfo_validate( table + MathKernInfo, valid );
 
260
 
 
261
    OTV_EXIT;
 
262
  }
 
263
 
 
264
 
 
265
  /*************************************************************************/
 
266
  /*************************************************************************/
 
267
  /*****                                                               *****/
 
268
  /*****                    MATH GLYPH CONSTRUCTION                    *****/
 
269
  /*****                                                               *****/
 
270
  /*************************************************************************/
 
271
  /*************************************************************************/
 
272
 
 
273
  static void
 
274
  otv_GlyphAssembly_validate( FT_Bytes       table,
 
275
                              OTV_Validator  valid )
 
276
  {
 
277
    FT_Bytes  p = table;
 
278
    FT_UInt   pcnt, table_size;
 
279
    FT_UInt   i;
 
280
 
 
281
    OTV_OPTIONAL_TABLE( DeviceTableOffset );
 
282
 
 
283
 
 
284
    /* OTV_NAME_ENTER( "GlyphAssembly" ); */
 
285
 
 
286
    OTV_LIMIT_CHECK( 6 );
 
287
 
 
288
    p += 2;                           /* Skip the Italics Correction value */
 
289
    OTV_OPTIONAL_OFFSET( DeviceTableOffset );
 
290
    pcnt = FT_NEXT_USHORT( p );
 
291
 
 
292
    OTV_LIMIT_CHECK( 8 * pcnt );
 
293
    table_size = 6 + 8 * pcnt;
 
294
 
 
295
    OTV_SIZE_CHECK( DeviceTableOffset );
 
296
    if ( DeviceTableOffset )
 
297
      otv_Device_validate( table + DeviceTableOffset, valid );
 
298
 
 
299
    for ( i = 0; i < pcnt; ++i )
 
300
    {
 
301
      FT_UInt  gid;
 
302
 
 
303
 
 
304
      gid = FT_NEXT_USHORT( p );
 
305
      if ( gid >= valid->glyph_count )
 
306
        FT_INVALID_GLYPH_ID;
 
307
      p += 2*4;             /* skip the Start, End, Full, and Flags fields */
 
308
    }
 
309
 
 
310
    /* OTV_EXIT; */
 
311
  }
 
312
 
 
313
 
 
314
  static void
 
315
  otv_MathGlyphConstruction_validate( FT_Bytes       table,
 
316
                                      OTV_Validator  valid )
 
317
  {
 
318
    FT_Bytes  p = table;
 
319
    FT_UInt   vcnt, table_size;
 
320
    FT_UInt   i;
 
321
 
 
322
    OTV_OPTIONAL_TABLE( GlyphAssembly );
 
323
 
 
324
 
 
325
    /* OTV_NAME_ENTER( "MathGlyphConstruction" ); */
 
326
 
 
327
    OTV_LIMIT_CHECK( 4 );
 
328
 
 
329
    OTV_OPTIONAL_OFFSET( GlyphAssembly );
 
330
    vcnt = FT_NEXT_USHORT( p );
 
331
 
 
332
    OTV_LIMIT_CHECK( 4 * vcnt );
 
333
    table_size = 4 + 4 * vcnt;
 
334
 
 
335
    for ( i = 0; i < vcnt; ++i )
 
336
    {
 
337
      FT_UInt  gid;
 
338
 
 
339
 
 
340
      gid = FT_NEXT_USHORT( p );
 
341
      if ( gid >= valid->glyph_count )
 
342
        FT_INVALID_GLYPH_ID;
 
343
      p += 2;                          /* skip the size */
 
344
    }
 
345
 
 
346
    OTV_SIZE_CHECK( GlyphAssembly );
 
347
    if ( GlyphAssembly )
 
348
      otv_GlyphAssembly_validate( table+GlyphAssembly, valid );
 
349
 
 
350
    /* OTV_EXIT; */
 
351
  }
 
352
 
 
353
 
 
354
  static void
 
355
  otv_MathVariants_validate( FT_Bytes       table,
 
356
                             OTV_Validator  valid )
 
357
  {
 
358
    FT_Bytes  p = table;
 
359
    FT_UInt   vcnt, hcnt, i, table_size;
 
360
 
 
361
    OTV_OPTIONAL_TABLE( VCoverage );
 
362
    OTV_OPTIONAL_TABLE( HCoverage );
 
363
    OTV_OPTIONAL_TABLE( Offset );
 
364
 
 
365
 
 
366
    OTV_NAME_ENTER( "MathVariants" );
 
367
 
 
368
    OTV_LIMIT_CHECK( 10 );
 
369
 
 
370
    p += 2;                       /* Skip the MinConnectorOverlap constant */
 
371
    OTV_OPTIONAL_OFFSET( VCoverage );
 
372
    OTV_OPTIONAL_OFFSET( HCoverage );
 
373
    vcnt = FT_NEXT_USHORT( p );
 
374
    hcnt = FT_NEXT_USHORT( p );
 
375
 
 
376
    OTV_LIMIT_CHECK( 2 * vcnt + 2 * hcnt );
 
377
    table_size = 10 + 2 * vcnt + 2 * hcnt;
 
378
 
 
379
    OTV_SIZE_CHECK( VCoverage );
 
380
    if ( VCoverage )
 
381
      otv_Coverage_validate( table + VCoverage, valid, vcnt );
 
382
 
 
383
    OTV_SIZE_CHECK( HCoverage );
 
384
    if ( HCoverage )
 
385
      otv_Coverage_validate( table + HCoverage, valid, hcnt );
 
386
 
 
387
    for ( i = 0; i < vcnt; ++i )
 
388
    {
 
389
      OTV_OPTIONAL_OFFSET( Offset );
 
390
      OTV_SIZE_CHECK( Offset );
 
391
      otv_MathGlyphConstruction_validate( table + Offset, valid );
 
392
    }
 
393
 
 
394
    for ( i = 0; i < hcnt; ++i )
 
395
    {
 
396
      OTV_OPTIONAL_OFFSET( Offset );
 
397
      OTV_SIZE_CHECK( Offset );
 
398
      otv_MathGlyphConstruction_validate( table + Offset, valid );
 
399
    }
 
400
 
 
401
    OTV_EXIT;
 
402
  }
 
403
 
 
404
 
 
405
  /*************************************************************************/
 
406
  /*************************************************************************/
 
407
  /*****                                                               *****/
 
408
  /*****                          MATH TABLE                           *****/
 
409
  /*****                                                               *****/
 
410
  /*************************************************************************/
 
411
  /*************************************************************************/
 
412
 
 
413
  /* sets valid->glyph_count */
 
414
 
 
415
  FT_LOCAL_DEF( void )
 
416
  otv_MATH_validate( FT_Bytes      table,
 
417
                     FT_UInt       glyph_count,
 
418
                     FT_Validator  ftvalid )
 
419
  {
 
420
    OTV_ValidatorRec  validrec;
 
421
    OTV_Validator     valid = &validrec;
 
422
    FT_Bytes          p     = table;
 
423
    FT_UInt           MathConstants, MathGlyphInfo, MathVariants;
 
424
 
 
425
 
 
426
    valid->root = ftvalid;
 
427
 
 
428
    FT_TRACE3(( "validating MATH table\n" ));
 
429
    OTV_INIT;
 
430
 
 
431
    OTV_LIMIT_CHECK( 10 );
 
432
 
 
433
    if ( FT_NEXT_ULONG( p ) != 0x10000UL )      /* Version */
 
434
      FT_INVALID_FORMAT;
 
435
 
 
436
    MathConstants = FT_NEXT_USHORT( p );
 
437
    MathGlyphInfo = FT_NEXT_USHORT( p );
 
438
    MathVariants  = FT_NEXT_USHORT( p );
 
439
 
 
440
    valid->glyph_count = glyph_count;
 
441
 
 
442
    otv_MathConstants_validate( table + MathConstants,
 
443
                                valid );
 
444
    otv_MathGlyphInfo_validate( table + MathGlyphInfo,
 
445
                                valid );
 
446
    otv_MathVariants_validate ( table + MathVariants,
 
447
                                valid );
 
448
 
 
449
    FT_TRACE4(( "\n" ));
 
450
  }
 
451
 
 
452
 
 
453
/* END */