w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

ttobjs.c
Go to the documentation of this file.
1 /****************************************************************************
2  *
3  * ttobjs.c
4  *
5  * Objects manager (body).
6  *
7  * Copyright (C) 1996-2020 by
8  * David Turner, Robert Wilhelm, and Werner Lemberg.
9  *
10  * This file is part of the FreeType project, and may only be used,
11  * modified, and distributed under the terms of the FreeType project
12  * license, LICENSE.TXT. By continuing to use, modify, or distribute
13  * this file you indicate that you have read the license and
14  * understand and accept it fully.
15  *
16  */
17 
18 
19 #include <freetype/internal/ftdebug.h>
20 #include <freetype/internal/ftstream.h>
21 #include <freetype/tttags.h>
22 #include <freetype/internal/sfnt.h>
23 #include <freetype/ftdriver.h>
24 
25 #include "ttgload.h"
26 #include "ttpload.h"
27 
28 #include "tterrors.h"
29 
30 #ifdef TT_USE_BYTECODE_INTERPRETER
31 #include "ttinterp.h"
32 #endif
33 
34 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
35 #include "ttgxvar.h"
36 #endif
37 
38  /**************************************************************************
39  *
40  * The macro FT_COMPONENT is used in trace mode. It is an implicit
41  * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
42  * messages during execution.
43  */
44 #undef FT_COMPONENT
45 #define FT_COMPONENT ttobjs
46 
47 
48 #ifdef TT_USE_BYTECODE_INTERPRETER
49 
50  /**************************************************************************
51  *
52  * GLYPH ZONE FUNCTIONS
53  *
54  */
55 
56 
57  /**************************************************************************
58  *
59  * @Function:
60  * tt_glyphzone_done
61  *
62  * @Description:
63  * Deallocate a glyph zone.
64  *
65  * @Input:
66  * zone ::
67  * A pointer to the target glyph zone.
68  */
69  FT_LOCAL_DEF( void )
70  tt_glyphzone_done( TT_GlyphZone zone )
71  {
72  FT_Memory memory = zone->memory;
73 
74 
75  if ( memory )
76  {
77  FT_FREE( zone->contours );
78  FT_FREE( zone->tags );
79  FT_FREE( zone->cur );
80  FT_FREE( zone->org );
81  FT_FREE( zone->orus );
82 
83  zone->max_points = zone->n_points = 0;
84  zone->max_contours = zone->n_contours = 0;
85  zone->memory = NULL;
86  }
87  }
88 
89 
90  /**************************************************************************
91  *
92  * @Function:
93  * tt_glyphzone_new
94  *
95  * @Description:
96  * Allocate a new glyph zone.
97  *
98  * @Input:
99  * memory ::
100  * A handle to the current memory object.
101  *
102  * maxPoints ::
103  * The capacity of glyph zone in points.
104  *
105  * maxContours ::
106  * The capacity of glyph zone in contours.
107  *
108  * @Output:
109  * zone ::
110  * A pointer to the target glyph zone record.
111  *
112  * @Return:
113  * FreeType error code. 0 means success.
114  */
116  tt_glyphzone_new( FT_Memory memory,
118  FT_Short maxContours,
120  {
121  FT_Error error;
122 
123 
124  FT_ZERO( zone );
125  zone->memory = memory;
126 
127  if ( FT_NEW_ARRAY( zone->org, maxPoints ) ||
128  FT_NEW_ARRAY( zone->cur, maxPoints ) ||
129  FT_NEW_ARRAY( zone->orus, maxPoints ) ||
130  FT_NEW_ARRAY( zone->tags, maxPoints ) ||
131  FT_NEW_ARRAY( zone->contours, maxContours ) )
132  {
133  tt_glyphzone_done( zone );
134  }
135  else
136  {
137  zone->max_points = maxPoints;
138  zone->max_contours = maxContours;
139  }
140 
141  return error;
142  }
143 #endif /* TT_USE_BYTECODE_INTERPRETER */
144 
145 
146  /* Compare the face with a list of well-known `tricky' fonts. */
147  /* This list shall be expanded as we find more of them. */
148 
149  static FT_Bool
151  {
152 
153 #define TRICK_NAMES_MAX_CHARACTERS 19
154 #define TRICK_NAMES_COUNT 26
155 
156  static const char trick_names[TRICK_NAMES_COUNT]
158  {
159  /*
160  PostScript names are given in brackets if they differ from the
161  family name. The version numbers, together with the copyright or
162  release year data, are taken from fonts available to the
163  developers.
164 
165  Note that later versions of the fonts might be no longer tricky;
166  for example, `MingLiU' version 7.00 (file `mingliu.ttc' from
167  Windows 7) is an ordinary TTC with non-tricky subfonts.
168  */
169 
170  "cpop", /* dftt-p7.ttf; version 1.00, 1992 [DLJGyShoMedium] */
171  "DFGirl-W6-WIN-BF", /* dftt-h6.ttf; version 1.00, 1993 */
172  "DFGothic-EB", /* DynaLab Inc. 1992-1995 */
173  "DFGyoSho-Lt", /* DynaLab Inc. 1992-1995 */
174  "DFHei-Md-HK-BF", /* maybe DynaLab Inc. */
175  "DFHSGothic-W5", /* DynaLab Inc. 1992-1995 */
176  "DFHSMincho-W3", /* DynaLab Inc. 1992-1995 */
177  "DFHSMincho-W7", /* DynaLab Inc. 1992-1995 */
178  "DFKaiSho-SB", /* dfkaisb.ttf */
179  "DFKaiShu",
180  "DFKaiShu-Md-HK-BF", /* maybe DynaLab Inc. */
181  "DFKai-SB", /* kaiu.ttf; version 3.00, 1998 [DFKaiShu-SB-Estd-BF] */
182  "DFMing-Bd-HK-BF", /* maybe DynaLab Inc. */
183  "DLC", /* dftt-m7.ttf; version 1.00, 1993 [DLCMingBold] */
184  /* dftt-f5.ttf; version 1.00, 1993 [DLCFongSung] */
185  "DLCHayMedium", /* dftt-b5.ttf; version 1.00, 1993 */
186  "DLCHayBold", /* dftt-b7.ttf; version 1.00, 1993 */
187  "DLCKaiMedium", /* dftt-k5.ttf; version 1.00, 1992 */
188  "DLCLiShu", /* dftt-l5.ttf; version 1.00, 1992 */
189  "DLCRoundBold", /* dftt-r7.ttf; version 1.00, 1993 */
190  "HuaTianKaiTi?", /* htkt2.ttf */
191  "HuaTianSongTi?", /* htst3.ttf */
192  "Ming(for ISO10646)", /* hkscsiic.ttf; version 0.12, 2007 [Ming] */
193  /* iicore.ttf; version 0.07, 2007 [Ming] */
194  "MingLiU", /* mingliu.ttf */
195  /* mingliu.ttc; version 3.21, 2001 */
196  "MingMedium", /* dftt-m5.ttf; version 1.00, 1993 [DLCMingMedium] */
197  "PMingLiU", /* mingliu.ttc; version 3.21, 2001 */
198  "MingLi43", /* mingli.ttf; version 1.00, 1992 */
199  };
200 
201  int nn;
202 
203 
204  for ( nn = 0; nn < TRICK_NAMES_COUNT; nn++ )
205  if ( ft_strstr( name, trick_names[nn] ) )
206  return TRUE;
207 
208  return FALSE;
209  }
210 
211 
212  /* XXX: This function should be in the `sfnt' module. */
213 
214  /* Some PDF generators clear the checksums in the TrueType header table. */
215  /* For example, Quartz ContextPDF clears all entries, or Bullzip PDF */
216  /* Printer clears the entries for subsetted subtables. We thus have to */
217  /* recalculate the checksums where necessary. */
218 
219  static FT_UInt32
221  FT_ULong length )
222  {
223  FT_Error error;
224  FT_UInt32 checksum = 0;
225  FT_UInt i;
226 
227 
228  if ( FT_FRAME_ENTER( length ) )
229  return 0;
230 
231  for ( ; length > 3; length -= 4 )
232  checksum += (FT_UInt32)FT_GET_ULONG();
233 
234  for ( i = 3; length > 0; length--, i-- )
235  checksum += (FT_UInt32)FT_GET_BYTE() << ( i * 8 );
236 
237  FT_FRAME_EXIT();
238 
239  return checksum;
240  }
241 
242 
243  /* XXX: This function should be in the `sfnt' module. */
244 
245  static FT_ULong
247  FT_UShort i )
248  {
249 #if 0 /* if we believe the written value, use following part. */
250  if ( face->dir_tables[i].CheckSum )
251  return face->dir_tables[i].CheckSum;
252 #endif
253 
254  if ( !face->goto_table )
255  return 0;
256 
257  if ( face->goto_table( face,
258  face->dir_tables[i].Tag,
259  face->root.stream,
260  NULL ) )
261  return 0;
262 
264  face->dir_tables[i].Length );
265  }
266 
267 
268  typedef struct tt_sfnt_id_rec_
269  {
272 
274 
275 
276  static FT_Bool
278  {
279 #define TRICK_SFNT_IDS_PER_FACE 3
280 #define TRICK_SFNT_IDS_NUM_FACES 29
281 
282  static const tt_sfnt_id_rec sfnt_id[TRICK_SFNT_IDS_NUM_FACES]
284 
285 #define TRICK_SFNT_ID_cvt 0
286 #define TRICK_SFNT_ID_fpgm 1
287 #define TRICK_SFNT_ID_prep 2
288 
289  { /* MingLiU 1995 */
290  { 0x05BCF058UL, 0x000002E4UL }, /* cvt */
291  { 0x28233BF1UL, 0x000087C4UL }, /* fpgm */
292  { 0xA344A1EAUL, 0x000001E1UL } /* prep */
293  },
294  { /* MingLiU 1996- */
295  { 0x05BCF058UL, 0x000002E4UL }, /* cvt */
296  { 0x28233BF1UL, 0x000087C4UL }, /* fpgm */
297  { 0xA344A1EBUL, 0x000001E1UL } /* prep */
298  },
299  { /* DFGothic-EB */
300  { 0x12C3EBB2UL, 0x00000350UL }, /* cvt */
301  { 0xB680EE64UL, 0x000087A7UL }, /* fpgm */
302  { 0xCE939563UL, 0x00000758UL } /* prep */
303  },
304  { /* DFGyoSho-Lt */
305  { 0x11E5EAD4UL, 0x00000350UL }, /* cvt */
306  { 0xCE5956E9UL, 0x0000BC85UL }, /* fpgm */
307  { 0x8272F416UL, 0x00000045UL } /* prep */
308  },
309  { /* DFHei-Md-HK-BF */
310  { 0x1257EB46UL, 0x00000350UL }, /* cvt */
311  { 0xF699D160UL, 0x0000715FUL }, /* fpgm */
312  { 0xD222F568UL, 0x000003BCUL } /* prep */
313  },
314  { /* DFHSGothic-W5 */
315  { 0x1262EB4EUL, 0x00000350UL }, /* cvt */
316  { 0xE86A5D64UL, 0x00007940UL }, /* fpgm */
317  { 0x7850F729UL, 0x000005FFUL } /* prep */
318  },
319  { /* DFHSMincho-W3 */
320  { 0x122DEB0AUL, 0x00000350UL }, /* cvt */
321  { 0x3D16328AUL, 0x0000859BUL }, /* fpgm */
322  { 0xA93FC33BUL, 0x000002CBUL } /* prep */
323  },
324  { /* DFHSMincho-W7 */
325  { 0x125FEB26UL, 0x00000350UL }, /* cvt */
326  { 0xA5ACC982UL, 0x00007EE1UL }, /* fpgm */
327  { 0x90999196UL, 0x0000041FUL } /* prep */
328  },
329  { /* DFKaiShu */
330  { 0x11E5EAD4UL, 0x00000350UL }, /* cvt */
331  { 0x5A30CA3BUL, 0x00009063UL }, /* fpgm */
332  { 0x13A42602UL, 0x0000007EUL } /* prep */
333  },
334  { /* DFKaiShu, variant */
335  { 0x11E5EAD4UL, 0x00000350UL }, /* cvt */
336  { 0xA6E78C01UL, 0x00008998UL }, /* fpgm */
337  { 0x13A42602UL, 0x0000007EUL } /* prep */
338  },
339  { /* DFKaiShu-Md-HK-BF */
340  { 0x11E5EAD4UL, 0x00000360UL }, /* cvt */
341  { 0x9DB282B2UL, 0x0000C06EUL }, /* fpgm */
342  { 0x53E6D7CAUL, 0x00000082UL } /* prep */
343  },
344  { /* DFMing-Bd-HK-BF */
345  { 0x1243EB18UL, 0x00000350UL }, /* cvt */
346  { 0xBA0A8C30UL, 0x000074ADUL }, /* fpgm */
347  { 0xF3D83409UL, 0x0000037BUL } /* prep */
348  },
349  { /* DLCLiShu */
350  { 0x07DCF546UL, 0x00000308UL }, /* cvt */
351  { 0x40FE7C90UL, 0x00008E2AUL }, /* fpgm */
352  { 0x608174B5UL, 0x0000007AUL } /* prep */
353  },
354  { /* DLCHayBold */
355  { 0xEB891238UL, 0x00000308UL }, /* cvt */
356  { 0xD2E4DCD4UL, 0x0000676FUL }, /* fpgm */
357  { 0x8EA5F293UL, 0x000003B8UL } /* prep */
358  },
359  { /* HuaTianKaiTi */
360  { 0xFFFBFFFCUL, 0x00000008UL }, /* cvt */
361  { 0x9C9E48B8UL, 0x0000BEA2UL }, /* fpgm */
362  { 0x70020112UL, 0x00000008UL } /* prep */
363  },
364  { /* HuaTianSongTi */
365  { 0xFFFBFFFCUL, 0x00000008UL }, /* cvt */
366  { 0x0A5A0483UL, 0x00017C39UL }, /* fpgm */
367  { 0x70020112UL, 0x00000008UL } /* prep */
368  },
369  { /* NEC fadpop7.ttf */
370  { 0x00000000UL, 0x00000000UL }, /* cvt */
371  { 0x40C92555UL, 0x000000E5UL }, /* fpgm */
372  { 0xA39B58E3UL, 0x0000117CUL } /* prep */
373  },
374  { /* NEC fadrei5.ttf */
375  { 0x00000000UL, 0x00000000UL }, /* cvt */
376  { 0x33C41652UL, 0x000000E5UL }, /* fpgm */
377  { 0x26D6C52AUL, 0x00000F6AUL } /* prep */
378  },
379  { /* NEC fangot7.ttf */
380  { 0x00000000UL, 0x00000000UL }, /* cvt */
381  { 0x6DB1651DUL, 0x0000019DUL }, /* fpgm */
382  { 0x6C6E4B03UL, 0x00002492UL } /* prep */
383  },
384  { /* NEC fangyo5.ttf */
385  { 0x00000000UL, 0x00000000UL }, /* cvt */
386  { 0x40C92555UL, 0x000000E5UL }, /* fpgm */
387  { 0xDE51FAD0UL, 0x0000117CUL } /* prep */
388  },
389  { /* NEC fankyo5.ttf */
390  { 0x00000000UL, 0x00000000UL }, /* cvt */
391  { 0x85E47664UL, 0x000000E5UL }, /* fpgm */
392  { 0xA6C62831UL, 0x00001CAAUL } /* prep */
393  },
394  { /* NEC fanrgo5.ttf */
395  { 0x00000000UL, 0x00000000UL }, /* cvt */
396  { 0x2D891CFDUL, 0x0000019DUL }, /* fpgm */
397  { 0xA0604633UL, 0x00001DE8UL } /* prep */
398  },
399  { /* NEC fangot5.ttc */
400  { 0x00000000UL, 0x00000000UL }, /* cvt */
401  { 0x40AA774CUL, 0x000001CBUL }, /* fpgm */
402  { 0x9B5CAA96UL, 0x00001F9AUL } /* prep */
403  },
404  { /* NEC fanmin3.ttc */
405  { 0x00000000UL, 0x00000000UL }, /* cvt */
406  { 0x0D3DE9CBUL, 0x00000141UL }, /* fpgm */
407  { 0xD4127766UL, 0x00002280UL } /* prep */
408  },
409  { /* NEC FA-Gothic, 1996 */
410  { 0x00000000UL, 0x00000000UL }, /* cvt */
411  { 0x4A692698UL, 0x000001F0UL }, /* fpgm */
412  { 0x340D4346UL, 0x00001FCAUL } /* prep */
413  },
414  { /* NEC FA-Minchou, 1996 */
415  { 0x00000000UL, 0x00000000UL }, /* cvt */
416  { 0xCD34C604UL, 0x00000166UL }, /* fpgm */
417  { 0x6CF31046UL, 0x000022B0UL } /* prep */
418  },
419  { /* NEC FA-RoundGothicB, 1996 */
420  { 0x00000000UL, 0x00000000UL }, /* cvt */
421  { 0x5DA75315UL, 0x0000019DUL }, /* fpgm */
422  { 0x40745A5FUL, 0x000022E0UL } /* prep */
423  },
424  { /* NEC FA-RoundGothicM, 1996 */
425  { 0x00000000UL, 0x00000000UL }, /* cvt */
426  { 0xF055FC48UL, 0x000001C2UL }, /* fpgm */
427  { 0x3900DED3UL, 0x00001E18UL } /* prep */
428  },
429  { /* MINGLI.TTF, 1992 */
430  { 0x00170003UL, 0x00000060UL }, /* cvt */
431  { 0xDBB4306EUL, 0x000058AAUL }, /* fpgm */
432  { 0xD643482AUL, 0x00000035UL } /* prep */
433  }
434  };
435 
437  int num_matched_ids[TRICK_SFNT_IDS_NUM_FACES];
438  FT_Bool has_cvt, has_fpgm, has_prep;
439  FT_UShort i;
440  int j, k;
441 
442 
443  FT_MEM_SET( num_matched_ids, 0,
444  sizeof ( int ) * TRICK_SFNT_IDS_NUM_FACES );
445  has_cvt = FALSE;
446  has_fpgm = FALSE;
447  has_prep = FALSE;
448 
449  for ( i = 0; i < face->num_tables; i++ )
450  {
451  checksum = 0;
452 
453  switch( face->dir_tables[i].Tag )
454  {
455  case TTAG_cvt:
457  has_cvt = TRUE;
458  break;
459 
460  case TTAG_fpgm:
462  has_fpgm = TRUE;
463  break;
464 
465  case TTAG_prep:
467  has_prep = TRUE;
468  break;
469 
470  default:
471  continue;
472  }
473 
474  for ( j = 0; j < TRICK_SFNT_IDS_NUM_FACES; j++ )
475  if ( face->dir_tables[i].Length == sfnt_id[j][k].Length )
476  {
477  if ( !checksum )
479 
480  if ( sfnt_id[j][k].CheckSum == checksum )
481  num_matched_ids[j]++;
482 
483  if ( num_matched_ids[j] == TRICK_SFNT_IDS_PER_FACE )
484  return TRUE;
485  }
486  }
487 
488  for ( j = 0; j < TRICK_SFNT_IDS_NUM_FACES; j++ )
489  {
490  if ( !has_cvt && !sfnt_id[j][TRICK_SFNT_ID_cvt].Length )
491  num_matched_ids[j]++;
492  if ( !has_fpgm && !sfnt_id[j][TRICK_SFNT_ID_fpgm].Length )
493  num_matched_ids[j]++;
494  if ( !has_prep && !sfnt_id[j][TRICK_SFNT_ID_prep].Length )
495  num_matched_ids[j]++;
496  if ( num_matched_ids[j] == TRICK_SFNT_IDS_PER_FACE )
497  return TRUE;
498  }
499 
500  return FALSE;
501  }
502 
503 
504  static FT_Bool
506  {
507  if ( !face )
508  return FALSE;
509 
510  /* For first, check the face name for quick check. */
511  if ( face->family_name &&
513  return TRUE;
514 
515  /* Type42 fonts may lack `name' tables, we thus try to identify */
516  /* tricky fonts by checking the checksums of Type42-persistent */
517  /* sfnt tables (`cvt', `fpgm', and `prep'). */
519  return TRUE;
520 
521  return FALSE;
522  }
523 
524 
525  /* Check whether `.notdef' is the only glyph in the `loca' table. */
526  static FT_Bool
528  {
529  FT_Bool result = FALSE;
530 
531  TT_Face face = (TT_Face)ttface;
532  FT_UInt asize;
533  FT_ULong i;
534  FT_ULong glyph_index = 0;
535  FT_UInt count = 0;
536 
537 
538  for( i = 0; i < face->num_locations; i++ )
539  {
540  tt_face_get_location( face, i, &asize );
541  if ( asize > 0 )
542  {
543  count += 1;
544  if ( count > 1 )
545  break;
546  glyph_index = i;
547  }
548  }
549 
550  /* Only have a single outline. */
551  if ( count == 1 )
552  {
553  if ( glyph_index == 0 )
554  result = TRUE;
555  else
556  {
557  /* FIXME: Need to test glyphname == .notdef ? */
558  FT_Error error;
559  char buf[8];
560 
561 
562  error = FT_Get_Glyph_Name( ttface, glyph_index, buf, 8 );
563  if ( !error &&
564  buf[0] == '.' && !ft_strncmp( buf, ".notdef", 8 ) )
565  result = TRUE;
566  }
567  }
568 
569  return result;
570  }
571 
572 
573  /**************************************************************************
574  *
575  * @Function:
576  * tt_face_init
577  *
578  * @Description:
579  * Initialize a given TrueType face object.
580  *
581  * @Input:
582  * stream ::
583  * The source font stream.
584  *
585  * face_index ::
586  * The index of the TrueType font, if we are opening a
587  * collection, in bits 0-15. The numbered instance
588  * index~+~1 of a GX (sub)font, if applicable, in bits
589  * 16-30.
590  *
591  * num_params ::
592  * Number of additional generic parameters. Ignored.
593  *
594  * params ::
595  * Additional generic parameters. Ignored.
596  *
597  * @InOut:
598  * face ::
599  * The newly built face object.
600  *
601  * @Return:
602  * FreeType error code. 0 means success.
603  */
606  FT_Face ttface, /* TT_Face */
607  FT_Int face_index,
608  FT_Int num_params,
610  {
611  FT_Error error;
614  TT_Face face = (TT_Face)ttface;
615 
616 
617  FT_TRACE2(( "TTF driver\n" ));
618 
619  library = ttface->driver->root.library;
620 
622  if ( !sfnt )
623  {
624  FT_ERROR(( "tt_face_init: cannot access `sfnt' module\n" ));
625  error = FT_THROW( Missing_Module );
626  goto Exit;
627  }
628 
629  /* create input stream from resource */
630  if ( FT_STREAM_SEEK( 0 ) )
631  goto Exit;
632 
633  /* check that we have a valid TrueType file */
634  FT_TRACE2(( " " ));
635  error = sfnt->init_face( stream, face, face_index, num_params, params );
636 
637  /* Stream may have changed. */
638  stream = face->root.stream;
639 
640  if ( error )
641  goto Exit;
642 
643  /* We must also be able to accept Mac/GX fonts, as well as OT ones. */
644  /* The 0x00020000 tag is completely undocumented; some fonts from */
645  /* Arphic made for Chinese Windows 3.1 have this. */
646  if ( face->format_tag != 0x00010000L && /* MS fonts */
647  face->format_tag != 0x00020000L && /* CJK fonts for Win 3.1 */
648  face->format_tag != TTAG_true && /* Mac fonts */
649  face->format_tag != TTAG_0xA5kbd && /* `Keyboard.dfont' (legacy Mac OS X) */
650  face->format_tag != TTAG_0xA5lst ) /* `LastResort.dfont' (legacy Mac OS X) */
651  {
652  FT_TRACE2(( " not a TTF font\n" ));
653  goto Bad_Format;
654  }
655 
656 #ifdef TT_USE_BYTECODE_INTERPRETER
657  ttface->face_flags |= FT_FACE_FLAG_HINTER;
658 #endif
659 
660  /* If we are performing a simple font format check, exit immediately. */
661  if ( face_index < 0 )
662  return FT_Err_Ok;
663 
664  /* Load font directory */
665  error = sfnt->load_face( stream, face, face_index, num_params, params );
666  if ( error )
667  goto Exit;
668 
669  if ( tt_check_trickyness( ttface ) )
670  ttface->face_flags |= FT_FACE_FLAG_TRICKY;
671 
673  if ( error )
674  goto Exit;
675 
676  if ( FT_IS_SCALABLE( ttface ) )
677  {
678 #ifdef FT_CONFIG_OPTION_INCREMENTAL
679  if ( !ttface->internal->incremental_interface )
680 #endif
681  {
683 
684  /* having a (non-zero) `glyf' table without */
685  /* a `loca' table is not valid */
686  if ( face->glyf_len && FT_ERR_EQ( error, Table_Missing ) )
687  goto Exit;
688  if ( error )
689  goto Exit;
690  }
691 
692  /* `fpgm', `cvt', and `prep' are optional */
694  if ( error && FT_ERR_NEQ( error, Table_Missing ) )
695  goto Exit;
696 
698  if ( error && FT_ERR_NEQ( error, Table_Missing ) )
699  goto Exit;
700 
702  if ( error && FT_ERR_NEQ( error, Table_Missing ) )
703  goto Exit;
704 
705  /* Check the scalable flag based on `loca'. */
706 #ifdef FT_CONFIG_OPTION_INCREMENTAL
707  if ( !ttface->internal->incremental_interface )
708 #endif
709  {
710  if ( ttface->num_fixed_sizes &&
711  face->glyph_locations &&
712  tt_check_single_notdef( ttface ) )
713  {
714  FT_TRACE5(( "tt_face_init:"
715  " Only the `.notdef' glyph has an outline.\n"
716  " "
717  " Resetting scalable flag to FALSE.\n" ));
718 
719  ttface->face_flags &= ~~FT_FACE_FLAG_SCALABLE;
720  }
721  }
722  }
723 
724 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
725 
726  {
727  FT_UInt instance_index = (FT_UInt)face_index >> 16;
728 
729 
730  if ( FT_HAS_MULTIPLE_MASTERS( ttface ) &&
731  instance_index > 0 )
732  {
733  error = TT_Set_Named_Instance( face, instance_index );
734  if ( error )
735  goto Exit;
736 
737  tt_apply_mvar( face );
738  }
739  }
740 
741 #endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
742 
743  /* initialize standard glyph loading routines */
745 
746  Exit:
747  return error;
748 
749  Bad_Format:
750  error = FT_THROW( Unknown_File_Format );
751  goto Exit;
752  }
753 
754 
755  /**************************************************************************
756  *
757  * @Function:
758  * tt_face_done
759  *
760  * @Description:
761  * Finalize a given face object.
762  *
763  * @Input:
764  * face ::
765  * A pointer to the face object to destroy.
766  */
767  FT_LOCAL_DEF( void )
768  tt_face_done( FT_Face ttface ) /* TT_Face */
769  {
770  TT_Face face = (TT_Face)ttface;
771  FT_Memory memory;
774 
775 
776  if ( !face )
777  return;
778 
779  memory = ttface->memory;
780  stream = ttface->stream;
781  sfnt = (SFNT_Service)face->sfnt;
782 
783  /* for `extended TrueType formats' (i.e. compressed versions) */
784  if ( face->extra.finalizer )
785  face->extra.finalizer( face->extra.data );
786 
787  if ( sfnt )
788  sfnt->done_face( face );
789 
790  /* freeing the locations table */
792 
794 
795  /* freeing the CVT */
796  FT_FREE( face->cvt );
797  face->cvt_size = 0;
798 
799  /* freeing the programs */
800  FT_FRAME_RELEASE( face->font_program );
801  FT_FRAME_RELEASE( face->cvt_program );
802  face->font_program_size = 0;
803  face->cvt_program_size = 0;
804 
805 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
806  tt_done_blend( face );
807  face->blend = NULL;
808 #endif
809  }
810 
811 
812  /**************************************************************************
813  *
814  * SIZE FUNCTIONS
815  *
816  */
817 
818 #ifdef TT_USE_BYTECODE_INTERPRETER
819 
820  /**************************************************************************
821  *
822  * @Function:
823  * tt_size_run_fpgm
824  *
825  * @Description:
826  * Run the font program.
827  *
828  * @Input:
829  * size ::
830  * A handle to the size object.
831  *
832  * pedantic ::
833  * Set if bytecode execution should be pedantic.
834  *
835  * @Return:
836  * FreeType error code. 0 means success.
837  */
839  tt_size_run_fpgm( TT_Size size,
840  FT_Bool pedantic )
841  {
842  TT_Face face = (TT_Face)size->root.face;
843  TT_ExecContext exec;
844  FT_Error error;
845 
846 
847  exec = size->context;
848 
849  error = TT_Load_Context( exec, face, size );
850  if ( error )
851  return error;
852 
853  exec->callTop = 0;
854  exec->top = 0;
855 
856  exec->period = 64;
857  exec->phase = 0;
858  exec->threshold = 0;
859 
860  exec->instruction_trap = FALSE;
861  exec->F_dot_P = 0x4000L;
862 
863  exec->pedantic_hinting = pedantic;
864 
865  {
866  FT_Size_Metrics* size_metrics = &exec->metrics;
867  TT_Size_Metrics* tt_metrics = &exec->tt_metrics;
868 
869 
870  size_metrics->x_ppem = 0;
871  size_metrics->y_ppem = 0;
872  size_metrics->x_scale = 0;
873  size_metrics->y_scale = 0;
874 
875  tt_metrics->ppem = 0;
876  tt_metrics->scale = 0;
877  tt_metrics->ratio = 0x10000L;
878  }
879 
880  /* allow font program execution */
881  TT_Set_CodeRange( exec,
883  face->font_program,
884  (FT_Long)face->font_program_size );
885 
886  /* disable CVT and glyph programs coderange */
887  TT_Clear_CodeRange( exec, tt_coderange_cvt );
888  TT_Clear_CodeRange( exec, tt_coderange_glyph );
889 
890  if ( face->font_program_size > 0 )
891  {
892  TT_Goto_CodeRange( exec, tt_coderange_font, 0 );
893 
894  FT_TRACE4(( "Executing `fpgm' table.\n" ));
895  error = face->interpreter( exec );
896 #ifdef FT_DEBUG_LEVEL_TRACE
897  if ( error )
898  FT_TRACE4(( " interpretation failed with error code 0x%x\n",
899  error ));
900 #endif
901  }
902  else
903  error = FT_Err_Ok;
904 
905  size->bytecode_ready = error;
906 
907  if ( !error )
908  TT_Save_Context( exec, size );
909 
910  return error;
911  }
912 
913 
914  /**************************************************************************
915  *
916  * @Function:
917  * tt_size_run_prep
918  *
919  * @Description:
920  * Run the control value program.
921  *
922  * @Input:
923  * size ::
924  * A handle to the size object.
925  *
926  * pedantic ::
927  * Set if bytecode execution should be pedantic.
928  *
929  * @Return:
930  * FreeType error code. 0 means success.
931  */
933  tt_size_run_prep( TT_Size size,
934  FT_Bool pedantic )
935  {
936  TT_Face face = (TT_Face)size->root.face;
937  TT_ExecContext exec;
938  FT_Error error;
939  FT_UInt i;
940 
941  /* unscaled CVT values are already stored in 26.6 format */
942  FT_Fixed scale = size->ttmetrics.scale >> 6;
943 
944 
945  /* Scale the cvt values to the new ppem. */
946  /* By default, we use the y ppem value for scaling. */
947  FT_TRACE6(( "CVT values:\n" ));
948  for ( i = 0; i < size->cvt_size; i++ )
949  {
950  size->cvt[i] = FT_MulFix( face->cvt[i], scale );
951  FT_TRACE6(( " %3d: %f (%f)\n",
952  i, face->cvt[i] / 64.0, size->cvt[i] / 64.0 ));
953  }
954  FT_TRACE6(( "\n" ));
955 
956  exec = size->context;
957 
958  error = TT_Load_Context( exec, face, size );
959  if ( error )
960  return error;
961 
962  exec->callTop = 0;
963  exec->top = 0;
964 
965  exec->instruction_trap = FALSE;
966 
967  exec->pedantic_hinting = pedantic;
968 
969  TT_Set_CodeRange( exec,
971  face->cvt_program,
972  (FT_Long)face->cvt_program_size );
973 
974  TT_Clear_CodeRange( exec, tt_coderange_glyph );
975 
976  if ( face->cvt_program_size > 0 )
977  {
978  TT_Goto_CodeRange( exec, tt_coderange_cvt, 0 );
979 
980  FT_TRACE4(( "Executing `prep' table.\n" ));
981  error = face->interpreter( exec );
982 #ifdef FT_DEBUG_LEVEL_TRACE
983  if ( error )
984  FT_TRACE4(( " interpretation failed with error code 0x%x\n",
985  error ));
986 #endif
987  }
988  else
989  error = FT_Err_Ok;
990 
991  size->cvt_ready = error;
992 
993  /* UNDOCUMENTED! The MS rasterizer doesn't allow the following */
994  /* graphics state variables to be modified by the CVT program. */
995 
996  exec->GS.dualVector.x = 0x4000;
997  exec->GS.dualVector.y = 0;
998  exec->GS.projVector.x = 0x4000;
999  exec->GS.projVector.y = 0x0;
1000  exec->GS.freeVector.x = 0x4000;
1001  exec->GS.freeVector.y = 0x0;
1002 
1003  exec->GS.rp0 = 0;
1004  exec->GS.rp1 = 0;
1005  exec->GS.rp2 = 0;
1006 
1007  exec->GS.gep0 = 1;
1008  exec->GS.gep1 = 1;
1009  exec->GS.gep2 = 1;
1010 
1011  exec->GS.loop = 1;
1012 
1013  /* save as default graphics state */
1014  size->GS = exec->GS;
1015 
1016  TT_Save_Context( exec, size );
1017 
1018  return error;
1019  }
1020 
1021 
1022  static void
1023  tt_size_done_bytecode( FT_Size ftsize )
1024  {
1025  TT_Size size = (TT_Size)ftsize;
1026  TT_Face face = (TT_Face)ftsize->face;
1027  FT_Memory memory = face->root.memory;
1028 
1029  if ( size->context )
1030  {
1031  TT_Done_Context( size->context );
1032  size->context = NULL;
1033  }
1034 
1035  FT_FREE( size->cvt );
1036  size->cvt_size = 0;
1037 
1038  /* free storage area */
1039  FT_FREE( size->storage );
1040  size->storage_size = 0;
1041 
1042  /* twilight zone */
1043  tt_glyphzone_done( &size->twilight );
1044 
1045  FT_FREE( size->function_defs );
1046  FT_FREE( size->instruction_defs );
1047 
1048  size->num_function_defs = 0;
1049  size->max_function_defs = 0;
1050  size->num_instruction_defs = 0;
1051  size->max_instruction_defs = 0;
1052 
1053  size->max_func = 0;
1054  size->max_ins = 0;
1055 
1056  size->bytecode_ready = -1;
1057  size->cvt_ready = -1;
1058  }
1059 
1060 
1061  /* Initialize bytecode-related fields in the size object. */
1062  /* We do this only if bytecode interpretation is really needed. */
1063  static FT_Error
1064  tt_size_init_bytecode( FT_Size ftsize,
1065  FT_Bool pedantic )
1066  {
1067  FT_Error error;
1068  TT_Size size = (TT_Size)ftsize;
1069  TT_Face face = (TT_Face)ftsize->face;
1070  FT_Memory memory = face->root.memory;
1071 
1072  FT_UShort n_twilight;
1073  TT_MaxProfile* maxp = &face->max_profile;
1074 
1075 
1076  /* clean up bytecode related data */
1077  FT_FREE( size->function_defs );
1078  FT_FREE( size->instruction_defs );
1079  FT_FREE( size->cvt );
1080  FT_FREE( size->storage );
1081 
1082  if ( size->context )
1083  TT_Done_Context( size->context );
1084  tt_glyphzone_done( &size->twilight );
1085 
1086  size->bytecode_ready = -1;
1087  size->cvt_ready = -1;
1088 
1089  size->context = TT_New_Context( (TT_Driver)face->root.driver );
1090 
1091  size->max_function_defs = maxp->maxFunctionDefs;
1092  size->max_instruction_defs = maxp->maxInstructionDefs;
1093 
1094  size->num_function_defs = 0;
1095  size->num_instruction_defs = 0;
1096 
1097  size->max_func = 0;
1098  size->max_ins = 0;
1099 
1100  size->cvt_size = face->cvt_size;
1101  size->storage_size = maxp->maxStorage;
1102 
1103  /* Set default metrics */
1104  {
1105  TT_Size_Metrics* tt_metrics = &size->ttmetrics;
1106 
1107 
1108  tt_metrics->rotated = FALSE;
1109  tt_metrics->stretched = FALSE;
1110 
1111  /* Set default engine compensation. Value 3 is not described */
1112  /* in the OpenType specification (as of Mai 2019), but Greg */
1113  /* says that MS handles it the same as `gray'. */
1114  /* */
1115  /* The Apple specification says that the compensation for */
1116  /* `gray' is always zero. FreeType doesn't do any */
1117  /* compensation at all. */
1118  tt_metrics->compensations[0] = 0; /* gray */
1119  tt_metrics->compensations[1] = 0; /* black */
1120  tt_metrics->compensations[2] = 0; /* white */
1121  tt_metrics->compensations[3] = 0; /* zero */
1122  }
1123 
1124  /* allocate function defs, instruction defs, cvt, and storage area */
1125  if ( FT_NEW_ARRAY( size->function_defs, size->max_function_defs ) ||
1126  FT_NEW_ARRAY( size->instruction_defs, size->max_instruction_defs ) ||
1127  FT_NEW_ARRAY( size->cvt, size->cvt_size ) ||
1128  FT_NEW_ARRAY( size->storage, size->storage_size ) )
1129  goto Exit;
1130 
1131  /* reserve twilight zone */
1132  n_twilight = maxp->maxTwilightPoints;
1133 
1134  /* there are 4 phantom points (do we need this?) */
1135  n_twilight += 4;
1136 
1137  error = tt_glyphzone_new( memory, n_twilight, 0, &size->twilight );
1138  if ( error )
1139  goto Exit;
1140 
1141  size->twilight.n_points = n_twilight;
1142 
1144 
1145  /* set `face->interpreter' according to the debug hook present */
1146  {
1148 
1149 
1150  face->interpreter = (TT_Interpreter)
1152  if ( !face->interpreter )
1153  face->interpreter = (TT_Interpreter)TT_RunIns;
1154  }
1155 
1156  /* Fine, now run the font program! */
1157 
1158  /* In case of an error while executing `fpgm', we intentionally don't */
1159  /* clean up immediately – bugs in the `fpgm' are so fundamental that */
1160  /* all following hinting calls should fail. Additionally, `fpgm' is */
1161  /* to be executed just once; calling it again is completely useless */
1162  /* and might even lead to extremely slow behaviour if it is malformed */
1163  /* (containing an infinite loop, for example). */
1164  error = tt_size_run_fpgm( size, pedantic );
1165  return error;
1166 
1167  Exit:
1168  if ( error )
1169  tt_size_done_bytecode( ftsize );
1170 
1171  return error;
1172  }
1173 
1174 
1176  tt_size_ready_bytecode( TT_Size size,
1177  FT_Bool pedantic )
1178  {
1180 
1181 
1182  if ( size->bytecode_ready < 0 )
1183  error = tt_size_init_bytecode( (FT_Size)size, pedantic );
1184  else
1185  error = size->bytecode_ready;
1186 
1187  if ( error )
1188  goto Exit;
1189 
1190  /* rescale CVT when needed */
1191  if ( size->cvt_ready < 0 )
1192  {
1193  FT_UInt i;
1194 
1195 
1196  /* all twilight points are originally zero */
1197  for ( i = 0; i < (FT_UInt)size->twilight.n_points; i++ )
1198  {
1199  size->twilight.org[i].x = 0;
1200  size->twilight.org[i].y = 0;
1201  size->twilight.cur[i].x = 0;
1202  size->twilight.cur[i].y = 0;
1203  }
1204 
1205  /* clear storage area */
1206  for ( i = 0; i < (FT_UInt)size->storage_size; i++ )
1207  size->storage[i] = 0;
1208 
1210 
1211  error = tt_size_run_prep( size, pedantic );
1212  }
1213  else
1214  error = size->cvt_ready;
1215 
1216  Exit:
1217  return error;
1218  }
1219 
1220 #endif /* TT_USE_BYTECODE_INTERPRETER */
1221 
1222 
1223  /**************************************************************************
1224  *
1225  * @Function:
1226  * tt_size_init
1227  *
1228  * @Description:
1229  * Initialize a new TrueType size object.
1230  *
1231  * @InOut:
1232  * size ::
1233  * A handle to the size object.
1234  *
1235  * @Return:
1236  * FreeType error code. 0 means success.
1237  */
1239  tt_size_init( FT_Size ttsize ) /* TT_Size */
1240  {
1241  TT_Size size = (TT_Size)ttsize;
1243 
1244 
1245 #ifdef TT_USE_BYTECODE_INTERPRETER
1246  size->bytecode_ready = -1;
1247  size->cvt_ready = -1;
1248 #endif
1249 
1250  size->ttmetrics.valid = FALSE;
1251  size->strike_index = 0xFFFFFFFFUL;
1252 
1253  return error;
1254  }
1255 
1256 
1257  /**************************************************************************
1258  *
1259  * @Function:
1260  * tt_size_done
1261  *
1262  * @Description:
1263  * The TrueType size object finalizer.
1264  *
1265  * @Input:
1266  * size ::
1267  * A handle to the target size object.
1268  */
1269  FT_LOCAL_DEF( void )
1270  tt_size_done( FT_Size ttsize ) /* TT_Size */
1271  {
1272  TT_Size size = (TT_Size)ttsize;
1273 
1274 
1275 #ifdef TT_USE_BYTECODE_INTERPRETER
1276  tt_size_done_bytecode( ttsize );
1277 #endif
1278 
1279  size->ttmetrics.valid = FALSE;
1280  }
1281 
1282 
1283  /**************************************************************************
1284  *
1285  * @Function:
1286  * tt_size_reset
1287  *
1288  * @Description:
1289  * Reset a TrueType size when resolutions and character dimensions
1290  * have been changed.
1291  *
1292  * @Input:
1293  * size ::
1294  * A handle to the target size object.
1295  *
1296  * only_height ::
1297  * Only recompute ascender, descender, and height;
1298  * this flag is used for variation fonts where
1299  * `tt_size_reset' is used as an iterator function.
1300  */
1303  FT_Bool only_height )
1304  {
1305  TT_Face face;
1306  FT_Size_Metrics* size_metrics;
1307 
1308 
1309  face = (TT_Face)size->root.face;
1310 
1311  /* nothing to do for CFF2 */
1312  if ( face->is_cff2 )
1313  return FT_Err_Ok;
1314 
1315  size->ttmetrics.valid = FALSE;
1316 
1317  size_metrics = &size->hinted_metrics;
1318 
1319  /* copy the result from base layer */
1320  *size_metrics = size->root.metrics;
1321 
1322  if ( size_metrics->x_ppem < 1 || size_metrics->y_ppem < 1 )
1323  return FT_THROW( Invalid_PPem );
1324 
1325  /* This bit flag, if set, indicates that the ppems must be */
1326  /* rounded to integers. Nearly all TrueType fonts have this bit */
1327  /* set, as hinting won't work really well otherwise. */
1328  /* */
1329  if ( face->header.Flags & 8 )
1330  {
1331  /* the TT spec always asks for ROUND, not FLOOR or CEIL */
1332  size_metrics->ascender = FT_PIX_ROUND(
1333  FT_MulFix( face->root.ascender,
1334  size_metrics->y_scale ) );
1335  size_metrics->descender = FT_PIX_ROUND(
1336  FT_MulFix( face->root.descender,
1337  size_metrics->y_scale ) );
1338  size_metrics->height = FT_PIX_ROUND(
1339  FT_MulFix( face->root.height,
1340  size_metrics->y_scale ) );
1341  }
1342 
1343  size->ttmetrics.valid = TRUE;
1344 
1345  if ( only_height )
1346  {
1347  /* we must not recompute the scaling values here since */
1348  /* `tt_size_reset' was already called (with only_height = 0) */
1349  return FT_Err_Ok;
1350  }
1351 
1352  if ( face->header.Flags & 8 )
1353  {
1354  /* base scaling values on integer ppem values, */
1355  /* as mandated by the TrueType specification */
1356  size_metrics->x_scale = FT_DivFix( size_metrics->x_ppem << 6,
1357  face->root.units_per_EM );
1358  size_metrics->y_scale = FT_DivFix( size_metrics->y_ppem << 6,
1359  face->root.units_per_EM );
1360 
1361  size_metrics->max_advance = FT_PIX_ROUND(
1363  size_metrics->x_scale ) );
1364  }
1365 
1366  /* compute new transformation */
1367  if ( size_metrics->x_ppem >= size_metrics->y_ppem )
1368  {
1369  size->ttmetrics.scale = size_metrics->x_scale;
1370  size->ttmetrics.ppem = size_metrics->x_ppem;
1371  size->ttmetrics.x_ratio = 0x10000L;
1372  size->ttmetrics.y_ratio = FT_DivFix( size_metrics->y_ppem,
1373  size_metrics->x_ppem );
1374  }
1375  else
1376  {
1377  size->ttmetrics.scale = size_metrics->y_scale;
1378  size->ttmetrics.ppem = size_metrics->y_ppem;
1379  size->ttmetrics.x_ratio = FT_DivFix( size_metrics->x_ppem,
1380  size_metrics->y_ppem );
1381  size->ttmetrics.y_ratio = 0x10000L;
1382  }
1383 
1384  size->metrics = size_metrics;
1385 
1386 #ifdef TT_USE_BYTECODE_INTERPRETER
1387  size->cvt_ready = -1;
1388 #endif /* TT_USE_BYTECODE_INTERPRETER */
1389 
1390  return FT_Err_Ok;
1391  }
1392 
1393 
1394  /**************************************************************************
1395  *
1396  * @Function:
1397  * tt_driver_init
1398  *
1399  * @Description:
1400  * Initialize a given TrueType driver object.
1401  *
1402  * @Input:
1403  * driver ::
1404  * A handle to the target driver object.
1405  *
1406  * @Return:
1407  * FreeType error code. 0 means success.
1408  */
1410  tt_driver_init( FT_Module ttdriver ) /* TT_Driver */
1411  {
1412 
1413 #ifdef TT_USE_BYTECODE_INTERPRETER
1414 
1415  TT_Driver driver = (TT_Driver)ttdriver;
1416 
1417  driver->interpreter_version = TT_INTERPRETER_VERSION_35;
1418 #ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY
1419  driver->interpreter_version = TT_INTERPRETER_VERSION_38;
1420 #endif
1421 #ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL
1422  driver->interpreter_version = TT_INTERPRETER_VERSION_40;
1423 #endif
1424 
1425 #else /* !TT_USE_BYTECODE_INTERPRETER */
1426 
1427  FT_UNUSED( ttdriver );
1428 
1429 #endif /* !TT_USE_BYTECODE_INTERPRETER */
1430 
1431  return FT_Err_Ok;
1432  }
1433 
1434 
1435  /**************************************************************************
1436  *
1437  * @Function:
1438  * tt_driver_done
1439  *
1440  * @Description:
1441  * Finalize a given TrueType driver.
1442  *
1443  * @Input:
1444  * driver ::
1445  * A handle to the target TrueType driver.
1446  */
1447  FT_LOCAL_DEF( void )
1448  tt_driver_done( FT_Module ttdriver ) /* TT_Driver */
1449  {
1450  FT_UNUSED( ttdriver );
1451  }
1452 
1453 
1454  /**************************************************************************
1455  *
1456  * @Function:
1457  * tt_slot_init
1458  *
1459  * @Description:
1460  * Initialize a new slot object.
1461  *
1462  * @InOut:
1463  * slot ::
1464  * A handle to the slot object.
1465  *
1466  * @Return:
1467  * FreeType error code. 0 means success.
1468  */
1471  {
1472  return FT_GlyphLoader_CreateExtra( slot->internal->loader );
1473  }
1474 
1475 
1476 /* END */
char pedantic
Definition: afm2tfm.c:233
#define count(a)
Definition: aptex-macros.h:781
#define name
@ FALSE
Definition: dd.h:101
@ TRUE
Definition: dd.h:102
int params
Definition: definitions.c:42
const unsigned int maxPoints
Definition: drvbase.h:80
#define error(a)
Definition: dviinfo.c:48
void Exit(int code)
Definition: dvispc.c:374
#define ft_strncmp
Definition: ftstdlib.h:89
#define ft_strstr
Definition: ftstdlib.h:92
#define FT_UNUSED(arg)
#define FT_FACE_FLAG_HINTER
Definition: freetype.h:1208
#define FT_HAS_MULTIPLE_MASTERS(face)
Definition: freetype.h:1361
FT_DivFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:607
#define FT_IS_SCALABLE(face)
Definition: freetype.h:1271
#define FT_FACE_FLAG_TRICKY
Definition: freetype.h:1210
FT_Get_Glyph_Name(FT_Face face, FT_UInt glyph_index, FT_Pointer buffer, FT_UInt buffer_max)
Definition: ftobjs.c:4110
FT_MulFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:508
#define TT_INTERPRETER_VERSION_38
Definition: ftdriver.h:744
#define TT_INTERPRETER_VERSION_40
Definition: ftdriver.h:745
#define TT_INTERPRETER_VERSION_35
Definition: ftdriver.h:743
#define FT_DEBUG_HOOK_TRUETYPE
Definition: ftmodapi.h:641
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:64
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
unsigned long FT_ULong
Definition: fttypes.h:253
#define FT_ERR_EQ(x, e)
Definition: fttypes.h:604
signed long FT_Fixed
Definition: fttypes.h:287
int FT_Error
Definition: fttypes.h:299
signed long FT_Long
Definition: fttypes.h:242
#define FT_ERR_NEQ(x, e)
Definition: fttypes.h:606
unsigned short FT_UShort
Definition: fttypes.h:209
char FT_String
Definition: fttypes.h:187
signed short FT_Short
Definition: fttypes.h:198
unsigned int FT_UInt
Definition: fttypes.h:231
signed int FT_Int
Definition: fttypes.h:220
#define FT_LOCAL_DEF(x)
#define FT_ERROR(varformat)
Definition: ftdebug.h:211
#define FT_TRACE5(varformat)
Definition: ftdebug.h:192
#define FT_TRACE6(varformat)
Definition: ftdebug.h:193
#define FT_THROW(e)
Definition: ftdebug.h:243
#define FT_TRACE2(varformat)
Definition: ftdebug.h:189
#define FT_TRACE4(varformat)
Definition: ftdebug.h:191
FT_GlyphLoader_CreateExtra(FT_GlyphLoader loader)
Definition: ftgloadr.c:166
#define FT_NEW_ARRAY(ptr, count)
Definition: ftmemory.h:341
#define FT_FREE(ptr)
Definition: ftmemory.h:337
#define FT_ZERO(p)
Definition: ftmemory.h:246
#define FT_MEM_SET(dest, byte, count)
Definition: ftmemory.h:234
#define NULL
Definition: ftobjs.h:61
#define FT_PIX_ROUND(x)
Definition: ftobjs.h:92
const void * FT_Get_Module_Interface(FT_Library library, const char *mod_name)
Definition: ftobjs.c:5012
#define FT_FRAME_ENTER(size)
Definition: ftstream.h:548
#define FT_GET_ULONG()
Definition: ftstream.h:315
#define FT_FRAME_RELEASE(bytes)
Definition: ftstream.h:562
#define FT_STREAM_SEEK(position)
Definition: ftstream.h:525
#define FT_GET_BYTE()
Definition: ftstream.h:309
#define FT_FRAME_EXIT()
Definition: ftstream.h:553
SFNT_Interface * SFNT_Service
Definition: sfnt.h:784
struct TT_FaceRec_ * TT_Face
Definition: tttypes.h:988
struct TT_SizeRec_ * TT_Size
Definition: tttypes.h:1722
FT_Error(* TT_Interpreter)(void *exec_context)
Definition: tttypes.h:993
#define TTAG_true
Definition: tttags.h:99
#define TTAG_prep
Definition: tttags.h:93
#define TTAG_0xA5kbd
Definition: tttags.h:112
#define TTAG_0xA5lst
Definition: tttags.h:115
#define TTAG_cvt
Definition: tttags.h:51
#define TTAG_fpgm
Definition: tttags.h:58
small capitals from c petite p scientific i
Definition: afcover.h:80
return FT_Err_Ok
Definition: ftbbox.c:526
FT_Face face
Definition: cffdrivr.c:659
FT_Library library
Definition: cffdrivr.c:660
SFNT_Service sfnt
Definition: ttdriver.c:208
TT_Init_Glyph_Loading(TT_Face face)
Definition: ttgload.c:779
TT_RunIns(TT_ExecContext exec)
const TT_GraphicsState tt_default_graphics_state
TT_New_Context(TT_Driver driver)
#define TRICK_SFNT_IDS_PER_FACE
tt_face_init(FT_Stream stream, FT_Face ttface, FT_Int face_index, FT_Int num_params, FT_Parameter *params)
Definition: ttobjs.c:605
tt_size_init(FT_Size ttsize)
Definition: ttobjs.c:1239
tt_size_done(FT_Size ttsize)
Definition: ttobjs.c:1270
static FT_Bool tt_check_trickyness_family(const FT_String *name)
Definition: ttobjs.c:150
#define TRICK_SFNT_IDS_NUM_FACES
tt_slot_init(FT_GlyphSlot slot)
Definition: ttobjs.c:1470
static FT_Bool tt_check_trickyness(FT_Face face)
Definition: ttobjs.c:505
tt_size_reset(TT_Size size, FT_Bool only_height)
Definition: ttobjs.c:1302
#define TRICK_SFNT_ID_cvt
static FT_Bool tt_check_single_notdef(FT_Face ttface)
Definition: ttobjs.c:527
#define TRICK_NAMES_MAX_CHARACTERS
struct tt_sfnt_id_rec_ tt_sfnt_id_rec
static FT_ULong tt_get_sfnt_checksum(TT_Face face, FT_UShort i)
Definition: ttobjs.c:246
tt_driver_init(FT_Module ttdriver)
Definition: ttobjs.c:1410
#define TRICK_SFNT_ID_prep
static FT_UInt32 tt_synth_sfnt_checksum(FT_Stream stream, FT_ULong length)
Definition: ttobjs.c:220
#define TRICK_NAMES_COUNT
#define TRICK_SFNT_ID_fpgm
tt_face_done(FT_Face ttface)
Definition: ttobjs.c:768
static FT_Bool tt_check_trickyness_sfnt_ids(TT_Face face)
Definition: ttobjs.c:277
tt_driver_done(FT_Module ttdriver)
Definition: ttobjs.c:1448
typedefFT_BEGIN_HEADER struct TT_DriverRec_ * TT_Driver
Definition: ttobjs.h:38
@ tt_coderange_font
Definition: ttobjs.h:137
@ tt_coderange_cvt
Definition: ttobjs.h:138
@ tt_coderange_glyph
Definition: ttobjs.h:139
tt_face_load_prep(TT_Face face, FT_Stream stream)
Definition: ttpload.c:468
tt_face_load_cvt(TT_Face face, FT_Stream stream)
Definition: ttpload.c:321
tt_face_free_hdmx(TT_Face face)
Definition: ttpload.c:611
tt_face_load_fpgm(TT_Face face, FT_Stream stream)
Definition: ttpload.c:404
tt_face_load_hdmx(TT_Face face, FT_Stream stream)
Definition: ttpload.c:531
tt_face_done_loca(TT_Face face)
Definition: ttpload.c:290
tt_face_load_loca(TT_Face face, FT_Stream stream)
Definition: ttpload.c:63
tt_face_get_location(TT_Face face, FT_UInt gindex, FT_UInt *asize)
Definition: ttpload.c:196
#define buf
#define length(c)
Definition: ctangleboot.c:65
int k
Definition: otp-parser.c:70
integer checksum
Definition: pbmtopk.c:63
set set set set set set set macro pixldst1 abits if abits op else op endif endm macro pixldst2 abits if abits op else op endif endm macro pixldst4 abits if abits op else op endif endm macro pixldst0 abits op endm macro pixldst3 mem_operand op endm macro pixldst30 mem_operand op endm macro pixldst abits if abits elseif abits elseif abits elseif abits elseif abits pixldst0 abits else pixldst0 abits pixldst0 abits pixldst0 abits pixldst0 abits endif elseif abits else pixldst0 abits pixldst0 abits endif elseif abits else error unsupported bpp *numpix else pixst endif endm macro pixld1_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl else error unsupported endif endm macro pixld2_s mem_operand if mov asr add asl add asl mov asr sub UNIT_X add asl mov asr add asl add asl mov asr add UNIT_X add asl else pixld1_s mem_operand pixld1_s mem_operand endif endm macro pixld0_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl endif endm macro pixld_s_internal mem_operand if mem_operand pixld2_s mem_operand pixdeinterleave basereg elseif mem_operand elseif mem_operand elseif mem_operand elseif mem_operand pixld0_s mem_operand else pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else error unsupported mem_operand if bpp mem_operand endif endm macro vuzp8 reg2 vuzp d d &reg2 endm macro vzip8 reg2 vzip d d &reg2 endm macro pixdeinterleave basereg basereg basereg basereg basereg endif endm macro pixinterleave basereg basereg basereg basereg basereg endif endm macro PF boost_increment endif if endif PF tst PF addne PF subne PF cmp ORIG_W if endif if endif if endif PF subge ORIG_W PF subges if endif if endif if endif endif endm macro cache_preload_simple endif if dst_r_bpp pld[DST_R, #(PREFETCH_DISTANCE_SIMPLE *dst_r_bpp/8)] endif if mask_bpp pld if[MASK, #(PREFETCH_DISTANCE_SIMPLE *mask_bpp/8)] endif endif endm macro fetch_mask_pixblock pixld mask_basereg pixblock_size MASK endm macro ensure_destination_ptr_alignment process_pixblock_tail_head if beq irp skip1(dst_w_bpp<=(lowbit *8)) &&((lowbit *8)<(pixblock_size *dst_w_bpp)) .if lowbit< 16 tst DST_R
integer nn[24]
Definition: pmxab.c:90
double scale
Definition: pnmhistmap.c:38
static int size
Definition: ppmlabel.c:24
struct stream_s stream
Definition: pts_fax.h:93
slotref slot
Definition: opcodes.h:237
#define glyph_index()
FT_ModuleRec root
Definition: ftobjs.h:801
FT_Driver driver
Definition: freetype.h:1071
FT_String * family_name
Definition: freetype.h:1038
FT_Short height
Definition: freetype.h:1057
FT_Short descender
Definition: freetype.h:1056
FT_Stream stream
Definition: freetype.h:1073
FT_UShort units_per_EM
Definition: freetype.h:1054
FT_Short max_advance_width
Definition: freetype.h:1059
FT_Memory memory
Definition: freetype.h:1072
FT_Short ascender
Definition: freetype.h:1055
FT_DebugHook_Func debug_hooks[4]
Definition: ftobjs.h:908
FT_Library library
Definition: ftobjs.h:501
FT_Face face
Definition: freetype.h:1634
FT_Fixed y_scale
Definition: freetype.h:1601
FT_Fixed x_scale
Definition: freetype.h:1600
FT_Pos descender
Definition: freetype.h:1604
FT_UShort x_ppem
Definition: freetype.h:1597
FT_UShort y_ppem
Definition: freetype.h:1598
FT_Pos max_advance
Definition: freetype.h:1606
FT_Bool rotated
Definition: ttobjs.h:264
FT_Bool stretched
Definition: ttobjs.h:265
FT_Long ratio
Definition: ttobjs.h:257
FT_Fixed scale
Definition: ttobjs.h:258
FT_F26Dot6 compensations[4]
Definition: ttobjs.h:260
FT_UShort ppem
Definition: ttobjs.h:256
Definition: ttf.h:413
uint16 maxStorage
Definition: ttf.h:422
Definition: sfnt.h:76
FT_ULong Length
Definition: ttobjs.c:271
FT_ULong CheckSum
Definition: ttobjs.c:270
Definition: zic.c:110
int j
Definition: t4ht.c:1589